python之zip、map、enumerate、lambda函数

1. zip函数常见用法

L1=[1,2,3,4,5]
L2=[6,7,8,9,10]
#创建元组对，是可迭代对象
zip(L1,L2)       #result:<zip at 0x9f46f48>
#需要调用list函数，来显示元组对
list(zip(L1,L2))  #result: [(1, 6), (2, 7), (3, 8), (4, 9), (5, 10)]


#可接受任何类型的可迭代对象，且可以有两个以上的参数，当参数长度不同时，以最小长度为准截断所得元组
list(zip('abc','1234','ABCDEF')) #result: [('a', '1', 'A'), ('b', '2', 'B'), ('c', '3', 'C')]

#并行迭代
for i,j in zip(L1,L2):
    print(i,'+',j,'=',i+j)
"""
result:
1 + 6 = 7
2 + 7 = 9
3 + 8 = 11
4 + 9 = 13
5 + 10 = 15
"""

#使用zip构造字典
keys=['names','sex','age','id']
vals=['lizihua','woman',23,27]
D=dict(zip(keys,vals))
#result:  {'age': 23, 'id': 27, 'names': 'lizihua', 'sex': 'woman'}

2. map函数常见用法

#map(func,seq)函数对一个序列中的每个元素作为函数func的参数，
#并返回一个包含所有函数调用结果的一个列表，与zip函数一样，需要调用list函数来显示结果

list(map(int,'12345'))  #reslut: [1, 2, 3, 4, 5]
list(map(lambda x:x+3,range(1,6)))  #reslut:[4, 5, 6, 7, 8]

#提供多个序列作为参数，能够并行返回以每个序列中的元素作为函数对应参数得到的结果的列表
list(map(pow,[1,2,3],[2,3,4]))  #reslut:[1, 8, 81]

#当参数长度不同时，以最小长度为准截断
list(map(pow,[1,2,3,4],[2,3,4]))   #reslut:[1, 8, 81]

3. enumerate函数常见用法

#当需要同时获取序列的元素以及该元素的偏移值时，可以使用enumerate函数
S='spam'
for (offset,item) in enumerate(S):
    print(item,'appears at offset',offset)
"""
result:
s appears at offset 0
p appears at offset 1
a appears at offset 2
m appears at offset 3
"""

#需要调用list函数，来显示元组对(offset,item)
list(enumerate(S))  #result: [(0, 's'), (1, 'p'), (2, 'a'), (3, 'm')]

#next 函数
E=enumerate(S)
next(E)  #result:(0, 's')
next(E)  #result:(1, 'p')
next(E)  #result:(2, 'a')

#在列表解析中使用
[c*i for (i,c) in enumerate(S)]    #result: ['', 'p', 'aa', 'mmm']

4. lambda函数常见用法

f=lambda x,y,z:z+y+z
f(2,3,4)       #result:11
#默认参数也能在lambda参数中使用
x=(lambda a="fee",b="fie",c="foe":a+b+c)
x("haha")       #result:'hahafiefoe'

#lambda 用来编写跳转表（行为的列表或字典，能够按照需要执行相应的动作）
#行为列表
L=[lambda x:x**2,
   lambda x:x**3,
   lambda x:x**4]
for f in L:
        print(f(2))   #result:4,8,16
print(L[0](3))        #L[0]:lambda x:x**2 ,result:9

#字典列表
key='got'
{'already':(lambda:2+2),'got':(lambda:2*4),'one':(lambda:2**6)}[key]()  #result:8

#lambda嵌套
action=(lambda x:(lambda y:x+y))
act=action(99)
print(act(3))                #result:102
#或print(action(99)(3)) 
"""
等效于：
def action(x):
    return (lambda y:x+y)    #记住x,并返回函数
act=action(99)
print(act(3))      #result:102
"""