（Python3版本）小白專用，學習心得，與大家分享一下，比較詳細，不喜勿噴
| 引數 | 性質 |
|---|---|
| f | 是fuction的縮寫，是一個函數。規定這個函數必須有兩個引數 |
| iterable | 是可迭代的物件，tuple, list, dictionary, string等可迭代物，必須引數 |
| initializer | 初始值，可選引數（只能給function第一個引數設定初始值，不能給第二個引數設定初始值） |
(迭代)使用指定的帶兩個引數的函數f對一個資料集合(可迭代物件)的所有資料進行下列操作：使用第一個和第二個資料作為引數用func()函數運算，得到的結果在與第三個資料作為引數用func()函數運算，以此類推，最後得到一個結果。
f為函數物件；iterable為可迭代物件；可選的initializer為初始值
程式碼如下（範例1：計算累加和）
import functools,operator
functools.reduce(operator.add,[1,2,3,4,5])
''' 第一個 執行結果：((((1+2)+3)+4)+5) = 15 '''
functools.reduce(operator.add,[1,2,3,4,5],10)
''' 第二個 執行結果：(((((10+1)+2)+3)+4)+5) = 15 '''
functools.reduce(operator.add,range(1,101)
''' 第三個 執行結果：(...(((((1+2)+3)+4)+5)+6)+...) = 5050 '''
溫馨提示： operator模組是python內建操作符的函數介面，add是此模組中的一個具有加法功能的函數。
reduce的工作流程：
程式碼如下（範例2：計算累乘結果）
import functools,operator
functools.reduce(operator.mul,range(1,11))
''' 執行結果：(((((((((1x2)x3)x4)x5)x6)x7)x8)x9)x10) = 3628800 '''
functools,partial()通過把一個函數的部分引數設定為預設值的方式返回一個新的可以呼叫的（callable）的partial 物件，其語法形式如下。
functools.partial( func, *args, **keywords)
| 引數 | 性質 |
|---|---|
| func | 是fuction的縮寫，是一個函數 |
| *args | *args表示任何多個無名引數,它是一個tuple（元組） |
| * *keywords | **keywords表示關鍵字引數,它是一個dict（字典 ：鍵值對） |
其中，func為函數；* args為其位置引數；* * keywords為關鍵字引數
import functools
def function(a,b,c,d):
print(a,b,c,d)
function(1,2,3,4)
''' 輸出結果為 1 2 3 4 '''
（直接繼續使用原來的引數進行呼叫）
3. 程式碼如下（使用 func, *args 引數的partial函數）
import functools
def function(a,b,c,d):
print(a,b,c,d)
fun1 = functools.partial(function,1,2)
fun1(5,6)
fun1(1,2)
''' 輸出結果為
1 2 5 6
1 2 1 2 '''
function函數預設值是1,2規定按順序賦值，即a=1,b=2。所以該函數變成了function（1,2,c,d），可以理解為產生了新的函數。
fun1(5,6)呼叫函數function，並傳入引數5和6 （用原來的引數進行函數呼叫），即c=5,d=6，所以最終輸出結果為1256，fun1(1,2)同理。
這通常只能把前面的引數固定，假如有個需求和現有的不一樣，需要使後面的引數固定，該怎麼做？可以使用下面的方法
（直接繼續使用原來的引數進行呼叫）
import functools
def function(a,b,c,d):
print(a,b,c,d)
fun1 = functools.partial(function,c=4,d=2)
fun1(5,6)
fun1(1,2)
''' 輸出結果為
5 6 4 2
1 2 4 2 '''
（需要使用關鍵字引數進行呼叫）
import functools
def function(a,b,c,d):
print(a,b,c,d)
fun1=functools.partial(function,c=6)
fun1(1,2,d=3)
fun2=functools.partial(function,a=6,b=3)
fun2(c=2,d=4)
''' 輸出結果為
1 2 6 3
6 3 2 4 '''
對於fun1函數中給c賦值為6，引數只有一個 （即非「連續」引數） ，規定需要使用關鍵字引數進行呼叫，即引數為c=6,則新的函數為function(a,b,6,d)
fun1(1,2,d=3)呼叫函數function，並傳入引數1和2和d=3 （用原來的引數進行函數呼叫），即a=1,b=2,c=6,d=3，所以最終結果為 1263
對於fun2函數中給a賦值為6，b賦值為3，引數只有兩個 （即直接對前面的連續引數賦值） ，規定需要使用關鍵字引數進行呼叫，即引數為a=6,b=3，則新的函數為function(6,3,c,d)
fun2(c=2,d=4)呼叫函數function，並傳入引數c=2和d=4 （用原來的引數進行函數呼叫），即a=6,b=3,c=2,d=4，所以最終結果為 6324
官方理解：
partial（）函數主要用於設定預先已知的引數，從而減少呼叫時傳遞引數的個數。
簡單理解：
partial（）函數 偏函數就是為了 固定某些引數的傳入,作為預設引數（預設值）傳入。
所以如果對引數有順序要求的,使用偏函數要比較謹慎
程式碼如下（範例2：計算2的n次方）
import functools,math
pow2 = functools.partial(math.pow,2) #封裝pow(x,y[,z]),指定引數x=2
list(map(pow2,range(11))) #輸出2的0~10次方
'''
執行結果：
[1.0,2.0,4.0,8.0,16.0,32.0,64.0,128.0,256.0,512.0,1024.0]
'''
溫馨提示：
1、range函數是 「左閉右開」
2、pow是屬於math模組裡的函數，pow函數可以有 兩個或者三個引數。pow(x,y):這個是表示x的y次冪，pow(x,y,z)：這個是表示x的y次冪後除以z的餘數 。
3、map函數的原型是map(function, iterable, …)，這個函數的意思就是將function應用於iterable的每一個元素，結果以列表的形式返回。
首先利用偏函數講pow函數裡的引數x賦值為2，即x=2為pow的預設值。（指數為2）
因此新的函數為pow2 = pow(2,y)
最後用map函數呼叫pow2函數對1至10範圍內數位進行迭代。（指數為2，冪從1~10）
最終的輸出的結果是被list()強制轉化為列表型別。
內建函數sorted()把一個可迭代物件進行排序，返回結果列表，其語法形式如下。
sorted( iterable,*,key = None, reverse = False)
| 引數 | 性質 |
|---|---|
| iterable | 可迭代型別，例如字典、列表… |
| key = None | 可迭代型別中某個屬性，對給定元素的每一項進行排序 |
| reverse = False | 降序或升序 |
numbers = [1,6,4,-2,9]
print(sorted(numbers)) #按數值自然排序
''' 輸出結果為 [-2,1,4,6,9] '''
print(numbers)
''' 輸出結果為 [1,6,4,-2,9] '''
由執行結果可知：
1.sorted()函數不需要定義。它是一個內建函數，可以在標準的Python安裝中使用。
2.在沒有額外的引數的情況下，sorted()函數按照升序對值進行排列，也就是按照從小到大的順序。
3.原始的numbers不會改變，因為sorted()函數提供了一個新的有序的輸出結果，並且不改變原始值的順序。
4.當sorted()函數被呼叫時，它會提供一個有序的列表作為返回值。
最後一點意味著列表可以使用sorted()函數，並且輸出結果可以立刻賦值給一個變數：
numbers = [1,6,4,-2,9]
number_sorted = sorted(numbers) #按數值自然排序
print(number_sorted)
''' 輸出結果為 [-2,1,4,6,9] '''
numbers = [1,6,4,-2,9]
number_sorted = sorted(numbers,reverse = True) #按數值逆序排序
print(number_sorted)
''' 輸出結果為 [9,6,4,1,-2] '''
numbers = [1,6,4,-2,9]
number_sorted = sorted(numbers,key = abs) #按絕對值排序
print(number_sorted)
''' 輸出結果為 [1,-2,4,6,9] '''
溫馨提示：abs()函數返回給定引數的絕對值，引數可以是實數(整數、浮點數等）或複數，
如果引數是複數，則返回複數的模。
在排序過程中，將對每個元素呼叫key函數來確定排序順序，但不會改變原來的數值
numbers中用絕對值可理解為，按照[1,6,4,-2,9] 的絕對值 [ 1,6,4,2,9 ] 來升序排序
（無reverse引數，預設reverse = False，不逆序，即預設升序排序）
又因為key函數只是用來確定排序順序，並不會改變原有的值
所以輸出結果為[1,-2,4,6,9]，而不是[1,2,4,6,9]
當使用帶有引數key的函數時，有兩個主要限制
1、傳遞給key的比較函數（該函數只能帶1個引數）
（例如定義一個函數名為add(x,y)，用於加法功能的函數。在排序過程中每次呼叫add()函數，它每次只從列表中接收一個元素）key=add是錯誤的，因為add()函數有兩個引數
2、帶有key的函數必須能夠處理迭代序列中的所有值
（詳細請看連結: 請點選這裡.）
str1 = ["Dog","Cat","Rabbit"] #首字母均是大寫
str2 = ["Dog","cat","Rabbit"] #cat首字母是小寫
str3 = ["Dog","cat","Rabbit"] #cat首字母是小寫
str1_sorted = sorted(str1) #按26字母表順序排序
str2_sorted = sorted(str2) #按照Unicode數值來排序
str3_sorted = sorted(str3,key=str.lower) #按26字母表順序排序
print(str1_sorted)
print(str2_sorted)
print(str3_sorted)
''' 輸出結果為
['Cat','Dog','Rabbit']
['Dog','Rabbit','cat']
['Cat','Dog','Rabbit']
'''
溫馨提示：lower()方法是Python字串方法。它將字串中所有大寫字母轉換為小寫字母，並返回一個新字串。
程式碼如下
str_1 = ["Dog","cat","Rabbit"] #cat首字母是小寫
str_1_sorted = sorted(str_1,key = len) #按字串長度排序
print(str_1_sorted)
'''輸出結果：
['Dog','cat','Rabbit']
'''
tuple1 = [('Bob',75),('Adam',92),('Lisa',88)]
tuple2 = [('Bob',75),('Adam',92),('Lisa',88)]
tuple1_sorted = sorted(tuple1) #預設按第一個元素排序
tuple2_sorted = sorted(tuple2,key = lambda t:t[1]) #按元組的第二個元素排序
print(tuple1_sorted)
print(tuple2_sorted)
'''輸出結果：
[('Adam',92),('Bob',75),('Lisa',88)]
[('Bob',75),('Lisa',88),('Adam',92)]
'''
溫馨提示：lambda 函數的語法只包含一個語句，表現形式如下：
lambda [arg1 [,arg2,…argn]]:expression
其中，lambda 是 Python 預留的關鍵字，[arg…] 和 expression 由使用者自定義。
[arg…] 是參數列，它的結構與 Python 中函數(function)的參數列是一樣的。[arg…] 可以有非常多的形式。
expression 是一個參數列達式，表示式中出現的引數需要在[arg…]中有定義，並且表示式只能是單行的，只能有一個表示式。
例如：f = lambda x,y:x+y 中f為函數，x,y為兩個引數, x+y為函數返回值
tuple1_sorted函數中的引數沒有key，則預設按第一個元素排序。
由於每個元組中第一個元素都是大寫字母，所以排序是按26字母順序表排序。
即A，B，L 所以輸出結果為 [(‘Adam’,92),(‘Bob’,75),(‘Lisa’,88)]
tuple2_sorted函數中有引數 key，key = lambda t:t[1] ，
此處的lambda匿名函數的作用是 按第二個元素 進行排序，
即75，88，92所以輸出結果為 [(‘Bob’,75),(‘Lisa’,88),(‘Adam’,92)]
連結: 請點選這裡.
python中 functools.reduce函數、偏函數（functools.partial）、sorted函數的理解