【知识点 】Python进阶-1

Python进阶–1

装饰器

  • 作用

保证在不改变原有函数结构的基础上,实现其功能的添加

即开放封闭原则:

  • 开放:可以增加新的功能
  • 封闭:原函数的代码不能修改
  • 可应用的场景
  1. 引入日志
  2. 函数执行时间统计
  3. 执行函数前的预处理
  4. 执行函数后的清理功能
  5. 权限检验
  6. 缓存
  • 无参无返回值的装饰器
def decorater(func):
    print('------>1')

    def addfunc():
        func()
        print('------>3')
        print('新增一个功能')
        print('再新增一个功能') 
        print('------>4')
        
    print('------2')
    return addfunc


@decorater	 	# 原理上等价于:oldfunc = decorater(oldfunc)
def oldfunc():
    print('可以实现一个功能')

oldfunc()

------>1
------2
可以实现一个功能
------>3
新增一个功能
再新增一个功能
------>4

  • 带有基本参数的装饰器
def decorater(func):
    print('------>1')

    def addfunc(para1):	 # 带参数的被修饰函数,需要在此添加参数
        func(para1)
        print('------>3')
        print('新增一个功能')
        print('再新增一个功能') 
        print('------>4')
        
    print('------2')
    return addfunc


@decorater     
def oldfunc(para1):
    print('可以实现一个{}功能'.format(para1))


oldfunc('收费')	# 这里oldfunc本质就是addfunc

------>1
------2
可以实现一个收费功能
------>3
新增一个功能
再新增一个功能
------>4

  • 带有可变参数和关键字参数的装饰器进阶版—*args和**kwargs
def decorater(func):

    def addfunc(*args, **kwargs):
        func(*args, **kwargs)
        print('略写')
        
    return addfunc


@decorater      # 原理上等价于:oldfunc = decorater(oldfunc)
def oldfunc(para1):
    print('可以实现一个{}功能'.format(para1))

@decorater      # 原理上等价于:oldfunc = decorater(oldfunc)
def oldfunc1(para1, para2):
    print('可以实现一个{}功能,预计花费{}元'.format(para1, para2))

@decorater      # 原理上等价于:oldfunc = decorater(oldfunc)
def oldfunc2(para1, para2, para3=3):
    print('可以实现一个{}功能,预计花费{}元,用时{}天'.format(para1, para2, para3))


oldfunc('收费')
oldfunc1('收费', 1000)
oldfunc2('收费', 1000)
oldfunc2('收费', 1000, para3=4)

可以实现一个收费功能
略写
可以实现一个收费功能,预计花费1000元
略写
可以实现一个收费功能,预计花费1000元,用时3天
略写
可以实现一个收费功能,预计花费1000元,用时4天
略写

  • 带有所有参数以及返回值的装饰器
def decorater(func):

    def addfunc(*args, **kwargs):
        func(*args, **kwargs)
        print('略写')
        return '实际花费了10天'
        
    return addfunc

@decorater      # 原理上等价于:oldfunc = decorater(oldfunc)
def oldfunc2(para1, para2, para3=3):
    print('可以实现一个{}功能,预计花费{}元,用时{}天'.format(para1, para2, para3))


result = oldfunc2('收费', 1000, para3=4)		# 等价于:oldfunc2 = addfunc
print(result)

可以实现一个收费功能,预计花费1000元,用时4天
略写
实际花费了10天

文件操作

  • 主要使用**open()**系统函数

https://www.runoob.com/python3/python3-func-open.html

https://www.runoob.com/python/python-func-open.html

  • 常用知识以及模块

os、open()

相对路径和绝对路径

  • 常用操作

仅读取–文本

with open(path + '\\调用文件\\2020_理科.txt', 'r') as f:
 for line in f.readlines():
     line_info = line.strip().split(",") 
     info_fenshu_2020_like.append(line_info[0])
     info_renshu_2020_like.append(line_info[1])
     info_paiming_2020_like.append(line_info[2])

追加写–文本

with open(os.getcwd() + './存储下载文件/小说/{}.txt'.format(book_name), mode='a+', encoding='utf-8') as f:
 f.write('**********************\n')
 f.write('**********************\n')
 f.write('{}\n'.format(title))
 f.write('**********************\n')
 f.write('**********************\n')
 f.write('\n\n\n')
 f.write(content)
 f.write('\n\n\n\n')

写–二进制文件

with open(path + '//存储下载文件//网易下载歌曲//{}.mp3'.format(name), 'wb') as f:
 f.write(response.content)
 f.flush()

跳过第一行非数据信息

with open('test.txt') as f:
    print(f.readlines())

with open('test.txt') as f:
    print(f.readline(), end='')
    next(f)			# 此命令可以保证跳过一行操作
    print(f.readline(), end='')

[‘wer\n’, ‘aer\n’, ‘awre’]
wer
awre

异常机制及异常捕获

  • 基本知识

语法错误:编写代码的时候可以人为检查

异常:出现在运行之后,通常是xxxError

有些异常不是程序的问题,而是输入不在程序正常运行的范围内。

这种情况可以通过异常处理来进行提示

  • 异常捕获注意事项

一个父异常下面可能包含很多个子异常

except异常处理是按照顺序,代码从上到下运行

所以父异常必须放在子异常后边

try:
    expression
 
except 子子异常:	  # 子子异常是子异常1或子异常2的子异常
    expression0
    
except 子异常2:	   # 子异常1、子异常1两者并列,属于父异常
    expression1

