Python第三方库pydash功能介绍

本文来自ChatGPT的回答整理

demo部分都验证过ok

介绍

pydash 是一个 Python 库，用于提供类似于 JavaScript 库 lodash 的功能。lodash 是一个在 JavaScript 中广泛使用的实用工具库，用于简化常见的操作，例如数组和对象的操作、函数式编程等。而 pydash 则是为 Python 提供类似的功能。

pydash 提供了许多实用的函数，可以用于集合操作（如列表和字典）、函数式编程、数据处理等。它可以帮助简化代码并提高代码的可读性和可维护性。一些常见的用途包括：

1. 集合操作：pydash 提供了许多操作集合数据（如列表和字典）的函数，如过滤、映射、排序、去重等。

2. 函数式编程：pydash 支持函数式编程范式，可以使用函数来转换和处理数据，从而减少副作用和改进代码的可测试性。

3. 链式操作：你可以使用链式语法来依次应用多个操作，这可以使代码更紧凑且易于理解。

4. 管道操作：类似于函数式编程中的管道操作，可以将一个操作的结果传递给另一个操作，形成数据处理流程。

5. 条件操作：pydash 提供了一些条件判断函数，用于处理逻辑判断。

6. 深度嵌套对象的处理：pydash 可以帮助你轻松地处理多层嵌套的对象，避免手动的深度访问。

以下是 pydash 可能包含的一些常用函数：

• map_
• filter_
• reduce_
• sort_by
• uniq
• chunk
• flatten
• omit
• pick
• deep_get
• deep_set

需要注意的是，虽然 pydash 提供了很多方便的函数，但在使用时也要根据具体情况权衡使用，以确保代码的可读性和性能。

map_ 映射

当提到 map_ 函数时，我想您可能是指 pydash 库中的 map_ 函数，它类似于 Python 内置的 map 函数，但具有一些额外的功能和灵活性。下面是一些使用 pydash 中的 map_ 函数的示例代码：

示例代码：

from pydash import map_

# 示例1：将列表中的每个元素平方
numbers = [1, 2, 3, 4, 5]
squared_numbers = map_(numbers, lambda x: x ** 2)
print(squared_numbers)  # 输出: [1, 4, 9, 16, 25]

# 示例2：提取字典中每个值的长度
person = {'name': 'Alice', 'age': '30', 'city': 'Wonderland'}
value_lengths = map_(person, len)
print(value_lengths)  # 输出: [5, 2, 10]

# 示例3：使用对象的属性作为映射函数
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

students = [Student('Alice', 25), Student('Bob', 22), Student('Charlie', 28)]
student_names = map_(students, 'name')
print(student_names)  # 输出: ['Alice', 'Bob', 'Charlie']

# 示例4：
age = map_([{'name': 'moe', 'age': 40},
                  {'name': 'larry', 'age': 50},], 'age')
print(age) # [40, 50]

在上述示例中，map_ 函数的第一个参数是要进行映射的集合，第二个参数可以是函数或字符串。如果是函数，它将应用于集合的每个元素；如果是字符串，它将被用作从集合的每个元素中提取的属性名。

请注意，这里使用的是 pydash 中的 map_ 函数，而不是 Python 内置的 map 函数。它们的区别在于 pydash 的版本提供了更多的功能和灵活性。

filter_ 过滤

当提到 filter_ 函数时，我认为您可能是指 pydash 库中的 filter_ 函数，它类似于 Python 内置的 filter 函数，但具有一些额外的功能和灵活性。

示例代码：

from pydash import filter_

# 示例1：从列表中筛选出所有偶数
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers = filter_(numbers, lambda x: x % 2 == 0)
print(even_numbers)  # 输出: [2, 4, 6, 8, 10]

# 示例2：从字典中筛选出所有年龄大于等于 30 的人
people = [
    {'name': 'Alice', 'age': 25},
    {'name': 'Bob', 'age': 35},
    {'name': 'Charlie', 'age': 28},
    {'name': 'David', 'age': 40}
]
senior_people = filter_(people, lambda person: person['age'] >= 30)
print(senior_people)  # 输出: [{'name': 'Bob', 'age': 35}, {'name': 'David', 'age': 40}]

# 示例3：筛选出对象列表中特定属性的值满足条件的对象
class Product:
    def __init__(self, name, price):
        self.name = name
        self.price = price

