一、装饰器
1.1 装饰器的引入背景
- 假如有新需求时，我们可以直接通过修改函数中的代码，但是这样做会产生一些问题：
- 如果修改过的地方过多，修改起来比较麻烦；
- 不方便后期维护
- 这样做违反开闭原则（ocp）: 程序的设计，要求开发对程序的扩展，要关闭对程序的修改。
- o : open , 开放对代码的扩展；c : close 关闭对代码的修改。
def fun1():
print('这是我的fun1函数')
def fun(fn, a, b):
print('函数开始执行')
fn(a, b)
print('函数执行结束')
def add(a, b)
return a + b
def mul(a, b):
return a * b
fun(fun1)
- 假如上面我们要不停的替换参数呢，是不是一直要修改功能函数，那么有什么好的方法可以优化呢 ？我们是不是可以使用 不定长参数：
def fun(fn, *args):
print('函数开始执行')
fn(*args)
print(r)
print('函数执行结束')
- 这样是不是不管有多少参数传递进来，我们都不用去修改功能函数了。
1.2 装饰器的使用
- 概念：装饰器时一个特殊的闭包函数，因此满足闭包函数的三大特性：
- 要有函数嵌套；
- 内部函数要到外部函数的变量；
- 外部函数要返回内部函数的变量。
比如：
def start_fun(fn): # 形参= 实参，即 fn = fun
def new_fun():
print('函数开始运行')
fn(): # 调用外部函数 fun
print(‘函数执行结束’)
return new_fun
def fun():
print('这是我的fun函数')
r = start_fun(fun)
r()
- 首先 start_fun() 调用外部函数，函数顺序执行，因为没有调用到内层函数，直接执行 def ();
- 然后，外层函数调用等于外层函数的返回值，那么现在 外层函数的返回值 new_fun 就是内存函数的函数对象。
3 现在，内层函数的调用需要函数对象加上括号，也就是调用。就是在外层函数的调用加上括号：因此 start_fun() = new_fun = r, start_fun()() = new_fun() = r() - start_fun(fn)，这里fn 是一个形参，start_fun(fun), 形参等于实参，因此 fn = fun, fn() = fun(), 这样也就完成了内层函数调用外层函数。
1.3 通用装饰器**
- 通过不定长参数，不管传多少参数，或者传不传参数，都不影响。
# 装饰器函数
def old_fun(a):、
# 内部函数
def new_fun(*args, **kwargs):
print('函数开始执行')
a(*args, **kwargs)
print('函数执行结束')
return new_fun
# 目标函数，被装饰的而函数
def fun():
print('我是目标函数')
1.4 装饰器的语法糖写法：
下面标准的通用装饰器语法糖的写法，使用起来非常方便。
def old_fun(a):、
# 内部函数
def new_fun(*args, **kwargs):
print('函数开始执行')
a(*args, **kwargs)
print('函数执行结束')
return new_fun
@old_fun # 装饰器的语法糖写法 @old_fun = old_fun(fun)
def fun():
print('我是目标函数')
fun()
注意：
- 装饰器要紧跟着被装饰目标函数
- 如果有多个目标函数被装饰，需要写多个 @ 装饰。
- 装饰器只能针对于函数，对其他数据类型没有意义。
二、推导式
推导式主要分为： 列推导式，字典推导式、集合推导式等，这里我们主要说其中一种也是最重要的，用的最多的列推导式。
2.1 列推导式
- 列推导式是 Ptyhon 构建列表 list 的一种快捷方式，可以使简洁的代码就创建出一个列表。简单理解就是由一个列表来构建出一个新的列表。
- 作用：快速生成一个列表。
- 语法：
- [表达式 for 变量 in 旧列表]
- [表达式 for 变量 in 旧列表 if 条件]
例子：假如要从 list1 = ['java', 'python', 'go', 'js', 'php'] 取值 保存到 list2 列表中，该怎么做呢 ?
一般方法：
list1 = ['java', 'python', 'go', 'js', 'php']
def fun(list1):
list2 = []
for i in list1:
if len(i) > 3:
list2.append(i)
print(list2)
如果采用列表推导式呢 ？
list3 = [i for i in list1 if len(i) > 3]
print(list3)
- 这样使用列表推导式是不是简单多了。
2.2 练习
- 需求 ：求 1-100 偶数之和
sum = [i for i in range(1, 101) if i % 2 == 0]
print(sum)
- 需求2： 求1-100 直接的偶数，并还要能整除4
list2 = [i for i in range*(1, 101) if i % 2 ==0 and i % 4 == 0]
print(list2)
三、生成器
背景
通过列表推导式，我们可以创建一个列表，但是受于内存限制，我们不能创建无限大的列表。假如现在有一个200万元素的列表，这样都会占用很大的内存空间，但是我们只需要取其中的几个元素，那么后面的元素占用着空间就是一种浪费。那么我们可不可以只用几个元素就创建出几个元素的列表呢。这样在一定程度上优化了内存，那么python 中有没有一边循环一边计算的机制呢？有，这个就是生成器。
3.1 创建生成器
- 创建生成器的方法：
方法一：使用类似列表推导式的方式得到生成器。
- 不希望一次性取到太多数据，想要多少数据就给多少数据，这样做非常人性化，有人为控制。
比如：取 1-10 之间的数，并乘以2 的结果
list1 = [i * 2 for i in range(1, 11)]
生成器：generation
gen = ( i * 2 for i in range(1, 11))
print(gen)
print(type(gen))
通过next() 函数来获得
gen = ( i * 2 for i in range(1, 11))
#print(gen.__next__()) # 通过 next 函数获得。
i = 0
while i < 11:
print(next(gen))
i += 1
- 注意，next() 只能从第一个取值。
方法二： 使用函数加上 yield 来实现生成器。
注意：yeild
def fun():
i = 0
while True:
i += 1
yield i
r = fun()
print(r)
print(next(r))
3.2 生成器的特性
- 生成器会记住你上一次取数据的位置，然后下次取数据时从上一次计住的位置继续取数据。
def fun():
i = 0
while True:
i += 1
yield i
r = fun()
print(r)
print(next(r))
print(next(r))
print(next(r))
---------输出----------
1
2
3
特性2 ： 生成器生成一次只能取一次数据，第二次取就不存在数据了。
gen = ( i * 2 for i in range(1, 11))
lst = [i for i in gen]
lst1 = [i for i in gen]
print(lst)
print(lst1)
---------输出----------
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]
[]
四、 迭代器
图片.png
迭代器时是访问集合元素的一种方式，爹大气是一个可以记住变量位置的对象，迭代器对象从集合的第一个元素开始访问，直到所有元素都被访问完结束。
可以被 next() 函数调用，并不断返回下一个值的对象称为迭代器 iterator。
- 生成器是可迭代的，也是迭代器
- 列表是可迭代的，但不是迭代器
- 通过iter() 函数可以将可迭代的变成一个迭代器。
4.1 生成迭代器
list1 = [1, 3, 5 ,7, 9, 11]
list2 =(1, 3, 5 ,7, 9, 11)
ite = iter(list1)
ite2 = iter(list2)
-------输出-------
<list_iterator object at 0x000002B9E4610CC0>
<tuple_iterator object at 0x000002B9E4610DA0>
迭代器：
class die():
def __init__(self, data+1):
self.data = data
def __iter__(self)
return self
def __next__(self):
if self.data > 5: # 当容器中的数据大于5， 就抛出异常
raise StopIteration
else:
self.data += 1 # 没有超过，则自加一。
return self.data
for item in test(3):
print(item)
五、PEP8代码规范
PEP8 Python代码风格指南
- PEP8提供了Python 代码的编写约定规则，主要提供代码的质量，提高可读性，其中有下列规范：
- 缩进4格，空格是首选的缩进方式，python3 不允许空格与tab键混合使用；
- 顶层函数、类的定义，前后使用2个空行隔开；
- import 导入，定义在不通的行；
- 导包位于文件顶部。导入顺序：
标准库导入
相关第三方导入
本地应用/库导入
在每一组导入之间加入空行
- Python 中定义字符串使用双引号，单引号，尽量保持使用同一方式定义字符串，当同时含双引号与单引号时，在最外层使用不同的符号来避免使用反斜杠""转义，从而提高可读性。
- 表达式和语句中的空格：
避免在(), [], {}这些括号后面跟空格；
避免在逗号、分号、冒号之前添加空格
冒号在切片中像二元运算符，两边要有相同数量的空格，如果某个切片参数省略，空格也省略。
避免为了另外一个赋值语句对其，中间使用多个空格。
避免在表达式尾部添加空格，因为尾部空格不可见，会产生混乱；
总在二元运算符两边加一个空格，赋值（=），增量赋值(+=,-=), 比较(==,>=,<=,!=,<,>,in,not in, is, is not) 布尔值(and,or,not) 等这些。
- 避免将小的代码块和 if/for/while 放在同一行，免得代码过长。
- 不要使用单个字符比如 l, O, I 这些单字符作用变量名，容易引起混淆。
- 类名一般首字母大写的约定
- 函数名要小写，为了提高可读性可以使用下划线_.
- 如果函数名和已有关键词冲突，可以在最后加下划线，比如class_ ,这样效果更好。也可以用其他同义词代替。
- 方法名和实例变量使用下划线分隔的小写单词，可以 提高可读性。
补充 time 模块
1. time.time() 方法
(1) Python 中 time time() 返回的是当前时间的时间戳（从1970纪元后经过的浮点秒数。）
(2) 语法格式
time.time()
- 注意，使用前要导入 time模块： import time
time.time() 返回值是从1970开始计算到现在的秒数。
(3) 实例介绍
import time #导入time模块
times = time.time()
print(times)
1616724143.7798808
2. time.localtime() 方法
(1) Python time localtime() 函数类似gmtime(), 作用是格式化时间戳为本地时间。如果sec 参数未输入，则以当前时间为转换标准。
(2) 语法：
time.localtime([sec])
sec - 参数，转换为 time.struct_time 类型的对象的秒数。
- 该函数没有返回值。
(3) 实例介绍
import time
times = time.time()
print(times)
print(time.localtime())
print(time.asctime(time.localtime())) #
1616725672.4887671
time.struct_time(tm_year=2021, tm_mon=3, tm_mday=26, tm_hour=10, tm_min=27, tm_sec=52, tm_wday=4, tm_yday=85, tm_isdst=0)
Fri Mar 26 10:27:52 2021
练习
- 请使用装饰器实现已存在的函数的执行所花费的时间
思路：
- 分别定义2个时间： 程序开始实际 start_time 和程序结束时间 end_time
- end_time - start_time 即为程序运行时间
import time
start_time = time.time() # 定义程序执行开始时间
def fun():
i = 4
while i > 0 :
year = int(input("请输入年份："))
if year % 400 == 0 or (year % 4 == 0 and year % 100 != 0):
print('%d是闰年' % year)
pass
else:
print('%d不是闰年' % year)
pass
i -= 1
fun()
# time.sleep(10)
end_time = time.time() # 定义程序执行结束时间
time_diff = end_time - start_time
print("程序运行时间为：%f 秒" % time_diff)
---------------输出-------------
请输入年份：2000
2000是闰年
请输入年份：2100
2100不是闰年
请输入年份：2200
2200不是闰年
请输入年份：2300
2300不是闰年
程序运行时间为：6.866755247116089 秒
