Python 常用内置函数

测试有道

于 2024-08-09 18:52:27 发布

阅读量1.1k

点赞数 9

分类专栏： Python 文章标签： python java 前端

本文链接：https://blog.csdn.net/liujunxhu/article/details/141031064

版权

Python 专栏收录该内容

13 篇文章 1 订阅

订阅专栏

1、enumerate函数

1.1、for循环中使用

1.2、enumerate指定索引的起始值

1.3、enumerate在线程中的作用

2、Map 函数

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

4.3.2. 使用lambda函数作为key

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 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 返回一个迭代器，支持惰性计算，避免了不必要的内存占用，尤其是对于大型数据集

示例：

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