Python中的 Toolz 模块

Toolz包为迭代器、函数和字典提供了一组实用函数。这些函数扩展了标准库itertools和functools ，并大量借鉴了当代函数式语言的标准库。该软件包由以下模块组成 -

• dicttoolz
• 功能工具
• 迭代工具
• 食谱
• 沙盒

dicttoolz

职能 -

• assoc(d, key, value[, factory]) –返回一个带有新键值对的新字典。它不会修改初始字典。

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

  输出 -

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

• assoc_in(d, keys, value[, factory]) –返回一个带有新的、潜在嵌套的键值对的新字典

  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, *keys) –返回一个删除给定键的新字典。它不会修改初始字典。

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

  输出 -

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

• get_in(keys, ds[, default, 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(predicate, d[, factory]) –逐项过滤字典中的项目。

  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[, factory]) –将函数应用于字典项。

  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(predicate, d[, factory]) -它通过键过滤字典中的项目。

  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}
  

• keymap(func, d[, factory] –将函数应用于字典的键。

  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}
  

• merge(*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, keys, func[, default, factory]) –更新嵌套字典中的值。如果 keys = [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(predicate, d[, factory]) –按值过滤字典中的项目。

  import toolz
    
    
  def func(value):
      return 4

  输出 -

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

• valmap(func, d[, factory]) –将函数应用于字典的值。

  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'}
  

功能工具

职能 -

• apply(*func_and_args, **kwargs) -它只是应用一个函数并返回结果。

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

  输出 -

  4
  

• 补码（func）——顾名思义，它转换返回所提供输入的逻辑补码。

  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
  

• compose(*funcs) -它返回一个按顺序应用其他函数的函数。函数从右到左应用。如果没有提供参数，则返回恒等函数(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)
  

  输出 -

  18
  

• compose_left(*funcs) -它返回一个按顺序应用其他函数的函数。函数从左到右应用。如果没有提供参数，则返回恒等函数(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)
  

  输出 -

  36
  

• flip –以相反的顺序调用带有参数的函数。

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

  输出 -

  7 % 3 : 1
  

• identity(x) -身份函数，简单地返回 x。

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

  输出 -

  6
  

• pipe(data, *funcs) –通过一系列函数传递一个值。相当于 compose_left(*funcs)

  import toolz
    
    
  print(toolz.functoolz.pipe(3, double, square))
  

  输出 -

  36
  

• thread_first(val, *forms) –通过一系列函数/表单的线程值。

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

  输出 -

  2
  

• thread_last(val, *forms) –通过一系列函数/表单的线程值。

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

  输出 -

  4
  

迭代工具

职能 -

• 累积(binop, seq[, initial]) -这类似于 'reduce'函数。它重复地将函数应用于累积结果的序列。

  import toolz
  from operator import add
    
  print(list(toolz.itertoolz.accumulate(add, [1, 2, 3, 4])))
  

  输出 -

  [1, 3, 6, 10]
  

• concat(seqs) –连接两个或多个可迭代对象。

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

  输出 -

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

• cons(item, seq) -它在序列的开头添加“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)]
  

• drop(n, seq) -它删除序列的前 n 个元素并返回新序列。

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

  输出 -

  [6, 4, 7]
  

• 频率（序列） -它返回一个字典，其中包含元素及其按顺序计数。它相当于 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
  

• isiterable(x) -如果 x 是可迭代的，则返回 True，否则返回 False。

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

  Output - True
  

• interleave(seqs) -它交错序列，即按索引连接序列。

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

  输出 -

  [10, 5, 20, 8, 11]
  

• topk(k, seq[, key]) –它返回序列的前 k 个最大元素。

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

  输出 -

  [20, 11]
  

• unique(seq[, key]) -它返回序列的不同元素，就像 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]
  

• remove(predicate, seq) –它从序列中返回谓词为 False 的那些元素。是滤波器的补函数。

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

  输出 -

  [5, 21]
  

食谱

职能 -

• countby(key, seq) –通过键函数计算集合的元素。

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

  输出 -

  {True: 2, False: 1}
  

• partitionby(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, )]
  

沙盒

职能 -

• parallel.fold(binop, seq[, default, map, ...] -减少但不保证有序减少。

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

  输出 -

  10

• core.unzip(seq) - zip 的倒数。

  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]