Python Toolz 模块

2024 年 8 月 29 日 | 阅读 15 分钟

在本教程中，我们将学习 toolz 模块、它的功能以及如何用它来解决复杂的编程语言问题。

Toolz 包提供了许多用于处理列表、函数和字典的函数。它为 Python 的常规库 itertools 和 functools 提供的功能添加了更多特性。Toolz 模块可以帮助您更有效地处理代码和数据。

此模块包含以下五个子模块 -

Dicttoolz
Functools
Itertools
Recipes
Sandbox

让我们来了解一下这些模块 -

Dicttoolz

dicttoolz 是 Toolz 包中的一个模块，它专门提供用于处理 Python 字典的实用函数。它提供了各种有用的函数，允许您以更有效和便捷的方式操作和交互字典。这些函数扩展了内置字典操作的功能，并提供了附加功能，使处理字典更加容易。

让我们来了解以下函数 -

assoc(d, key, value[, factory]) - 它通过添加一个新的键值对来创建一个新字典。原始字典保持不变。

示例

import toolz
original_dict = {'Java': 0}
new_dict = toolz.dicttoolz.assoc(original_dict, 'Tpoint', 1)
print("Original Dictionary:", original_dict)
print("New Dictionary:", new_dict)

输出

Original Dictionary: {'Java': 0}
New Dictionary: {'Java': 0, 'Tpoint': 1}

assoc_in(d, keys, value[, factory]) - 它通过添加一个新的键值对来生成并返回一个新字典，该键值对可以嵌套在特定键下。原始字典保持不变。

示例

import toolz
original_dict = {'Java': 0}
new_dict = toolz.dicttoolz.assoc_in(original_dict, ['Tpoint'], 1)

print("Original Dictionary:", original_dict)
print("New Dictionary:", new_dict)

输出

Original Dictionary: {'Java': 0}
New Dictionary: {'Java': 0, 'Tpoint': 1}

dissoc(d, *keys) - 它通过从字典中移除指定的键来创建一个新字典。原始字典保持不变。

示例

import toolz

original_dict = {'P': 0, 'e': 1, 't': 2, 'e': 3, 'r': 4}
new_dict = toolz.dicttoolz.dissoc(original_dict, 'e')

print(new_dict)

输出

{'P': 0, 't': 2, 'r':4}

get_in(keys, ds[, default, no_default]) - 它使用一系列键 `[I0, I1, …, IX]` 从嵌套字典 `ds` 中检索值。如果找不到该值，则返回指定的 `default`。

示例

import toolz

nested_dict = {
    'd1': {'k1': 'v1', 'k2': 'v2'},
    'd2': {'k3': {'d2A': {'k4': 'v4'}}}
}

value1 = toolz.dicttoolz.get_in(['d1', 'k2'], nested_dict, default='Not Found')
value2 = toolz.dicttoolz.get_in(['d2', 'k3', 'd2A', 'k4'], nested_dict, default='Not Found')

print(value1)
print(value2)

输出

v2
v4

get_in(keys, ds[, default, no_default]) - 它使用一系列键 [I0, I1, …, IX] 从嵌套字典 `ds` 中检索值。如果找不到该值，则返回指定的 `default`。

示例

import toolz
nested_dict = {
    'd1': {'k1': 'v1', 'k2': 'v2'},
    'd2': {'k3': {'d2A': {'k4': 'v4'}}}
}

value1 = toolz.dicttoolz.get_in(['d1', 'k2'], nested_dict, default='Not Found')
value2 = toolz.dicttoolz.get_in(['d2', 'k3', 'd2A', 'k4'], nested_dict, default='Not Found')

print(value1)
print(value2)

输出

v2
v4

itemmap(func, d[, factory]) - 它将指定的函数应用于字典中的每个项。它创建一个新字典，其中包含将函数应用于每个项的结果。

示例

import toolz

def transform_item(item):
    key, val = item
    return (val, key)

original_dict = {0: 'A', 1: 'B', 3: 'C', 5: 'F'}
transformed_dict = toolz.dicttoolz.itemmap(transform_item, original_dict)

print(transformed_dict)

输出

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

keyfilter(predicate, d[, factory])- 它根据应用于键的指定谓词函数过滤字典项。

示例

import toolz
def filter_func(key):
    return 5 <= len(key) < 7

original_dict = {'': 0, 'julia': 1, 'java': 3, 'javascript': 5}
filtered_dict = toolz.dicttoolz.keyfilter(filter_func, original_dict)

print(filtered_dict)

输出

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

keymap(func, d[, factory]) - 它将指定的函数应用于字典中的每个键。让我们来了解下面的示例。

