Python 常用内置函数

1、enumerate函数

1.1、for循环中使用

1.2、enumerate指定索引的起始值

1.3、enumerate在线程中的作用

2、Map 函数

2.1、map()函数可以传多个迭代器对象

3、lambda表达式（匿名函数）

示例

4、sort函数和sorted函数

4.1、sort()函数

4.2、sorted函数

4.3、关键字参数key的使用

4.3.1. 使用内置函数作为key

4.3.2. 使用lambda函数作为key

4.3.3、多级排序

5、filter函数

6、 eval和exec函数

6.1、eval() 函数

6.2、exec() 函数

7、repr函数

7.1、str()和repr()区别

7.1、'!s' ，'!r' 和 '!a' 的使用

8、join函数

1、enumerate函数

功能：用于同时遍历数据对象的索引和值。它常用于迭代序列类型（如列表、元组、字符串等），返回的是一个包含索引和值的元组。

作用：

简化代码：避免手动追踪和维护索引变量，使代码更简洁和易读。
同时获取索引和值：方便在迭代过程中获取元素的索引，特别适用于需要索引信息的情况。
灵活设置起始索引：通过 start 参数可以设置起始索引值，便于与其他代码或计算习惯对齐。

1.1、for循环中使用

dict = [{"name":"Hello", "age":18}, {"name":"Tom", "age":24}, {"name":"Cat", "age":28}]
for index,t in enumerate(dict):
print (index, t)

1.2、enumerate指定索引的起始值

dict = [{"name":"Hello", "age":18}, {"name":"Tom", "age":24}, {"name":"Cat", "age":28}]
for index,t in enumerate(dict, 1):print (index, t)

1.3、enumerate在线程中的作用

1、threading.enumerate(): 返回一个包含正在运行的线程的list。
2、正在运行指线程启动后、结束前，不包括启动前和终止后的线程。
3、返回一个list类型，通过这个list类型我们就可以得知，目前线程数量的多少。

import threadingdef task():time.sleep(3)print("this is task")if __name__ == '__main__':t1 = threading.Thread(target=task)t2 = threading.Thread(target=task)t1.start()t2.start()for i, thread in enumerate(threading.enumerate()):print(f"Thread {i}: {thread.name}")t1.join()t2.join()

2、Map 函数

功能：map 函数用于将指定函数应用于可迭代对象（如列表）的每个元素，并返回一个迭代器，其中包含应用函数后的结果。

语法：map(func, *iterables)

作用：

map 返回一个迭代器，支持惰性计算，避免了不必要的内存占用，尤其是对于大型数据集

示例：

t = ['1', '2', '3', '4', '5', '6']
print(t)
res = map(lambda x: int(x) * int(x), t)
for i in res:print(i, end=' ')
print()
# 此时迭代器中数据已为空
print(list(res))

2.1、map()函数可以传多个迭代器对象

map 函数会将提供的函数应用于来自多个可迭代对象的对应元素，直到其中一个可迭代对象耗尽为止

示例：

list1 = [1, 2, 3, 4, 5]
list2 = [1, 2, 3, 4, 5, 6]
list3 = [1, 2, 3, 4, 5, 6, 7]def func(x, y, z):return x, y, z
# 此处的map函数传入了多个迭代器对象
res = map(func, list1, list2, list3)
# 因为 list1 的长度最短，所以 map 会在 list1 长度的限制下进行映射，即到 list1 的最后一个元素为止
print(list(res))

3、lambda表达式（匿名函数）

Lambda表达式，也称为匿名函数，是Python等编程语言中一种快速定义单行的小函数的方法。使用lambda表达式可以写出更简洁、更清晰的代码，尤其是在需要使用函数对象的场合。Lambda表达式的基本语法如下：

lambda 参数列表: 表达式

这里的“参数列表”是传入函数的参数，它们可以是多个，用逗号分隔。
而“表达式”是关于参数的某种运算，其运算结果就是这个函数的返回值。
注意，lambda表达式不需要写return，表达式的计算结果会自动成为这个函数的返回值。

