函數式編程中的字符串
在函數式編程中，經常用到 Python 字符串，因其是不可變數據結構。
字符串本身是一個對象，具備很多對象方法，與常識中函數的使用不太相同，例如下述代碼
|
1
2
3
|
my_str = "xiangpica"print(my_str.upper())print(len(my_str.upper())) |
其中 len() 函數的用法被稱為前置寫法，而 my_str.upper() 被稱為后置寫法，這樣很容易造成函數式編程的理解問題，所以需要系統性的解決該問題。
如果上述代碼可以修改為 len(upper(my_str))，就變得相對容易理解。
|
1
2
3
4
5
6
7
|
# 類型 Text 是 str 的別名from typing import Textmy_str = "xiangpica"def upper(str: Text) -> Text: return str.upper()print(upper(my_str))print(len(upper(my_str))) |
上述代碼重新定義了一個前置用法的函數 upper，用于解決函數式編程中的一致性問題，該解決辦法在后續代碼中會經常出現。
不變類型元組
除字符串外，Python 中的另一個不可變數據類型為元組，元組分為普通元組與命名元組。
普通元組的聲明與訪問
在之前的文章中對元組的基本知識，已經進行了說明，可以去稍微復習一下，然后在進入本文的學習。
先看一下代碼，然后再判斷是否可以理解。
|
1
2
3
4
5
6
|
from typing import Tuple, Text, CallableLANGUAGE = Tuple[Text, Text, Text]python: Callable[[LANGUAGE], Text] = lambda languages: languages[1]items = ("c","python","js")a = python(items)print(a) |
上述代碼定義了一個新的類型 LANGUAGE，該類型是一個元組，具備三個元素。
python 類型注解是 Callable[[LANGUAGE], Text]，即它的參數是 LANGUAGE 類型，返回值是字符串類型。
注意 typing 模塊加入不會影響程序的運行不會報正式的錯誤，僅作為類型檢查，防止運行時出現參數、返回值類型不符，開發人員查閱。
除上述內容外，還可以使用命名元組來實現。
|
1
2
3
4
5
|
from collections import namedtupleLanguage = namedtuple("Language",("name1", "name2", "name3"))l = Language("c", "python", "js")print(l)print(l.name1) |
或者直接使用 typing 模塊的 NamedTuple 也可以。
|
1
2
3
4
5
6
7
8
|
from typing import NamedTuple, Textclass Language(NamedTuple): name: Text description: Textl = Language("C", "C語言")print(l)print(l.name)print(l.description) |
函數式的分類
函數大類分為兩種：
- 標量函數：函數的返回結果為一個值；
- 集合函數：函數的結果為可迭代的集合。
集合函數也可以細分：
- 規約/累積函數：將集合內的元素進行累積計算，最后得到一個值；
- 映射函數：將標量函數應用于幾個的每個元素，最后得到一個與原集合相同長度的新集合；
- 過濾函數：將標量函數應用于每個元素，保留一部分，得到一個子集。
有了上述概念之后，對于函數式編程的理解可以更進一步。
any() 、all() 、len()、sum() 對比學習
any 與 all 兩個函數屬于規約函數，進行的操作叫做布爾規約，即將一個集合的元素歸約為 True 或者 False，all 需要所有值都是 True，any 只要有一個值是 True 即可。
len 與 sum 也是歸約函數，它們分別表示計算集合中所有值的個數和匯總值。
zip()、reversed()、enumerate()
zip 函數可以把多個可迭代對象或者序列，之間的數據進行交叉組合，即將 n 個元素的可迭代對象轉換為 n 元組，然后返回一個生成器。
如果 zip 函數沒有輸入參數，那將返回一個空列表 []。
|
1
2
|
a = zip()print(list(a)) |
reversed 函數用于改變序列順序，即反轉序列。
enumerate 函數獲取序列或者可迭代對象的下標值，轉換成概念描述就是將可迭代對象映射為二元組序列（帶上序號了），每個二元組序列中，第一個元素是下標值，第二個元素是值本身。
高階函數
學習 Python 函數式編程，繞不開高階函數的學習，高階函數就是以函數為參數，或者以返回值為函數的函數。
函數 max 和 min()
上述兩個函數是規約函數，即輸入的是集合，輸出的是單個值，主要用途就是尋找極值。
一般在學習的時候，可以把二者當成普通的函數，也可用于高階函數，主要為參數位置的差異。
最簡單的用法為：
|
1
2
3
4
|
max_num = max(1, 2, 3, 4)min_num = min(1, 2, 3, 4)print(max_num)print(min_num) |
接下來就是其高階函數模式的實現，自定義比較規則。
|
1
2
3
4
5
6
7
8
9
10
|
# 第一種寫法，比較字符串長度max_num = max("a", "abc", "ceda", "aaaaa", key=lambda x: len(x))min_num = min("a", "abc", "ceda", "aaaaa", key=lambda x: len(x))print(max_num)print(min_num)# 第二種寫法，比較字符串長度max_num = max(["a", "abc", "ceda", "aaaaa"], key=lambda x: len(x))min_num = min(["a", "abc", "ceda", "aaaaa"], key=lambda x: len(x))print(max_num)print(min_num) |
上述代碼的 key 為可選參數，默認值為 None。
map 函數
map 函數用于將一個集合映射到另一個集合，例如可以將一個由字符串組成的列表中的每一項，都轉換為整數。
|
1
2
3
|
data = ["1", "2", "3"]print(map(int, data))print(list(map(int, data))) |
代碼 map(int, data) 的含義就是將 int 函數作用于 data 中的每一項。
map 函數的第一個參數也可以用 lambda 代替。
|
1
2
3
|
data = ["1", "2", "3"]print(map(lambda x: int(x), data))print(list(map(int, data))) |
filter 函數
filter 函數主要用于將一個**判定函數（謂語函數）**用于集合的每一個元素，最后得到滿足判定函數的結果集，測試代碼如下：
|
1
2
3
|
data = [1, 3, 5, 7, 9]print(filter(lambda x: x > 3, data))print(list(filter(lambda x: x > 3, data))) |
sorted 函數
sorted 函數也支持高階函數 key 參數定制規則。
|
1
2
|
result = sorted(["afghsss", "abc", "ceda", "aaaaa"], key=lambda x: len(x))print(result) |
同一需求的不同效率問題
通過 map 函數，生成器表達式，存在迭代器的生成器函數分別多 一億 數據量的列表進行測試。
|
1
2
3
4
5
6
7
8
9
10
11
12
13
|
import timedef demo(x): return x * 2def demo1(f, l): for x in l: yield f(x)my_list = list(range(1, 10000000))start = time.perf_counter()# map(lambda x: x * 2, my_list) # 程序運行耗時 3.904999999998493e-06# (demo(x) for x in my_list) # 程序運行耗時 6.310000000009364e-06demo1(demo, my_list) # 程序運行耗時 5.1070000000041915e-06cost_time = time.perf_counter() - startprint("程序運行耗時", cost_time) |
得到的結果是 map 最快，所以用就完事了。
以上就是簡析Python函數式編程字符串和元組及函數分類與高階函數的詳細內容，更多關于Python函數式編程的資料請關注服務器之家其它相關文章！
原文鏈接：https://dream.blog.csdn.net/article/details/120153197
