快捷導(dǎo)航

淺談Python 函數(shù)式編程

更新時(shí)間：2020年06月20日 16:41:19 作者：認(rèn)真對(duì)待世界的小白

這篇文章主要介紹了Python 函數(shù)式編程的相關(guān)資料，文中講解非常細(xì)致，代碼幫助大家更好的理解和學(xué)習(xí)，感興趣的朋友可以了解下

匿名函數(shù)lambda表達(dá)式

什么是匿名函數(shù)？

匿名函數(shù)，顧名思義就是沒(méi)有名字的函數(shù)，在程序中不用使用 def 進(jìn)行定義，可以直接使用 lambda 關(guān)鍵字編寫簡(jiǎn)單的代碼邏輯。lambda 本質(zhì)上是一個(gè)函數(shù)對(duì)象，可以將其賦值給另一個(gè)變量，再由該變量來(lái)調(diào)用函數(shù)，也可以直接使用。

#平時(shí)，我們是先定義函數(shù)，再進(jìn)行調(diào)用
def power(x):
 return x ** 2

print(power(2))

#使用lambda表達(dá)式的時(shí)候，我們可以這樣操作
power = lambda x : x ** 2
print(power(2))

#覺(jué)得太麻煩，還可以這樣調(diào)用
print((lambda x: 2 * x)(8))

lambda表達(dá)式的基本格式：lambda 入?yún)?: 表達(dá)式

#入?yún)⒖梢杂卸鄠€(gè)，比如 
power = lambda x, n: x ** n

print(power(2, 3))

lambda 表達(dá)式的使用場(chǎng)景

一般適用于創(chuàng)建一些臨時(shí)性的，小巧的函數(shù)。比如上面的 power函數(shù)，我們當(dāng)然可以使用 def 來(lái)定義，但使用 lambda 來(lái)創(chuàng)建會(huì)顯得很簡(jiǎn)潔，尤其是在高階函數(shù)的使用中。

定義一個(gè)函數(shù)，傳入一個(gè)list，將list每個(gè)元素的值加1

def add(l = []):
 return [x +1 for x in l]

print(add([1,2,3]))

上面的函數(shù)改成將所有元素的值加2

可能大家會(huì)說(shuō)，這還不簡(jiǎn)單，直接把return里的1改成2就行了。但是真的行嗎？如果函數(shù)被多個(gè)地方使用，而其他地方并不想加2，怎么辦？

這好辦，把變得那部分抽出來(lái)，讓調(diào)用者自己傳

def add(func,l = []):
 return [func(x) for x in l]

def add1(x):
 return x+1

def add2(x):
 return x+2

print(add(add1,[1,2,3]))
print(add(add2,[1,2,3]))

一個(gè)簡(jiǎn)簡(jiǎn)單單的問(wèn)題，一定要用這么多代碼實(shí)現(xiàn)？

def add(func,l = []):
 return [func(x) for x in l]

print(add(lambda x:x+1,[1,2,3]))
print(add(lambda x:x+2,[1,2,3]))

map函數(shù)

map的基本格式

map(func, *iterables)

map() 函數(shù)接收兩個(gè)以上的參數(shù)，開(kāi)頭一個(gè)是函數(shù)，剩下的是序列，將傳入的函數(shù)依次作用到序列的每個(gè)元素，并把結(jié)果作為新的序列返回。也就是類似 map(func,[1,2,3])

同樣的，我們還是來(lái)完成這樣一個(gè)功能：將list每個(gè)元素的值加1

def add(x):
 return x + 1

result = map(add, [1, 2, 3, 4])
print(type(result))
print(list(result))

使用lambda表達(dá)式簡(jiǎn)化操作

result = map(lambda x: x + 1, [1, 2, 3, 4])
print(type(result))
print(list(result))

函數(shù)中帶兩個(gè)參數(shù)的map函數(shù)格式

使用map函數(shù)，將兩個(gè)序列的數(shù)據(jù)對(duì)應(yīng)位置求和，之后返回,也就是對(duì)[1,2,3],[4,5,6]兩個(gè)序列進(jìn)行操作之后，返回結(jié)果[5,7,9]

