[Python学习日记-35] Python 中的内置函数（上）

简介

内置函数详解（A-E）

简介

        在 Python 中有很多内置函数，例如 len()，这些函数是 Python 解释器自带的，可以直接使用。本篇将介绍 A-H 的内置函数，下图是官方给出的所有 Python 解释器自带的函数

内置函数官方详解：Built-in Functions — Python 3.12.6 documentation

内置函数详解（A-E）

一、abs()

         求绝对值，该方法将会返回一个数字的绝对值，演示代码如下

abs(-1)

代码输出如下：

二、aiter()

        在 Python 中，aiter() 是一个异步迭代器。它可以用来创建一个异步可迭代对象，该对象可以在异步代码中进行迭代。等同于调用 x.__aiter__()。

        注意：与 iter() 不同的是 aiter() 并没有两个参数的版本。

三、all()

        用于判断给定的可迭代对象（如列表、元组等）的所有元素是否都为真（即非零、非空、非 None 等）。它的语法如下

all(iterable)

参数：

• iterable：表示一个可迭代对象，比如列表、元组、集合、字典、字符串等。

all() 函数返回一个布尔值：

• 如果可迭代对象中所有元素都为 True，则返回 True
• 如果可迭代对象中有任何一个元素为 False 或等价于 False 的值（如空字符串、0、空列表等），则返回 False

演示代码如下

my_list = [True, False, True]
result = all(my_list)
print(result) # 输出 False

my_tuple = (1, 2, 3)
result = all(my_tuple)
print(result) # 输出 True

my_string = "Hello"
result = all(my_string)
print(result) # 输出 True

代码输出如下：

在使用 all() 函数时，需要注意以下几点：

• 如果可迭代对象为空，则 all() 返回 True
• 对于空字符串、空列表、空元组等可迭代对象，all() 返回 True
• 可迭代对象中的元素为零、空、None 等情况时，all() 返回 False
• 可以使用列表推导式或生成器表达式来生成可迭代对象进行判断

四、anext()

         在 Python 中，anext() 是一个异步生成器函数的内置函数。它用于获取异步生成器的下一个值。与普通的迭代器中的 next() 函数类似，anext() 函数在每次调用时都会返回异步生成器产生的下一个值。

        anext() 有一个参数的版本和两个参数的版本，两种版本的语法如下

anext(async_iterator)

anext(async_iterator, default)

参数：

• async_iterator：表示异步迭代器对象。
• default：可选参数，表示当异步迭代器没有更多的值时，返回的默认值。

        anext() 函数会返回一个表示异步迭代器的awaitable对象。可以使用 await 语句来调用 anext() 函数，从而等待异步迭代器生成下一个值。 

五、any()

         在 Python 中，any() 函数用于判断可迭代对象中是否存在至少一个为 True 的元素。它的语法如下

any(iterable)

参数：

• iterable：表示一个可迭代对象，比如列表、元组、集合、字典、字符串等

any() 函数返回一个布尔值：

• 如果可迭代对象中至少有一个元素为 True，则返回 True
• 如果可迭代对象为空，返回 False

演示代码如下

# 判断列表中是否有大于10的元素
my_list = [5, 8, 12, 3, 7]
result = any(x > 10 for x in my_list)
print(result)  # 输出True

# 判断字符串中是否有小写字母
my_string = "Hello World"
result = any(x.islower() for x in my_string)
print(result)  # 输出True

# 判断集合中是否有负数
my_set = {1, 2, 3, -4, 5}
result = any(x < 0 for x in my_set)
print(result)  # 输出True

# 判断字典中是否有值为True的元素
my_dict = {"a": False, "b": True, "c": False}
result = any(my_dict.values())
print(result)  # 输出True

# 判断空列表是否有元素
empty_list = []
result = any(empty_list)
print(result)  # 输出False
 

代码输出如下：

六、ascii()

        在 Python 中，ascii() 函数用于返回一个字符串的 ASCII 表示。它的语法如下

ascii(object)

参数：

• object：表示要转换为 ASCII 表示的对象，可以是字符串、整数等

        ascii() 函数返回一个字符串，其中包含了给定对象的 ASCII 表示。如果对象有 __repr__() 方法，则该方法将被调用来获取对象的字符串表示，然后将其转换为 ASCII 表示。如果对象没有 __repr__() 方法，则将使用默认的 __repr__() 方法来获取对象的字符串表示。