示例

1、简单的lambda表达式：

# 使用lambda表达式定义一个简单的加法函数  
add = lambda x, y: x + y  # 调用这个函数  
print(add(3, 5))  # 输出8

2、结合map()函数使用：

# 使用lambda表达式和map()函数将列表中的每个元素乘以2  
numbers = [1, 2, 3, 4]  
doubled = map(lambda x: x * 2, numbers)  # 将map对象转换为列表  
doubled_list = list(doubled)  
print(doubled_list)  # 输出[2, 4, 6, 8]

3、结合filter()函数使用：

# 使用lambda表达式和filter()函数过滤出列表中的偶数  
numbers = [1, 2, 3, 4, 5, 6]  
even_numbers = filter(lambda x: x % 2 == 0, numbers)  # 将filter对象转换为列表  
even_numbers_list = list(even_numbers)  
print(even_numbers_list)  # 输出[2, 4, 6]

4、sort函数和sorted函数

4.1、sort()函数

使用对象：sort()是列表（list）对象的一个方法，只能用于列表的排序。
排序方式：sort()方法默认在原列表上进行排序，也就是说，它会改变原列表的元素顺序。
返回值：sort()方法没有返回值，或者说返回值是None。排序结果直接体现在原列表上。
参数：sort()方法接受两个可选的关键字参数key和reverse。key用于指定一个从列表中每个元素提取比较键的函数，reverse用于指定排序顺序（默认为False，即升序；如果为True，则为降序）。

示例：

numbers = [3, 2, 8, 5, 1]  
numbers.sort()  # 默认升序排序  
print(numbers)  # 输出: [1, 2, 3, 5, 8]  numbers.sort(reverse=True)  # 降序排序  
print(numbers)  # 输出: [8, 5, 3, 2, 1]

4.2、sorted函数

使用对象：sorted()是Python的内建函数，可以对任何可迭代对象进行排序，包括列表、元组、字典等。排序后的结果是一个新的列表，原可迭代对象的顺序不会被改变。
排序方式：sorted()函数返回一个新的排序后的列表，原可迭代对象保持不变。
返回值：sorted()函数返回一个新的排序后的列表。
参数：与sort()方法类似，sorted()函数也接受key和reverse作为关键字参数，用于指定排序的依据和顺序。

示例：

numbers = [3, 2, 8, 5, 1]  
sorted_numbers = sorted(numbers)  # 默认升序排序，返回新列表  
print(sorted_numbers)  # 输出: [1, 2, 3, 5, 8]  
print(numbers)  # 输出: [3, 2, 8, 5, 1]，原列表不变  sorted_numbers_desc = sorted(numbers, reverse=True)  # 降序排序  
print(sorted_numbers_desc)  # 输出: [8, 5, 3, 2, 1]

4.3、关键字参数key的使用

4.3.1. 使用内置函数作为key

示例1：按字符串长度排序

words = ['banana', 'apple', 'cherry', 'date']  
words.sort(key=len)  
print(words)  # 输出: ['date', 'apple', 'cherry', 'banana']  # 或者使用sorted()函数，不会改变原列表  
sorted_words = sorted(words, key=len)  
print(sorted_words)  # 输出: ['date', 'apple', 'cherry', 'banana']

示例2：按数字大小排序（字符串形式的数字）

numbers_str = ['10', '3', '22', '1']  
numbers_str.sort(key=int)  
print(numbers_str)  # 输出: ['1', '3', '10', '22']  # 或者使用sorted()函数  
sorted_numbers_str = sorted(numbers_str, key=int)  
print(sorted_numbers_str)  # 输出: ['1', '3', '10', '22']

4.3.2. 使用lambda函数作为key

lambda函数提供了一种快速定义单行小函数的方法，非常适合作为key参数的值。

示例1：按元组中某个元素排序