示例 -

import toolz

def transform_key(key):
    return key.upper()

original_dict = {'': 0, 'julia': 1, 'java': 3, 'javascript': 5}
transformed_dict = toolz.dicttoolz.keymap(transform_key, original_dict)
print(transformed_dict)

输出

{'': 0, 'JULIA': 1, 'JAVA': 3, 'JAVASCRIPT': 5}

merge(*dicts, kwargs) - 它合并一组字典。让我们来了解下面的示例。

示例 -

import toolz

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

print(merged_dict)

输出

{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}
merged_dict = toolz.dicttoolz.merge_with(sum, dict1, dict2)

print(merged_dict)

输出

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

update_in(d, keys, func[, default, factory]) - 它更新嵌套字典中的值。让我们来了解下面的示例。

示例 -

import toolz

def func(value):
    return value // 2

nested_dict = {1: {11: 111}, 2: {22: 222}}
updated_dict = toolz.dicttoolz.update_in(nested_dict, [1, 11], func)

print(updated_dict)

输出

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

valfilter(predicate, d[, factory]) - 它通过值过滤字典中的项。让我们来了解下面的示例。

示例 -

import toolz

def filter_func(value):
    return 4 < len(value) < 7

original_dict = {0: '', 1: 'julia', 3: 'java', 5: 'javascript'}
filtered_dict = toolz.dicttoolz.valfilter(filter_func, original_dict)

print(filtered_dict)

输出

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

valmap(func, d[, factory]) - 它将函数应用于字典的值。让我们来了解下面的示例。

示例 -

import toolz

def transform_value(value):
    return value.upper()

original_dict = {0: '', 1: 'julia', 3: 'java', 5: 'javascript'}
transformed_dict = toolz.dicttoolz.valmap(transform_value, original_dict)

print(transformed_dict)

输出

{0: '', 1: 'JULIA', 3: 'JAVA', 5: 'JAVASCRIPT'}

Functoolz

functoolz 是一个 Python 库，它提供了一系列用于处理函数和可调用对象的实用函数。它通过提供额外的函数来扩展内置 functools 模块的功能，这些函数在函数式编程和数据处理任务中非常有用。

toolz 扩展了 itertools 和 functools 等标准库的功能，而 functoolz 则通过添加函数式编程和数据处理中常见的更多功能来扩展内置的 functools 模块。

该库包含各种函数，可用于组合、柯里化和操作函数等。它提供了一套工具，可以以更函数式、更简洁的方式处理函数，从而实现更清晰、更具表现力的代码。

函数

apply(*func_and_args, **kwargs) - 此函数仅使用提供的参数应用给定的函数并返回结果。

示例 -

import toolz
  
def square(n):
    return n * n
  
result = toolz.functoolz.apply(square, 5)
print(result)

输出

complement(func) - 此函数返回提供函数的输出的逻辑补集。让我们来了解下面的示例 -

示例 -

import toolz
  
def is_even(n):
    return n % 2 == 0
  
is_odd = toolz.functoolz.complement(is_even)
  
print(is_even(7))
print(is_odd(7))

输出

False
True

解释 -

在上面的示例中，complement() 函数用于创建一个新函数 `not_divisible_by_3`，该函数返回 `is_divisible_by_3()` 的相反结果。这使您可以根据需要轻松地切换函数的输出。

compose(*funcs) - 此函数创建一个新函数，该函数以特定顺序（从右到左）应用一系列函数。如果没有提供函数，它将返回身份函数（该函数仅返回其输入而不改变）。

示例 -

import toolz
  
def double(n):
    return n + n
  
def square(n):
    return n * n
  
composed_function = toolz.functoolz.compose(double, square)
result = composed_function(3)
print(result)

输出

解释 -

在示例中，compose() 函数将 double() 和 square() 函数组合起来创建一个新函数。当将此组合函数应用于值 3 时，它首先将其加倍到 6，然后将其平方，得到最终结果 18。

compose_left(*funcs) - 此函数创建一个新函数，该函数以特定顺序（从左到右）应用一系列函数。如果没有提供函数，它将返回身份函数（该函数仅返回其输入而不改变）。

示例 -

import toolz
def double(n):
    return n + n
  
def square(n):
    return n * n
  
composed_function = toolz.functoolz.compose_left(double, square)
result = composed_function(3)
print(result)

输出

解释 -

在示例中，compose_left() 函数将 double() 和 square() 函数组合起来创建一个新函数。当将此组合函数应用于值 3 时，它首先将其平方到 9，然后将其加倍，得到最终结果 18。