演示代码如下

# 将字符串转换为 ASCII 表示
my_string = "Hello, World!"
ascii_string = ascii(my_string)
print(ascii_string)  # 输出 'Hello, World!'

# 将整数 65 转换为 ASCII 表示
my_int = 65
ascii_int = ascii(my_int)
print(ascii_int)  # 输出 '65'

# 将特殊字符转换为 ASCII 表示
special_char = "@#$%^&*"
ascii_special_char = ascii(special_char)
print(ascii_special_char)  # 输出 '@#$%^&*'

# 将中文字符转换为 ASCII 表示
chinese_char = "你好"
ascii_chinese_char = ascii(chinese_char)
print(ascii_chinese_char)  # 输出 '\u4f60\u597d'

代码输出如下：

        值得注意的是，对于非 ASCII 字符，ascii() 函数会使用 Unicode 转义序列来表示它们。

七、bin()

        在 Python 中，bin() 函数用于将整数转换为二进制字符串表示。它的语法如下

bin(x)

参数：

• x：要转换为二进制的整数

bin() 函数返回一个字符串，表示给定整数的二进制表示。返回的二进制字符串以前缀“0b”开头，表示它是一个二进制数。

演示代码如下

# 将整数转换为二进制字符串
my_int = 10
binary_string = bin(my_int)
print(binary_string)  # 输出 '0b1010'

# 将负数转换为二进制字符串
negative_int = -5
binary_negative = bin(negative_int)
print(binary_negative)  # 输出 '-0b101'

# 将小数转换为二进制字符串
my_float = 3.5
binary_float = bin(my_float)
print(binary_float)  # 抛出 TypeError: 'float' object cannot be interpreted as an integer

代码输出如下：

注意：bin() 函数只能用于整数，如果尝试将浮点数转换为二进制字符串，则会引发一个 TypeError 异常。

八、bool()

        在Python中，bool() 函数用于将给定的值转换为布尔值。它的语法如下

bool(x)

参数：

• x：要转换为布尔值的值

bool() 函数返回一个布尔值，表示给定值的真假。

演示代码如下

# 将整数转换为布尔值
print(bool(0))     # 输出 False
print(bool(10))    # 输出 True

# 将浮点数转换为布尔值
print(bool(0.0))   # 输出 False
print(bool(3.14))  # 输出 True

# 将字符串转换为布尔值
print(bool(''))       # 输出 False
print(bool('Hello'))  # 输出 True

# 将列表转换为布尔值
print(bool([]))       # 输出 False
print(bool([1, 2, 3]))  # 输出 True

# 将字典转换为布尔值
print(bool({}))       # 输出 False
print(bool({'a': 1}))  # 输出 True

代码输出如下：

        根据 Python 的定义，0、空值（None）、空的序列（如空字符串、空列表、空元组等）、空的映射（如空字典）会被视为 False。其他值都被视为True。

九、breakpoint()

        在 Python 中，breakpoint() 是一个内置函数，用于在代码中设置断点。断点是在调试程序时，在程序执行到指定位置时暂停程序的一种方法。当程序执行到 breakpoint() 函数时，会暂停执行并进入调试模式。在调试模式下，可以查看变量的值、执行单行代码、跟踪函数调用等。要使用 breakpoint() 函数，需要在代码中将其放置在希望设置断点的位置。演示代码如下

def my_function():
    print("some code")
    
    breakpoint()  # 设置断点
    
    print("more code")

my_function()

代码输出如下：

 

        值得注意的是，breakpoint() 函数只在 Python 3.7 及以上版本中可用。在 Python 3.6 及以下版本中，可以使用 pdb 工具来实现类似的效果代码如下

import pdb

def my_function():
    print("some code")
    
    pdb.set_trace()  # 设置断点
    
    print("more code")

my_function()

代码输出如下：