products = [Product('Apple', 1.0), Product('Banana', 0.5), Product('Orange', 2.0)]
expensive_products = filter_(products,  lambda product: product.price >= 1.0)
print([product.name for product in expensive_products]) # ['Apple', 'Orange']

在上述示例中，filter_ 函数的第一个参数是要进行过滤的集合，第二个参数可以是函数或字典。如果是函数，它将应用于集合的每个元素，返回 True 或 False；如果是字典，它将用于筛选出属性满足特定条件的对象。

请注意，这里使用的是 pydash 中的 filter_ 函数，而不是 Python 内置的 filter 函数。它们的区别在于 pydash 的版本提供了更多的功能和灵活性。

flattern 展平

当提到 flatten 函数时，我认为您可能是指 pydash 库中的 flatten 函数，它用于将嵌套的列表（或其他可迭代对象）展平为单层列表。下面是使用 pydash 中的 flatten 函数的一些示例代码：

示例代码：

from pydash import flatten,flatten_deep

# 示例1：展平嵌套的列表
nested_list1 = [[1, 2, 3], [4, 5], [6, 7, 8]]
flattened_list = flatten(nested_list1)
print(flattened_list)  # 输出: [1, 2, 3, 4, 5, 6, 7, 8]

# 示例2：展平多层嵌套的列表
nested_list2 = [1, 2, [3, [4, 5, [6, 7]]]]
flattened_list21 = flatten(nested_list2) # 只展平一层
flattened_list22 = flatten_deep(nested_list2) # 递归展平多层
print(flattened_list21)  # 输出: [1, 2, 3, [4, 5, [6, 7]]]
print(flatten(flattened_list21))  # 输出: [1, 2, 3, 4, 5, [6, 7]]

print(flattened_list22)  # 输出: [1, 2, 3, 4, 5, 6, 7, 8]

在上述示例中，flatten 函数会将嵌套的可迭代对象中的所有元素展平为一个单层列表。你可以通过设置 none_values 参数来指定是否忽略 None 值。默认情况下，none_values 参数为 False，即不忽略 None 值。

请注意，这里使用的是 pydash 中的 flatten 函数。如果你想要使用 Python 内置的方法来展平列表，你也可以考虑使用递归或其他方式来实现。

sort_by 排序

当提到 sort_by 函数时，我认为您可能是指 pydash 库中的 sort_by 函数，它用于根据给定的条件对集合进行排序。

示例代码：

from pydash import sort_by

# 示例1：按照数字大小对列表进行排序
numbers = [10, 5, 8, 3, 1]
sorted_numbers = sort_by(numbers)
print(sorted_numbers)  # 输出: [1, 3, 5, 8, 10]

# 示例2：按照字符串长度对字符串列表进行排序
words = ['apple', 'banana', 'cherry', 'date', 'elderberry']
sorted_words_by_length = sort_by(words, len)
print(sorted_words_by_length)  # 输出: ['date', 'apple', 'banana', 'cherry', 'elderberry']

# 示例3：按照字典的某个属性对字典列表进行排序
people = [
    {'name': 'Alice', 'age': 30},
    {'name': 'Bob', 'age': 25},
    {'name': 'Charlie', 'age': 35}
]
sorted_people_by_age = sort_by(people, 'age')
print(sorted_people_by_age)
# 输出: [{'name': 'Bob', 'age': 25}, {'name': 'Alice', 'age': 30}, {'name': 'Charlie', 'age': 35}]

在上述示例中，sort_by 函数用于对集合进行排序。它的第一个参数是要排序的集合，第二个参数可以是一个函数或字符串。如果是函数，它将用于从集合的每个元素中提取用于排序的值；如果是字符串，它将被用作字典中的键来提取排序值。

请注意，这里使用的是 pydash 中的 sort_by 函数。如果你想要使用 Python 内置的 sorted 函数来实现排序，你也可以使用类似的逻辑来提取排序值并应用排序。

uniq 去重

当提到 uniq 函数时，我认为您可能是指 pydash 库中的 uniq 函数，它用于从列表中移除重复的元素，返回一个不包含重复元素的新列表。

示例代码：

from pydash import uniq

# 示例1：从列表中移除重复的整数
numbers = [1, 2, 2, 3, 4, 4, 5]
unique_numbers = uniq(numbers)
print(unique_numbers)  # 输出: [1, 2, 3, 4, 5]

