目录
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