Python 內置函數&filter()&map()&reduce()&sorted()

經常使用內置函數

Python 2.x 返回列表，Python 3.x 返回迭代器

在進行篩選或映射時，輸出的結果是一個數組，須要list幫助.

如：print(list(map(lambda x:x+1, [1,2,3])))

1、filter() ——過濾、篩選

剛接觸filter時 ，運行老是出現<filter object at 0x000001B68F052828> 得不到想要的數據，後來發現是由於filter的結果是一個數組， 須要 list 幫助，後來將print(f) 改成 print(list(f)) 能成功運行

語法: filter(function,iterable)

function: 用來篩選的函數,在filter中會自動的把iterable中的元素傳遞給function,而後根據function返回的True或者False來判斷是否保留此項數據

iterable:可迭代對象

lst = [{'id':1,'name':'alex','age':18},
        {'id':1,'name':'wusir','age':17},
        {'id':1,'name':'taibai','age':16},
      ]

ls = filter(lambda e:e['age'] > 16,lst)
print(list(ls))

結果:
[{'id': 1, 'name': 'alex', 'age': 18},
 {'id': 1, 'name': 'wusir', 'age': 17}]

2、map() ——映射函數

語法: map(function,iterable)

對可迭代對象中的每個元素執行相同函數功能的操做

function：它是一個功能函數，能夠是lambda函數，也能夠是def函數，它所作的操做是對每個元素執行相同函數功能的操做

iterable：可迭代對象，也可理解爲一個或多個序列，序列中是每個要操做的元素對象

注意：map函數不改變原有的序列，而是返回一個新的序列

如下實例是使用lambda函數和結合函數使用的不一樣寫法：

lis = [1, 2, 3, 4, 5]
lis1 = []
for i in lis:
    def square(x):  # 計算平方數

        return x ** 2
    a = square(i)
    lis1.append(a)
print(lis1)

結果：[1, 4, 9, 16, 25]


def square(x):  # 計算平方數
    return x ** 2

a = map(square, [1, 2, 3, 4, 5])  # 計算列表各個元素的平方
print(list(a))

結果：[1, 4, 9, 16, 25]

a = map(lambda x: x ** 2, [1, 2, 3, 4, 5])  # 使用 lambda 匿名函
print(list(a))

結果：[1, 4, 9, 16, 25]

3、reduce() ——累計算

在Python2.x版本中recude是直接 import就能夠的, Python3.x版本中須要從functools這個包中導入

語法：reduce(function,iterable)

reduce是先把列表中的前倆個元素取出計算出一個值，而後臨時保存,接下來用這個臨時保存的值和列表中第三個元素進行計算,求出一個新的值將最開始臨時保存的值覆蓋掉，依次類推，獲得最終的累計和，並返回

這兩個參數必須都要有,缺一個不行

注意:咱們放進去的可迭代對象沒有更改

from functools import reduce
def func(x,y):
    return x + y

ret = reduce(func,[3,4,5,6,7])
print(ret) 

結果：25


匿名函數版
from functools import reduce
l = reduce(lambda x,y:x*10+y,[1,2,3,4])     
print(l)

結果：1234

# x = 1,y = 2   12
# x = 12,y = 3  123
# x = 123,y = 4 1234

累計加

from functools import reduce

lis = [1, 2, 3, 4]
result = reduce(lambda x, y: x+y, lis)
print(result)

結果：10

統計出現的次數

from functools import reduce
str1 = "fufhfjhjfurfh"
b =reduce(lambda a,x:a+x.count("f"),str1,0)     # 0是從0算起
print(b)

結果：5

from functools import reduce
str1 = "fufhfjhjfurfh"
b =reduce(lambda a,x:a+x.count("f"),str1,1)     # 1是從1算起
print(b)

結果：6

4、sorted() ——排序

sort 與 sorted 區別：

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

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

語法：sorted(iterable, cmp=None, key=None, reverse=False)

iterable：可迭代對象

cmp ：比較的函數，這個具備兩個參數，參數的值都是從可迭代對象中取出，此函數必須遵照的規則爲，大於則返回1，小於則返回-1，等於則返回0。

key：主要是用來進行比較的元素，只有一個參數，具體的函數的參數就是取自於可迭代對象中，指定可迭代對象中的一個元素來進行排序。

reverse：排序規則，reverse = True 降序 ， reverse = False 升序（默認）

實例

a = [5, 7, 6, 3, 4, 1, 2]
b = sorted(a)  # 保留原列表
print(b)

lis = [('b', 2), ('a', 1), ('c', 3), ('d', 4)]
b = sorted(lis, key=lambda x: x[1])  # 利用key
print(b)

students = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
b = sorted(students, key=lambda s: s[2])  # 按年齡排序
print(b)

b = sorted(students, key=lambda s: s[2], reverse=True)  # 按降序
print(b)

結果：[1, 2, 3, 4, 5, 6, 7]
     [('a', 1), ('b', 2), ('c', 3), ('d', 4)]
     [('dave', 'B', 10), ('jane', 'B', 12), ('john', 'A', 15)]
     [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

只需瞭解

1、max() —— 求最大值

實例：

print(max([1,2,3]))  # 返回此序列最大值

能夠在main函數加key索引

ret = max([1,2,-5,],key=abs)  # 按照絕對值的大小，返回此序列最小值
print(ret)
# 加key是能夠加函數名，min自動會獲取傳入函數中的參數的每一個元素，而後經過你設定的返回值比較大小，返回最大的傳入的那個參數。

print(max(1,2,-5,6,-3,key=lambda x:abs(x)))  # 能夠設置不少參數比較大小

dic = {'a':3,'b':2,'c':1}
print(max(dic,key=lambda x:dic[x]))

# x爲dic的key，lambda的返回值（即dic的值進行比較）返回最大的值對應的鍵

2、min() ——求最小值

實例：

print(min([1,2,3]))  # 返回此序列最小值

能夠在main函數加key索引

ret = min([1,2,-5,],key=abs)  # 按照絕對值的大小，返回此序列最小值
print(ret)
# 加key是能夠加函數名，min自動會獲取傳入函數中的參數的每一個元素，而後經過你設定的返回值比較大小，返回最小的傳入的那個參數。

print(min(1,2,-5,6,-3,key=lambda x:abs(x)))  # 能夠設置不少參數比較大小

dic = {'a':3,'b':2,'c':1}
print(min(dic,key=lambda x:dic[x]))

# x爲dic的key，lambda的返回值（即dic的值進行比較）返回最小的值對應的鍵