flip(oper, a, b) - 此函数在调用函数时反转参数的顺序。

示例

import toolz
  
def divide(a, b):
    return a / b
  
result = toolz.functoolz.flip(divide, 4, 8)
print(result)

输出

2.0

解释 -

在示例中，flip() 函数用于反转调用 `divide()` 函数时参数的顺序。不是 4 / 8，而是 8 / 4，结果商为 `2.0`。

identity(x) - 身份函数按原样返回输入值。

示例 -

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

输出

toolz 包中的 pipe() 函数允许您将一个值按顺序通过一系列函数。这类似于从左到右应用一系列函数。让我们来了解下面的示例 -

示例 -

import toolz
def double(n):
    return n + n
  
def square(n):
    return n * n

result = toolz.functoolz.pipe(3, double, square)
print(result)

输出

在给定的示例中，使用 pipe() 函数，值 3 首先加倍到 6，然后平方，得到最终结果 36。

pipe() - toolz 包中的 pipe() 函数允许您将一个值按顺序通过一系列函数。这类似于从左到右应用一系列函数。

示例 -

import toolz

def double(n):
    return n + n
  
def square(n):
    return n * n

result = toolz.functoolz.pipe(3, double, square)
print(result)

输出

在给定的示例中，使用 pipe() 函数，值 3 首先加倍到 6，然后平方，得到最终结果 36。

thread_last() - `toolz` 包中的 thread_last() 函数允许您将一组函数或形式依次应用于给定值。它的工作方式是将值从左到右通过这些函数/形式进行传递，类似于将线穿过针眼。

示例 -

import toolz
def mod(a, b):
    return a % b
  
def double(n):
    return n + n

result = toolz.functoolz.thread_last(3, (mod, 2), double)
print(result)

输出

解释 -

在此提供的示例中，值 3 首先应用于带有参数 2 的 `mod` 函数，生成输出 1。接下来，使用 double() 函数将输出 1 加倍，通过 thread_last() 得到最终输出 `4`。

Itertoolz

itertoolz 是一个 Python 库，它提供了一组用于处理迭代器和可迭代对象的实用函数。它旨在扩展和增强内置 `itertools` 模块的功能，提供用于常见数据处理任务的附加函数。该库是 `toolz` 生态系统的一部分，该生态系统旨在为 Python 中的函数式编程和数据处理提供各种实用程序。

它提供了允许您高效地对列表、元组、生成器等可迭代对象执行操作的函数。这些函数使您能够使用函数式编程范例来组合复杂的数据转换和操作，从而使您的代码更具可读性和可维护性。

该库包含用于过滤、映射、分组和转换可迭代对象内数据的常见任务的函数。通过使用 itertoolz，您可以编写遵循函数式编程原则的代码，从而实现更模块化的代码。

函数

concat() - concat(seqs) 函数允许将多个序列（如列表）逐个合并。这就像创建一个更长的序列，其中包含原始序列中您提供的所有元素。让我们来了解下面的示例。

示例 -

import toolz
# Define three lists
list1 = [1]
list2 = ['a']
list3 = [2, 3, 4]

# Concatenate the lists using the concat function and convert to a list
result = list(toolz.itertoolz.concat([list1, list2, list3]))
print(result)

输出

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

在此示例中，concat() 函数接受三个列表，并创建一个包含所有元素的新列表，保持其原始顺序。生成的列表 `[1, 'a', 2, 3, 4]` 包含来自所有三个输入列表的元素。

diff() - `diff(*seqs, **kwargs)` 函数允许您比较两个可迭代对象中相应位置的元素。随后，它会生成一个列表，其中包含两个序列之间不同的元素对。

让我们理解以下示例 -

示例 -

import toolz
# Compare elements at corresponding indices and identify differing pairs
result = list(toolz.itertoolz.diff([1, 2, 3], [2, 2, 4]))
print(result)

输出

[(1, 2), (3, 4)]

在此示例中，diff() 函数会检查序列 `[1, 2, 3]` 和 `[2, 2, 4]` 中相同索引处的元素。随后，它会组合对，例如 `(1, 2)` 和 `(3, 4)`，以表示这些相应位置的不同元素。

drop() - `itertoolz` 库中的 `drop(n, seq)` 函数允许您排除序列的前 `n` 个元素。然后返回修改后的序列，不包含那些初始元素。让我们来了解下面的示例 -

示例 -

import toolz
# Drop the first 3 elements from the sequence
result = list(toolz.itertoolz.drop(3, [2, 3, 2, 6, 4, 7]))

print(result)

输出

