推导式
推导式:做一些有规律的数据结构
列表推导式：
1.普通循环
print([i for i in range(1,51)])
[加工后的变量 for 循环]
print([f "学习python{i}天" for i in range(1,51))
2.筛选模式
print([i for i in range(1,51) if i > 25])
print([i+j for i in range(2) for j in range(2)])
字典推导式
1.普通循环
{键：值 for 循环}
print({i:i+1 for i in range(3) if i > 1})
print(f"Python{i}":f"DAY{i+1}" for i in range(3)})
输出：{'Python0': 'DAY1', 'Python1': 'DAY2', 'Python2': 'DAY3'}
2.筛选模式
{加工后的变量：加工后的变量 for循环 加工条件}
print({i:i+1 for i in range(3) if i > 1})
集合推导式
1.普通循环
{变量 for 循环}
print({i for i in range(3)})
2.筛选模式
{加工后的变量 for循环 加工条件}
print({i for i in range(3) if i >2})
生成器推导式
1.普通模式
g = (i for i in range(3))
#print(next(g))
#print(next(g))
#print(next(g))
2.筛选模式
g = (i for i in range(3) if i+1 ==2)
#print(next(g))
#print(next(g))
推导式：简化代码，提供逼格，提高可读性
生成一些有规律的数据，生成的数据较大时建议使用生成器推导式
例子：找到S字符串中有几个e
普通写法：
s = "alex,meet"
for i in s:
if i=="e":
print(count)
count += 1
推导式写法：print([i for i in range(len(s)) if s[i] =="e"])
例子2 找到names中带e的
names = [['Tom', 'Billy', 'Jefferson', 'Andrew', 'Wesley', 'Steven', 'Joe'], ['Alice', 'Jill', 'Ana', 'Wendy', 'Jennifer', 'Sherry', 'Eva']]
普通写法：
for i in names:
for em in i:
if"e" in em:
print(em)
推导式写法：print([em for i in names for em in i if "e" in em])
匿名函数
-
匿名函数：一句话函数
-
匿名函数的名字叫做lambda
-
匿名函数的编写格式：
f = lambada a,b:a+b
# def func(a,b):
# c = a + b
# return c
# print(func(1,2))
lambda 和 def 是一样的 定义函数
a,b 和（a,b) 是一样的 形参
返回值 ：a+b 和 return a+b 是一样的
形参 :能接受位置参数，动态位置参数（*args），默认参数，动态关键字参数（**kwargs)，可以不写
返回值：只能返回一个数据，必须写，如果是多个数据需要带括号
f = lambda x,y:(x,y,x+y)
print(f(1,2)) 输出结果（1，2，3）
f = lambda x:(x[0],x[2]) 也可以索引
print(func("asdasdas"))
f = lambda x,y:x if x>y else y 后边也可以跟条件
print(f(3,122)) 结果122
g=(lambda i：i+1 for j in range(3)) 带括号的是生成器
print([em(3)for em in g]) [4,4,4] for j in range(3)创建三个生成器，for em in g循环三个生成器，传参3，结果是[4,4,4]
g=[lambda :i+1 for i in range(3)] for i in range(3) 创建三个lambda匿名函数，pirnt(g) 是三个匿名函数内存地址，存放在g这个列表中
print([em() for em in g]) [3,3,3] 循环每个lambda 由于创建完三个lambda,i的值停留最后一个，所以
i的值是2,故2+1 调用三次函数 结果[3,3,3]
高阶函数
filter() map() max() min() reversed() sorted() reduce() zip()
filter函数 过滤
语法: filter(function,iterable)
function: 用来筛选的函数,在filter中会自动的把iterable中的元素传递给function,然后根据function返回True或者False来判断是否保留此项数据
iterable:可迭代对象
模拟filter函数
lst = [1,2,3,4,6,45,34,25]
def foo(x) #规则函数
return x > 4 #判断是True和false
print(filter(foo,lst)) 得到的是filter对象
print(list(filter(foo,lst))) 得到的是[6, 45, 34, 25]
filter解析：for循环lst，源码中filter自动会循环传入的lst, 然后运行foo函数，返回x>4的值(判断返回值是否符合x>4，为True返回)
匿名函数的filter写法
lst = [1,2,3,4,54,65,7,8,]
print(list(filter(lambda x:x>4,lst))) 结果[54,65,7,8]
# lst = [{'id':1,'name':'alex','age':18},
# {'id':1,'name':'wusir','age':17},
# {'id':1,'name':'taibai','age':16},]
# def func(x):
# return x['age'] >= 17
# print(list(filter(func,lst)))
#print(list(filter(lambda x:x["age"]>=17,lst)))
#def func(a): #规则函数
return len(a["name"])<5 #过滤条件
print(list(filter(lambda a:len(a["name"])<5,lst)))
map 函数
map() 映射，将可迭代对象中每个元素执行函数功能
map函数就是将function应用于iterable的每一个元素
语法: map(function,iterable) 可以对可迭代对象中的每一个元素进映射,分别去执行function
lst1 = [1,2,3]
lst2 = [3,2,1]
lst3 = [3,2,1,5]
for i in range(len(lst1)):
print(lst1[i] + lst2[i])
def func(x,y,z):
return x+y+z
print(list(map(func,lst1,lst2,lst3))) 像lst3中5 没有的添加就不管
#print(list(map(lambda x,y,z:x+y+z,lst1,lst2,lst3))) 结果[7，6，5]
a=(1,2,3,4,5)
b=[1,2,3,4,5]
c="zhangkang"
la=list(map(str,a))
lb=list(map(str,b))
lc=list(map(str,c))
print(la)
print(lb)
print(lc)
输出：
['1', '2', '3', '4', '5']
['1', '2', '3', '4', '5']
['z', 'h', 'a', 'n', 'g', 'k', 'a', 'n', 'g']
str()是python的内置函数，这个例子是把列表/元组/字符串的每个元素变成了str类型，然后以列表的形式返回。当然我们也可以传入自定义的函数，看下面的例子。
sort函数
语法:sorted(iterable,key=None,reverse=False)
iterable : 可迭代对象
key: 排序规则(排序函数),在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数.根据函数运算的结果进行排序
reverse :是否是倒序,True 倒序 False 正序
lst = [1,3,2,5,4]
lst2 = sorted(lst)
print(lst) #原列表不会改变
print(lst2) #返回的新列表是经过排序的
lst3 = sorted(lst,reverse=True)
print(lst3) #倒序
字典使用sorted排序
dic = {1:'a',3:'c',2:'b'}
print(sorted(dic)) # 字典排序返回的就是排序后的key
结果:
[1,2,3]
和函数组合使用
# 定义一个列表,然后根据一元素的长度排序
lst = ['天龙八部','西游记','红楼梦','三国演义']
# 计算字符串的长度
def func(s):
return len(s)
print(sorted(lst,key=func))
# 结果:
# ['西游记', '红楼梦', '天龙八部', '三国演义']
和lambda组合使用
lst = ['天龙八部','西游记','红楼梦','三国演义']
print(sorted(lst,key=lambda s:len(s)))
结果:
['西游记', '红楼梦', '天龙八部', '三国演义']
例子：# 按照年龄对学生信息进行排序
lst = [{'id':1,'name':'alex','age':18},
{'id':2,'name':'wusir','age':17},
{'id':3,'name':'taibai','age':16},]
print(sorted(lst,key=lambda x:x['age'],reverse=True))
结果[{'id': 1, 'name': 'alex', 'age': 18}, {'id': 2, 'name': 'wusir', 'age': 17}, {'id': 3, 'name': 'taibai', 'age': 16}] 按照年龄 降序排列
# print(sorted(lst,key=lambda x:x["age"])) 正序排列
min()和max()函数 最小值 最大值
print(max([1,2,3,4,5,6,-9,10,-22],key=abs)) 最大值
print(min([1,2,3,4,5,6,-9,10,-22])) 最小值
dic = {'a':3,'b':2,'c':1}
print(max(dic.values())) 结果 3
dic={"a":3,"b":2,"c":1}
print(max(dic,key=lambda x:dic[x])) 结果a
reduce函数 阶乘
from functools import reduce
def func(x,y):
return x + y
# reduce 的使用方式:
# reduce(函数名,可迭代对象) # 这两个参数必须都要有,缺一个不行
ret = reduce(func,[3,4,5,6,7])
print(ret) # 结果 25
reduce的作用是先把列表中的前俩个元素取出计算出一个值然后临时保存着,
接下来用这个临时保存的值和列表中第三个元素进行计算,求出一个新的值将最开始
临时保存的值覆盖掉,然后在用这个新的临时值和列表中第四个元素计算.依次类推
就是3和4当x和y 算完之后return的值，再次当作x，而y是列表中的5,在执行函数，然后在拿算完的return出来的值当作x和下一个6继续执行函数，依次类推
注意:我们放进去的可迭代对象没有更改
以上这个例子我们使用sum就可以完全的实现了.我现在有[1,2,3,4]想让列表中的数变成1234,就要用到reduce了.
普通函数版
from functools import reduce
def func(x,y):
return x * 10 + y
# 第一次的时候 x是1 y是2 x乘以10就是10,然后加上y也就是2最终结果是12然后临时存储起来了
# 第二次的时候x是临时存储的值12 x乘以10就是 120 然后加上y也就是3最终结果是123临时存储起来了
# 第三次的时候x是临时存储的值123 x乘以10就是 1230 然后加上y也就是4最终结果是1234然后返回了
l = reduce(func,[1,2,3,4])
print(l)
匿名函数版
l = reduce(lambda x,y:x*10+y,[1,2,3,4])
print(l)
print函数
# print("alex","wusir","太亮",sep=" ",end=" ") sep以什么分割 end 默认换行
# print("meet")
# f = open("a","a",encoding="utf-8")
# print("meet",file=f)
zip函数 拉链
zip() 拉链方法。函数用于将可迭代的对象作为参数,将对象中对应的元素打包成一个个元组,
然后返回由这些元祖组成的内容,如果各个迭代器的元素个数不一致,则按照长度最短的返回
# lst1 = [1,2,3,4,5]
# lst2 = [5,4,3,2,1]
print(dict(map(lambda x,y:(x,y),lst1,lst2)))
print(dict(zip(lst1,lst2))) {1: 5, 2: 4, 3: 3, 4: 2, 5: 1}
print(list(map(lambda x,y:(x,y),lst1,lst2))) [(1, 5), (2, 4), (3, 3), (4, 2), (5, 1)]