匿名函數,經常使用內置函數

匿名函數

語法
lambda 形參:表達式至關與函數返回值

匿名函數一般不會單獨使用,是配合內置函數一塊兒使用

# 匿名函數：
# 1.匿名函數沒有函數名
# 2.匿名函數的關鍵字採用lambda
# 3.關鍵字 lambda 與標識函數功能體 : 之間必定是參數，因此省略()
# 4.匿名函數沒有函數體，只有返回值，因此函數體和返回值的return關鍵字都省略了

# 注意：
# 1.參數的使用和有名函數同樣，六種形參都支持
# 2.返回值必須明確成一個值，能夠爲單個值對象，也能夠爲一個容器對象
用匿名函數有個好處，由於函數沒有名字，沒必要擔憂函數名衝突。匿名函數也是一個函數對象，也能夠把匿名函數賦值給一個變量，再利用變量來調用該函數,不將匿名函數賦值給變量用完就會被垃圾回收機制回收

a = lambda *args, **kwargs: '返回值1', '返回值2'
print(a)  # (<function <lambda> at 0x0000022D0B7E88C8>, '返回值2')

print(a[0]())  # 返回值1

經常使用的內置函數

max

內部是基於for循環的計較元素大小得出最大值

max結合匿名函數工做原理

#max(iter, lambda x: x)

# 1.max內部會遍歷iter，將遍歷結果一一傳給lambda的參數x
# 2.依據lambda的返回值做爲比較條件，獲得最大條件下的那個遍歷值
# 3.對外返回最大的遍歷值

min()原理工做原理和max()同樣，獲得的是最小值

map()

描述
map() 會根據提供的函數對指定序列作映射。

map() 函數語法：

map(function, iterable, ...)

參數
function -- 函數
iterable -- 一個或多個序列
第一個參數 function 以參數序列中的每個元素調用 function 函數，返回包含每次 function 函數返回值的新列表。

返回值
Python 2.x 返回列表

Python 3.x 返回迭代器


>>>def square(x) :            # 計算平方數
...     return x ** 2
... 
>>> map(square, [1,2,3,4,5])   # 計算列表各個元素的平方
[1, 4, 9, 16, 25]
>>> map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函數
[1, 4, 9, 16, 25]
 
# 提供了兩個列表，對相同位置的列表數據進行相加
>>> map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10])
[3, 7, 11, 15, 19]

 

zip()

函數用於將可迭代的對象做爲參數，將對象中對應的元素打包成一個個元組，而後返回由這些元組組成的列表。

若是各個迭代器的元素個數不一致，則返回列表長度與最短的對象相同，利用 * 號操做符，能夠將元組解壓爲列表。

zip 方法在 Python 2 和 Python 3 中的不一樣：在 Python 3.x 中爲了減小內存，zip() 返回的是一個對象。如需展現列表，需手動 list() 轉換。

zip 語法：

# zip([iterable, ...])   

iterabl -- 一個或多個迭代器;
返回元組列表

>>>a = [1,2,3]
>>> b = [4,5,6]
>>> c = [4,5,6,7,8]
>>> zipped = zip(a,b)     # 打包爲元組的列表
[(1, 4), (2, 5), (3, 6)]
>>> zip(a,c)              # 元素個數與最短的列表一致
[(1, 4), (2, 5), (3, 6)]
>>> zip(*zipped)          # 與 zip 相反，*zipped 可理解爲解壓，返回二維矩陣式
[(1, 2, 3), (4, 5, 6)]

filter()

描述
filter() 函數用於過濾序列，過濾掉不符合條件的元素，返回由符合條件元素組成的新列表。

該接收兩個參數，第一個爲函數，第二個爲序列，序列的每一個元素做爲參數傳遞給函數進行判，而後返回 True 或 False，最後將返回 True 的元素放到新列表中。

注意: Pyhton2.7 返回列表，Python3.x 返回迭代器對象，具體內容能夠查看：Python3 filter() 函數

filter() 方法的語法:

filter(function, iterable)
參數
function -- 判斷函數。
iterable -- 可迭代對象
返回值:返回列表

過濾出列表中的全部奇數：
def is_odd(n):
    return n % 2 == 1
 
newlist = filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10])
print(newlist)     #輸出結果 ：[1, 3, 5, 7, 9]

過濾出1~100中平方根是整數的數：
import math
def is_sqr(x):
    return math.sqrt(x) % 1 == 0
 
newlist = filter(is_sqr, range(1, 101))
print(newlist)
#輸出結果 :[1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

sorted()

sorted() 函數對全部可迭代的對象進行排序操做。

sort 與 sorted 區別：

sort 是應用在 list 上的方法，sorted 能夠對全部可迭代的對象進行排序操做。

list 的 sort 方法返回的是對已經存在的列表進行操做，無返回值，而內建函數 sorted 方法返回的是一個新的 list，而不是在原來的基礎上進行的操做。

sorted 語法：
sorted(iterable, cmp, key, reverse)

參數說明：
iterable -- 可迭代對象。
cmp -- 比較的函數，這個具備兩個參數，參數的值都是從可迭代對象中取出，此函數必須遵照的規則爲，大於則返回1，小於則返回-1，等於則返回0。
key -- 主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。
reverse -- 排序規則，reverse = True 降序 ， reverse = False 升序（默認）。

返回值:返回從新排序的列表。

>>>a = [5,7,6,3,4,1,2]
>>> b = sorted(a)       # 保留原列表
>>> a 
[5, 7, 6, 3, 4, 1, 2]
>>> b
[1, 2, 3, 4, 5, 6, 7]
 
>>> L=[('b',2),('a',1),('c',3),('d',4)]
>>> sorted(L, cmp=lambda x,y:cmp(x[1],y[1]))   # 利用cmp函數
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
>>> sorted(L, key=lambda x:x[1])               # 利用key
[('a', 1), ('b', 2), ('c', 3), ('d', 4)]
 
 
>>> students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
>>> sorted(students, key=lambda s: s[2])            # 按年齡排序
[('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
 
>>> sorted(students, key=lambda s: s[2], reverse=True)       # 按降序
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

reduce()

reduce() 函數會對參數序列中元素進行累積。

函數將一個數據集合（鏈表，元組等）中的全部數據進行下列操做：用傳給 reduce 中的函數 function（有兩個參數）先對集合中的第 一、2 個元素進行操做，獲得的結果再與第三個數據用 function 函數運算，最後獲得一個結果。

reduce() 函數語法：
reduce(function, iterable[, initializer])

參數
function -- 函數，有兩個參數
iterable -- 可迭代對象
initializer -- 可選，初始參數

返回值:返回函數計算結果

>>>def add(x, y) :            # 兩數相加
...     return x + y
... 
>>> reduce(add, [1,2,3,4,5])   # 計算列表和：1+2+3+4+5
15
>>> reduce(lambda x, y: x+y, [1,2,3,4,5])  # 使用 lambda 匿名函數
15