tuples = [(1, 'apple'), (3, 'banana'), (2, 'cherry')]  
tuples.sort(key=lambda x: x[0])  # 按元组的第一个元素排序  
print(tuples)  # 输出: [(1, 'apple'), (2, 'cherry'), (3, 'banana')]  # 或者按照元组的第二个元素排序  
tuples.sort(key=lambda x: x[1])  
print(tuples)  # 输出: [(1, 'apple'), (3, 'banana'), (2, 'cherry')]

示例2：按字典中的某个值排序

students = [{'name': 'Alice', 'age': 22}, {'name': 'Bob', 'age': 20}, {'name': 'Charlie', 'age': 23}]  
students.sort(key=lambda x: x['age'])  # 按字典中的'age'值排序  
print(students)  
# 输出: [{'name': 'Bob', 'age': 20}, {'name': 'Alice', 'age': 22}, {'name': 'Charlie', 'age': 23}]

4.3.3、多级排序

示例1：先按年龄，再按姓名排序

students = [{'name': 'Alice', 'age': 22}, {'name': 'Bob', 'age': 20}, {'name': 'Alice', 'age': 21}]  
students.sort(key=lambda x: (x['age'], x['name']))  
print(students)  
# 输出: [{'name': 'Bob', 'age': 20}, {'name': 'Alice', 'age': 21}, {'name': 'Alice', 'age': 22}]

5、filter函数

功能：filter函数是Python中的一个内置函数，用于过滤序列，过滤掉那些不符合条件的元素，返回一个迭代器。如果序列中的元素符合某个条件（即函数返回True），则保留这个元素，否则过滤掉。

filter函数的基本语法如下：

filter(function, iterable)

function：判断函数。用于判断序列中的元素是否符合某种条件，如果符合条件则返回True，否则返回False。如果function为None，那么会直接返回iterable中的所有真值元素。
iterable：一个序列，可以是列表、元组、字符串等可迭代对象。

返回值是一个迭代器，包含了所有符合条件（使判断函数返回True）的元素。

示例

# 使用filter函数过滤掉列表中的所有偶数  
def is_odd(n):  return n % 2 == 1  numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9]  
filtered_numbers = filter(is_odd, numbers)  print(list(filtered_numbers))  
# 输出: [1, 3, 5, 7, 9]

6、 eval和exec函数

在Python中，eval()和exec()是两个功能强大的内置函数，它们都能够执行字符串形式的Python代码，但它们在用法和返回值方面存在显著差异。

常见用途：将字符串转成相应的对象，例如 string 转成 list ，string 转成 dict，string 转 tuple 等等。

6.1、eval() 函数

eval()函数用于执行一个字符串表达式，并返回表达式的值。其基本语法如下：

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

expression：必需的参数，表示要计算的Python表达式，以字符串形式给出。
globals：可选参数，一个字典，用于定义全局变量。如果未提供，则使用当前的全局命名空间。
locals：可选参数，一个字典，用于定义局部变量。如果未提供，则默认使用globals参数。

示例：

x = 1  
result = eval('x + 1')  
print(result)  # 输出: 2  # 使用 globals 参数  
result = eval('x + y', {'x': 1, 'y': 2})  
print(result)  # 输出: 3  # 处理复杂表达式  
result = eval('[x**2 for x in range(5)]')  
print(result)  # 输出: [0, 1, 4, 9, 16]

注意事项：

eval()只能执行单个表达式，并返回表达式的值；不支持复杂的代码逻辑，例如赋值操作、循环语句等等。
由于eval()可以执行任意代码，因此存在安全风险，特别是当执行的代码来源于不受信任的来源时。

6.2、exec() 函数

exec()函数用于动态执行Python代码。与eval()不同，exec()可以执行更复杂的代码块，包括多行代码、声明和控制流语句，但它不返回任何值（即返回值为None）。其基本语法如下：

exec(source, globals=None, locals=None)

