python高级内置函数介绍及应用举例

1. 概述

Python中有许多高级内置函数，它们提供了丰富的功能和便利性，可以大大简化代码并提高效率。以下是一些常用的高级内置函数：

map()：

用于将一个函数应用于一个可迭代对象的所有项，返回一个新的迭代器。
filter()：

用于根据指定的条件过滤可迭代对象中的元素，返回一个迭代器。
reduce()（在Python 3中被移到了functools模块）：

用于对可迭代对象中的元素进行累积操作，返回一个单一的结果。
lambda函数：

匿名函数，用于快速定义简单的小型函数。
enumerate()：

用于将一个可迭代对象的元素同时返回索引和值。
zip()：

用于将多个可迭代对象的对应位置的元素组合成元组。
any() 和 all()：

用于检查可迭代对象中的元素是否为True。
sorted()：

用于对可迭代对象进行排序。
reversed()：

用于反转一个序列。
min() 和 max()：

用于找到可迭代对象中的最小和最大值。
sum()：

用于对可迭代对象中的所有元素求和。
any() 和 all()：

用于检查可迭代对象中的元素是否为True。
getattr() 和 setattr()：

用于获取和设置对象的属性。
slice()：

用于创建一个切片对象，可以用于切取可迭代对象的一部分。
**zip() 和 *args / kwargs 结合使用：

可以用于函数调用时传递可变数量的参数。
这些高级内置函数可以极大地简化代码并提高代码的可读性和可维护性。同时也能够使得代码更加高效和灵活。

2. 举例

1. map(): 该函数将一个函数应用于给定序列的每个元素，并将每个结果作为一个新序列返回。例如，将一个列表中的所有元素平方：

nums = [1, 2, 3, 4]
squares = list(map(lambda x: x**2, nums))
print(squares)
# 输出: [1, 4, 9, 16]
1
2
3
4

避免 for 循环
假设有一个列表，包含学生的姓名和成绩，如下所示：

提取出成绩值

students = [('Alice', 80), ('Bob', 75), ('Charlie', 90), ('David', 85)]

scores = list(map(lambda x: x[1], students))  
#  输出 [80, 75, 90, 85]
1
2
3
4

根据成绩值匹配对应的学生姓名（先用filter过滤，再用map逐一映射）

sorted_scores = sorted(scores, reverse=True)  #降序

sorted_students = list(map(lambda x: (list(filter(lambda y: y[1]==x, students)))[0], sorted_scores))
# [('Charlie', 90), ('David', 85), ('Alice', 80), ('Bob', 75)]
1
2
3
4

好的应用：

df_ws['is_turn'] = df_ws['ws_equival'].map(lambda x: 1 if x <= 0.99 else (3 if x > 1.03 else 0))
1