十、bytearray()

        在 Python 中，bytearray() 是一个用于创建一个可变的字节数组对象。字节数组是一种类似于列表的数据类型，它可以存储一系列的字节值。与普通的字符串不同，字节数组中的每一个元素是一个范围为0-255的整数，表示一个字节的值。如图所示

        bytearray() 函数可以接受多种参数，用于初始化字节数组对象。具体用法如下：

1、不带参数的情况下，创建一个空的字节数组对象，代码如下

empty_bytearray = bytearray()

代码输出如下：

2、传入一个可迭代对象作为参数，将其转换为字节数组，代码如下

values = [65, 66, 67]  # ASCII码值
byte_array = bytearray(values)
print(byte_array)

代码输出如下：

3、传入一个指定大小的整数作为参数，创建一个指定大小的空字节数组对象，代码如下

size = 5
byte_array = bytearray(size)
print(byte_array)

代码输出如下：

4、传入一个指定大小和初始值的元组作为参数，创建一个指定大小，每个元素都是初始值的字节数组对象，代码如下

size = 3
value = 1
byte_array = bytearray((value,)) * size
print(byte_array)

代码输出如下：

        前面学习字符串的时候提到，字符串是一堆字符组成的字符元组，是不可变的，但是这也不是必然的，我们可以使用创建字节数组对象来通过索引和切片操作来访问和修改其中的元素。还可以使用字节数组对象的方法，如 append()、extend()、insert() 等对字节数组进行操作和修改。下面我们来看其中一种修改演示

        可以看出，对一个字节数值进行了修改后再重新进行解码，字符已经发生了改变。值得注意的是，字节数组对象是可变的，而字节串对象（bytes）是不可变的。因此，如果需要一个不可变的字节序列，应该使用 bytes 类型而不是 bytearray 类型。

十一、bytes()

        bytes() 用于创建一个不可变的字节串对象与上面所提到的 bytearray() 函数形成对比。

        bytes() 函数可以接受多种参数，用于初始化字节串对象。具体用法如下：

1、不带参数的情况下，创建一个空的字节串对象，代码如下

empty_bytes = bytes()
print(empty_bytes)

代码输出如下： 

2、传入一个可迭代对象作为参数，将其转换为字节串，代码如下

values = [65, 66, 67]  # ASCII码值
byte_string = bytes(values)
print(byte_string)

代码输出如下：  

3、传入一个字符串和编码方式作为参数，将字符串转换为字节串，代码如下

string = "Hello"
encoding = "utf-8"
byte_string = bytes(string, encoding)
print(byte_string)

代码输出如下：  

4、通过字面量表示法创建字节串对象，代码如下

byte_string = b'hello'
print(byte_string)

代码输出如下：  

        创建了字节串对象，它的元素是不可变的，无法直接修改。但是可以通过索引和切片操作来访问其中的元素。字节串对象与字符串对象之间可以相互转换，可以使用 encode() 方法将字符串编码为字节串，使用 decode() 方法将字节串解码为字符串，也可以使用 hex() 方法将字节串转换为十六进制。

十二、callable()

        callable() 用于检查对象是否可调用。可调用对象指的是可以像函数一样被调用的对象，包括函数、方法、类以及实现了 __call__() 方法的对象，这个主要用于后面学到的面向对象当中。

        callable() 函数接受一个参数，即需要检查的对象，返回一个布尔值表示对象是否是可调用的。具体用法如下：

1、检查函数是否可调用，代码如下

def my_func():
    print("Hello")

result = callable(my_func)
print(result)  # 输出True

代码输出如下：

2、检查类下的函数是否可调用，代码如下

class MyClass:
    def my_method(self):
        print("Hello")

instance = MyClass()
result = callable(instance.my_method)
print(result)  # 输出True

代码输出如下： 

3、检查类是否可调用（即可以作为构造函数调用），代码如下

class MyClass:
    pass

result = callable(MyClass)
print(result)  # 输出True

代码输出如下： 

4、检查对象是否可调用（是否实现了 __call__() 方法），代码如下

class MyCallable:
    def __call__(self):
        print("Hello")

instance = MyCallable()
result = callable(instance)
print(result)  # 输出True

代码输出如下：

        值得注意的是，callable() 函数只会检查对象本身是否可调用，不会执行对象。