[6, 4, 7]

在此示例中，`drop` 函数从提供的序列 [2, 3, 2, 6, 4, 7] 中省略前三个元素，得到修改后的序列 [6, 4, 7]。

frequencies(seq) - itertoolz 库中的 `frequencies(seq)` 函数生成一个字典，显示给定序列中元素的出现次数及其计数。此操作类似于使用 collections.Counter。让我们来了解下面的示例。

示例 -

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

输出

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

在此示例中，**frequencies()** 函数会检查提供的序列中的元素，并构建一个字典，显示每个元素的出现次数和计数。

groupby(func, seq) - groupby(func, seq) 函数通过根据应用指定函数的the result 来分组序列的元素来形成一个字典。让我们来了解下面的示例。

示例 -

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

输出

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

在此示例中，**groupby()** 函数将 `len` 函数应用于序列中的每个元素。然后它形成一个字典，其中键代表元素的长度，相应的值是包含该长度的元素列表。

groupby(func, seq) - `groupby(func, seq)` 函数通过根据应用指定函数的the result 来分组序列的元素来形成一个字典。让我们来了解下面的示例 -

示例 -

import toolz

sequence = ['geeks', 'for', 'geeks']
result = toolz.itertoolz.groupby(len, sequence)

print(result)

输出

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

isiterable(x) - `itertoolz` 库中的 `isiterable(x)` 函数确定给定的对象 `x` 是否是可迭代的。如果对象可以被迭代，则返回 `True`；否则返回 `False`。

示例

import toolz
my_list = [10]
result = toolz.itertoolz.isiterable(my_list)

print(result)

输出

True

在此示例中，该函数检查列表 my_list 是否可迭代。由于列表是可迭代对象，因此该函数返回 `True`。

interleave(seqs) - interleave(seqs) 函数通过根据索引交错其元素来组合序列。它将每个序列在相同索引位置的元素连接起来。

示例

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

输出

[10, 5, 20, 8, 11]

在此示例中，该函数交错序列 `[10, 20]` 和 `[5, 8, 11]` 的元素，得到 `[10, 5, 20, 8, 11]`。

topk(k, seq[, key]) - 此函数从序列中选择 k 个最大的元素。它有助于识别集合中的最高值。

示例 -

import toolz
scores = [95, 85, 75, 90, 88, 92]
top_scores = list(toolz.itertoolz.topk(3, scores))
print(top_scores)

输出

[95, 92, 90]

在此示例中，topk() 函数从列表 [95, 85, 75, 90, 88, 92] 中提取三个最高分，得到输出 [95, 92, 90]。

unique(seq[, key]) - 此函数检索并返回序列中的唯一元素，类似于 set() 函数的操作方式。让我们来了解下面的示例。

示例 -

import toolz
colors = ['red', 'blue', 'green', 'blue', 'yellow', 'red']
unique_colors = list(toolz.itertoolz.unique(colors))
print(unique_colors)

输出

['red', 'blue', 'green', 'yellow']

在此示例中，`unique` 函数从列表 `['red', 'blue', 'green', 'blue', 'yellow', 'red']` 中滤除了重复元素，得到输出 `['red', 'blue', 'green', 'yellow']`。

merge_sorted(*seqs, **kwargs) - 此函数将多个已排序的可迭代对象合并到一个已排序的集合中。

示例 -

import toolz
list1 = [3, 8, 15, 22]
list2 = [4, 9, 13, 18]
list3 = [1, 6, 10, 17]
merged_sorted = list(toolz.itertoolz.merge_sorted(list1, list2, list3))
print(merged_sorted)

输出

[1, 3, 4, 6, 8, 9, 10, 13, 15, 17, 18, 22]

在此示例中，`merge_sorted` 函数将已排序的列表 `list1`、`list2` 和 `list3` 合并创建一个已排序的列表 merged_sorted()，其中包含所有元素，按升序排列。

mapcat(func, seqs) - 此函数将指定的函数应用于每个序列，然后将结果连接成一个序列。

示例 -

import toolz

def double_elements(seq):
    return [element * 2 for element in seq]

list1 = [3, 7, 10]
list2 = [5, 8, 12]

result = list(toolz.itertoolz.mapcat(double_elements, [list1, list2]))
print(result)

输出

[6, 14, 20, 10, 16, 24]

在此示例中，`mapcat` 函数将 `double_elements()` 函数应用于输入列表 `list1` 和 `list2`。然后将结果连接到最终的 `result` 列表中。

remove(predicate, seq) - 此函数返回序列中谓词函数返回 False 的元素。可以将其视为 `filter` 函数的补集函数。