title_dictionary = {
 "Mr": "Mr",
 "Mrs": "Mrs",
 "Miss": "Miss",
 "Master": "Master",
 "Don": "Royalty",
 "Rev": "Officer",
 "Dr": "Officer",
 "Mme": "Mrs",
 "Ms": "Mrs",
 "Major": "Officer",
 "Lady": "Royalty",
 "Sir": "Royalty",
 "Mlle": "Miss",
 "Col": "Officer",
 "Capt": "Officer",
 "the Countess": "Royalty",
 "Jonkheer": "Royalty",
 "Dona": 'Mrs'
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

df_titanic['title'] = df_titanic['title'].map(title_dictionary)
df_titanic['title'].value_counts()
1
2

执行结果如下：

Mr         757
Miss       262
Mrs        201
Master      61
Officer     23
Royalty      5
1
2
3
4
5
6

另一个类别

df_ws['is_turn'] = df_ws['ws_equival/ws_lungu'].map(lambda x: 1 if x < 0.987 else (3 if x >= 0.99 else 0))
1

2. filter(): 该函数返回一个由符合条件的元素组成的新序列。例如，从列表中过滤出奇数：

nums = [1, 2, 3, 4]
odd_nums = list(filter(lambda x: x % 2 != 0, nums))
print(odd_nums)
# 输出: [1, 3]
1
2
3
4

3. reduce(): 该函数接收一个函数和一个序列，重复地将函数应用于序列中的元素，最终返回一个单一的值。例如，计算列表中所有元素的和：

对一个列表中的所有数进行求和：

from functools import reduce

nums = [1, 2, 3, 4]
sum = reduce(lambda a, b: a + b, nums)
print(sum)
# 输出: 10
1
2
3
4
5
6

找出一个列表中的最大值：

from functools import reduce

lst = [1, 2, 5, 3, 4]
max = reduce(lambda x, y: x if x > y else y, lst)
print(max)
# 5
1
2
3
4
5
6

将一个列表中的所有字符串连接成一个字符串：

from functools import reduce

lst = ['hello', 'world', 'python']
string = reduce(lambda x, y: x + ' ' + y, lst)
print(string)
# hello world python
1
2
3
4
5
6

计算阶乘：

from functools import reduce

n = 5
factorial = reduce(lambda x, y: x * y, range(1, n+1))
print(factorial)
# 120
1
2
3
4
5
6

将一个列表中的所有元素转换为字符串

from functools import reduce

nums = [1, 2, 3, 4, 5]
string = reduce(lambda x, y: str(x) + ' ' + str(y), nums)
print(string) # '1 2 3 4 5'
1
2
3
4
5

先合并字符串，再转为整数

from functools import reduce

# 定义转换函数
def str_to_int(s):
    return int(s)

# 定义拼接函数
def concat(s1, s2):
    return s1 + s2

# 定义字符串列表
str_list = ['1', '2', '3', '4', '5']

# 使用reduce函数执行拼接和转换操作
result = reduce(concat, str_list)
result = str_to_int(result)

print(result)
# 12345
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

from functools import reduce
import pandas as pd

# 假设df4, df5, df6, df7, df8, df9是已经定义好的DataFrame列表
dataframes = [df4, df5, df6, df7, df8, df9]

# 使用reduce和merge来合并所有DataFrame
merged_df = reduce(lambda left, right: pd.merge(left, right, on='time', how='inner'), dataframes)
1
2
3
4
5
6
7
8

4. sorted(): 该函数返回一个排序后的序列。例如，对一个列表进行排序：

nums = [4, 2, 5, 1, 3]
sorted_nums = sorted(nums)
print(sorted_nums)
# 输出: [1, 2, 3, 4, 5]
1
2
3
4

5. zip(): 该函数将多个序列并排组合成一个新的序列。例如，将两个列表按位合并：

first_names = ["John", "Jane", "Bob"]
last_names = ["Doe", "Smith", "Johnson"]
names = list(zip(first_names, last_names))
print(names)
# 输出: [("John", "Doe"), ("Jane", "Smith"), ("Bob", "Johnson")]
1
2
3
4
5

6. enumerate()：

介绍：enumerate() 用于将一个可迭代对象的元素同时返回索引和值。
应用举例：

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(index, fruit)
# 输出:
# 0 apple
# 1 banana
# 2 cherry
1
2
3
4
5
6
7

7. 匿名函数（lambda函数）：

介绍：lambda函数是一种简洁的定义小型函数的方式，通常用于需要一个简单的函数的情况。
应用举例：

add = lambda x, y: x + y
result = add(3, 5)
# 输出: 8
1
2
3

Lambda函数经常与map和filter函数一起使用。Lambda用于定义map或filter应该采用的操作。

# 使用Lambda和map函数将列表中的所有元素转换为字符串
a = [1, 2, 3, 4, 5]
a = list(map(lambda x: str(x), a))

# 使用Lambda和filter函数从列表中过滤出符合条件的元素
a = [1, 2, 3, 4, 5]
a = list(filter(lambda x: x % 2 == 0, a))
1
2
3
4
5
6
7

排序：Lambda函数可以用于对列表或其他数据结构进行排序。

# 使用Lambda对字符串列表进行排序
a = ['apple', 'banana', 'orange', 'pear']
a.sort(key=lambda x: len(x))

# 使用Lambda对字典列表进行排序
a = [{'name':'John', 'age':25}, {'name':'Jane', 'age':30}, {'name':'Bob', 'age':20}]
a.sort(key=lambda x: x['age'])
1
2
3
4
5
6
7

元素的多条件过滤：Lambda函数可以用于对具有多个条件的元素进行过滤。

# 使用Lambda和filter函数从列表中过滤出符合两个条件的元素
a = [{'name':'John', 'age':25}, {'name':'Jane', 'age':30}, {'name':'Bob', 'age':20}]
a = list(filter(lambda x: x['age'] > 20 and x['name'].startswith('J'), a))
1
2
3

函数作为参数：Lambda函数可以作为其他函数的参数。在这种情况下，Lambda函数可以用于定义函数应该采取的操作。

一个例子是在 Python 中使用内置的 sorted() 函数来对一个列表进行排序。sorted() 函数可以使用 Lambda 函数作为其 key 参数，以指定排序的方式。例如，以下代码将一个字符串列表按照其长度从短到长进行排序：

# 使用Lambda函数作为sorted函数的key参数
words = ['apple', 'banana', 'cherry', 'date', 'elderberry']
sorted_words = sorted(words, key=lambda x: len(x))
print(sorted_words)
1
2
3
4

输出为：[‘date’, ‘apple’, ‘banana’, ‘cherry’, ‘elderberry’]。

在这个例子中，Lambda 函数 lambda x: len(x) 作为 key 参数被传递给 sorted() 函数，它告诉 sorted() 函数，对于列表中的每个元素 x，应该使用其长度作为排序的关键。这样，sorted() 函数就可以生成一个按照字符串长度排序的新列表 sorted_words。

8. any() 和 all()：
   在 Python 中，any() 和 all() 都是用于对可迭代对象进行逻辑判断的函数。

any() 函数接受一个可迭代对象作为参数，返回 True 或 False。如果可迭代对象中至少有一个元素为 True，那么返回 True，否则返回 False。例如：

>>> any([False, True, False])
True
>>> any([False, False, False])
False
1
2
3
4

all() 函数也接受一个可迭代对象作为参数，返回 True 或 False。如果可迭代对象中的所有元素都为 True，那么返回 True，否则返回 False。例如：

>>> all([True, True, True])
True
>>> all([True, False, True])
False
1
2
3
4

需要注意的是，如果可迭代对象为空，那么 any() 和 all() 都会返回 False。

all函数在Python中用于判断一个可迭代对象中的所有元素是否都为True。如果所有元素都为True，则返回True，否则返回False。

下面是一个all函数的应用举例：

# 判断列表中的所有元素是否都为正数
lst = [1, 2, 3, 4, 5]
if all(i > 0 for i in lst):
    print("所有元素都为正数")
else:
    print("存在非正数元素")

# 输出结果：所有元素都为正数


# 判断字符串中的所有字符是否都为小写字母
s = "hello world"
if all(c.islower() for c in s):
    print("所有字符都为小写字母")
else:
    print("存在非小写字母字符")

# 输出结果：所有字符都为小写字母


# 判断字典中的所有值是否都大于10
d = {'a': 12, 'b': 13, 'c': 9}
if all(v > 10 for v in d.values()):
    print("所有值都大于10")
else:
    print("存在值小于等于10的键值对")

# 输出结果：存在值小于等于10的键值对
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28

从上面的三个例子可以看出，all函数可以用于判断各种类型的可迭代对象中的元素是否都满足条件，其语法为：all(iterable)，其中iterable为一个可迭代对象。

any函数是Python内置函数之一，用于判断可迭代对象中是否有元素为True。以下是几个any函数的应用示例：

1. 检查列表中是否有偶数

numbers = [1, 3, 5, 6, 7, 9]
if any(number % 2 == 0 for number in numbers):
    print("列表中存在偶数")
else:
    print("列表中不存在偶数")
1
2
3
4
5

2. 检查字符串中是否包含特定字符

string = "Hello World"
if any(char.isdigit() for char in string):
    print("字符串中存在数字")
else:
    print("字符串中不存在数字")
1
2
3
4
5

3. 检查字典中是否存在指定值

dictionary = {"apple": 2, "banana": 4, "orange": 1}
if any(value == 4 for value in dictionary.values()):
    print("字典中存在值为4的键值对")
else:
    print("字典中不存在值为4的键值对")
1
2
3
4
5

9. getattr() 和 setattr()：
getattr() 和 setattr() 是 Python 内置函数，用于获取和设置对象的属性。

getattr() 用于获取对象的属性值，语法为：

getattr(object, name[, default])
1

其中，object 为对象，name 为属性名，default 为默认值，如果对象没有该属性，则返回默认值。如果不提供默认值，当对象没有该属性时会抛出 AttributeError 异常。

在Python中，使用getattr函数的主要场景是你无法确定要访问哪个属性，或者需要在运行时动态地决定访问哪个属性。以下是一些必须使用getattr的情况：

• 当你需要根据用户的输入或其他动态因素来决定访问哪个属性时，getattr 可以用来动态地取出属性的值。比如，用户可能会告诉你“给我看看alex的体重”，这时你可以用getattr(alex,‘weight’)来取出体重的值。
• 当对象有多个属性，并且你需要根据特定的条件来访问其中的一个或多个属性时，getattr 可以帮助你动态地访问这些属性。
• 当某些属性可能不存在于对象上，但你仍希望访问它们时，getattr 可以避免抛出 AttributeError 异常。你可以提供一个默认值，当属性不存在时，返回这个默认值。
• 总的来说，如果你需要更多的动态性和错误处理，或者需要在运行时决定访问哪个属性，那么使用getattr是很有用的。但在大多数情况下，使用点运算符（obj.attribute）是更简洁和直观的方式。
  示例：

class MyClass:
    my_attr = 42

obj = MyClass()
print(getattr(obj, 'my_attr'))  # 输出 42
print(getattr(obj, 'not_exist_attr', 'default_value'))  # 输出 default_value
1
2
3
4
5
6

上述代码，也可以直接通过’.'来获取属性：

print(obj.my_attr)
1

二者对比：（在灵活性上有优势）

getattr 函数是 Python 的内置函数，用于动态地获取对象的属性。它的优点主要有以下几点：

• 动态性：getattr 可以用于在运行时动态地获取对象的属性，这在一些需要动态属性访问的场景下非常有用。
• 错误处理：当试图访问一个不存在的属性时，getattr 不会像使用点运算符那样抛出 AttributeError 异常，而是返回一个默认值（如果提供的话）。这有助于编写更健壮的代码，避免因为属性不存在而导致的程序崩溃。
• 灵活性： getattr 可以接受一个默认值参数，当属性不存在时返回该默认值，而不是抛出异常。这可以让代码更灵活地处理缺失的属性。

然而，这些优点并不总是必需的。在许多常见情况下，使用点运算符来访问对象的属性更加简洁和直观。因此，除非有特定的需求需要使用 getattr，否则通常推荐使用点运算符。

setattr() 用于设置对象的属性值，语法为：
任何需要动态设置或更改属性值的情况都可能需要使用该函数。

setattr(object, name, value)
1

其中，object 为对象，name 为属性名，value 为属性值。

示例：

class MyClass:
    my_attr = 42

obj = MyClass()
setattr(obj, 'my_attr', 100)
print(obj.my_attr)  # 输出 100
setattr(obj, 'my_attr2', 400)
print(obj.my_attr2)  # 输出 400
1
2
3
4
5
6
7
8

这些函数是Python中内置的非常有用的高级函数，可以大大简化代码，提高效率。