十三、chr()

        chr() 用于将 Unicode 编码转换为对应的字符。

        chr() 函数接收一个整数作为参数，并返回一个代表该整数对应字符的字符串。整数必须是0到1114111（十六进制为0x10FFFF）之间的有效 Unicode 编码。具体用法如下：

1、将整数转换为对应的字符，代码如下

unicode_code = 65
character = chr(unicode_code)
print(character)  # 'A'

代码输出如下：

2、结合循环使用chr()函数，将一系列整数转换为对应的字符，代码如下

unicode_codes = [65, 66, 67]
characters = [chr(code) for code in unicode_codes]
print(characters)  # ['A', 'B', 'C']

代码输出如下： 

        值得注意的是，chr() 函数只能用于将整数转换为单个字符，如果整数超出了有效的 Unicode 编码范围，会抛出 ValueError 异常，如下图所示

十四、classmethod()

        classmethod() 用于定义类方法。类方法是绑定到类而不是实例的方法。可以通过类本身调用，也可以通过类的实例调用。类方法的第一个参数通常被命名为 cls，用于引用类本身。使用 classmethod() 装饰器可以将一个普通的方法转换为类方法。在定义方法时，将 @classmethod 放在方法的上方即可。代码如下

class MyClass:
    x = 10
    
    @classmethod
    def class_method(cls):
        print("This is a class method")
        print(cls.x)  # 使用cls引用类属性

# 调用类方法
MyClass.class_method()

代码输出如下：

        在上面的代码中，class_method() 被定义为类方法。通过使用 @classmethod 装饰器（后面的篇章将会讲到），将其转换为类方法，然后可以通过类本身调用该方法。值得注意的是，类方法可以访问类本身的属性和方法，但不能直接访问实例属性和方法，如果需要在类方法中访问实例属性和方法，可以通过传递一个实例作为参数来实现。

十五、compile()

        compile() 用于将一个字符串或一个代码对象编译为可执行的代码或者一个代码对象。在源码中 compile() 函数的形参有 source、filename、mode、flags（默认为0）、dont_inherit（默认为False）、optimize（默认为-1）参数解释如下

• source：要编译的源代码，可以是一个字符串或者一个代码对象。如果是字符串，使用 mode 参数指定的模式进行编译
• filename：编译代码的文件名。如果代码不是从文件中读取的，可以使用一个虚拟的文件名
• mode：指定编译的模式。可以是以下之一：
  • 'exec'：用于编译包含顶层代码（如模块、脚本）的字符串或代码对象
  • 'eval'：用于编译包含一个表达式的字符串或代码对象
  • 'single'：用于编译包含一系列交互式命令的字符串或代码对象
• flags：可选参数，用于指定编译时的标志和调优选项
• dont_inherit：可选参数，控制是否继承来自外部源代码的编译器标志和设置
• optimize：可选参数，用于控制编译优化级别。默认值为 -1，表示使用默认优化级别

注意：compile() 函数返回一个代码对象。如果编译出错，会抛出一个 SyntaxError 异常。

演示代码如下

source_code = """
def say_hello(name):
    print(f"Hello, {name}!")

say_hello("Python")
"""

compiled_code = compile(source_code, filename="<string>", mode="exec")
exec(compiled_code)    # exec() 函数后面会讲到

代码输出如下：

十六、complex()

        complex() 用于创建一个复数对象。它的语法如下

complex(real, imag)

参数：

• real：表示复数的实部，可以是一个数值或一个字符串
• imag：表示复数的虚部，可以是一个数值或一个字符串

        其中，real 和 imag 都是可选参数，默认值为0。如果省略其中一个参数，则使用默认值0。complex() 函数返回一个表示复数的对象。

演示代码如下

z1 = complex(2, 3)
print(z1)  # 输出: (2+3j)

z2 = complex(4)
print(z2)  # 输出: (4+0j)

z3 = complex("5-2j")
print(z3)  # 输出: (5-2j)

z4 = complex("-1.5")
print(z4)  # 输出: (-1.5+0j)

代码输出如下：

        值得注意的是，复数对象在 Python 中可以进行各种数学运算，如加法、减法、乘法、除法等。可以使用复数对象的属性和方法来获取和操作实部和虚部的值。一般人用不到。