print(list(map(lambda x, y: x + y, [1, 2, 3], [4, 5, 6])))

對(duì)于兩個(gè)序列元素個(gè)數(shù)一樣的，相對(duì)好理解。如果兩個(gè)序列個(gè)數(shù)不一樣的，會(huì)不會(huì)報(bào)錯(cuò)？

print(list(map(lambda x, y: x + y, [1, 2, 3], [4, 5])))

我們可以看到不會(huì)報(bào)錯(cuò)，但是結(jié)果以個(gè)數(shù)少的為準(zhǔn)

reduce函數(shù)

reduce函數(shù)的基本格式

reduce(function, sequence, initial=None)

reduce把一個(gè)函數(shù)作用在一個(gè)序列上，這個(gè)函數(shù)必須接收兩個(gè)參數(shù)，reduce函數(shù)把結(jié)果繼續(xù)和序列的下一個(gè)元素做累積計(jì)算，跟遞歸有點(diǎn)類似，reduce函數(shù)會(huì)被上一個(gè)計(jì)算結(jié)果應(yīng)用到本次計(jì)算中

reduce(func, [1,2,3]) = func(func(1, 2), 3)

使用reduce函數(shù)，計(jì)算一個(gè)列表的乘積

from functools import reduce

def func(x, y):
 return x * y

print(reduce(func, [1, 2, 3, 4]))

結(jié)合lambda表達(dá)式，簡(jiǎn)化操作

from functools import reduce

print(reduce(lambda x, y: x * y, [1, 2, 3, 4]))

filter 函數(shù)

filter 顧名思義是過(guò)濾的意思，帶有雜質(zhì)的（非需要的數(shù)據(jù)），經(jīng)過(guò) filter 處理之后，就被過(guò)濾掉。

filter函數(shù)的基本格式

filter(function_or_None, iterable)

filter() 接收一個(gè)函數(shù)和一個(gè)序列。把傳入的函數(shù)依次作用于每個(gè)元素，然后根據(jù)返回值是 True 還是 False 決定保留還是丟棄該元素。

使用 filter 函數(shù)對(duì)給定序列進(jìn)行操作，最后返回序列中所有偶數(shù)

print(list(filter(lambda x: x % 2 == 0, [1, 2, 3, 4, 5])))

sorted 函數(shù)

sorted從字面上就可以看去這是個(gè)用來(lái)排序的函數(shù)，sorted 可以對(duì)所有可迭代的對(duì)象進(jìn)行排序操作

sorted的基本格式

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

#iterable -- 可迭代對(duì)象。
#key -- 主要是用來(lái)進(jìn)行比較的元素，只有一個(gè)參數(shù)，具體的函數(shù)的參數(shù)就是取自于可迭代對(duì)象中，指定可迭代對(duì)象中的一個(gè)元素來(lái)進(jìn)行排序。
#reverse -- 排序規(guī)則，reverse = True 降序 ， reverse = False 升序（默認(rèn)）。 

#對(duì)序列做升序排序
print(sorted([1, 6, 4, 5, 9]))

#對(duì)序列做降序排序
print(sorted([1, 6, 4, 5, 9], reverse=True))

#對(duì)存儲(chǔ)多個(gè)列表的列表做排序
data = [["Python", 99], ["c", 88]]
print(sorted(data, key=lambda item: item[1]))

閉包

在萬(wàn)物皆對(duì)象的Python中,函數(shù)是否能作為函數(shù)的返回值進(jìn)行返回呢？

def my_power():
 n = 2
 def power(x):
  return x ** n
 return power

p = my_power()
print(p(4))

#------------------------------------------------------------
def my_power():
 n = 2
 def power(x):
  return x ** n
 return power

n = 3
p = my_power()
print(p(4))

我們可以看到，my_power 函數(shù)在返回的時(shí)候，也將其引用的值（n）一同帶回，n 的值被新的函數(shù)所使用，這種情況我們稱之為閉包

當(dāng)我們把n的值移除到my_power函數(shù)外面，這個(gè)時(shí)候來(lái)看下計(jì)算結(jié)果

n = 2

def my_power():
 def power(x):
  return x ** n
 return power

