前言

（Python3版本）小白專用，學習心得，與大家分享一下，比較詳細，不喜勿噴

一、functools.reduce()函式

1. “迭代”的理解

1. 迭代時，當前保存的結果作為下一次回圈計算的初始值，

2. reduce()函式的概念

2.1語法

1. functools.reduce (f,iterable[,initializer])

• (迭代)使用指定的帶兩個引數的函式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的作業流程：

1. 無初始值（運行程序）： 例如 functools.reduce(operator.add,[1,2,3,4,5])
   第一個資料1與第二個資料2作為引數用operator.add函式運算，得到的結果 3 再與第三個資料3 作為引數用operator.add函式運算，以此類推，最后得到一個結果，
2. 有初始值（運行程序）：例如 functools.reduce(operator.add,[1,2,3,4,5]，10)
   第一個資料10與第二個資料1作為引數用operator.add函式運算，得到的結果 11 再與第三個資料2 作為引數用operator.add函式運算，以此類推，最后得到一個結果，

代碼如下（示例2：計算累乘結果）

import functools,operator
functools.reduce(operator.mul,range(1,11))

''' 運行結果：(((((((((1x2)x3)x4)x5)x6)x7)x8)x9)x10) = 3628800 '''

• 溫馨提示：range函式是 “左閉右開”， operator模塊是python內置運算子的函式介面，mul是此模塊中的一個具有乘法功能的函式，
• 首先確定，functools.reduce(operator.mul,range(1,11)) 沒有初始值，即運算程序同理，

2.2 reduce函式的意義

• reduce函式使代碼看起來更精簡，而且運行性能更好，更準確，

二、functools.partial()偏函式

1. 偏函式的概念

1. functools,partial()通過把一個函式的部分引數設定為默認值的方式回傳一個新的可以呼叫的（callable）的partial 物件，其語法形式如下，

   functools.partial( func, *args, **keywords)

其中，func為函式；* args為其位置引數；* * keywords為關鍵字引數

• 簡單理解：
  partial（）函式 偏函式就是為了 固定某些引數的傳入,作為默認引數（默認值）傳入，
• functools.partial (固定的函式, *args(值), **keywords（鍵值對))

2. 代碼如下（新建一個原函式）

import functools
def function(a,b,c,d):
	print(a,b,c,d)
function(1,2,3,4)

''' 輸出結果為 1 2 3 4 '''

• 此處是新建一個函式function，其輸出結果為1234

1.1 使用 func, *args 引數的partial函式，只能是前面“連續”的引數固定

（直接繼續使用原來的引數進行呼叫）
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)同理，

• 這通常只能把前面的引數固定，假如有個需求和現有的不一樣，需要使后面的引數固定，該怎么做？可以使用下面的方法

1.2 使用 func, **keywords 引數的partial函式，分為兩種情況

1.2.1 后面“連續”的引數固定

（直接繼續使用原來的引數進行呼叫）

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 	'''

• 使用關鍵字引數（**keywords），例如此時關鍵字引數為 c=4,d=2,則默認引數為4和2，
  即 新的函式為function(a,b,4,2)
  fun1(5,6)呼叫函式function，并傳入引數5和6 （用原來的引數進行函式呼叫），即a=5,b=6
  (規定默認按順序賦值)，所以最終輸出結果為5642，fun1(1,2)同理，

1.2.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

1.3 偏函式的理解

• 官方理解：

  partial（）函式主要用于設定預先已知的引數，從而減少呼叫時傳遞引數的個數，

• 簡單理解：
  partial（）函式 偏函式就是為了 固定某些引數的傳入,作為默認引數（默認值）傳入，

  所以如果對引數有順序要求的,使用偏函式要比較謹慎

1.4 舉一個例子

代碼如下（示例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()函式

1. sorted()函式的概念

1. 內置函式sorted()把一個可迭代物件進行排序，回傳結果串列，其語法形式如下，

   sorted( iterable,*,key = None, reverse = False)

• iterable為待排序的可迭代物件；
  key = None為其比較函式（默認None，按自然順序排序）
  reverse = False為指定是否逆序排序
• 單獨一個星號（*）不是引數，它是一個“分割符號”，它的作用是“告訴大家，呼叫函式時傳入排在它（*）后面的引數，都要帶名字（類似鍵值對）”

2. 對數值進行排序

2.1 只有一個引數（iterable）時

1. 代碼如下（sorted（）函式示例）

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_sorted存盤了sorted()函式的輸出結果，

2.2 有引數reverse = False時

• sorted()函式有一個可選的引數reverse，它將根據分配給它的布林值改變排序，如果reverse = True，那么就會按照降序排列；如果reverse = False或者沒有引數reverse，那么就會按照升序排列：

numbers = [1,6,4,-2,9] 
number_sorted = sorted(numbers,reverse = True)	#按數值逆序排序
print(number_sorted)

''' 輸出結果為 [9,6,4,1,-2] '''

2.3 有引數key = None時

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的函式必須能夠處理迭代序列中的所有值
（詳細請看鏈接: 請點擊這里.）

3. 對字串進行排序

3.1 當你對字串排序時，大小寫很重要

• 串列中字串首字母均是大寫 或者 小寫的時候，默認 按26字母表排序，若第一個字母相同，就看第二個，以此類推，
• 串列中的字串字母 即有大寫字母開頭的字串，又有小寫字母開頭的字串，則按照Unicode數值來從小到大排序，

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字串方法，它將字串中所有大寫字母轉換為小寫字母，并回傳一個新字串，

• str1中的三個字串首字母都是大寫，所以按照26字母表排序，
• str2中的cat中的c是小寫，Dog和Rabbit中首字母是大寫，因此有大小寫，即按照字母在Unicode中所對應的數值排序，Unicode碼分別對應的數值 D：68 、R：82 、c：99
  因此排序為 Dog，Rabbit，cat
• str3中元素與str2相同，但是 比較函式 key = str.lower，意味著將str3中的元素全部當成 小寫字母 來比較，雖然str3中的既有大寫又有小寫，但排序方式是按小寫字母排序的，即26字母表排序，因此輸出結果為 [‘Cat’,‘Dog’,‘Rabbit’]

3.2 按字串長度排序

代碼如下

str_1 = ["Dog","cat","Rabbit"] #cat首字母是小寫
str_1_sorted = sorted(str_1,key = len) #按字串長度排序
print(str_1_sorted)

'''輸出結果：
['Dog','cat','Rabbit']
'''

• 因為key=len，所以對str_1函式是用長度進行排序的，默認從小到大，
• 字串若長度相同，則按字典排序， D：68、c：99
  所以輸出結果為 [‘Dog’,‘cat’,‘Rabbit’]

3.3 按元組的元素排序

• 默認按元組的第一個元素排序
• 若要按第二個或者第三等等，則需要修改 比較函式 key
  代碼如下

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)]

4. 如果您還不懂 或者 想詳細了解sorted函式，請點擊下方鏈接，

鏈接: 請點擊這里.

總結

python中 functools.reduce函式、偏函式（functools.partial）、sorted函式的理解

• 1、functools.reduce (f,iterable[,initializer]) 函式就是 將第一個引數（函式）對 第二個引數物件進行迭代運算，
  2、partial（）函式 偏函式就是為了 固定某些引數的傳入,作為默認引數（默認值）傳入，
  3、內置函式sorted()把一個可迭代物件進行排序，回傳結果串列，