十七、delattr()

        delattr() 用于删除对象的属性，会从对象的命名空间中删除指定的属性。它的语法如下

delattr(object, name)

参数：

• object：表示要删除属性的对象
• name：表示要删除的属性名

演示代码如下

class MyClass:
    def __init__(self):
        self.x = 1
        self.y = 2

obj = MyClass()
print(obj.x)  # 输出: 1

delattr(obj, 'x')
print(obj.x)  # 报错 AttributeError: 'MyClass' object has no attribute 'x'

代码输出如下：

        上面的输出可以看出，在使用 delattr(obj, 'x') 删除了 obj 的属性x。再次打印 obj.x 时，会报 AttributeError 错误，因为这个属性已经被删除了。需要注意的是，如果要删除的属性不存在，delattr() 函数会报 AttributeError 错误。另外，delattr() 函数只能删除对象的属性，不能删除对象的方法。

十八、dict()

        dict() 用于创建一个字典对象。具体用法如下

1、创建一个空字典，代码如下

d = dict()
print(d)

代码输出如下：

2、通过可迭代对象创建字典

        其中这个可迭代对象可以是一个包含键值对的序列（如列表或元组），或者是一个包含可迭代对象（比如一个列表或元组）的序列。

通过传递一个包含键值对的列表，创建了一个字典，代码如下

d = dict([('a', 1), ('b', 2), ('c', 3)])
print(d)   # 输出: {'a': 1, 'b': 2, 'c': 3}

代码输出如下：

除了传递包含键值对的列表外，还传递了一些关键字参数，代码如下

d = dict([('a', 1), ('b', 2), ('c', 3)], x=4, y=5)
print(d)   # 输出: {'a': 1, 'b': 2, 'c': 3, 'x': 4, 'y': 5}

 代码输出如下：

3、通过关键字参数创建字典，代码如下

d = dict(x=1, y=2, z=3)
print(d)   # 输出: {'x': 1, 'y': 2, 'z': 3}

代码输出如下：

        另外，dict() 函数还可以用来进行字典的浅拷贝，例如 d2 = dict(d1)。

十九、dir()

        dir() 用于返回一个对象的所有属性和方法的列表。dir() 函数可以用于任何类型的对象，例如模块、类、实例对象等。它返回的列表包含了对象的所有可访问的属性、方法和特殊方法（以双下划线开头和结尾的方法名）。具体用法如下

1、对于模块和内置对象，可以直接调用 dir() 函数来查看其属性和方法的列表，代码如下

import math
print(dir(math))  # 显示 math 模块的属性和方法列表

print(dir(list))  # 显示列表对象的属性和方法列表

代码输出如下：

2、对于自定义的类，可以调用 dir() 函数来查看类的属性和方法列表，代码如下

class MyClass:
    def __init__(self):
        self.x = 10

    def my_method(self):
        print("This is a method.")

obj = MyClass()
print(dir(obj))  # 显示 obj 对象的属性和方法列表

代码输出如下：

        值得注意的是，dir() 函数只返回对象的可访问属性和方法的名称列表，而不会提供它们的具体值或实现细节。如果想要查看属性和方法的具体信息，可以通过其他方式，例如使用 help() 函数。

二十、divmod()

        divmod() 用于同时执行除法和取模运算，返回一个包含商和余数的元组。divmod(a, b) 接受两个参数 a 和 b，并返回一个包含 a 除以 b 的商和余数的元组（quotient, remainder）。

演示代码如下

result = divmod(10, 3)
print(result)  # 输出 (3, 1)，10 除以 3 的商是 3，余数是 1

result = divmod(25, 7)
print(result)  # 输出 (3, 4)，25 除以 7 的商是 3，余数是 4

result = divmod(100, 10)
print(result)  # 输出 (10, 0)，100 除以 10 的商是 10，余数是 0

代码输出如下：

        值得注意的是，divmod() 函数对整数和浮点数都适用。如果参数是浮点数，则返回结果也将是浮点数。另外，如果除数为零，则会引发 ZeroDivisionError 异常，如下图所示

二十一、enumerate()

enumerate() 用于在迭代时同时获取元素的索引和值。它的语法如下

enumerate(iterable, start)

参数：

