🚀一、常见内置函数

Python 提供了许多内置函数，这些函数无需导入任何模块即可直接使用，极大地丰富了编程的便捷性。以下是一些常用的Python内置函数及其简要说明：

函数	概念
len()	查长度
min()	求最小值
max()	求最大值
sorted()	排序
reversed()	反向（返回一个反转的迭代器）
sum()	求和
bin()	转化二进制
int(‘转化进制数据’，‘进制类型’)	转化为十进制
oct()	转化为八进制
hex()	转化为十六进制
ord()	字符转ASCLL码
chr()	ASCLL码转字符
range()	生成一个给定范围内的数字序列。
…	…

这些只是冰山一角，Python还有许多其他有用的内置函数，建议查阅官方文档或使用help()函数深入学习。

🌈二、高级内置函数

⭐1. enumerate函数

enumerate是Python的一个内置函数，它在遍历（如循环）过程中为可迭代对象（如列表、元组、字符串等）的每个元素生成索引号，这样就可以同时访问到元素的索引和值。这对于需要追踪元素位置的情况非常有用，而无需单独维护一个计数器变量。

基本语法：

enumerate(iterable, start=0)

• iterable：需要遍历的可迭代对象。
• start：索引起始值，默认为0。你可以设置任意整数作为起始索引。

a = ['apple', 'banana', 'orange']
for index, value in enumerate(a):
    print(index, value)

👊2. eval函数

eval() 是 Python 中的一个内置函数，它的作用是执行一个字符串表达式，并返回表达式的值。这个功能强大但也危险，因为它可以执行任意的 Python 代码，这可能导致安全风险，特别是当处理来自不可信来源的数据时。

基本语法：

eval(expression, globals=None, locals=None)

• expression: 要被解析和执行的字符串形式的 Python 表达式。
• globals: 可选参数，一个字典，将用作全局命名空间。如果未提供，则使用当前的全局命名空间。
• locals: 可选参数，一个映射，将用作局部命名空间。如果未提供，则使用当前的局部命名空间。

x = 10
y = 5

# 使用 eval 计算两个数的和
sum_str = "x + y"
result = eval(sum_str)

print("The sum is:", result)  # 输出: The sum is: 15

注意：尽管 eval() 可用于动态执行代码或计算字符串形式的表达式，但应谨慎使用，特别是在处理用户输入时，以避免代码注入攻击。最佳实践是尽量寻找更安全的替代方案，如使用 ast.literal_eval() 处理安全的字面量数据结构，或者直接编写代码来避免执行用户提供的代码。

❤️3. exec函数

exec() 函数也是 Python 的一个内置函数，它用来执行储存在字符串或文件中的 Python 代码。与 eval() 类似，exec() 功能更为强大，可以执行复杂的代码块，包括声明、赋值、函数定义等，而不只是简单的表达式。然而，这也意味着它带来了更大的安全风险，尤其是在执行来自不可信来源的代码时。

基本语法：

exec(object[, globals[, locals]])

• object: 一个包含 Python 代码的字符串，或者一个代码对象。
• globals: 可选参数，一个字典，用作全局命名空间。如果未提供，默认使用当前的全局命名空间。
• locals: 可选参数，一个映射，用作局部命名空间。如果未提供，默认使用全局命名空间的一个拷贝，或者如果提供了 globals 参数且它是一个字典，则使用 globals 的拷贝。

code = """
def greet(name):
    print(f"Hello, {name}!")
greet("World")
"""
# 执行代码
exec(code)

注意：由于 exec() 可以执行任意的 Python 代码，因此也存在一些安全性问题。如果向 exec() 中传入了恶意代码，就可能会导致程序出现安全漏洞。建议只在必要的情况下使用 exec()，并且不要将用户输入的字符串直接作为参数传入。

💥4. eval与exec 中 globals与locals如何用

☔4-1 globals 参数

globals 参数接受一个字典对象，用于指定全局变量的名称和值。当代码块中访问某个未定义的全局变量时，默认会在 globals 参数所指定的字典中查找对应的值。

【示例】：

a = 100
b = 200
my_globals = {"a": 300, "b": 400}
exec("""
def func():
    c = a + b
    print(c)
func()""", my_globals)

使用 exec() 函数来执行函数 func()，并通过 my_globals 参数指定了全局变量 a 和 b 的值为 300 和 400。因此，代码块中计算出的 c 的值为 700。

🎬4-2 locals 参数

locals 参数接受一个字典对象，用于指定局部变量的名称和值。当代码块中声明了一个新的局部变量时（如：x=100），该变量将被添加到 locals 参数所指定的字典中。

【示例】：

my_locals = {}
exec("x = 100", None, my_locals)
print(my_locals["x"])
# 输出 100

exec() 函数执行了一个简单的赋值语句，并将结果保存在 my_locals 字典中。由于局部变量 x 被添加到了 my_locals 中，因此我们可以通过该字典获取变量的值。

locals 参数仅在 exec() 函数中生效。在 eval() 函数中，局部变量会被设置为 eval() 函数内部定义的变量。

【示例】：

x = 100
y = eval("x + 1")
print(y)
# 输出 101

eval() 函数执行了简单的算术表达式，其中包含了全局变量 x。由于 eval() 函数的局部环境是固定的，因此它无法读取或修改其他变量定义。

❤️5. filter函数