n = 3
p = my_power()
print(p(4))

為什么輸出的結(jié)果會(huì)是64？

我們先來(lái)看看閉包時(shí)，p.__closure____的結(jié)果

#例1
def my_power():
 n = 2
 def power(x):
  return x ** n
 return power

p = my_power()
print(p.__closure__)

#結(jié)果：(<cell at 0x00000264518F9A38: int object at 0x00007FFA7F617120>)
#closure是內(nèi)部函數(shù)的一個(gè)屬性，用來(lái)保存環(huán)境變量

#---------------------------------------------------------------------

#例2
n = 2
def my_power():
 def power(x):
  return x ** n
 return power

n = 3
p = my_power()
print(p.__closure__)

#輸出結(jié)果 None

通過(guò)例1跟例2對(duì)比，我們可以知道，例2并不是閉包

閉包經(jīng)典問(wèn)題

下面的程序是否是閉包？能否正確運(yùn)行

def my_power():
 n = 2
 
 def power(x):
  n += 1
  return x ** n
 
 return power

p = my_power()
print(p(3))

如何讓上面的程序正確運(yùn)行？看看改正之后的結(jié)果

def my_power():
 n = 2
 
 def power(x):
  nonlocal n
  n += 1
  return x ** n
 
 return power

p = my_power()
print(p.__closure__)
print(p(3))
print(p(3))

看看下面的程序的運(yùn)行結(jié)果

def my_power():
 n = 2
 L = []
 for i in range(1, 3):
  def power():
   return i ** n
  
  L.append(power)
 return L

f1, f2 = my_power()
print(f1())
print(f2())
print(f1.__closure__[0].cell_contents)
print(f2.__closure__[0].cell_contents)

python的函數(shù)只有在執(zhí)行時(shí)，才會(huì)去找函數(shù)體里的變量的值，也就是說(shuō)你連形參都不確定，你咋求知道 i為幾呢？在這里，你只需要記住如果你連形參都不確定，python就只會(huì)記住最后一個(gè)i值。

裝飾器及其應(yīng)用

什么是裝飾器模式

裝飾器模式（Decorator Pattern）允許向一個(gè)現(xiàn)有的對(duì)象添加新的功能，同時(shí)又不改變其結(jié)構(gòu)。這種類型的設(shè)計(jì)模式屬于結(jié)構(gòu)型模式，它是作為現(xiàn)有的類的一個(gè)包裝。

這種模式創(chuàng)建了一個(gè)裝飾類，用來(lái)包裝原有的類，并在保持類方法簽名完整性的前提下，提供了額外的功能。

import time

start = time.time()
time.sleep(4)
end = time.time()
print(end - start)

從實(shí)際例子來(lái)看裝飾器

def my_fun():
 print("這是一個(gè)函數(shù)")

my_fun()

要再打印“這是一個(gè)函數(shù)”前面在打印多一行hello world。

def my_fun():
 begin = time.time()
 time.sleep(2)
 print("這里一個(gè)函數(shù)")
 end = time.time()
 print(end-begin)

my_fun()

這個(gè)時(shí)候，如果不想修改原有的函數(shù)，咋整？

def my_fun():
 print("這是一個(gè)函數(shù)")

def my_time(func):
 begin = time.time()
 time.sleep(2)
 func()
 end = time.time()
 print(end - begin)

my_time(func)

這種方式，因?yàn)橐黾庸δ?，?dǎo)致所有的業(yè)務(wù)調(diào)用方都得進(jìn)行修改，此法明顯不可取。

另一種方式：

def print_cost(func):
 def wrapper():
  begin = time.time()
  time.sleep(2)
  func()
  end = time.time()
  print(end - begin)
  return wrapper

@print_cost
def my_fun():
 print("這里一個(gè)函數(shù)")

第二種方式并沒(méi)有修改func函數(shù)的內(nèi)部實(shí)現(xiàn)，而是使用裝飾器模式對(duì)其功能進(jìn)行裝飾增強(qiáng)。

以上就是淺談Python 函數(shù)式編程的詳細(xì)內(nèi)容，更多關(guān)于Python 函數(shù)式編程的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！

您可能感興趣的文章: