目录
[2、Map 函数](#2、Map 函数)
[4.3.1. 使用内置函数作为key](#4.3.1. 使用内置函数作为key)
[4.3.2. 使用lambda函数作为key](#4.3.2. 使用lambda函数作为key)
[4.3.3、 多级排序](#4.3.3、 多级排序)
[6、 eval和exec函数](#6、 eval和exec函数)
[6.1、eval() 函数](#6.1、eval() 函数)
[6.2、exec() 函数](#6.2、exec() 函数)
[7.1、'!s' ，'!r' 和 '!a' 的使用](#7.1、'!s' ，'!r' 和 '!a' 的使用)
1、enumerate函数
功能：用于同时遍历数据对象的索引和值。它常用于迭代序列类型（如列表、元组、字符串等），返回的是一个包含索引和值的元组。
作用：
- 简化代码：避免手动追踪和维护索引变量，使代码更简洁和易读。
- 同时获取索引和值：方便在迭代过程中获取元素的索引，特别适用于需要索引信息的情况。
- 灵活设置起始索引 ：通过
start参数可以设置起始索引值，便于与其他代码或计算习惯对齐。
1.1、for循环中使用
python
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指定索引的起始值
python
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类型我们就可以得知，目前线程数量的多少。
python
import threading
def 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返回一个迭代器，支持惰性计算，避免了不必要的内存占用，尤其是对于大型数据集
示例：
python
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函数会将提供的函数应用于来自多个可迭代对象的对应元素，直到其中一个可迭代对象耗尽为止
示例：
python
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表达式的基本语法如下：
python
lambda 参数列表: 表达式- 这里的"参数列表"是传入函数的参数，它们可以是多个，用逗号分隔。
- 而"表达式"是关于参数的某种运算，其运算结果就是这个函数的返回值。
- 注意，lambda表达式不需要写
return，表达式的计算结果会自动成为这个函数的返回值。
示例
- 1、简单的lambda表达式：
python
# 使用lambda表达式定义一个简单的加法函数
add = lambda x, y: x + y
# 调用这个函数
print(add(3, 5)) # 输出8- 2、结合
map()函数使用：
python
# 使用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()函数使用：
python
# 使用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，则为降序）。
示例：
python
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作为关键字参数，用于指定排序的依据和顺序。
示例：
python
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：按字符串长度排序
python
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：按数字大小排序（字符串形式的数字）
python
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：按元组中某个元素排序
python
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：按字典中的某个值排序
python
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：先按年龄，再按姓名排序
python
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函数的基本语法如下：
python
filter(function, iterable)- function：判断函数。用于判断序列中的元素是否符合某种条件，如果符合条件则返回True，否则返回False。如果function为None，那么会直接返回iterable中的所有真值元素。
- iterable：一个序列，可以是列表、元组、字符串等可迭代对象。
返回值是一个迭代器，包含了所有符合条件（使判断函数返回True）的元素。
示例
python
# 使用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()函数用于执行一个字符串表达式，并返回表达式的值。其基本语法如下：
python
eval(expression, globals=None, locals=None)- expression：必需的参数，表示要计算的Python表达式，以字符串形式给出。
- globals：可选参数，一个字典，用于定义全局变量。如果未提供，则使用当前的全局命名空间。
- locals：可选参数，一个字典，用于定义局部变量。如果未提供，则默认使用globals参数。
示例：
python
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）。其基本语法如下：
python
exec(source, globals=None, locals=None)- source：必需的参数，表示要执行的Python代码，可以是字符串或编译后的代码对象。
- globals和locals：与eval()函数相同，分别用于定义全局和局部命名空间。
python
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参数以限制作用域。比如下面的代码，就禁用了内置模块：
python
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__
示例：
python
示例：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' 的使用
示例：
python
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是一个字符串方法，用于将序列（如列表）中的元素以指定的字符（或字符串）连接生成一个新的字符串。
python
separator = ", "
words = ["Hello", "world", "Python"]
sentence = separator.join(words)
print(sentence) # 输出: Hello, world, Python注意：分割对象储存的对象要为字符串，否则会报错
问题：如果储存非字符串的元组、列表、字典等拼接时报错，比如元组储存数字进行连接，则会报错
示例：
python
a = (1,2,3) #定义元组a
';'.join(a)
#报错:TypeError: sequence item 0: expected str instance, int found解决方案：要将数字连接起来成为一个字符串，则结合for循环语句并将数字转为字符串再连接起来
python
a = (1,2,3) #定义元组a
';'.join(a)
#报错:TypeError: sequence item 0: expected str instance, int found
b = (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