Python Toolz用法及代碼示例

Toolz 包為迭代器、函數和字典提供了一組實用函數。這些函數擴展了標準庫 itertools 和 functools，並大量借鑒了當代函數式語言的標準庫。該軟件包包含以下模塊 -

dicttoolz
functoolz
itertoolz
recipes
sandbox

字典工具

函數 -

assoc(d, 鍵, 值[, 工廠]) -返回具有新鍵值對的新字典。它不會修改初始字典。


import toolz 
  
  
d = toolz.dicttoolz.assoc({'Geeks':0}, 'forGeeks', 1) 
print(d)

輸出 -

{'Geeks': 0, 'forGeeks': 1}

assoc_in(d, 鍵, 值[, 工廠]) -返回一個新的字典，其中包含新的、可能嵌套的鍵值對
```
import toolz 
  
d = toolz.dicttoolz.assoc_in({'Geeks':0}, 'forGeeks', 1) 
print(d) 
```
輸出 -

{‘Geeks’: 0, ‘f’: {‘o’: {‘r’: {‘G’: {‘e’: {‘e’: {‘k’: {‘s’: 1}}}}}}}}

dissoc(d, *鍵) -返回刪除給定鍵的新字典。它不會修改初始字典。


import toolz 
  
d = toolz.dicttoolz.dissoc({'g':0, 'e':1,  
                            'k':2, 's':3}, 
                            'k', 'e') 
print(d)

輸出 -

{'g': 0, 's': 3}

get_in(鍵，ds[，默認值，no_default]) -返回 ds[I0][I1]…[IX]，其中 [I0, I1, …, IX] 是鍵，ds 是嵌套字典。如果找不到 ds[I0][I1]…[IX]，則返回“default”。


import toolz 
  
  
nested_dict ={'d1':{'k1':'v1', 'k2':'v2'},  
              'd2':{'k3':{'d2A':{'k4':'v4'}}}} 
  
d = toolz.dicttoolz.get_in(['d1'], nested_dict) 
print(d) 
  
d = toolz.dicttoolz.get_in(['d2', 'k3', 'd2A'],  
                           nested_dict) 
print(d)

輸出 -

{'k1': 'v1', 'k2': 'v2'}
{'k4': 'v4'}

itemfilter(謂詞, d[, 工廠]) -它按項目過濾字典中的項目。


import toolz 
  
  
def func(item): 
      
    key, val = item 
      
    return key == ord(val)-65
  
d = {0:'A', 1:'B', 3:'C', 5:'F'} 
print(toolz.dicttoolz.itemfilter(func, d))

輸出 -

{0: 'A', 1: 'B', 5: 'F'}

itemmap(func, d[, 工廠]) -將函數應用於字典的項目。


import toolz 
  
  
d = {0:'A', 1:'B', 3:'C', 5:'F'} 
print(toolz.dicttoolz.itemmap(reversed, d))

輸出 -

{'A': 0, 'B': 1, 'C': 3, 'F': 5}

keyfilter(謂詞, d[, 工廠]) -它按鍵過濾字典中的項目。


import toolz 
  
  
def func(key): 
    return 5<= len(key)<7
  
d = {'python': 0, 'julia': 1, 'java': 3, 'javascript': 5} 
print(toolz.dicttoolz.keyfilter(func, d))

輸出 -

{'python': 0, 'julia': 1}

