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'))) # 字符串 会被迭代 还是字符串

#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))) #

# 迭代循环取值

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) # 返回成一个迭代器

print(list(ls),type(ls) ,dir(ls)) # '__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局部作用域中. ...概念比较抽象