示例 -

import toolz
def is_even(x):
    return x % 2 == 0
numbers = [9, 4, 15, 7, 12, 8]
result = list(toolz.itertoolz.remove(is_even, numbers))
print(result)

输出

[9, 15, 7]

在此示例中，`remove` 函数将 `is_even` 谓词函数应用于 `numbers` 列表中的每个元素。谓词返回 False 的元素包含在最终的 `result` 列表中。

Recipes

recipes 指的是一系列常用的函数和工作流程，它们能为各种编程任务提供高效简洁的解决方案。这些 recipes 旨在帮助您以更流畅、更函数式的方式处理迭代器、序列和数据处理。它们利用 toolz 模块提供的函数和实用程序来实现特定目标。

countby() - countby() 函数允许您根据指定的键函数来计算集合的元素。此函数对于根据特定标准对元素进行分类和计数特别有用。它允许您使用选定的键函数对集合中的元素进行分类和计数。这对于根据特定属性组织数据非常有利。

示例 -

import toolz

def is_prime(n):
    if n <= 1:
        return False
    for i in range(2, int(n ** 0.5) + 1):
        if n % i == 0:
            return False
    return True

numbers = [7, 14, 17, 21, 23, 28]

result = toolz.recipes.countby(is_prime, numbers)
print(result)

输出

{True: 3, False: 3}

解释 -

在此示例中，`countby` 函数根据数字是否为素数来对列表中的数字进行分类。生成的字典表明给定的列表中有 3 个素数和 3 个非素数。

partitionby() - partitionby 函数有助于根据指定的函数对序列进行分段。如果连续的元素满足函数设定的条件，则将它们分组在一起。

它允许您根据选定的函数将序列划分为子组。它将满足给定函数标准的连续元素聚集成簇。让我们来了解下面的示例。

示例 -

import toolz
def is_prime(number):
    if number <= 1:
        return False
    for i in range(2, int(number**0.5) + 1):
        if number % i == 0:
            return False
    return True

numbers = [3, 8, 11, 20, 23, 30, 37]

result = toolz.recipes.partitionby(is_prime, numbers)
print(list(result))

输出

[(3,), (8, 11), (20,), (23,), (30,), (37,)]

解释 -

在此示例中，partitionby() 函数将数字列表分割成组，其中连续的数字具有相同的素数状态。生成的元组列表显示了每个组中的数字，基于它们是否为素数。

Sandbox

sandbox 用于一个上下文或环境，您可以在其中尝试 toolz 库提供的各种函数、实用程序和 recipes。这个概念与 toolz 所倡导的函数式编程范例一致。

Functions -

fold(binop, seq[, default, map, ...]) - 此函数使用二元操作对序列进行归约，但不保留归约的顺序。它适用于顺序不重要的场景。例如，您可以使用它来同时对数字列表求和。

示例 -

import toolz    
def product(a, b):
        return a * b
result = toolz.sandbox.parallel.fold(product, [1, 2, 3, 4])
print(result)

输出

unzip(seq): 此函数是 `zip` 操作的逆向操作。它接受一个元组序列并返回两个单独的序列，有效地将元组拆分成它们的各个组成部分。

示例 -

import toolz    
pairs = [(10, 'apple'), (20, 'banana'), (15, 'orange')]
numbers, fruits = toolz.sandbox.core.unzip(pairs)    
print(numbers)
print(fruits)

输出

(10, 20, 15)
('apple', 'banana', 'orange')

结论

toolz 模块是一个强大而通用的模块，它扩展了 Python 内置工具的功能。它提供了一系列函数和 recipes，旨在简化常见的编程任务，例如处理序列、字典和函数式编程构造。该模块分为几个子模块，每个子模块处理数据处理和计算的不同方面。

下一个主题Tensorflow 如何用于预处理花卉训练

Python Toolz 模块

Dicttoolz

Functoolz

Itertoolz

Sandbox

结论

联系信息

关注我们

教程

面试题

在线编译器

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

Python 问题

Python Toolz 模块

Dicttoolz

Functoolz

Itertoolz

Sandbox

结论

相关帖子

如何在 Python 中读取 CSV 文件

Python 中的动态类型

Python 中的运算符优先级和结合性

Python Time asctime() 方法

如何在 Python 中读取文本文件

Python __call__ 方法

Python 随机密码生成器

使用 Selenium Python 的 find_Elements_by_Xpath()

Python 中的自守数

Python 音乐推荐系统项目及源代码

订阅 Tpoint Tech

联系信息

关注我们

教程

面试题

在线编译器

Python call 方法