鍵映射(func，d[，工廠] -將函數應用於字典的鍵。


import toolz 
  
  
def func(key): 
    return ''.join(reversed(key)) 
  
d = {'python': 0, 'julia': 1, 'java': 3, 'javascript': 5} 
print(toolz.dicttoolz.keymap(func, d))

輸出 -

{'nohtyp': 0, 'ailuj': 1, 'avaj': 3, 'tpircsavaj': 5}

合並(*dicts，**kwargs)-它合並了字典的集合。


import toolz 
  
  
dict1 = {1:1, 2:4} 
dict2 = {3:9, 2:8, 4:16} 
print(toolz.dicttoolz.merge(dict1, dict2))

輸出 -

{1: 1, 2: 8, 3: 9, 4: 16}

merge_with(func, *dicts, **kwargs) -合並字典並將函數應用於組合值。


import toolz 
  
  
dict1 = {1:1, 2:4} 
dict2 = {3:9, 2:8, 1:1} 
print(toolz.dicttoolz.merge_with(sum, dict1, dict2))

輸出 -

{1: 2, 2: 12, 3: 9}

update_in(d, 鍵, func[, 默認, 工廠]) -更新嵌套字典中的值。如果 key = [k0, .., kX] 且 d[k0, …, kX] = value，update_in 返回原始字典的副本，其中 ‘value’ 替換為 func(value)。


import toolz 
  
  
def func(value): 
    return value//2
  
nested_dict = {1:{11:111}, 2:{22:222}} 
print(toolz.dicttoolz.update_in(nested_dict,  
       [1, 11], func))

輸出 -

{1: {11: 55}, 2: {22: 222}}

valfilter(謂詞, d[, 工廠]) -按值過濾字典中的項目。


import toolz 
  
  
def func(value): 
    return 4<len(value)<7
  
d = {0: 'python', 1: 'julia', 3: 'java', 5: 'javascript'} 
print(toolz.dicttoolz.valfilter(func, d))

輸出 -

{0: 'python', 1: 'julia'}

valmap(func, d[, 工廠]) -將函數應用於字典的值。


import toolz 
  
  
def func(value): 
    return ''.join(reversed(value)) 
  
d = {0: 'python', 1: 'julia', 3: 'java', 5: 'javascript'} 
print(toolz.dicttoolz.valmap(func, d))

輸出 -

{0: 'nohtyp', 1: 'ailuj', 3: 'avaj', 5: 'tpircsavaj'}

函數工具

函數 -

應用(*func_and_args，**kwargs)-它隻是應用一個函數並返回結果。


import toolz 
  
  
def double(n): 
    return n + n 
  
print(toolz.functoolz.apply(double, 2))

輸出 -

補碼(函數)-顧名思義，它轉換返回所提供輸入的邏輯補碼。


import toolz 
  
  
def is_mulitple_of_5(n): 
    return n % 5 == 0
  
not_multiple_of_5 = toolz.functoolz.complement(is_mulitple_of_5) 
  
print(is_mulitple_of_5(10)) 
print(not_multiple_of_5(10))

輸出 -

True
False

撰寫(*函數)-它返回一個按順序應用其他函數的函數。函數從右到左應用。如果未提供參數，則返回恒等函數 (f(x) = x)。


import toolz 
  
  
def func(n): 
    return n + n 
  
def square(n): 
    return n * n 
  
x = toolz.functoolz.compose(func, square)(3) 
print(x)

輸出 -

compose_left(*函數) -它返回一個按順序應用其他函數的函數。函數從左到右應用。如果未提供參數，則返回恒等函數 (f(x) = x)。


import toolz 
  
  
def func(n): 
    return n + n 
  
def square(n): 
    return n * n 
  
x = toolz.functoolz.compose_left(func, square)(3) 
print(x)

輸出 -

flip -以相反的順序使用參數調用該函數。


import toolz 
  
  
def mod(a, b): 
    return a % b 
  
print('7 % 3 :', toolz.functoolz.flip(mod, 3, 7))

輸出 -

7 % 3 : 1

身份(x) -恒等函數，簡單地返回x。


import toolz 
  
  
print(toolz.functoolz.identity(6))

輸出 -

管道(數據，*函數)-通過一係列函數傳遞一個值。它相當於compose_left(*funcs)
```
import toolz 
  
  
print(toolz.functoolz.pipe(3, double, square)) 
```
輸出 -
```
36
```

thread_first(val, *形式) -通過一係列函數/表單來傳遞值。


import toolz 
  
  
def mod(a, b): 
    return a % b 
  
def double(n): 
    return n + n 
  
print(toolz.functoolz.thread_first(3, (mod, 2), double))

輸出 -

thread_last(val, *形式) -通過一係列函數/表單來傳遞值。


import toolz 
  
  
def mod(a, b): 
    return a % b 
  
def double(n): 
    return n + n 
  
print(toolz.functoolz.thread_last(3, (mod, 2), double))

輸出 -

迭代工具

函數 -

累積(binop，seq [，初始])-這與‘reduce’函數類似。它重複地將函數應用於累積結果的序列。
```
import toolz 
from operator import add 
  
print(list(toolz.itertoolz.accumulate(add, [1, 2, 3, 4]))) 
```
輸出 -
```
[1, 3, 6, 10]
```

連接(序列)-它連接兩個或多個可迭代對象。


import toolz 
  
print(list(toolz.itertoolz.concat([[1],  
                                  ['a'],  
                                  [2, 3, 4]])))

輸出 -

[1, 'a', 2, 3, 4]

缺點(項目，序列)-它在序列的開頭添加‘item’。它相當於插入(0，項目)。
```
import toolz 
  
  
print(list(toolz.itertoolz.cons(1, ['a', 'b']))) 
```
輸出 -
```
[1, 'a', 'b']
```
diff(*seqs, **kwargs) -它比較兩個迭代中每個索引處的元素並返回不同對的列表。
```
import toolz 
  
  
print(list(toolz.itertoolz.diff([1, 2, 3], [2, 2, 4]))) 
```
輸出 -
```
[(1, 2), (3, 4)]
```

刪除(n，seq)-它刪除序列的前 n 個元素並返回新序列。


import toolz 
  
print(list(toolz.itertoolz.drop(3, [2, 3, 2, 6, 4, 7])))

輸出 -

[6, 4, 7]

頻率(seq) -它返回一個字典，其中包含元素及其按順序計數。它相當於collections.Counter。


import toolz 
  
print(toolz.itertoolz.frequencies(['c', 
                                   'b', 
                                   'c',  
                                   'b',  
                                   'd',  
                                   'e',  
                                   'h',  
                                   'h', 
                                   'b']))

輸出 -

{'c': 2, 'b': 3, 'd': 1, 'e': 1, 'h': 2}

groupby(func, seq) -它根據 func 對序列元素進行分組後返回一個字典。


import toolz 
  
print(toolz.itertoolz.groupby(len,  
                              ['geeks', 'for', 'geeks']))

輸出 -

{5: ['geeks', 'geeks'], 3: ['for']}

isdistinct(seq) -如果序列中的所有元素都不同，則返回 True，否則返回 False。
```
import toolz 
  
print(toolz.itertoolz.isdistinct('geeks')) 
```
輸出 -
```
False
```
可迭代 (x) -如果 x 是可迭代的，則返回 True，否則返回 False。


print(toolz.itertoolz.isiterable([10]))

Output - True

交錯(seq)-它交錯序列，即連接序列index-wise。


import toolz 
  
  
print(list(toolz.itertoolz.interleave([[10, 20],  
                                       [5, 8, 11]])))

輸出 -

[10, 5, 20, 8, 11]

topk(k, seq[, 鍵]) -它返回序列中前 k 個最大的元素。


import toolz 
  
print(list(toolz.itertoolz.topk(2, 
                                [10, 20, 5, 8, 11])))

輸出 -

[20, 11]

唯一(seq[，鍵])-它返回序列的不同元素，就像 set(seq) 一樣。


import toolz 
  
print(list(toolz.itertoolz.unique([10, 
                                   20, 
                                   5, 
                                   8,  
                                   10, 
                                   20])))

輸出 -

[10, 20, 5, 8]

merge_sorted(*seqs, **kwargs) -它以這樣的方式合並已排序的可迭代對象，使得結果集合也已排序。


import toolz 
  
print(list(toolz.itertoolz.merge_sorted([5, 10, 20],  
                                        [4, 12, 24])))

輸出 -

[4, 5, 10, 12, 20, 24]

mapcat(func, seqs) -它將 func 應用於每個序列並連接結果。


import toolz 
  
print(list(toolz.itertoolz.mapcat(lambda iter: [e * 2 for e in iter],  
                                  [[5, 10, 20],  
                                   [4, 12, 24]])))

輸出 -

[10, 20, 40, 8, 24, 48]

刪除(謂詞，序列)-它返回序列中謂詞為 False 的那些元素。它是濾波器的補函數。


import toolz 
  
print(list(toolz.itertoolz.remove(lambda x: x % 2 == 0, 
                                  [5, 21, 4, 12, 24])))

輸出 -

[5, 21]

食譜

函數 -

countby(鍵, seq) -通過關鍵函數對集合中的元素進行計數。


import toolz 
  
  
def iseven(n): 
    return n % 2 == 0
  
print(toolz.recipes.countby(iseven, [12, 123, 1234]))

輸出 -

{True: 2, False: 1}

分區(func，seq)-根據給定函數劃分序列。


import toolz 
  
  
def iseven(n): 
    return n % 2 == 0
  
print(list(toolz.recipes.partitionby(iseven,  
                                     [12, 123,   
                                      31, 1234])))

輸出 -

[(12, ), (123, 31), (1234, )]

沙箱

函數 -

並行.fold(binop, seq[, 默認, Map, …] -減少但不保證有序減少。


import toolz 
  
def sum(a, b): 
    return a + b 
  
print(toolz.sandbox.parallel.fold(sum, [1, 2, 3, 4]))

輸出 -

core.unzip(seq) -拉鏈的倒數。


import toolz 
  
l1, l2 = toolz.sandbox.core.unzip([(0, 1), 
                                   (1, 2), 
                                   (2, 3)]) 
  
print(list(l1), list(l2))

輸出 -

[0, 1, 2] [1, 2, 3]

相關用法

注：本文由純淨天空篩選整理自naina024大神的英文原創作品 Toolz module in Python。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。