Python进阶(五)----内置函数Ⅱ 和 闭包
Python进阶(五)----内置函数Ⅱ 和 闭包
一丶内置函数Ⅱ
####内置函数#### 特别重要,反复练习
###print() 打印输入
#sep 设定分隔符
# end 默认是换行可以打印到一行
print(1,2,3,4,sep='|',end=' ')
print(1,2,3,4,sep='|')
# print() 还可以写字符串到文件, file= 文件句柄
f=open('log','a',encoding='utf-8')
print('这是要写入的文件',file=f)
print([1,2,3,4],file=f) #可以写任意类型的哦!!! 写入就成字符串了
print((1,2,34),file=f) #可以写任意类型的哦!!! 写入就成字符串了
print({'a':1},file=f) #可以写任意类型的哦!!! 写入就成字符串了
print(1,file=f) #可以写任意类型的哦!!! 写入就成字符串了
###list()
#创建列表的集中方式
#1. 直接创建
li=[]
#2. list() 方法
li1=list()
#3. 列表推导表达式
a=[i for i in range(10)]
print(a) #[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
###dict()
#字典的创建方式 4 中
#1.直接创建
dic={}
#2. dict()
dic2=dict()
#3. 字典推导式
b={i:1 for i in range(10)}
#4. fromkeys
dic3=dict.fromkeys([1,2,3,4],1)
###获取绝对值 abs()
print(abs(-100))
###sum(iterable,) 求和 必须是数字
print(sum([1,2,3,4]))
print(sum([1,2,3,4],100))
print(sum('1234')) # 字符串不能求和
print(sum({1:1,2:2,3:3})) # 字典的键是数字 so 可以相加求和
print(sum((1,2,3,4,5,6)))
####min(*args ,key=) 取最小的值 和 max()用法相同
#1. 普通使用
print(min([1,2,3,4])) # 1
print(min((23,10,1,2,3,4))) # 1
print(min('413'),type(min('413'))) #<class 'str'> 字符串 会被迭代 还是字符串
#2 特殊功能 key=func ===> key=匿名函数
#默认情况
def func(x): # 此处x得到是迭代对象的每个元素, so 分别是: wuad , aler , field
return x[1] # 返回是以字符串索引为1的字母,比较这个位置的字母的大小.返回最小的
print(min(['wuad','aler','field'],key=func)) # field
#特殊使用 key=lambda
print(min(['dalao','aordi','xiaocang'],key=lambda x:x[0])) #aordi
### 👇 min(*args ,key=lambda) 测试
li = [('艾利克斯', 33, '170cm'), ('杨白', 18, '185cm'), ('武大', 35, '159cm'),]
#需求: 找年龄最小的元组
# 分析: 1 找到每个元素 元组,2 把年龄作为返回值 3,打印
print(min(li,key=lambda x:x[1]))
#需求: 找年龄最小的元组的身高
#分析: 1.min(li,key=lambda x:x[1]) 返回一个最小的元组, 2. [2]得到元组后面是取索引位2的值
print(min(li,key=lambda x:x[1])[2])
####总结:
#1. 返回值是什么就按照什么比较最小的。
#2. min()会自动的将可迭代对象的每一个元素作为实参传给形参，
# so 继续来测试
##测试1
dic = {'a':3,'b':2,'c':1}
#需求: 将dic值最小的键返回。
#分析: 最小的键是 a
print(min(dic,key=lambda x:dic[x]))
#需求: 将dic值最小的值返回。
#分析: 最小的值的键是 c ,so 拿键取值
print(dic[min(dic,key=lambda x:dic[x])])
##测试2
dic = {'A':['李业', 67],'b': ['怼哥', 95],'c': ['冯垚', 85]}
#*需求: 将成绩最低的从属于的那个列表返回。
#分析: 成绩最低 : .需要的是成绩元素为排序的标准,
# 1 通过键拿到对应的值,值为列表,列表中成绩索引为1 ,根据成绩找到最小so,返回一个键
print(dic[min(dic,key=lambda x:dic[x][1])])
#*需求: 将成绩最低的分数返回。
#分析:得到成绩最低的分数 .需要的是成绩元素为排序的标准, 并拿到这个成绩
# 1.通过键拿到对应的值,值为列表,列表中成绩索引为1根据成绩找到最小 so,返回一个列表,根据列表索引取成绩值
print(dic[min(dic,key=lambda x:dic[x][1])][1])
###👆👆👆 如果还是不理解,请指出不理解的点. i can help you to solve
###reversed() 将一个可迭代的对象进行翻转 ,并返回成一个迭代器(生成器)
s1='不打广告'
print(reversed(s1),type(reversed(s1))) #<reversed object at 0x00000185BD268048> <class 'reversed'>
# 迭代循环取值
s2=reversed(s1) #可以直接迭代
print(s2.__next__()) #这样可以取值
print(next(s2)) #这样可以取值
for i in s2: #这样也可以取值
print(i)
###bytes() 将(字符串,或者是数字,但数字就不需要加编码)数据转换成 字节类型
s1='不打广告'
s2='budaguanggao'
s3=1
print(bytes(s1,encoding='utf-8'))
print(bytes(s2,encoding='utf-8'))
print(bytes(1))
#编码
s1 = '不打广告'
# 方法一：
print(s1.encode('utf-8'))
# 方法二：
print(bytes(s1,encoding='utf-8'))
# 解码：
b1 =b'\xe4\xb8\x8d\xe6\x89\x93\xe5\xb9\xbf\xe5\x91\x8a'
# 方法一：
print(b1.decode('utf-8'))
# 方法二：
print(str(b1, encoding='utf-8'))
####zip() 拉链函数 用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组
li=[1,2,3,4]
tu=('a','b','c')
s='python'
z=zip(li,tu,s) #把生成的迭代器赋给变量z
print(z,dir(z)) #返回一个迭代器 '__next__', '__iter__'
for i in z: # 元素个数与最短的列表一致
print(i)
##### sorted() 排序 ,形成新列表
li=[6,3,1,5,9,2,4]
print(sorted(li))
#sorted(iterable , key= , reverse=)
li= [('张一东', 80), ('张耳洞', 75), ('怼怼哥', 7), ('李业', 59)]
print(sorted(li,key=lambda x :x[1]),) #按照分数排序 升序
print(sorted(li,key=lambda x :x[1],reverse=True)) # 降序
print(sorted(li,key=lambda x :x,reverse=True)) # 默认按照,循环元素的第一个位置排序
####filter(函数,可迭代对象) 列表推导式的筛选模式 # 返回成一个迭代器
lst = [{'id':1,'name':'tom','age':30},
{'id':1,'name':'jam','age':12},
{'id':1,'name':'aim','age':16},
]
ls=filter(lambda x :x['age']<30,lst) # 把age大于30的过滤
print(ls) # 返回成一个迭代器<filter object at 0x000001CDF1500E48>
print(list(ls),type(ls) ,dir(ls)) # <class 'filter'> '__iter__', '__next__',
####map(函数,可迭代对象) 返回一个迭代器 ,生成器表达式:循环模式
# 使用 lambda 匿名函数,计算平方数
ls=[1, 2, 3, 4, 5]
map(lambda x: x ** 2, ls)
# 提供了两个列表，对相同位置的列表数据进行相加
li1=[1, 3, 5, 7, 9]
li2=[2, 4, 6, 8, 10]
map(lambda x, y: x + y,li1,li2 )
####reduce 函数会对参数序列中元素进行累积。
from functools import reduce
li=[1,2,3,4,5]
num=reduce(lambda x, y: x+y,li ) # 使用 lambda 匿名函数
print(num)
二丶闭包
什么是闭包:
1.闭包是嵌套在函数中的函数
2.闭包必须是内层函数对外层函数的变量(非全局变量)进行引用
3.闭包函数必须返回内部嵌套的函数地址.
闭包的作用:
保存局部信息不被销毁，保证数据的安全性。
在编写代码时,非常节省.
在面相对象的思想中,闭包可以理解为封装,简化代码量
闭包的应用
1.装饰器
2.可以保存一些非全局变量但是不易被销毁、改变的数据。
###闭包为了保证数据的安全
def make_average():
li=[] #自由变量 # | 这个区间就是闭包 👇
def average(price):
li.append(price)
total=sum(li)
print(locals())
return total/len(li)
print(locals())
return average # | 这个区间就是闭包 👆
avg=make_average()
avg(10)
avg(12)
avg(11)
#查看 avg 也就是average函数中的自由变量是有哪些.
print(avg.__code__.co_freevars) # 查看自由变量 ,元组类型 ('li',) li是一个字符串,
###总结: li 作为自由变量, 当外层函数(make_average)执行完毕之后,li变量会被保留.
#个人理解: li 为什么会被保留,程序编译完成,li和内部函数(make_average)已经建立一个引用关系,当程序执行外层函数(make_average)时,li变量和内部函数(average)的引用关系就激活.li还在被引用,即使外层函数(make_average)执行完毕了. li还会存在. li存在哪里呢? li还在make_average局部作用域中. ...概念比较抽象