source：必需的参数，表示要执行的Python代码，可以是字符串或编译后的代码对象。
globals和locals：与eval()函数相同，分别用于定义全局和局部命名空间。

exec("print('Hello, world!')")  # 输出: Hello, world!  # 动态生成变量  
exec("a = 10")  
print(a)  # 输出: 10  # 执行复杂代码块  
code = """  
def greet(name):  return f"Hello, {name}!"  result = greet("Alice")  
print(result)  
"""  
exec(code)  # 输出: Hello, Alice!

注意事项：

exec()可以执行任意代码，因此同样存在安全风险。
使用exec()时，应尽量避免执行不受信任的代码，或明确指定globals和locals参数以限制作用域。比如下面的代码，就禁用了内置模块：

s = {'__builtins__': None}
eval("__import__('os').system('whoami')", s)

7、repr函数

7.1、str()和repr()区别

在 Python 中要将某一类型的变量或者常量转换为字符串对象通常有两种方法，即str() 或者 repr() 。自定义对象输出格式需要重写函数__repr__。

str()和repr()区别：

1、函数str( )将其转化成为适于人阅读的前端样式文本，面向用户
2、函数repr(object)将对象转化为供解释器读取的形式，面向程序员，返回一个对象的 string 格式，并且可以通过eval函数还原为原来的对象。
3、如果两个都重写，那么则优先调用__str__；只重写__repr__,则只调用__repr__

示例：

示例：s = 'python'
a = str(s)
b = repr(s)print(a)
print(b)
print(type(a))
print(type(b))
print(eval(b))print("-" * 100)print(a == b)

运行结果：

注意：

对于字符串类型，repr转换后外层会多一对引号，对于int类型转换为字符串类型不会。
命令行下直接输出对象调用的是对象的repr方法，而print输出调用的是str方法

7.1、'!s' ，'!r' 和 '!a' 的使用

示例：

def __repr__(self):return f"user={self.user!r}, variant={self.variant!r}"result  = func(*args, **kwargs)
print(f" {func.__name__!r} returned {result!r}")

说明：

默认情况下，f 字符串显示对花括号内的值调用str的结果。指定!r显示调用repr的结果。
转换字段在格式化之前会导致类型强制。通常，格式化值的工作是由值本身的format () 方法完成的。但是，在某些情况下，需要强制将类型格式化为字符串，覆盖其自己的格式化定义。通过在调用format ()之前将值转换为字符串，绕过了正常的格式化逻辑。
当前支持三种转换标志：'!s' 调用 str() 值，'!r' 调用 repr() 和 '!a' 调用 ascii()。

8、join函数

它的主要作用是将一个字符串列表（或数组）中的所有元素连接成一个单独的字符串，元素之间可以插入一个指定的分隔符。这个函数在处理文本、生成文件路径或URL时非常有用。

示例：

在Python中，join是一个字符串方法，用于将序列（如列表）中的元素以指定的字符（或字符串）连接生成一个新的字符串。

separator = ", "  
words = ["Hello", "world", "Python"]  
sentence = separator.join(words)  
print(sentence)  # 输出: Hello, world, Python

注意：分割对象储存的对象要为字符串，否则会报错

问题：如果储存非字符串的元组、列表、字典等拼接时报错，比如元组储存数字进行连接，则会报错

示例：

a = (1,2,3) #定义元组a
';'.join(a)#报错:TypeError: sequence item 0: expected str instance, int found

解决方案：要将数字连接起来成为一个字符串，则结合for循环语句并将数字转为字符串再连接起来

a = (1,2,3) #定义元组a
';'.join(a)#报错:TypeError: sequence item 0: expected str instance, int foundb = (186234,1385475,1235462)
';'.join(str(i) for i in b)# 输出结果为：186234;1385475;1235462#调用set函数去重处理
e = (1,2,3,2) #定义元组a
'、'.join(str(i) for i in set(e))# 输出结果为：1、2、3