•  iterable：可迭代对象
• start：可选的起始索引，默认为0

该函数将返回一个迭代器，迭代器返回的每个元素都是一个包含索引和对应值的元组 (index, value)。

演示代码如下

fruits = ['apple', 'banana', 'cherry']

for index, fruit in enumerate(fruits):
    print(index, fruit)

# 输出：
# 0 apple
# 1 banana
# 2 cherry

# 可以指定起始索引
for index, fruit in enumerate(fruits, start=1):
    print(index, fruit)

# 输出：
# 1 apple
# 2 banana
# 3 cherry

代码输出如下：

        enumerate() 函数常用于遍历列表、元组、字符串等可迭代对象，同时获取元素的索引和值，方便在循环过程中进行操作和处理。

二十二、eval()

        eval() 可以把字符串形式的 list、dict、set、tuple，再转换成其原有的数据类型。它的语法如下

eval(expression, globals, locals)

参数：

•  expression：接受一个字符串形式的表达式作为参数
• globals：可选地接受一个字典形式的全局变量，默认为 None
• locals：可选地接受一个字典形式的局部变量，默认为 None

         该内置函数是 Python 编译器自己使用的，而我们编译好的代码通常都是存储在硬盘当中的，如果需要保存像列表这种可变的数据类型时 Python 会如何操作呢？代码如下

a = [1,2,3,4,5]
f = open("str_list","w")
f.write(a)    # Python 中的数据类型无法直接存入到硬盘当中，需要先转换为字符串再存入
f.close()

        列表直接写入是无法写入的，并且会报 TypeError 的错误，那我们应该如何保存我们已经写好的列表呢？我们可以先把列表转换为字符串后再写入就可以了，代码如下

a = [1,2,3,4,5]
f = open("str_list","w")
f.write(str(a))
f.close()

f = open("str_list","r")
s = f.read()
print(s,":",type(s))
print(s[0])
print(s[1])
print(s[2])
f.close()

代码输出如下：

        从输出来看，重新读取后的代码并不像预想那样 s[0] 为1，s[1] 为2，s[2] 为3，而是变成了  s[0] 为[，s[1] 为1，s[2] 为“,”，这是因为重新读取的列表代码是以字符串形式读取的，我们都知道字符串其实就是有字符组成的字符元组，那自然而然下标为0的就是[，下标为1的就是1，这个时候我们就需要使用 eval() 函数了，代码如下

a = [1,2,3,4,5]
f = open("str_list","w")
f.write(str(a))
f.close()

f = open("str_list","r")
s = eval(f.read())
print(s,":",type(s))
print(s[0])
print(s[1])
print(s[2])
f.close()

代码输出如下：

        eval() 函数在某些情况下非常有用，例如当需要在运行时根据字符串构建动态表达式时。但需要注意的是，eval() 函数具有执行任意代码的能力，因此在使用时应确保输入的字符串是可信的，以避免潜在的安全风险。

二十三、exec()

exec() 是把字符串格式的代码，进行解义并执行，例如 exec("print('helworld')”) ，会解义里面的字符串并执行。它的语法如下

exec(object, globals, locals)

 参数：

• object：接受一个字符串形式的代码块作为参数，可以是任何合法的 Python 代码，如函数定义、类定义、赋值语句等
• globals：可选地接受一个字典形式的全局变量，默认为 None
• locals：可选地接受一个字典形式的局部变量，默认为 None

演示代码如下

# 执行简单的赋值语句
x = 5
exec("y = x + 1")
print(y)
# 输出：6

# 执行函数定义
def hello(name):
    print("Hello, " + name)
    
code = '''
hello("John")
'''
exec(code)
# 输出：Hello, John

# 使用 globals 和 locals 参数
globals_dict = {}
locals_dict = {}
code = '''
x = 10
'''
exec(code, globals_dict, locals_dict)
print(globals_dict)
# 输出：{'x': 10}
print(locals_dict)
# 输出：{}

代码输出如下：

 与 eval() 相同 exec() 函数在某些情况下非常有用，例如在运行时动态执行代码块或者执行一段动态生成的代码。并且 exec() 函数也具有执行任意代码的能力，因此在使用时应确保输入的代码是可信的，以避免潜在的安全风险。