1、 zip()，打包函数，当两边元素数量不相同时，多的一边不会显示多余的值，会和少的一边形成映射的关系。
l1 = [1,2,3,4]
l2 = [1,2,3,4,5,6,7]
# zip函数生成的是一个迭代器
for i in zip(l1,l2): # l1限制l2，l2从属于l1
print(i)也可以使用zip进行解包操作
v = [(1,a),(2,b),(3,c)]
print(zip(*v))
>>> [(1,2,3),(a,b,c)]
2、enumerate()函数，使目标变成可迭代的对象，枚举型
l1 = [1,2,3,4]
for i in enumerate(l1):
print(i)
>>>(0,1),(1,2),(2,3),(3,4)3、eval()函数：把字符串的表达式运算出来
num = '1+2'
print(eval(num))
>>> 3把字符串中的数据结构提取出来(文件里面写的是字典格式，但是读出来确是字符串，这时候用eval)
num = "{'1':'2'}"
print(type(num))
print(type(eval(num)))
>>><class 'str'>
<class 'dict'>4、匿名函数：lambda ,通过声明一个变量来调用匿名函数
res = lambda x:x+1 # x是形参，x+1是返回值
print(res(2))
>>>3返回多个值需要自己加括号变成元组,否则报错
res = lambda x,y,z:(x+1,y+2,z+3)
print(res(2,1,0))
>>>(3,3,3)主要是配合其他高阶函数的使用：
min() max() sorted() 等其他高阶函数都可以穿key(用来规定的lambda)
l1 = [-4,-5,3,6,5]
# 输出列表绝对值最小的原素
print(min(l1, key=lambda x: abs(x)))
# 输出列表绝对值最大的原素
print(max(l1, key=lambda x: abs(x)))
# 按照列表元素绝对值排序
print(sorted(l1, key=lambda x:abs(x)))5、format()函数：格式化输出的函数
# '{}' 是一个占位符，无特殊指定时，按顺序依次赋值
x = '{} is {}'.format('3', 'int')
print(x)
>>> 3 is int
# :d 代表十进制整数 :s 代表字符串
x = '{:d} is int'.format(3,'int')
print(x)
>>> 3 is int
# 可以传一个字典
x = '{k1},{k2}'.format(k1 = 1,k2 = 2)
print(x)
>>> 1,2
# 传两个列表相当于先组合成为一个元组
x = '{0[1]},{1[1]}'.format([1,2,3],[4,5,6])
print(x)
>>> 2,5
# ** 代表传的一个字典
x = '{k1},{k2}'.format(**{'k2':52,'k1':23})
print(x)
>>>23,52
# * 代表传的一个列表
x = '{1}'.format(*[1,2,3])
print(x)
>>> 26、普通的格式化输出
x = '%d is int' %(3)
print(x)
# 传字典，是冒号而不是等号
x = '%(name)s is %(age)s' %{'name':'Jax','age':'15' }
print(x)7、可变长参数：*args接受多余的值，组成元组。当传一个列表时，前面加*则为元组，没有就是一个元组里嵌套列表。 **kwargs 接受多余的赋值传参，组成一个字典，前面加**则为字典，没有则按照*args处理 。
def test(k,*args,**kwargs):
print(k,args,kwargs)
return None
test(1,2,3,x=5,y=6 )
>>>1 (2,3) {'x':5,'y':6}
def test(*args,**kwargs):
print(args,kwargs)
return None
test(*[1,2,3],*{'name':'Jax','age':'18'})
>>> (1,2,3,'name','age') {}
def test(*args,**kwargs):
print(args,kwargs)
return None
test([1,2,3],{'name':'Jax','age':'18'})
>>>([1,2,3],{'name':'Jax','age':'18'}) {}8、高阶函数:1、把函数当作参数传给另外的一个函数 2、返回值中包含函数
def test1():
def test2():
def test3():
print('ok')
return test3
return test2 # 返回的函数地址
test1()()() # 加'()'相当于运行函数9、map函数:处理序列中的每个元素，得到结果是一个可迭代的对象，不会改变该列表
返回结果过是可迭代的，一般转换为列表,map(func,list) func:函数功能/函数名(可以不用写lambda),可以重新定义函数def list:可迭代对象。
l1 = [1,2,3,4,5,6]
print(map(lambda x:x+1,l1)) # 如果是判断则会返回布尔值
print(list(map(lambda x:x+1,l1)))
print(l1)
>>> <map object at 0x000001E805D1B278>
>>> [2, 3, 4, 5, 6, 7]
>>> [1, 2, 3, 4, 5, 6]10、filter函数: 过滤函数 遍历每个元素，判断得到布尔值，如果是True就保留，得到一个可迭代对象
filter(func,list) func:函数功能/函数名(可以不用写lambda) list:可迭代对象
l1 = [1,2,3,4,5,6]
print(filter(lambda x:x<3,l1))
print(list(filter(lambda x:x<3,l1)))
print(l1)
>>> <filter object at 0x0000014E51B4B278>
[1, 2]
[1, 2, 3, 4, 5, 6]11、reduce函数: 处理一个序列然后合并,需要导入模块 from functools import reduce
reduce(func,list,init) func:函数功能/函数名(可以不用写lambda) list:可迭代对象, init默认累计器
from functools import reduce
l1 = [1,2,3,4,5,6]
# 需要两个参数，最后的参数是默认起始值
print(reduce(lambda x,y:x+y,l1,2))
>>> 2312、with后面可以打开多个文件
with open('1.txt','r',encoding='utf8') as f,open('2.txt','w',encoding='utf8') as fp:
f.read()
fp.read()13、 通过字符串的方式调用模块: __import__()
14、字典
dic = {'name': 'Jax', 'age': '19', 'gender': 'male'}
print(dic.keys()) # 取键
print(dic.items()) # 取键值对，每一对组成元组返回
print(dic.values()) # 取值
print(dic.get('name')) # 获取相应的元素，不存在返回none
print(dic["key"]) # 获取相应的值,不存在时会报错
>>> dict_keys(['name', 'age', 'gender'])
>>> dict_items([('name', 'Jax'), ('age', '19'), ('gender', 'male')])
>>> dict_values(['Jax', '19', 'male'])
>>> Jax
# 设置默认值，存在，不设置，或取当前key对应的值。不存在，设置，或取当前key对应的值
dic.setdefault('mingzi','Yi') # setdefault('key','values') 用于添加
print(dic)
>>> {'name': 'Jax', 'age': '19', 'gender': 'male', 'mingzi': 'Yi'}
# 元组可以作为key，而列表不可以。(因为列表可以修改，不可以哈希)
dic = {'name': 'Jax', (1,2,3): '19', 'gender': 'male'}
print(dic.get((1,2,3)))
>>> 19
# dict.fromkeys()快速生成字典，传普通参数生成值为空的字典
print(dict.fromkeys([1,2,3,4,5,6],[7,8,9])) # 最多传两个参数
>>> {1: [7, 8, 9], 2: [7, 8, 9], 3: [7, 8, 9], 4: [7, 8, 9], 5: [7, 8, 9], 6: [7, 8, 9]}15、集合：可变。 由元组，数字，字符串组成。无序排列。
用frozenset()就是不可变集合
s1 = {1,2,3,4}
a = frozenset(s1)
print(type(a))
>>> <class 'frozenset'> # 不可变集合
s1 = {1,2,3,4,5,6}
s2 = {4,5,6,7,8,9}
# 集合的并集，写符号或字母都可以
print(s1|s2) # print(s1.union(s2))
# 集合的交集
print(s1&s2) # print(s1.intersection(s2))
# 集合的差集
print(s1-s2) # print(s1.difference(s2))
# 集合的交叉补集
print(s1^s2) # print(s1.symmetric_difference(s2))
# 删除元素
s1.discard(1)
print(s1)
# 添加元素
s1.add(7)
print(s1)
>>> {1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> {4, 5, 6}
>>> {1, 2, 3}
>>> {1, 2, 3, 7, 8, 9}
>>> {2, 3, 4, 5, 6}
>>> {1, 2, 3, 4, 5, 6, 7}16、chr()将数值转换为对应的ascll码
print(chr(97))17、ord()将ascll码转换为对应的数值
print(ord('a'))18、pow()计算数值次方
print(pow(2,3)) # 计算2的3次方
>>> 8
print(pow(2,3,3)) # 计算2的3次方然后再取余
>>> 2
19、偏函数
from functools import partial
def func(a1,a2):
print(a1,a2)
# 函数名,参数
new_func = partial(func,999) # 这里传递的参数相当于a1=999， 如果这里写的是位置参数，则下面必须写位置参数
new_func(666) # a2 = 666偏函数的返回值的类型是一个function
from flask.globals import _request_ctx_stack
from functools import partial
def _lookup_req_object(name):
top = _request_ctx_stack.top
if top is None:
raise RuntimeError("")
return getattr(top, name)
class Foo:
def __init__(self):
self.xxx = 123
print(partial(_lookup_req_object,"xxx"))
>>> functools.partial(<function _lookup_req_object at 0x000001E037FB3E18>, 'xxx') # 返回一个函数20、拼接(不一定必须是函数，也可以是其他类型的参数)
from itertools import chain
def f1():
print("***")
def f2():
print(321)
func_list = [f1,lambda x:x+1]
new_func_list = chain([f2], func_list) # 会将所有的参数组成一个链，两个参数都必须是可迭代类型的
for i in new_func_list:
print(i)21、all()函数
只有当里面的元素全为真才返回True。
p1 = [True,True]
p2 = [True, False]
print(all(p1))
print(all(p2))
>>> True
>>> False需要注意的是 ‘ [] ’ 在all函数里面当作真值处理，如果要想当成False处理就[None] 。
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
