python_0基础开始_day13

发布时间：2020-12-20 10:55:21 所属栏目：Python 来源：网络整理

导读：第十三节一，匿名函数匿名函数 == 一行函数 lambda == def == 关键字函数体中存放的是代码生成器体中存放的也是代码就是yield导致函数和生成器的结果不统一 lambda x: x # x，可以不写是普通函数的形参，可以不接受参数 # :后边是返回值，x必须写是普

第十三节

一，匿名函数

匿名函数 == 一行函数

lambda == def == 关键字

函数体中存放的是代码
生成器体中存放的也是代码
就是yield导致函数和生成器的结果不统一

lambda x:x
# x，可以不写是普通函数的形参，可以不接受参数
# :后边是返回值，x必须写 是普通函数的函数值 (lambda只能返回一个数据类型)
print(lambda x:x)
print((lambda x:x+6)(5))
?
f = lambda x:x+6(5)
print(f.__name__)# 查看函数名字 ? lambda
?
f1 = lambda x,y,z,:(x,z) # :返回值必须是一个数据类型
print(f(1,2,3))# 输出一个元组(1,2,3)
?
print([lambda :5][0]())
print((lambda :5)())
a = lambda :5
a()
# 返回 5 5 ?
?
lst = [lambda :i for i in range(5)]
print(lst[1]) # 返回的是索引1的函数内存地址
print(lst[0]()) # 调用函数，返回值，返回的是i最后一次循环所赋值

lst = [] # [lambda x:x+1,lambda x:x+1]
for i in range(2):
 ? ?lst.append(lambda x:x+1)
print(lst[-1](5)) # 输出6， lambda 5:5+1
?
lst = [lambda x:x+1 for i in range(5)] # 同上一个
print(lst[0](5))# 输出6， lambda 5:5+1 
?
tu = (lambda :i for i in range(3)) # 生成器
print(next(tu)) # 没调用，就是返回函数地址
print(next(tu)()) # 记录上一次查看的位置，输出 1

# 面试题拆解:
lst = []　
for i in range(5):
 ? ?def func():
 ? ? ? ?return i
 ? ?lst.append(func) #　lst 里面放了5个func函数的地址
print(lst[1]) # 输出的是函数地址
print(lst[1]()) # 调用函数，返回的是i最后一次循环

def func():
 ? ?for i in range(3): ?# i = 0 1 2
 ? ? ? ?def foo(): ? ? ?# foo1 foo2 foo3
 ? ? ? ? ? ?return i
 ? ? ? ?yield foo ? ? ? # foo1 foo2 foo3
g = func()
print(next(g)()) ?# foo1 返回的是值
print(next(g)()) ?# foo2
print(next(g)) ?# foo3 返回的是地址，没有调用
------------------------------------------------------
lst = [lambda :i for i in range(3)] # lst中有三个lambda : i
print(lst[0]()) # 取的是最后一次i循环的值
-----------------------------------------------------
tu = (lambda : i for i in range(3)) # 生成器是把循环的每次值 都存放在一个地址中
print(next(tu)())
print(next(tu)()) ?# 每次都是yield 逐个提取
print(next(tu)())

lst = [lambda x:x+5 for i in range(2)]
# lst = [lambda x:x+5,lambda x:x+5]
print([i(2) for i in lst]) # x = 2,
# 返回结果 [7,7]
# 以下为分解式子
lst = [] # [lambda x:x+5,lambda x:x+5]
for i in range(2):
 ? ?lst.append(lambda x:x+5)
new_lst = []
for i in lst:
 ? ?new_lst.append(i(2))
print(new_lst)
---------------------------------------------------
lst = (lambda x:x+5 for i in range(2))
print(i(2) for i in lst) # 是一个内存地址
print([i(2) for i in lst]) # 是列表的两个值，[7，7]
# 以下是分解
def func():
 ? ?for i in range(2):
 ? ? ? ?f = lambda x: x + 5
 ? ? ? ?yield f
g = func()
lst = []
for i in g:
 ? ?lst.append(i(2))
print(lst)

lst = [lambda x:x*i for i in range(2)]
print([i(2) for i in lst]) ?#[2,2]
# 以下为分解式
lst = [] # [lambda x:x*i,lambda x:x*i]
for i in range(2):
 ? ?lst.append(lambda x:x*i)
# print(i)
new_lst = []
for em in lst:
 ? ?new_lst.append(em(2))
print(new_lst)

lst = (lambda x:x*i for i in range(2))# 这是一个生成器
print([i(2) for i in lst]) ?#[0,2] # i为0的时候存储一次，i为1的时候存储一次
# 分解
def func():
 ? ?for i in range(2):
 ? ? ? ?f = lambda x:x*i
 ? ? ? ?yield f
g = func()
lst = []
for i in g:
 ? ?lst.append(i(2))
print(lst)

func = lambda x:[i for i in x]
print(func(‘afafasd‘))
# 将字符串转换列表[‘a‘,‘f‘,‘a‘,‘s‘,‘d‘]
print(list(‘afafasd‘))

二，内置函数Ⅱ

sep ：每一个元素之间分割的方法默认 " "
```
print(1,3,sep="|")# 1|2|3
```
end ： print执行完后的结束语句，默认n
```
print(1,end="")
print(4,5,6,end="") # 1 2 34 5 6
```

file ：文件句柄，默认显示到屏幕

print(1,4,file=open("test","w",encoding="utf-8"))

