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。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。