# 示例2：从列表中移除重复的字符串
words = ['apple', 'banana', 'apple', 'cherry', 'banana']
unique_words = uniq(words)
print(unique_words)  # 输出: ['apple', 'banana', 'cherry']

# 示例3：从列表中移除重复的字典
people = [
    {'name': 'Alice', 'age': 25},
    {'name': 'Bob', 'age': 30},
    {'name': 'Alice', 'age': 25}
]
unique_people = uniq(people)
print(unique_people)
# 输出: [{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}]

在上述示例中，uniq 函数用于从列表中移除重复的元素，返回一个只包含不重复元素的新列表。请注意，重复的定义是基于元素的值。对于字典等复杂对象，只有对象的值相等才被认为是重复的。

请注意，这里使用的是 pydash 中的 uniq 函数。如果你想要使用 Python 内置的方式来实现去重，你可以使用集合 (set) 或循环来进行处理。

chunk 分割成块

当提到 chunk 函数时，我认为您可能是指 pydash 库中的 chunk 函数，它用于将一个列表分割成块，每个块包含特定数量的元素（最后一个块可能包含较少的元素）。

示例代码：

from pydash import chunk

# 示例1：将列表分割成大小为3的块
numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
chunked_numbers = chunk(numbers, 3)
print(chunked_numbers)  # 输出: [[1, 2, 3], [4, 5, 6], [7, 8, 9], [10]]

# 示例2：将字符串分割成大小为2的块
text = "Hello, world!"
chunked_text = chunk(text, 2)
print(chunked_text)  # 输出: ['He', 'll', 'o,', ' w', 'or', 'ld', '!']

# 示例3：将列表分割成大小为2的块，同时保留不足块大小的元素
data = [1, 2, 3, 4, 5]
chunked_data = chunk(data, 2)
print(chunked_data)  # 输出: [[1, 2], [3, 4], [5]]

在上述示例中，chunk 函数用于将一个列表分割成块，每个块包含指定数量的元素。最后一个块可能会包含少于指定数量的元素，取决于原始列表的长度。这在处理分页、批处理等情况时非常有用。

请注意，这里使用的是 pydash 中的 chunk 函数。如果你想要使用 Python 内置的方式来实现分块，你可以使用循环和切片来实现类似的效果。

omit 删除

当提到 omit 函数时，我认为您可能是指 pydash 库中的 omit 函数，它用于从字典或对象中删除指定的属性。

示例代码：

from pydash import omit

# 示例1：从字典中删除指定的属性
person = {'name': 'Alice', 'age': 30, 'city': 'Wonderland'}
omitted_person = omit(person, ['age', 'city'])
print(omitted_person)  # 输出: {'name': 'Alice'}

# 示例2：从对象中删除指定的属性
class Student:
    def __init__(self, name, age):
        self.name = name
        self.age = age

student = Student('Bob', 22)
omitted_student = omit(student, ['age'])
print(omitted_student)  # 输出: {'name': 'Bob'}

在上述示例中，omit 函数用于从字典或对象中删除指定的属性，返回一个新的字典或对象，不包含被删除的属性。

请注意，这里使用的是 pydash 中的 omit 函数。如果你想要使用 Python 内置的方式来删除字典或对象中的属性，你可以使用 del 关键字或使用字典/对象的 pop 方法来实现类似的效果。

pick 摘取

当提到 pick 函数时，我认为您可能是指 pydash 库中的 pick 函数，它用于从字典或对象中选取指定的属性。

示例代码：

from pydash import pick

# 示例1：从字典中选取指定的属性
person = {'name': 'Alice', 'age': 30, 'city': 'Wonderland'}
picked_attributes = pick(person, ['name', 'age'])
print(picked_attributes)  # 输出: {'name': 'Alice', 'age': 30}

# 示例2：从对象中选取指定的属性
class Student:
    def __init__(self, name, age, major):
        self.name = name
        self.age = age
        self.major = major

student = Student('Bob', 22, 'Computer Science')
picked_attributes = pick(student, ['name', 'major'])
print(picked_attributes)  # 输出: {'name': 'Bob', 'major': 'Computer Science'}

在上述示例中，pick 函数用于从字典或对象中选取指定的属性，返回一个新的字典或对象，只包含被选取的属性。

请注意，这里使用的是 pydash 中的 pick 函数。如果你想要使用 Python 内置的方式来选取字典或对象中的属性，你可以手动创建一个新的字典或对象，并复制所需的属性。