except 子异常1:
    expression2
    
except 父异常 as err:
    print('异常是:', err)		# 可以获得错误的具体内容
    expression3

【知识点 】Python进阶-1_第1张图片

  • 异常处理机制

基本

try:
    expression
    
except Error1:
    expression1
---------------可添加部分---------------
except Error2:
    expression2
    
except Error3:
    expression3
    
...................
---------------可添加部分---------------

try - except - else

try:
    expression
    
except Error3:
    expression3			# 有else,表达式就不能出现return

else:					# 没有异常,才会执行else的内容
    expression

try - except - finally

try:
    expression
    
except Error3:
    expression3	    # 有finally,即使里面有return,也会执行finally的内容

finally:			# 有没有异常,都会执行,常用于f.close()
    expression
  • 抛出异常

有时候你需要判断代码的输入是否符合要求,并作相应处理

就可以抛出一个自定义的异常或者已有的异常机制

配合异常处理机制来明确问题所在

'''
expression
'''

raise Exception('字符长度异常')
raise NameLensError('名字不合要求')

推导式

列表推导式

[表达式 (变量) for 变量 in 旧列表]

[表达式 (变量) for 变量 in 旧列表 if 条件]

[x*x for x in range(6)]
[x*x for x in range(9) if x % 2 ==0]


names = ['lily', 'rouse', 'jack', 'Tom']

newname = [name  for name in names  if len(name)>3]
print(newname)

newname = tuple([name.upper()  for name in names  if len(name)>3])
print(newname)

[‘lily’, ‘rouse’, ‘jack’]
(‘LILY’, ‘ROUSE’, ‘JACK’)

双重循环

suit = ['♥','♦','♣','♠']
face = ['A','2','3','4','5','6','7','8','9','10','J','Q','K']
poke = [(x,y) for x in suit for y in face]

字典推导式

# 列表生成式可以使用两个变量,实现字典的键值交换

d = {"X":"A","Y":"B","Z":"C"}
list5 = {v:k for k,v in d.items()}
print(list5)

集合推导式

{x for x in range(10)}

生成器

  • 基本

列表推导式可以直接创建一个列表

如果列表内容很大,且只需要前边部分数据,这样就非常占用空间。

可以用生成器generator来解决这个问题

通过某种算法推算列表元素,在循环中不断推算后续元素,就不需要创建列表,从而节省大量空间

这种一边循环一边计算的机制,就是生成器

  • 获取生成器

通过推导式生成

gener = (x * 3 for x in range(20))
print(type(gener))

调用

gener = (x * 3 for x in range(20))
print(type(gener))

print(gener.__next__())

print(next(gener))


0
3

超出数据量后就会抛出异常,可用异常处理机制避免这个

通过函数生成

def generator():	# 1.定义函数表达式
    x = 0
    while True:
        x += 1
        yield x		# 2.使用yiled关键字,生成器返回x的值。yield相当于 return+暂停功能


g = generator()		# 3.调用,就是生成器了
print(type(g))
print(next(g))
print(next(g))

g = generator()		# 重新生成,再调用
print(next(g))
print(next(g))

g = generator()		# 重新生成,再调用
t1 = g.send(None)	# send的更多作用后边单列讲解
t2 = g.send(1)		# 调用send必须赋参数
print(t1, t2)


1
2
1
2
1 2

send()函数

def genera():
    n = 0
    while True:
        temp = yield n
        for i in range(temp):
            print('----->', i)
        n += 1

g = genera()
print(g.send(None))		# 第一次调用,必须赋予参数None
print(g.send(5))		# send函数把5传给temp,然后g.send(5)的返回值是n
print(g.send(4))		# 同理

0
-----> 0
-----> 1
-----> 2
-----> 3
-----> 4
1
-----> 0
-----> 1
-----> 2
-----> 3
2

迭代器和可迭代对象

  • 可迭代对象

迭代是访问集合元素的一种方式

可以用isinstance()函数判断对象是否可迭代

from collections import Iterable

list1 = [1, 2, 3, 4]
strs = 'abc'
ints = 100
print(isinstance(list1, Iterable))
print(isinstance(strs, Iterable))
print(isinstance(ints, Iterable))

True
True
False

不可迭代:int型数据

可迭代:元组、列表、集合、字典、字符串、生成器

  • 迭代器

可以被next()函数调用并不断返回下一个值的对象称为迭代器

是一个可以记住遍历的位置的对象

迭代器对象从集合第一个元素开始访问,直到所有元素被访问结束

gener = (x * 3 for x in range(20))
print(type(gener))

print(next(gener))		# 生成器就是迭代器的一种
  • 概念辨别

【知识点 】Python进阶-1_第2张图片

迭代器是一个大类,其定义为:

可以被next()函数调用并不断返回下一个值的对象称为迭代器

其内部包含生成器

生成器可以直接迭代,直接使用next函数

还包括list、tuple、set等一系列的 “可迭代对象”

可迭代对象不可直接迭代,即不能直接调用next()函数

【是否可迭代用isinstance()函数判断】

上述可迭代对象可以使用iter()函数,使得可迭代对象变为迭代器,从而调用next()函数

list1 = [1, 2, 3, 4]
list1 = iter(list1)

print(next(list1))
print(next(list1))

1

2

总的来说迭代器包含两大类

一类是生成器,可以直接迭代,生成器本身属于迭代器的一种

一类是可以通过iter()函数变为迭代器的可迭代对象

你可能感兴趣的:(Python知识点,python,开发语言,django)