flush 刷新
sum ：求和，可迭代对象容器,容器的元素必须是数字
```
print(sum([1,1]))
print(sum([10,20,30,40],100))# 设置初始值
```
abs ：绝对值
```
print(abs(-9))
```
dir ：查看当前对象的所有方法
```
print(dir(str))
```

zip ：拉链，当长度不一致时选择最短的进行合并

lst1 = [1,5]
lst2=["alex","wusir","元"]
print(list(zip(lst1,lst2))) # 拉链
# 面试题:
print(dict(zip(lst1,lst2)))
# {1: ‘alex‘,2: ‘wusir‘,3: ‘宝元‘}

format ：格式转换

print(format("alex",">20")) ?# 右对齐
print(format("alex","<20")) ?# 左对齐
print(format("alex","^20")) ?# 居中
# 进制转换:
# 将十进制转换成二进制 bin
print(format(12,"b"))
print(format(12,"08b"))
?
# 将十进制转换成八进制 ? oct
print(format(12,"o"))
print(format(12,"08o"))
?
#　将二进制转换成十进制 ? digit
print(format(0b11001,"d"))
?
# 将十进制转换成十六进制 ? hex
print(format(17,"x"))
print(format(17,"08x"))

reversed ：反转

print(list(reversed("alex")))
# [‘x‘,‘e‘,‘l‘,‘a‘]
print(list(reversed([1,5])))
# [5,4,3,1]

filter ：过滤，1,指定过滤规则(函数名[函数的内存地址]) 2,要过滤的数据

lst = [1,6]
print(list(filter(lambda x:x>1,lst)))
# 分解
def func(a):
 ? ?return a>1
print(list(filter(func,lst)))
-------------------------------------------------
# 底层代码
lst = [1,6]
def f(func,args):
 ? ?new_lst = []
 ? ?for i in args:
 ? ? ? ?if func(i):
 ? ? ? ? ? ?new_lst.append(i)
 ? ?return new_lst
def func(a):
 ? ?return a>1
print(f(func,lst)) # [2,5,6]
# fiter写法
print(list(filter(lambda x:x>2,[1,5])))

lst = [{‘id‘:1,‘name‘:‘alex‘,‘age‘:18},
 ? ? ? {‘id‘:1,‘name‘:‘wusir‘,‘age‘:17},‘name‘:‘taibai‘,‘age‘:16},]
# 筛选年龄大于16岁的
print(list(filter(lambda x:x[‘age‘]>16,lst)))
--------------------------------------------------
def func(a):
 ? ?return a>1
print(list(filter(func,5])))
print(list(filter(lambda a:a>1,5])))

map ：映射函数（将每个元素都执行了执行的方法）

print([i*8 for i in [1,4]])
#[8,16,24,32]
-----------------------------------------------------------
lst = []
for i in [1,-22,6]:
 ? ?lst.append(abs(i))
lst.sort()
print(lst)# [1,6,22]
------------------------------------------------------------
def map(argv,args):
 ? ?lst = []
 ? ?num = len(args) if len(args) < len(argv) else len(argv)
 ? ?for i in range(num):
 ? ? ? ?lst.append(argv[i] + args[i])
 ? ?return lst
print(map([1,4],[3,7,8,9,0]))
print(list(map(lambda x,y:x+y,5],[33,22,44,55])))
# [4,8,10]

sorted ：排序

print(sorted([1,6],reverse=True))
print(sorted([1,-6],reverse=True,key=abs))
lst = ["三国演义","红楼梦","铁道游击队","西游记","水浒传","活着"]
print(sorted(lst,key=len))
# [6,1]
# [-6,1]
# [‘活着‘,‘红楼梦‘,‘西游记‘,‘水浒传‘,‘三国演义‘,‘铁道游击队‘]
-----------------------------------------------------------------
print(sorted([1,key=abs)) ?# key指定排序规则
#[1,-22]
------------------------------------------------------------------
lst = [{"age":19},{"age1":20},{"age2":80},{"age3":10}]
print(sorted(lst,key=lambda x:list(x.values()))) # 值排序
print(sorted(lst,key=lambda x:list(x.keys()),reverse=True)) # 键排序

max ：最大值

min ：最小值

print(max(10,12,13,15,16))
print(max([10,-16],key=abs))
# 16 ? -16

reduce ：累计算

from functools import reduce

# 从 functools工具箱中拿来了reduce工具
from functools import reduce
def func(x,y):
 ? ?return x+y
print(reduce(func,5]))
print(reduce(lambda x,5]))
# 15 15 ?

三，闭包

什么是闭包？

在嵌套函数内，使用非本层变量和非全局变量就是闭包
闭包的作用：

1，保护数据的安全性。2，装饰器
__colsure__查看是是否为闭包

函数执行完后，函数体内文件自动销毁

例一：
def wrapper():
 ? ?a = 1
 ? ?def inner():
 ? ? ? ?print(a)
 ? ?return inner
ret = wrapper() # 闭包
例二：
a = 2
def wrapper():
 ? ?def inner():
 ? ? ? ?print(a)
 ? ?return inner
ret = wrapper() # 不是
例三：
def wrapper(a,b):
 ? ?def inner():
 ? ? ? ?print(a)
 ? ? ? ?print(b)
 ? ?inner()
a = 1
b = 2
wrapper(a，b)

（编辑：李大同）

【声明】本站内容均来自网络，其相关言论仅代表作者个人观点，不代表本站立场。若无意侵犯到您的权利，请及时与联系站长删除相关内容!