整理------函数
函数参数顺序
位置参数 > *args > 默认值参数 > **kwargs
动态参数的另一种传参方式 : 在实参位置上给一个序列,列表,可迭代对象前面加个*表示把这个序列按顺序打散
l = [11,22,33,44] s = "臣妾做不到" def fun(*args): print(args) fun(*l) #fun打印结果为: (11, 22, 33, 44) fun(*s) #fun打印结果为: ('臣', '妾', '做', '不', '到')
在形参的位置上的* 表示把接收到的参数组合成一个元组
如果是一个字典, 那么也可以打散. 不过需要用两个*
def fun(**kwargs): print(kwargs) dic = {'a':1, 'b':2} fun(**dic) # {'a': 1, 'b': 2}
函数的注释:
def chi(food, drink): """ 这里是函数的注释, 先写一下当前这个函数是干什么的, 比如我这个函数就是一个吃 :param :param food: 参数food是什么意思 :param :param drink: 参数drink是什么意思 :return :return: 返回的是什么东东 """ print(food, drink) return "very good"
命名空间
在python解释器开始执行之后, 就会在内存中开辟一个空间, 每当遇到一个变量的时候, 就把变量名和值之间的关系记录下来, 但是当遇到函数定义的时候, 解释器只是把函数名读入内存, 表示这个函数存在了, 至于函数内部的变量和逻辑, 解释器是不关心的. 也就是说一开始
的时候函数只是加载进来, 仅此而已, 只有当函数被调用和访问的时候, 解释器才会根据函数内部声明的变量来进行开辟变量的内部空间. 随着函数执行完毕而被清空.
命名空间分类:
1. 全局命名空间--> 我们直接在py文件中, 函数外声明的变量都属于全局命名空间
2. 局部命名空间--> 在函数中声明的变量会放在局部命名空间
3. 内置命名空间--> 存放python解释器为我们提供的名字, list, tuple, str, int这些都是内置命名空间
加载顺序:
1. 内置命名空间
2. 全局命名空间
3. 局部命名空间(函数被执行的时候)
取值顺序:
1. 局部命名空间
2. 全局命名空间
3. 内置命名空间
我们可以通过globals()函数来查看全局作用域中的内容, 也可以通过locals()来查看局部作
用域中的变量和函数信息
print(globals()) #{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <_frozen_importlib_external.SourceFileLoader object at 0x00466590>, '__spec__': None,
'__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:/Users/ZYP/PycharmProjects/python_ui/test_tools/test.py', '__cached__': None} def func(): a = 10 print(locals()) #{'a': 10} func()
对于可变数据类型可以直接进行访问. 但是不能改地址. 说白了. 不能赋值
l = [11,22,33,44] def fun(): l.append(55) print(l) # [11, 22, 33, 44, 55] fun() print(l) # [11, 22, 33, 44, 55]
a = 2 def w(): a +=1 print(a) w() #报错,不能赋值
迭代器
闭包
闭包就是内层函数, 对外层函数(非全局)的变量的引用. 叫闭包
def func1(): name = "zyp" def func2(): print(name) # 闭包 func2() func1() 结果: zyp
我们可以使用__closure__来检测函数是否是闭包. 使用函数名.__closure__返回cell就是闭包. 返回None就不是闭包
def func1(): name = "zyp" def func2(): print(name) # 闭包 func2() print(func2.__closure__) func1() 结果: zyp
闭包的作用就是让一个变量能够常驻内存. 供后面的程序使用
生成器和迭成器表达式
生成器
什么是生成器.生成器其实就是迭代器
在python中有三种方式来获取生成器:
1. 通过生成器函数
2. 通过各种推导式来实现生成器
3. 通过数据的转换也可以获取生成器
def func(): print("111") return 222 ret = func() print(ret) 结果: 111 222
将函数中的return换成yield就是生成器
def func(): print("111") yield 222 ret = func() print(ret) 结果: <generator object func at 0x10567ff68>
运行的结果和面⾯不一样. 为什么呢. 由于函数中存在了yield. 那么这个函数就是一个生成器函数. 这个时候. 我们再执行这个函数的时候. 就不再是函数的执行了. 而是获取这个生成器我们可以直接执行__next__()来执行以下生成器.
def func(): print("111") yield 222 ret = func() print("ret",ret) a = ret.__next__() print("a",a) 结果 ret <generator object func at 0x0209AF60> 111 a 222
那么我们可以看到, yield和return的效果是一样的. 有什么区别呢? yield是分段来执行一个函数. return呢? 直接停止执行函数.
def func(): print("111") yield 222 print("333") yield 444 gener = func() ret = gener.__next__() print(ret) ret2 = gener.__next__() print(ret2) ret3 = gener.__next__() # 最后⼀个yield执⾏完毕. 再次__next__()程序报错, 也就是 说. 和return⽆关了. print(ret3) 结果: 111 Traceback (most recent call last): 222 333 File "/Users/sylar/PycharmProjects/oldboy/iterator.py", line 55, in <module> 444 ret3 = gener.__next__() # 最后⼀个yield执⾏完毕. 再次__next__()程序报错, 也 就是说. 和return⽆关了. StopIteration
当程序运行完最后一个yield. 那么后面继续进行__next__()程序会报错.
生成器有什么作用呢?
占内存少,用多少取多少
send和__next__()⼀样都可以让生成器执行到下一个yield.
def eat(): print("我吃什么啊") a = yield "馒头" print("a=",a) b = yield "饼" print("b=",b) c = yield "菜盒" print("c=",c) yield "GAME OVER" gen = eat() # 获取⽣成器 ret1 = gen.__next__() print(ret1) ret2 = gen.send("胡辣汤") print(ret2) ret3 = gen.send("狗粮") print(ret3) ret4 = gen.send("猫粮") print(ret4) 结果 我吃什么啊 馒头 a= 胡辣汤 饼 b= 狗粮 菜盒 c= 猫粮 GAME OVER
send和__next__()区别:
1. send和next()都是让生成器向下走一次
2. send可以给上面个yield的位置传递值, 不能给最后一个yield发送值. 在第一次执行生成器代码的时候不能使用send()
列表推导式, 生成器表达式以及其他推导式
列表推导式
lst = [i for i in range(1, 15)] print(lst)
常用写法:
[ 结果 for 变量 in 可迭代对象]
我们还可以对列表中的数据进行筛选筛选模式:
[ 结果 for 变量 in 可迭代对象 if 条件 ]
# 获取1-100内所有的偶数 lst = [i for i in range(1, 100) if i % 2 == 0] print(lst)
生成器表达式和列表推导式的语法基本上是一样的. 只是把[]替换成()
gen = (i for i in range(10)) print(gen) 结果: <generator object <genexpr> at 0x106768f10>
打印的结果就是一个⽣生成器. 我们可以使用for循环来循环这个生成器:
for i in gen: print(i)
生成器表达式也可以进行筛选:
# 获取1-100内能被3整除的数 gen = (i for i in range(1,100) if i % 3 == 0) for num in gen: print(num)
生成器表达式和列表推导式的区别:
1. 列表推导式比较耗内存. 一次性加载. 生成器表达式几乎不占用内存. 使用的时候才分
配和使用内存
2. 得到的值不一样. 列表推导式得到的是一个列表. 生成器表达式获取的是个生成器
深坑==> 生成器. 要值得时候才拿值.
字典推导式:
dic = {"a":1,"b":2}
new_dic = {dic[key]:key for key in dic}
print(new_dic) #{1: 'a', 2: 'b'}
lst1 = ['11', '22', '33'] lst2 = ['aa', 'bb', 'cc'] dic = {lst1[i]:lst2[i] for i in range(len(lst1))} print(dic) #{'11': 'aa', '22': 'bb', '33': 'cc'}
集合推导式:
集合推导式可以帮我们直接生成一个集合. 集合的特点: 无序, 不重复. 所以集合推导式自带去重功能
lst = [1, -1, 8, -8, 12] s = {abs(i) for i in lst} #绝对值abs print(s) # {8, 1, 12}
总结: 推导式有, 列表推导式, 字典推导式, 集合推导式, 没有元组推导式
