python基礎 ---lambda函數和常用內建函數

lambda函數

(1)lambda函數也叫匿名函數，單行函數，也叫lambda表達式
(2)匿名函數就是沒有名字的函數，沒有def function_name()這個格式的定義

常規函數向lambda函數的轉換

#常規函數
def add(x, y):
	return x + y

#lambda函數	
lambda x,y: x+y

再舉個栗子

#常規函數
def list_init():
	L1 = []
	for i in range(10):
		L1.append(i)
	
#lambda函數
L1 = ((lambda *args: [x for x in args])(*range(10))) #列表生成

lambda函數的應用範圍很廣，排序，對象生成，過濾等函數都會用到lambda函數

#容器生成
(lambda *args: (x for x in args))(*range(10)) #生成器
(lambda *args: [x+1 for x in args])(*range(10)) #生成列表
(lambda *args: {str(x): x+1 for x in args})(*range(10)) #生成字典
(lambda *args: [(x,x+1) for x in args])(*range(10)) #只包含元組的列表,注意元組要加上小括號
(lambda *args: {x%2 for x in args})(range(16))  #只包含偶數的集合

排序sorted

sorted(iterable, *, key=None, reverse=False) --> list #會生成新的列表

#對於列表排序，直接調用sorted函數即可
L1 = [1,3,-12,9,34,2,5]
sorted(L1, reverse=False) #會返回排序後的列表

L3.sort(reverse=False) #會排序L3，但是無返回，或者說是返回None

#字典排序，默認按照字典的key排序
d1 = {1:'aaa', 2:(1,2), 5:['haoba'], -3:2}
sorted(d1, key=None, reverse=False) #不會返回排序後的key的列表

過濾filter

filter(function, iterable)
對可迭代對象進行遍歷，返回一個迭代器
function參數是一個參數函數，且返回值應當是bool類型，或其返回值等效布爾值。
function參數如果是None，可迭代對象的每一個元素自身等效布爾值

print(list(filter(lambda x: x%3==0, [1,9,55,150,-3,78,28,123]))) #只有x%3 == 0的才輸出，其他的都被過濾
print(list(filter(lambda x:x%3, [1,9,55,150,-3,78,28,123]))) #注意與上面的區別，這個是過濾掉能被3整除的數值
print(list(filter(None, range(5)))) #默認情況下，值爲布爾假的元素都會被過濾掉
print(list(filter(None, range(-5, 5)))) #同上
[9, 150, -3, 78, 123]
[1, 2, 3, 4]
[-5, -4, -3, -2, -1, 1, 2, 3, 4]

映射map

定義 map(function, *iterables) -> map object
對多個可迭代對象的元素，按照指定的函數進行映射
返回一個迭代器

print(list(map(lambda x: 2*x+1, range(10)))) #注意lambda表達式
print(dict(map(lambda x: (x%5, x), range(500))))
print(dict(map(lambda x,y: (x,y), 'abcde', range(10)))) #兩個可迭代對象分別映射至lambda表達式的x和y變量
[1, 3, 5, 7, 9, 11, 13, 15, 17, 19]
{0: 495, 1: 496, 2: 497, 3: 498, 4: 499}
{'a': 0, 'b': 1, 'c': 2, 'd': 3, 'e': 4}

拉鍊函數zip

zip(*iterables) 
像拉鍊一樣，把多個可迭代對象合併在一起，返回一個迭代器
將每次從不同對象中取到的元素合併成一個元組

print(tuple(zip(range(5),range(5),range(5))))
print(list(zip(range(5),range(5),range(5))))
print(tuple(zip(range(5), range(3), range(5))))
((0, 0, 0), (1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)) #元組和列表的差別
[(0, 0, 0), (1, 1, 1), (2, 2, 2), (3, 3, 3), (4, 4, 4)]
((0, 0, 0), (1, 1, 1), (2, 2, 2)) #zip函數具有木桶原則，根據元素少的來組合

print(dict(zip(range(10),range(10))))
print(dict(zip(range(5), range(3)))) #同樣具有木桶原則
print({str(x):y for x,y in zip(range(10),range(10))})
{0: 0, 1: 1, 2: 2, 3: 3, 4: 4, 5: 5, 6: 6, 7: 7, 8: 8, 9: 9}
{0: 0, 1: 1, 2: 2}
{'0': 0, '1': 1, '2': 2, '3': 3, '4': 4, '5': 5, '6': 6, '7': 7, '8': 8, '9': 9}

lambda函數配合其他函數

print(dict(map(lambda x: (chr(65+x), 10-x), range(5))))  #  高階函數，構建字典
d = dict(map(lambda x: (chr(65+x), 10-x), range(5)))     # 高階函數
sorted(d.items(), key=lambda x:x[1])