python编写函数_浅谈Python 函数式编程
匿名函數(shù)lambda表達式
什么是匿名函數(shù)？
匿名函數(shù)，顧名思義就是沒有名字的函數(shù)，在程序中不用使用 def 進行定義，可以直接使用 lambda 關(guān)鍵字編寫簡單的代碼邏輯。lambda 本質(zhì)上是一個函數(shù)對象，可以將其賦值給另一個變量，再由該變量來調(diào)用函數(shù)，也可以直接使用。
?
1
2
3
4
5
6
7
8
9
10
11
12
#平時，我們是先定義函數(shù)，再進行調(diào)用
def power(x):
return x** 2
print(power(2))
#使用lambda表達式的時候，我們可以這樣操作
power= lambda x : x** 2
print(power(2))
#覺得太麻煩，還可以這樣調(diào)用
print((lambda x:2 * x)(8))
lambda表達式的基本格式：lambda 入?yún)?: 表達式
?
1
2
3
4
#入?yún)⒖梢杂卸鄠€，比如
power= lambda x, n: x** n
print(power(2,3))
lambda 表達式的使用場景
一般適用于創(chuàng)建一些臨時性的，小巧的函數(shù)。比如上面的 power函數(shù)，我們當然可以使用 def 來定義，但使用 lambda 來創(chuàng)建會顯得很簡潔，尤其是在高階函數(shù)的使用中。
定義一個函數(shù)，傳入一個list，將list每個元素的值加1
?
1
2
3
4
def add(l= []):
return [x+1 for xin l]
print(add([1,2,3]))
上面的函數(shù)改成將所有元素的值加2
可能大家會說，這還不簡單，直接把return里的1改成2就行了。但是真的行嗎？如果函數(shù)被多個地方使用，而其他地方并不想加2，怎么辦？
這好辦，把變得那部分抽出來，讓調(diào)用者自己傳
?
1
2
3
4
5
6
7
8
9
10
11
def add(func,l= []):
return [func(x)for xin 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]))
一個簡簡單單的問題，一定要用這么多代碼實現(xiàn)？
?
1
2
3
4
5
def add(func,l= []):
return [func(x)for xin 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ù)接收兩個以上的參數(shù)，開頭一個是函數(shù)，剩下的是序列，將傳入的函數(shù)依次作用到序列的每個元素，并把結(jié)果作為新的序列返回。也就是類似 map(func,[1,2,3])
同樣的，我們還是來完成這樣一個功能：將list每個元素的值加1
?
1
2
3
4
5
6
def add(x):
return x+ 1
result= map(add, [1,2,3,4])
print(type(result))
print(list(result))
使用lambda表達式簡化操作
?
1
2
3
result= map(lambda x: x+ 1, [1,2,3,4])
print(type(result))
print(list(result))
函數(shù)中帶兩個參數(shù)的map函數(shù)格式
使用map函數(shù)，將兩個序列的數(shù)據(jù)對應(yīng)位置求和，之后返回,也就是對[1,2,3],[4,5,6]兩個序列進行操作之后，返回結(jié)果[5,7,9]
?
1
print(list(map(lambda x, y: x+ y, [1,2,3], [4,5,6])))
對于兩個序列元素個數(shù)一樣的，相對好理解。如果兩個序列個數(shù)不一樣的，會不會報錯？
?
1
print(list(map(lambda x, y: x+ y, [1,2,3], [4,5])))
我們可以看到不會報錯，但是結(jié)果以個數(shù)少的為準
reduce函數(shù)
reduce函數(shù)的基本格式
reduce(function, sequence, initial=None)
reduce把一個函數(shù)作用在一個序列上，這個函數(shù)必須接收兩個參數(shù)，reduce函數(shù)把結(jié)果繼續(xù)和序列的下一個元素做累積計算，跟遞歸有點類似，reduce函數(shù)會被上一個計算結(jié)果應(yīng)用到本次計算中
reduce(func, [1,2,3]) = func(func(1, 2), 3)
使用reduce函數(shù)，計算一個列表的乘積
?
1
2
3
4
5
6
from functoolsimport reduce
def func(x, y):
return x* y
print(reduce(func, [1,2,3,4]))
結(jié)合lambda表達式，簡化操作
?
1
2
3
from functoolsimport reduce
print(reduce(lambda x, y: x* y, [1,2,3,4]))
filter 函數(shù)
filter 顧名思義是過濾的意思，帶有雜質(zhì)的（非需要的數(shù)據(jù)），經(jīng)過 filter 處理之后，就被過濾掉。
filter函數(shù)的基本格式
filter(function_or_None, iterable)
filter() 接收一個函數(shù)和一個序列。把傳入的函數(shù)依次作用于每個元素，然后根據(jù)返回值是 True 還是 False 決定保留還是丟棄該元素。
使用 filter 函數(shù)對給定序列進行操作，最后返回序列中所有偶數(shù)
?
1
print(list(filter(lambda x: x% 2 == 0, [1,2,3,4,5])))
sorted 函數(shù)
sorted從字面上就可以看去這是個用來排序的函數(shù)，sorted 可以對所有可迭代的對象進行排序操作
sorted的基本格式
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
sorted(iterable, key=None, reverse=False)
#iterable -- 可迭代對象。
#key -- 主要是用來進行比較的元素，只有一個參數(shù)，具體的函數(shù)的參數(shù)就是取自于可迭代對象中，指定可迭代對象中的一個元素來進行排序。
#reverse -- 排序規(guī)則，reverse = True 降序 ， reverse = False 升序（默認）。
#對序列做升序排序
print(sorted([1,6,4,5,9]))
#對序列做降序排序
print(sorted([1,6,4,5,9], reverse=True))
#對存儲多個列表的列表做排序
data= [["Python",99], ["c",88]]
print(sorted(data, key=lambda item: item[1]))
閉包
在萬物皆對象的Python中,函數(shù)是否能作為函數(shù)的返回值進行返回呢？
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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ù)在返回的時候，也將其引用的值（n）一同帶回，n 的值被新的函數(shù)所使用，這種情況我們稱之為閉包
當我們把n的值移除到my_power函數(shù)外面，這個時候來看下計算結(jié)果
?
1
2
3
4
5
6
7
8
9
10
n= 2
def my_power():
def power(x):
return x** n
return power
n= 3
p= my_power()
print(p(4))
為什么輸出的結(jié)果會是64？
我們先來看看閉包時，p.__closure____的結(jié)果
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
#例1
def my_power():
n= 2
def power(x):
return x** n
return power
p= my_power()
print(p.__closure__)
#結(jié)果：()
#closure是內(nèi)部函數(shù)的一個屬性，用來保存環(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
通過例1跟例2對比，我們可以知道，例2并不是閉包
閉包經(jīng)典問題
下面的程序是否是閉包？能否正確運行
?
1
2
3
4
5
6
7
8
9
10
11
def my_power():
n= 2
def power(x):
n+= 1
return x** n
return power
p= my_power()
print(p(3))
如何讓上面的程序正確運行？看看改正之后的結(jié)果
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
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))
看看下面的程序的運行結(jié)果
?
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
def my_power():
n= 2
L= []
for iin 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ù)體里的變量的值，也就是說你連形參都不確定，你咋求知道 i為幾呢？在這里，你只需要記住如果你連形參都不確定，python就只會記住最后一個i值。
裝飾器及其應(yīng)用
什么是裝飾器模式
裝飾器模式（Decorator Pattern）允許向一個現(xiàn)有的對象添加新的功能，同時又不改變其結(jié)構(gòu)。這種類型的設(shè)計模式屬于結(jié)構(gòu)型模式，它是作為現(xiàn)有的類的一個包裝。
這種模式創(chuàng)建了一個裝飾類，用來包裝原有的類，并在保持類方法簽名完整性的前提下，提供了額外的功能。
?
1
2
3
4
5
6
import time
start= time.time()
time.sleep(4)
end= time.time()
print(end- start)
從實際例子來看裝飾器
?
1
2
3
4
def my_fun():
print("這是一個函數(shù)")
my_fun()
要再打印“這是一個函數(shù)”前面在打印多一行hello world。
?
1
2
3
4
5
6
7
8
def my_fun():
begin= time.time()
time.sleep(2)
print("這里一個函數(shù)")
end= time.time()
print(end-begin)
my_fun()
這個時候，如果不想修改原有的函數(shù)，咋整？
?
1
2
3
4
5
6
7
8
9
10
11
def my_fun():
print("這是一個函數(shù)")
def my_time(func):
begin= time.time()
time.sleep(2)
func()
end= time.time()
print(end- begin)
my_time(func)
這種方式，因為要增加功能，導(dǎo)致所有的業(yè)務(wù)調(diào)用方都得進行修改，此法明顯不可取。
另一種方式：
?
1
2
3
4
5
6
7
8
9
10
11
12
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("這里一個函數(shù)")
第二種方式并沒有修改func函數(shù)的內(nèi)部實現(xiàn)，而是使用裝飾器模式對其功能進行裝飾增強。
以上就是淺談Python 函數(shù)式編程的詳細內(nèi)容，更多關(guān)于Python 函數(shù)式編程的資料請關(guān)注服務(wù)器之家其它相關(guān)文章！
原文鏈接：https://www.cnblogs.com/jwen1994/p/13127205.html
總結(jié)
以上是生活随笔為你收集整理的python编写函数_浅谈Python 函数式编程的全部內(nèi)容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： python预测模型_Python多元线
- 下一篇： 柠檬班python自动化视频百度云_py