filter() 函数是 Python 中的一个内置高阶函数，用于对序列进行过滤操作，构造一个新的迭代器，该迭代器生成满足特定条件的元素。filter() 函数接收两个参数：一个是函数（该函数用于测试序列中的每个元素），另一个是可迭代对象（如列表、元组、字符串等），然后返回一个迭代器，该迭代器生成经过测试函数筛选后的元素。

基本语法：

filter(function, iterable)

• function: 一个函数，它接受一个元素并返回 True 或 False。如果该参数为 None，则假定它是一个身份函数，即只保留那些在布尔上下文中为 True 的元素（例如，非零、非空元素）。
• iterable: 一个可迭代的对象，如列表、元组、字符串等。

【示例】：过滤掉所有的偶数，只保留奇数

numbers = [1, 2, 3, 4, 5, 6]
# 定义一个函数来测试是否为奇数
is_odd = lambda x: x % 2 != 0
# 使用 filter 函数
filtered_numbers = filter(is_odd, numbers)
# 将迭代器转换为列表查看结果
print(list(filtered_numbers))  # 输出: [1, 3, 5]

注意：从 Python 3 开始，filter() 直接返回一个迭代器而不是列表，因此如果需要实际的列表或其他容器，通常需要将结果转换为所需的类型。

👊6. zip函数

zip() 是 Python 中的一个内置函数，用于将多个可迭代对象（如列表、元组、字符串等）打包成一个元组的列表（在 Python 2 中返回列表，在 Python 3 中返回迭代器，但通常习惯性转换为列表使用）。如果传入的各个可迭代对象长度不一致，zip() 函数会以最短的那个对象为准。

迭代器对象（Iterator）是 Python 的内置类型之一，用于对序列进行遍历和访问。所有的 Python 可迭代对象都可以通过 iter() 函数生成一个迭代器。
迭代器的优点在于可以逐个返回元素，从而可以直接在序列上进行操作，而不需要创建一个新的列表或元组。
迭代器有两个常用的方法，即 iter() 和 next()：

• iter()：返回迭代器本身。
• next()：返回当前迭代位置的下一个元素。

基本语法：

zip(iterable1, iterable2, ..., iterableN)

• iterable1, iterable2, ..., iterableN：多个可迭代对象作为参数。

功能说明：

• 当传入两个或多个可迭代对象时，zip() 会将这些可迭代对象中相同位置的元素配对，形成一个元组，然后将这些元组合并成一个列表（或在 Python 3 中直接返回一个迭代器）。
• 如果只有一个可迭代对象被传入，zip() 会将这个对象的元素与它们自己的索引配对。
• 当可迭代对象长度不同时，zip() 会停止于最短的那个可迭代对象结束。

names = ['Alice', 'Bob', 'Charlie']
ages = [24, 30, 22]

# 使用 zip 函数配对姓名和年龄
pairs = list(zip(names, ages))
print(pairs)  # 输出: [('Alice', 24), ('Bob', 30), ('Charlie', 22)]

# 如果有不同长度的列表
heights = [165, 180]
# 配对时以最短的列表为准
short_pairs = list(zip(names, ages, heights))
print(short_pairs)  # 输出: [('Alice', 24, 165), ('Bob', 30, 180)]

解压 zip 对象：
已经创建了一个 zip 对象并想恢复原始的可迭代对象，可以使用 zip(*zipped) 结构，这里的 * 操作符用于解包 zip 对象。

# 假设我们有之前创建的 pairs
pairs = [('Alice', 24), ('Bob', 30), ('Charlie', 22)]

# 解压 pairs 回到 names 和 ages
names_back, ages_back = zip(*pairs)
print(list(names_back))  # 输出: ['Alice', 'Bob', 'Charlie']
print(list(ages_back))   # 输出: [24, 30, 22]

🚲7. map函数

map() 是 Python 的一个内置函数，它接受一个函数和一个或多个可迭代对象作为输入，将函数依次应用于可迭代对象的每个元素上，并返回一个由处理结果组成的迭代器（在 Python 2 中返回列表，在 Python 3 中返回迭代器，通常可以通过 list()、tuple() 等转换为具体的数据结构）。

基本语法：

map(function, iterable1, iterable2, ...)

• function：一个接受单个或多个参数的函数，会被应用到每个迭代器的元素上。
• iterable1, iterable2, ...：一个或多个可迭代对象，这些对象的元素将作为参数传递给 function。

功能说明：

• map() 会遍历每个可迭代对象，并将相应的元素作为参数传递给 function。
• 当提供多个可迭代对象时，function 必须接受与可迭代对象数量相等的参数。
• 如果可迭代对象长度不一致，map() 会以最短的那个为准。

# 将列表中的每个元素平方
numbers = [1, 2, 3, 4]
squared = map(lambda x: x**2, numbers)
print(list(squared))  # 输出: [1, 4, 9, 16]

# 对两个列表中的元素进行相加
nums1 = [1, 2, 3]
nums2 = [4, 5, 6]
sums = map(lambda x, y: x+y, nums1, nums2)
print(list(sums)) 

注意：

• 在 Python 3 中，map() 返回的是一个迭代器，因此通常需要通过 list()、tuple() 或在循环中直接使用来获取具体的结果。
• 使用 map() 可以使代码更加简洁和高效，尤其是配合匿名函数 lambda 使用时，非常适合进行简单的数据处理任务。然而，在某些情况下，列表推导式可能提供更清晰的代码可读性。