内建函数

abs()

返回一个数的绝对值

语法

abs(x)

参数

• x：要求绝对值的数值。

返回值

• abs() 函数返回 x 的绝对值，如果 x 是整数或浮点数，则返回一个非负数；如果 x 是复数，则返回其模。

示例

print(abs(-5))       # 5
print(abs(3.14))     # 3.14
print(abs(-2.5))     # 2.5
print(abs(0))        # 0

complex_num = 3 + 4j
print(abs(complex_num))  # 5.0

在上面的示例中，abs(-5) 返回 5，因为 -5 的绝对值是 5。

abs(3.14) 返回 3.14，因为 3.14 本身就是非负数。

abs(-2.5) 返回 2.5，因为 -2.5 的绝对值是 2.5。

abs(0) 返回 0，因为 0 的绝对值也是 0。

abs(complex_num) 返回 5.0，因为 complex_num 是一个复数，其模为 5.0。

all()

如果可迭代对象中的所有元素都为 True，则返回 True，否则返回 False

判断可迭代对象中的所有元素是否都为真（非零、非空、非None）。如果可迭代对象中的所有元素都为真，则 all() 返回 True；如果可迭代对象中存在一个或多个元素为假，则 all() 返回 False。

语法

all(iterable)

参数

• iterable：可迭代对象，如列表、元组、集合、字典等。

返回值

• all() 函数返回一个布尔值，如果可迭代对象中的所有元素都为真，则返回 True，否则返回 False。

示例

list1 = [True, True, True]
print(all(list1))    # True，因为列表 list1 中的所有元素都为真。

list2 = [True, False, True]
print(all(list2))    # False，因为列表 list2 中存在一个假元素。

tuple1 = (1, 2, 3)
print(all(tuple1))   # True，因为元组 tuple1 中的所有元素都为真。

set1 = {0, 1, 2}
print(all(set1))     # False，因为集合 set1 中存在一个假元素。

dict1 = {'name': 'John', 'age': 25}
print(all(dict1))    # True，因为字典 dict1 中的所有键都被视为真。

empty_list = []
print(all(empty_list))  # True，空列表视为全部为真

any()

any() 是一个 Python 内置函数，用于判断可迭代对象中的元素是否有一个为 True。如果可迭代对象中至少有一个元素为 True，则 any() 返回 True；如果可迭代对象中所有元素均为 False，则返回 False。

例如，对于一个包含布尔值的列表：

my_list = [False, True, False]
result = any(my_list)
print(result)  # 输出结果为 True，因为列表中有一个元素为 True

如果可迭代对象中的任何元素都为 True，则返回 True，否则返回 False

any() 函数是 Python 内置函数之一，用于判断可迭代对象中的任何一个元素是否为真（非零、非空、非None）。如果可迭代对象中存在一个或多个元素为真，则 any() 返回 True；如果可迭代对象中的所有元素都为假，则 any() 返回 False。

语法

any(iterable)

参数

• iterable：可迭代对象，如列表、元组、集合、字典等。

返回值

• any() 函数返回一个布尔值，如果可迭代对象中的任何一个元素为真，则返回 True，否则返回 False。

示例

list1 = [False, False, False]
print(any(list1))    # False，因为列表 list1 中的所有元素都为假。

list2 = [True, False, False]
print(any(list2))    # True，因为列表 list2 中存在一个真元素。

tuple1 = (0, 0, 0)
print(any(tuple1))   # False，因为元组 tuple1 中的所有元素都为假。

set1 = {1, 0, 0}
print(any(set1))     # True，因为集合 set1 中存在一个真元素。

dict1 = {'name': '', 'age': 25}
print(any(dict1))    # True，因为字典 dict1 中的 age 键对应的值为真。

empty_list = []
print(any(empty_list))  # False，空列表视为全部为假

ascii()

ascii() 函数是 Python 内置函数之一，用于返回一个对象的可打印ASCII表示形式。它将对象转换为一个字符串，其中非ASCII字符通过转义序列进行表示。

语法

ascii(object)

参数

• object：要转换为ASCII表示形式的对象。

返回值

• ascii() 函数返回一个字符串，表示对象的可打印ASCII表示形式。

示例

print(ascii('hello'))        # 'hello'
print(ascii('你好'))           # '\u4f60\u597d'
print(ascii('こんにちは'))    # '\u3053\u3093\u306b\u3061\u306f'
print(ascii(123))             # 123
print(ascii([1, 2, '三']))    # '[1, 2, \'\\u4e09\']'

• ascii('hello') 返回 'hello'，因为字符串 'hello' 中的所有字符都是可打印的ASCII字符
• ascii('你好') 返回 '\u4f60\u597d'，因为字符串 '你好' 中的字符不是ASCII字符，所以使用转义序列进行表示。
• ascii('こんにちは') 返回 '\u3053\u3093\u306b\u3061\u306f'，因为字符串 'こんにちは' 中的字符不是ASCII字符，所以使用转义序列进行表示。
• ascii(123) 返回 123，因为数字 123 是可打印的ASCII字符。
• ascii([1, 2, '三']) 返回 [1, 2, '\u4e09']，因为列表中的元素包含非ASCII字符，所以使用转义序列进行表示。

append()

append() 是列表（list）对象的一个方法，用于在列表的末尾添加一个元素。

语法

list.append(element)

参数

• element：要添加到列表末尾的元素。

返回值

• append() 方法没有返回值，它会直接修改原列表，将元素添加到末尾。

示例

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)   # [1, 2, 3, 4]

my_list.append('five')
print(my_list)   # [1, 2, 3, 4, 'five']

在上面的示例中，首先创建一个名为 my_list 的列表，包含整数元素 [1, 2, 3]。然后，使用 append() 方法将整数 4 添加到列表末尾，得到 [1, 2, 3, 4]。接着，使用 append() 方法将字符串 'five' 添加到列表末尾，得到 [1, 2, 3, 4, 'five']。可以看到，每次调用 append() 方法都会将元素添加到列表的最后一个位置。

bytearray()

返回一个新的 bytearray 对象

bytearray() 函数是 Python 内置函数之一，用于创建一个可变的字节数组对象。字节数组是一种可变序列，它包含整数值（0-255）的元素。

语法

bytearray([source[, encoding[, errors]]])

参数

• source（可选）：用于初始化字节数组的参数。可以是整数、可迭代对象、缓冲区、字符串等。
• encoding（可选）：如果 source 是字符串，则指定用于编码的字符编码方式。
• errors（可选）：如果 source 是字符串，则指定编码错误处理方式。

返回值 bytearray() 函数返回一个新的可变字节数组对象。

示例

ba1 = bytearray()                             # 空的字节数组
print(ba1)                                   # bytearray(b'')

ba2 = bytearray([65, 66, 67])                 # 使用整数列表初始化
print(ba2)                                   # bytearray(b'ABC')

ba3 = bytearray('Hello', 'utf-8')             # 使用字符串和编码方式初始化
print(ba3)                                   # bytearray(b'Hello')

ba4 = bytearray(b'Python')                    # 使用字节字符串初始化
print(ba4)                                   # bytearray(b'Python')

在上面的示例中，bytearray() 函数被用于创建不同的字节数组对象。ba1 是一个空的字节数组，由 bytearray() 创建。ba2 使用整数列表 [65, 66, 67] 初始化，表示 ASCII 码值对应的字符 'A'、'B'、'C'。ba3 使用字符串 'Hello' 和编码方式 'utf-8' 初始化，根据指定的编码方式将字符串转换为字节数组。ba4 使用字节字符串 b'Python' 初始化，即直接使用字节字符串作为初始值。可以看到，bytearray() 返回的字节数组对象可变，可以根据需要进行修改。

bytes()

返回一个新的 bytes 对象

bytes() 函数是 Python 内置函数之一，用于创建一个不可变的字节对象。字节对象是一种不可变序列，它包含整数值（0-255）的元素。

语法

bytes([source[, encoding[, errors]]])

参数

• source（可选）：用于初始化字节对象的参数。可以是整数、可迭代对象、缓冲区、字符串等。
• encoding（可选）：如果 source 是字符串，则指定用于编码的字符编码方式。
• errors（可选）：如果 source 是字符串，则指定编码错误处理方式。

返回值 bytes() 函数返回一个新的不可变字节对象。

示例

b1 = bytes()                                # 空的字节对象
print(b1)                                   # b''

b2 = bytes([65, 66, 67])                    # 使用整数列表初始化
print(b2)                                   # b'ABC'

b3 = bytes('Hello', 'utf-8')                # 使用字符串和编码方式初始化
print(b3)                                   # b'Hello'

b4 = bytes(b'Python')                       # 使用字节字符串初始化
print(b4)                                   # b'Python'

在上面的示例中，bytes() 函数被用于创建不同的字节对象。b1 是一个空的字节对象，由 bytes() 创建。b2 使用整数列表 [65, 66, 67] 初始化，表示 ASCII 码值对应的字符 'A'、'B'、'C'。b3 使用字符串 'Hello' 和编码方式 'utf-8' 初始化，根据指定的编码方式将字符串转换为字节对象。b4 使用字节字符串 b'Python' 初始化，即直接使用字节字符串作为初始值。可以看到，bytes() 返回的字节对象是不可变的，不能进行修改。

callable()

callable() 函数用于检查对象是否可调用，即判断对象是否可以作为函数调用。

如果对象是可调用的，则返回 True，否则返回 False

语法

callable(object)

参数

• object：要检查的对象。

返回值

• callable() 函数返回一个布尔值，如果对象可调用则返回 True，否则返回 False。

可调用对象 可调用对象是指可以像函数一样调用的对象。以下是一些可调用对象的示例：

• 函数：Python 中的函数是可调用对象，可以通过函数名加括号的方式进行调用。
• 方法：类中定义的方法也是可调用对象，可以通过实例对象来调用。
• 类：类本身也可以作为可调用对象，会调用类的 __new__() 方法创建一个新的实例对象。
• 类实例：如果类实现了 __call__() 方法，那么该实例也是可调用的。

示例

def foo():
    pass

class Bar:
    def __call__(self):
        pass

print(callable(foo))  # True
print(callable(Bar))  # True

b = Bar()
print(callable(b))  # True

x = 10
print(callable(x))  # False

在上面的示例中，foo 是一个函数，Bar 是一个类。

callable(foo) 返回 True，因为函数是可调用对象。

callable(Bar) 返回 True，因为类是可调用对象，会调用类的 __new__() 方法创建一个新的实例对象。

b 是 Bar 类的一个实例，callable(b) 也返回 True，因为 Bar 类实现了 __call__() 方法。

而变量 x 是一个整数，callable(x) 返回 False，因为整数是不可调用对象。

chr()

返回 Unicode 码位对应的字符

chr() 函数是 Python 内置函数之一，用于将 Unicode 码点转换为对应的字符。

语法

chr(i)

参数

• i：一个整数，表示 Unicode 码点。

返回值

• chr() 函数返回一个字符串，表示给定 Unicode 码点对应的字符。

示例

print(chr(65))     # A

print(chr(8364))   # €

print(chr(128516)) # 😄

• chr(65) 返回 'A'，因为 Unicode 码点 65 对应的字符是大写字母 'A'。
• chr(8364) 返回 '€'，因为 Unicode 码点 8364 对应的字符是欧元符号 '€'。
• chr(128516) 返回 '😄'，因为 Unicode 码点 128516 对应的字符是一个笑脸符号 '😄'。可以通过 chr() 函数将整数 Unicode 码点转换为对应的字符。

classmethod()

将一个方法转换为类方法

classmethod() 是 Python 内置函数之一，用于定义类方法。类方法是绑定到类而不是实例的方法，可以通过类或实例调用。

语法

pythonCopy code@classmethod
def method(cls, ...)
    # 方法代码

参数

• cls：隐式参数，表示类本身，用于访问类的属性和调用其他类方法。

返回值 classmethod() 并不返回任何值，它是用于修饰方法的装饰器。

示例

pythonCopy codeclass MyClass:
    count = 0

    def __init__(self, name):
        self.name = name
        MyClass.count += 1

    @classmethod
    def get_count(cls):
        return cls.count

    @classmethod
    def reset_count(cls):
        cls.count = 0


obj1 = MyClass('Object 1')
obj2 = MyClass('Object 2')
obj3 = MyClass('Object 3')

print(MyClass.get_count())   # 3

MyClass.reset_count()
print(MyClass.get_count())   # 0

在上面的示例中，MyClass 类定义了两个类方法 get_count() 和 reset_count()。get_count() 方法使用 @classmethod 装饰器修饰，表示它是一个类方法。类方法可以通过隐式的 cls 参数来访问类的属性，这里使用 cls.count 访问类变量 count。reset_count() 方法也是一个类方法，用于将 count 重置为 0。

在示例中，创建了三个 MyClass 类的实例，并使用类方法 get_count() 获取实例的数量，返回值为 3。然后，调用类方法 reset_count() 将计数器重置为 0，并再次调用 get_count() 方法，返回值为 0。

可以看到，类方法可以在不创建实例的情况下通过类直接调用，或者通过实例对象调用。并且，类方法可以访问类的属性和调用其他类方法。

compile()

将一个字符串编译为代码对象

compile() 函数是 Python 内置函数之一，用于将源代码编译为可执行代码或者生成代码对象。

语法

pythonCopy code
compile(source, filename, mode[, flags[, dont_inherit]])

参数

• source：要编译的源代码，可以是字符串、字节对象或 AST（抽象语法树）对象。

• filename：指定源代码的文件名。如果源代码不来自文件，可以使用一个适当的值，如 '<'。

• mode

  ：指定编译的模式。可以是以下值之一：

  • 'exec'：编译为可执行代码（例如，模块、函数、类）。
  • 'eval'：编译为一个表达式。
  • 'single'：编译为交互式执行的语句序列。

• flags

  （可选）：控制编译过程的标志参数。可以是零个或多个标志的按位或组合。常用的标志有：

  • ast.PyCF_SOURCE_IS_UTF8：如果源代码是 UTF-8 编码，则启用此标志。
  • ast.PyCF_ONLY_AST：只生成抽象语法树，不执行代码。

• dont_inherit（可选）：布尔值，指示是否继承来自 __future__ 模块的编译器标志。默认为 False。

返回值 compile() 函数返回一个代码对象（code 对象），它可以通过 exec()、eval() 或 single() 函数执行。

示例

pythonCopy codesource_code = """
for i in range(5):
    print(i)
"""

compiled_code = compile(source_code, filename='<string>', mode='exec')
exec(compiled_code)

在上面的示例中，source_code 是一个字符串，包含一个简单的 for 循环打印数字的代码块。使用 compile() 函数将这段源代码编译为可执行代码。指定的模式为 'exec'，表示编译为可执行代码。编译完成后，得到一个代码对象 compiled_code。然后，通过 exec() 函数执行这个代码对象，输出数字 0 到 4。

compile() 函数的使用场景还有很多，例如在动态执行代码、实现自定义的解释器等方面具有灵活的应用。

dict()

创建一个字典

dict() 是 Python 内置函数之一，用于创建一个字典对象。

语法

dict()
dict(iterable)
dict(**kwargs)

参数

• iterable（可选）：表示可迭代对象，例如列表、元组、字典等。可以通过键值对的形式来提供初始的键值对。
• **kwargs（可选）：表示关键字参数，用于提供初始的键值对。

返回值

• dict() 函数返回一个新的字典对象，其中包含了初始的键值对。

示例

在下面的示例中，展示了 dict() 函数的几种用法。

dict1 = dict()
print(dict1)      # {}

• 通过 dict() 创建一个空字典对象，不传递任何参数。返回的字典为空字典 {}。

dict2 = dict([('name', 'Alice'), ('age', 30)])
print(dict2)      # {'name': 'Alice', 'age': 30}

• 通过 dict([('name', 'Alice'), ('age', 30)]) 创建一个字典 dict2，提供了一个包含键值对的可迭代对象。
• 返回的字典为 {'name': 'Alice', 'age': 30}，即根据提供的键值对创建了一个字典对象。

dict3 = dict(name='Bob', age=25)
print(dict3)      # {'name': 'Bob', 'age': 25}

• 通过 dict(name='Bob', age=25) 创建一个字典 dict3，提供了关键字参数来指定键值对。
• 返回的字典为 {'name': 'Bob', 'age': 25}，即根据提供的键值对创建了一个字典对象。

dict() 函数提供了创建字典对象的多种方式。可以通过提供包含键值对的可迭代对象、关键字参数等方式来初始化字典对象。字典是无序的键值对集合，用于存储和访问数据。

delattr()

删除对象的属性

delattr() 是 Python 内置函数之一，用于删除对象的属性。

语法

pythonCopy code
delattr(object, name)

参数

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

返回值 delattr() 函数没有返回值。它会删除指定对象的属性。

示例

pythonCopy codeclass Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(person.name)      # Alice

delattr(person, 'name')
print(person.name)      # AttributeError: 'Person' object has no attribute 'name'

在上面的示例中，定义了一个 Person 类，并创建了一个 person 对象。

通过 delattr(person, 'name') 删除了对象 person 的 'name' 属性。之后再次访问 person.name 时，会抛出 AttributeError，提示对象 person 没有属性 'name'。

delattr() 函数提供了一种方便的方式来删除对象的属性。通过指定对象和属性名称，可以删除指定对象的属性。请注意，使用 delattr() 删除属性时，属性名作为字符串传递给函数。

dir()

返回对象的所有属性和方法的列表。

dir() 函数对于查看对象的属性和方法非常有用。它返回一个列表，包含了对象的所有名称，可以用于探索对象的可用功能。

语法

dir([object])

参数

• object（可选）：表示要获取属性和方法的对象。如果未提供对象，则返回当前作用域的所有名称。

返回值

• dir() 函数返回一个包含对象属性和方法名称的列表。

示例

在下面的示例中，展示了 dir() 函数的几种用法。

numbers = [1, 2, 3]
print(dir(numbers))
## ['__add__', '__class__', '__contains__', '__delattr__', '__delitem__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__', '__iadd__', '__imul__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__', '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count', 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']

• 通过 dir(numbers) 获取列表 numbers 的属性和方法的列表。返回的列表包含了列表对象的内置属性和方法，以及列表对象自定义的方法（例如 append、clear、copy 等）。

text = "hello"
print(dir(text))
## ['__add__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__getitem__', '__getnewargs__', '__gt__', '__hash__', '__init__', '__iter__', '__le__', '__len__', '__lt__', '__mod__', '__mul__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__rmod__', '__rmul__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', 'capitalize', 'casefold', 'center', 'count', 'encode', 'endswith', 'expandtabs', 'find', 'format', 'format_map', 'index', 'isalnum', 'isalpha', 'isascii', 'isdecimal', 'isdigit', 'isidentifier', 'islower', 'isnumeric', 'isprintable', 'isspace', 'istitle', 'isupper', 'join', 'ljust', 'lower', 'lstrip', 'maketrans', 'partition', 'replace', 'rfind', 'rindex', 'rjust', 'rpartition', 'rsplit', 'rstrip', 'split', 'splitlines', 'startswith', 'strip', 'swapcase', 'title', 'translate', 'upper', 'zfill']

• 通过 dir(text) 获取字符串 text 的属性和方法的列表。返回的列表包含了字符串对象的内置属性和方法，以及字符串对象自定义的方法（例如 capitalize、lower、replace 等）。

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(dir(person))
## ['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'age', 'name']

• 通过 dir(person) 获取对象 person 的属性和方法的列表。返回的列表包含了对象 person 的内置属性和方法，以及自定义的属性（例如 name、age）。

divmod()

返回两个数的商和余数

divmod() 是 Python 内置函数之一，用于同时进行整数除法和取模运算，返回一个包含商和余数的元组。

语法

pythonCopy code
divmod(x, y)

参数

• x：表示被除数。
• y：表示除数。

返回值 divmod() 函数返回一个包含商和余数的元组 (quotient, remainder)，其中 quotient 表示整数除法的商，remainder 表示取模运算的余数。

示例

pythonCopy coderesult = divmod(10, 3)
print(result)    # (3, 1)

result2 = divmod(20, 7)
print(result2)   # (2, 6)

在上面的示例中，展示了 divmod() 函数的用法。

通过 divmod(10, 3) 进行整数除法和取模运算。整数除法 10 // 3 的结果为 3，取模运算 10 % 3 的结果为 1。返回的元组为 (3, 1)，表示整数除法的商为 3，取模运算的余数为 1。

通过 divmod(20, 7) 进行整数除法和取模运算。整数除法 20 // 7 的结果为 2，取模运算 20 % 7 的结果为 6。返回的元组为 (2, 6)，表示整数除法的商为 2，取模运算的余数为 6。

divmod() 函数提供了一种便捷的方式来同时进行整数除法和取模运算，并将结果以元组形式返回。可以在需要同时获得商和余数时使用该函数。

enumerate()

将一个可迭代对象组合为一个枚举对象，可以在循环中同时访问可迭代对象的索引和值。

这在需要同时获取索引和值的场景下非常有用，例如需要追踪元素的位置或编写带有计数的循环。

语法

enumerate(iterable, start=0)

• iterable：表示一个可迭代对象，例如列表、元组、字符串等。
• start（可选）：表示索引的起始值，默认为 0。

返回值

• enumerate() 函数返回一个枚举对象，该对象包含了可迭代对象中元素的索引和值。
• 每个元素都是一个由索引和值组成的元组。

示例

numbers = [10, 20, 30, 40]
for index, value in enumerate(numbers):
    print(index, value)
## 0 10
## 1 20
## 2 30
## 3 40

text = "hello"
for index, char in enumerate(text, start=1):
    print(index, char)
## 1 h
## 2 e
## 3 l
## 4 l
## 5 o

eval()

将一个字符串作为表达式进行求值

eval() 函数是 Python 内置函数之一，用于执行以字符串形式给出的表达式，并返回表达式的结果。

语法

pythonCopy code
eval(expression[, globals[, locals]])

参数

• expression：要执行的表达式，通常是一个字符串。它可以包含变量、函数调用、运算符等。
• globals（可选）：一个字典，用于指定全局命名空间中的变量和函数。如果未提供，则使用当前全局命名空间。
• locals（可选）：一个字典，用于指定局部命名空间中的变量和函数。如果未提供，则使用当前局部命名空间。

返回值 eval() 函数返回表达式的结果。

示例

pythonCopy codex = 10
y = 5
result = eval('x + y')
print(result)  # 15

expression = input('Enter an expression: ')
result = eval(expression)
print(result)

在上面的示例中，首先定义了变量 x 和 y，然后使用 eval() 函数执行字符串 'x + y'，并将结果赋值给变量 result。由于 'x + y' 是一个表达式，eval() 函数会计算表达式的结果，即 10 + 5，得到 15。然后打印出变量 result 的值。

另外，示例中还演示了使用 eval() 函数接收用户输入的表达式，并计算表达式的结果。用户可以输入任意有效的表达式，eval() 函数会将其计算并返回结果。注意在接收用户输入时要注意安全性，避免执行恶意代码。

exec()

将一个字符串作为代码进行执行

exec() 函数是 Python 内置函数之一，用于执行以字符串形式给出的 Python 代码。

语法

pythonCopy code
exec(source[, globals[, locals]])

参数

• source：要执行的代码，通常是一个字符串。可以是单行或多行代码。
• globals（可选）：一个字典，用于指定全局命名空间中的变量和函数。如果未提供，则使用当前全局命名空间。
• locals（可选）：一个字典，用于指定局部命名空间中的变量和函数。如果未提供，则使用当前局部命名空间。

返回值 exec() 函数没有返回值。

示例

pythonCopy codex = 10
y = 5
code = '''
result = x + y
print(result)
'''
exec(code)

在上面的示例中，首先定义了变量 x 和 y，然后使用 exec() 函数执行了一个字符串形式的 Python 代码块。代码块中定义了一个变量 result，并计算了 x + y 的结果，并使用 print() 函数打印结果。通过执行 exec() 函数，字符串形式的代码被解释和执行，输出结果为 15。

exec() 函数可用于动态执行代码，特别是在需要在运行时构建和执行代码块的情况下。请注意，在使用 exec() 函数时要小心安全性，确保执行的代码是可信的，以避免执行恶意代码。

filter()

使用一个函数过滤一个可迭代对象

filter() 函数是 Python 内置函数之一，用于根据指定条件筛选可迭代对象中的元素，并返回符合条件的元素构成的迭代器（或者在 Python 3 中返回一个可迭代对象）。

语法

pythonCopy code
filter(function, iterable)

参数

• function：用于筛选元素的函数，可以是一个返回布尔值的函数或者为 None。如果为 None，则只返回非零、非空、非 None 的元素。
• iterable：可迭代对象，如列表、元组、集合、字典等。

返回值 filter() 函数返回一个迭代器（在 Python 3 中）或者一个可迭代对象（在 Python 2 中），其中包含符合筛选条件的元素。

示例

pythonCopy codedef is_even(n):
    return n % 2 == 0

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

even_numbers = filter(is_even, numbers)
print(list(even_numbers))  # [2, 4, 6, 8, 10]

odd_numbers = filter(lambda x: x % 2 != 0, numbers)
print(list(odd_numbers))   # [1, 3, 5, 7, 9]

在上面的示例中，定义了一个函数 is_even()，用于判断一个数是否为偶数。然后，创建了一个列表 numbers，其中包含一组整数。使用 filter() 函数结合 is_even() 函数，筛选出列表中的偶数，返回一个迭代器（或可迭代对象）。通过 list() 函数将迭代器转换为列表，打印出符合筛选条件的偶数列表。

另外，示例中还使用了匿名函数（lambda 函数），通过 filter() 函数筛选出列表中的奇数，同样将迭代器转换为列表并打印出结果。

filter() 函数提供了一种方便的方法来筛选出符合特定条件的元素，非常适用于需要对可迭代对象进行过滤操作的场景。

format()

根据指定的格式对值进行格式化，并返回格式化后的字符串。

可以起到f前缀的效果

语法

format(value, format_spec)

参数

• value：要格式化的值，可以是数字、字符串、对象等。
• format_spec：格式化规范，指定了值的显示方式。它可以是一个格式字符串，也可以是一个包含格式化选项的对象。

返回值

• format() 函数返回一个格式化后的字符串。

示例

pi = 3.14159

formatted_pi = format(pi, '.2f')

print(formatted_pi)   # '3.14'

• format(pi, '.2f') 将浮点数 pi 格式化为两位小数的字符串 '3.14'。

formatted_int = format(42, '04d')

print(formatted_int)  # '0042'

• format(42, '04d') 将整数 42 格式化为占位符宽度为 4 的字符串 '0042'，其中使用零填充。

name = 'Alice'
age = 25

formatted_text = format('My name is {} and I am {} years old.', name, age)

print(formatted_text)  # 'My name is Alice and I am 25 years old.'

• 使用花括号 {} 作为占位符。
• format('My name is {} and I am {} years old.', name, age) 将字符串中的占位符分别替换为变量 name 和 age 的值，生成新的字符串 'My name is Alice and I am 25 years old.'。

x = 123

print('{} number is'.format(x)) # 123 number is

• x = 123: 这行代码将整数值 123 赋给变量 x。
• print('{} number is'.format(x)): 这行代码使用了字符串的 format 方法来创建一个字符串。在字符串中的 {} 是一个占位符，它会被传递给 format 方法的参数所替代。在这个例子中，参数就是变量 x 的值，也就是 123。因此，这行代码的执行结果将会打印出类似于 “123 number is” 的字符串。

范例1

f前缀

#!/usr/local/bin/python3
import threading
import time
y = 'xml'

def print_numbers():
    for i in range(1, 6):
        print(f"Number: {i} {y}")
        time.sleep(1)
        if i == 3:
            return 123 # 通过return的方式

## 创建线程
t1 = threading.Thread(target=print_numbers)


## 启动线程
t1.start()
'''
Number: 1 xml
Number: 2 xml
Number: 3 xml
'''

代替f前缀

#!/usr/local/bin/python3
import threading
import time
y = 'xml'

def print_numbers():
    for i in range(1, 6):
        print("Number: {} {}".format(i, y))
        time.sleep(1)
        if i == 3:
            return 123 # 通过return的方式

## 创建线程
t1 = threading.Thread(target=print_numbers)


## 启动线程
t1.start()
'''
Number: 1 xml
Number: 2 xml
Number: 3 xml
'''

范例2

for i in range(3):
    print("{}a{}".format(i))

for i in range(3):
    print("{0}a{0}".format(i))

上面的代码会报错是因为在第一个 print 语句中，使用了 {} 来格式化字符串，但是在 .format() 方法中只提供了一个参数 i。这会导致 Python 报错，因为在字符串中有一个格式化字段，但是没有足够的参数来填充它。

下面的代码中，使用了 {0} 来指定索引位置，这与提供的参数 i 相匹配，因此不会报错，可以正常执行。

format() 函数是用于格式化字符串的内置函数，在 Python 中非常强大且常用。它允许你将各种数据类型插入到字符串中，并指定它们的格式。下面是对 format() 函数的详细解释：

基本用法

formatted_string = "Some text with {} and {}".format(value1, value2)

在这个例子中，{} 是占位符，format() 函数会按顺序将提供的参数 value1 和 value2 插入到字符串中。

索引和位置参数

formatted_string = "Some text with {1} and {0}".format(value1, value2)

你可以通过索引来指定要插入的参数的位置，这样就可以在字符串中对它们进行重排。

关键字参数

formatted_string = "My name is {name} and I'm {age} years old".format(name="Alice", age=30)

你可以使用关键字参数来指定插入的值，这样就不必按照顺序提供参数。

格式规范

formatted_string = "The result is {:.2f}".format(3.14159)

你可以使用格式规范来控制输出的格式，例如指定小数位数、填充字符等。

填充和对齐

formatted_string = "{:<10}".format("left")
formatted_string = "{:>10}".format("right")
formatted_string = "{:^10}".format("center")

这些示例演示了如何填充和对齐字符串。

格式化字典和列表

person = {"name": "Alice", "age": 30}
formatted_string = "My name is {name} and I'm {age} years old".format(**person)

numbers = [1, 2, 3, 4, 5]
formatted_string = "Numbers: {}, {}, {}, {}, {}".format(*numbers)

你可以使用字典和列表来提供格式化参数，通过 ** 和 * 运算符来展开它们。

format() 函数提供了强大的字符串格式化功能，可以根据需要进行灵活的操作，这使得字符串的构建变得更加方便和可读。

frozenset()

创建一个不可变的集合

frozenset() 函数是 Python 内置函数之一，用于创建一个不可变的冻结集合对象。不可变集合是一种无序且不可变的集合类型，它不支持添加、删除或修改元素。

语法

pythonCopy code
frozenset([iterable])

参数

• iterable：可迭代对象，如列表、元组、集合等。如果提供了可迭代对象，则会创建一个包含可迭代对象中所有唯一元素的不可变集合。如果未提供可迭代对象，则创建一个空的不可变集合。

返回值 frozenset() 函数返回一个不可变的集合对象（frozenset 对象）。

示例

pythonCopy codefruits = frozenset(['apple', 'banana', 'orange'])
print(fruits)   # frozenset({'orange', 'banana', 'apple'})

empty_set = frozenset()
print(empty_set)   # frozenset()

numbers = frozenset([1, 2, 3, 4, 4, 3, 2, 1])
print(numbers)   # frozenset({1, 2, 3, 4})

在上面的示例中，使用 frozenset() 函数创建了不可变集合对象。fruits 是一个不可变集合，包含字符串元素 'apple'、'banana' 和 'orange'。empty_set 是一个空的不可变集合。numbers 是一个不可变集合，包含整数元素 1、2、3、4，并且重复元素被自动去除。

不可变集合是一种常用的数据结构，它可以用于需要在不可变环境中存储一组唯一元素的场景，同时也可以作为字典的键或集合的元素。由于不可变集合是不可变的，因此它具有哈希性质，可以作为字典的键使用。

getattr()

返回对象的属性值

getattr() 函数是 Python 内置函数之一，用于获取对象的属性值或者调用对象的方法。

语法

pythonCopy code
getattr(object, name[, default])

参数

• object：表示一个对象，可以是模块、类、实例或者其他对象。
• name：表示要获取的属性名或者方法名。
• default（可选）：如果指定的属性或者方法不存在，则返回默认值。如果未提供默认值，则会引发 AttributeError 异常。

返回值 getattr() 函数返回指定属性或者方法的值或者引用。

示例

pythonCopy codeclass MyClass:
    def __init__(self, x):
        self.x = x

    def hello(self):
        print("Hello!")

obj = MyClass(10)

print(getattr(obj, 'x'))        # 10
print(getattr(obj, 'hello'))    # <bound method MyClass.hello of <__main__.MyClass object at 0x7f...>>
getattr(obj, 'hello')()         # Hello!

print(getattr(obj, 'y', 0))     # 0
print(getattr(obj, 'z'))        # AttributeError: 'MyClass' object has no attribute 'z'

在上面的示例中，首先定义了一个 MyClass 类，包含一个属性 x 和一个方法 hello()。然后创建了一个 MyClass 的实例 obj。

使用 getattr() 函数分别获取了 obj 的属性 x 和方法 hello 的值或者引用。getattr(obj, 'x') 返回实例 obj 的属性 x 的值，即 10。getattr(obj, 'hello') 返回实例 obj 的方法 hello 的引用，即 <bound method MyClass.hello of <__main__.MyClass object at 0x7f...>>。可以通过 getattr(obj, 'hello')() 的方式调用该方法，输出 Hello!。

另外，getattr(obj, 'y', 0) 指定了默认值为 0，因为实例 obj 没有属性 y，所以返回默认值 0。getattr(obj, 'z') 尝试获取实例 obj 的属性 z，但由于该属性不存在，所以引发 AttributeError 异常。

getattr() 函数在动态访问对象的属性和方法时非常有用，可以根据需要进行属性或方法的获取和调用，同时提供了默认值的选项。

hasattr()

检查对象是否有指定的属性

hasattr() 函数是 Python 内置函数之一，用于检查对象是否具有指定的属性。

语法

pythonCopy code
hasattr(object, name)

参数

• object：表示一个对象，可以是模块、类、实例或其他对象。
• name：表示要检查的属性名。

返回值 hasattr() 函数返回一个布尔值，如果对象具有指定的属性，则返回 True，否则返回 False。

示例

pythonCopy codeclass MyClass:
    x = 10

    def hello(self):
        print("Hello!")

obj = MyClass()

print(hasattr(obj, 'x'))        # True
print(hasattr(obj, 'hello'))    # True
print(hasattr(obj, 'y'))        # False

在上面的示例中，首先定义了一个 MyClass 类，包含属性 x 和方法 hello()。然后创建了一个 MyClass 的实例 obj。

使用 hasattr() 函数检查了实例 obj 是否具有属性 x、方法 hello 和属性 y。hasattr(obj, 'x') 返回 True，因为实例 obj 具有属性 x。hasattr(obj, 'hello') 返回 True，因为实例 obj 具有方法 hello。hasattr(obj, 'y') 返回 False，因为实例 obj 不具有属性 y。

hasattr() 函数对于在运行时动态检查对象的属性非常有用，可以根据需要进行属性的存在性检查，以避免在访问属性之前引发异常。

hash()

返回一个对象的哈希值

hash() 函数是 Python 内置函数之一，用于返回对象的哈希值。

语法

pythonCopy code
hash(object)

参数

• object：表示一个对象，可以是数字、字符串、元组、集合、字典等不可变类型的对象。

返回值 hash() 函数返回对象的哈希值，是一个整数。

示例

pythonCopy codeprint(hash(42))                     # 42
print(hash('Hello'))                # 8815480496954004819
print(hash((1, 2, 3)))              # 529344067295497451
print(hash(frozenset([1, 2, 3])))   # -4355126433369837482

在上面的示例中，hash() 函数被用于获取不同类型对象的哈希值。hash(42) 返回 42，因为整数的哈希值就是其自身。hash('Hello') 返回一个大整数，表示字符串 'Hello' 的哈希值。hash((1, 2, 3)) 返回另一个整数，表示元组 (1, 2, 3) 的哈希值。hash(frozenset([1, 2, 3])) 返回一个负整数，表示不可变集合 frozenset([1, 2, 3]) 的哈希值。

哈希值在 Python 中主要用于字典的键，集合的元素和判断对象的唯一性。哈希函数将对象映射到一个固定大小的整数，具有相同值的对象将具有相同的哈希值。

help()

显示help() 函数是 Python 内置函数之一，用于获取对象的帮助信息，包括对象的文档字符串（docstring）和可调用属性的帮助信息。

语法

pythonCopy code
help([object])

参数

• object（可选）：表示要获取帮助信息的对象。可以是函数、类、模块、方法、关键字等。如果未提供对象，则进入交互式帮助模式。

返回值 help() 函数在交互式模式下会显示对象的帮助信息。在非交互式模式下，它会返回一个包含对象帮助信息的字符串。

示例

pythonCopy codehelp(print)

help(list)

help(str.upper)

在上面的示例中，使用 help() 函数获取了不同对象的帮助信息。help(print) 显示了 print 函数的帮助信息，包括函数的用法、参数和示例。help(list) 显示了 list 类的帮助信息，包括类的方法、属性和示例。help(str.upper) 显示了字符串类型的 upper() 方法的帮助信息，描述了方法的功能、参数和示例。

通过 help() 函数，可以在交互式环境中查看对象的帮助信息，了解对象的用法、功能和使用示例。这对于探索和学习 Python 内置函数、类、模块以及第三方库中的函数和类非常有帮助。

id()

返回一个对象的唯一标识符

id() 函数是 Python 内置函数之一，用于返回对象的唯一标识符（即内存地址）。

语法

id(object)

参数

• object：表示一个对象，可以是任意类型的对象。

返回值

• id() 函数返回一个整数，表示对象的唯一标识符。

示例

x = 42
y = 'Hello'
z = [1, 2, 3]

print(id(x))   # 输出一个整数
print(id(y))   # 输出一个整数
print(id(z))   # 输出一个整数

在上面的示例中，使用 id() 函数获取了不同类型对象的唯一标识符。id(x) 返回整数，表示整数对象 x 的唯一标识符（内存地址）。id(y) 返回整数，表示字符串对象 y 的唯一标识符。id(z) 返回整数，表示列表对象 z 的唯一标识符。

每个对象在内存中都有一个唯一的地址，可以通过 id() 函数获取该地址。不同对象的唯一标识符是不同的，相同对象的唯一标识符是相同的。注意，唯一标识符是整数值，它只在对象的生命周期内保持不变，对象被销毁后，该地址可能被重用。

input()

input() 函数是 Python 内置函数之一，用于从标准输入读取用户的输入，并返回用户输入的字符串。

当您调用 input() 函数时，程序会停止执行并等待用户输入。一旦用户输入了一些文本并按下回车键，input() 函数将返回用户输入的字符串。通常，您需要将 input() 的结果存储在一个变量中，以便后续使用。

语法

input([prompt])

参数

• prompt（可选）：一个字符串，用于向用户显示提示信息，以引导用户输入。如果省略 prompt，则将没有提示消息显示给用户。

返回值

• input() 函数返回用户输入的字符串。

注意事项：

• 需要注意的是，input() 函数返回的结果始终是字符串类型的值。如果您需要将输入的字符串转换为其他类型（如整数、浮点数等），则需要使用相应的类型转换函数（如 int()、float() 等）。
• 另外，由于 input() 函数接受任何用户输入，因此需要小心处理用户输入中可能出现的错误和异常情况，例如空输入、非法输入等。可以在处理用户输入时要进行适当的错误处理和验证，以确保输入的有效性和安全性。

示例

name = input("Enter your name: ")

print("Hello, " + name + "!")

"""
Enter your name: azheng
Hello, azheng!
"""

在上面的示例中，首先使用 input() 函数获取用户输入的名称，并将其赋值给变量 name。然后使用获取的名称打印出问候消息。

age = input("Enter your age: ")
age = int(age)  # 将输入的字符串转换为整数
print("You are " + str(age) + " years old.")

另外，使用 input() 函数获取用户输入的年龄，并将其赋值给变量 age。由于 input() 函数返回的是字符串类型的用户输入，如果需要将其视为整数类型，可以使用 int() 函数将字符串转换为整数。然后打印出用户的年龄。

isinstance()

检查一个对象是否是指定类型（或指定类型的子类）的实例。

语法

isinstance(object, classinfo)

• object：表示要检查的对象。
• classinfo：表示要检查的类型或类型元组。可以是内置类型（如 int、str、list 等）、用户自定义类或抽象基类。

返回值

• isinstance() 函数返回一个布尔值。如果对象是指定类型（或指定类型的子类）的实例，则返回 True；否则返回 False。

isinstance() 函数对于判断对象的类型以及类型的继承关系非常有用，可以在编写可复用的代码时进行类型检查和处理。

示例1：

在下面的示例中，定义了一个名为 MyClass 的类。然后创建了一个整数对象 x、一个字符串对象 y 和一个 MyClass 的实例对象 z。

class MyClass:
    pass

x = 10
y = 'Hello'
z = MyClass()

print(isinstance(x, int))       # True
print(isinstance(y, str))       # True
print(isinstance(z, MyClass))   # True
print(isinstance(z, object))    # True
print(isinstance(z, str))       # False

使用 isinstance() 函数检查了不同对象是否是指定类型的实例。

• isinstance(x, int) 返回 True，因为 x 是整数类型的实例。
• isinstance(y, str) 返回 True，因为 y 是字符串类型的实例。
• isinstance(z, MyClass) 返回 True，因为 z 是 MyClass 类型的实例。
• isinstance(z, object) 返回 True，因为 object 是所有对象的基类，z 是 object 类型的实例。
• isinstance(z, str) 返回 False，因为 z 不是字符串类型的实例。

示例2：

print(isinstance(True, bool))  # True
print(isinstance(False, bool))  # True
print(isinstance(True, int))  # True
print(isinstance(False, int))  # True

• 因为在 Python 中，True 和 False 都是 int 类型的子类。

• 具体来说，True 和 False 的值分别为 1 和 0，它们继承了 int 类型的所有属性和方法。

• 因此，isinstance(True, int) 和 isinstance(False, int) 都会返回 True。虽然这看起来有点奇怪，但这是 Python 设计的一部分，它允许将布尔值用于数值计算，并与其他整数类型进行比较。

• True 和 False 分别被赋予了整数值 1 和 0，所以在某些情况下可以像整数一样使用它们。

• 例如，下面的代码是合法的：

x = True + 1
print(x)  # 输出 2

在这个例子中，我们将 True 和整数 1 相加，由于 True 被赋值为 1，所以这条语句等价于 x = 1 + 1，结果为 2。

示例3：

print(isinstance(1, (str, list, tuple)))  # False
print(isinstance(1, (str, list, tuple, int)))  # True

• 这两行代码都使用了 Python 中的 isinstance() 函数来判断一个对象是否属于指定的类型或类型组合。
• 第一行代码的含义是判断整数 1 是否是字符串、列表或元组中的任意一种类型，由于 1 不是这三种类型的实例，因此 isinstance() 返回 False。
• 第一行代码的含义是判断整数 1 是否是字符串、列表、元组或整数中的任意一种类型，由于 1 是整数类型的实例，因此 isinstance() 返回 True。
• 这两行代码说明了 isinstance() 函数的灵活性，可以检查一个对象是否属于指定类型的单个类，也可以检查一个对象是否属于指定类型的组合，即多个类的元组。

示例4：

class Foo:
    pass

class Bar(Foo):
    pass

foo = Foo()
bar = Bar()

print(isinstance(foo, Foo))  # True
print(isinstance(foo, Bar))  # False
print(isinstance(bar, Foo))  # True
print(isinstance(bar, Bar))  # True

## 判断对象是否是多个类的实例
print(isinstance(bar, (Foo, Bar)))  # True

• isinstance(foo, Foo) 返回 True，因为 foo 是 Foo 的实例；
• isinstance(foo, Bar) 返回 False，因为 foo 不是 Bar 的实例；
• isinstance(bar, Foo) 返回 True，因为 bar 是 Foo 的子类 Bar 的实例；
• isinstance(bar, Bar) 返回 True，因为 bar 是 Bar 的实例。
• isinstance(bar, (Foo, Bar)) 返回 True，因为 bar 是 Foo 或 Bar 的实例。

issubclass()

检查一个类是否是另一个类的子类

issubclass() 函数是 Python 内置函数之一，用于检查一个类是否是另一个类的子类（或者是指定类的子类的子类）。

语法

pythonCopy code
issubclass(class, classinfo)

参数

• class：表示要检查的类。
• classinfo：表示要检查的类或类元组。可以是内置类型（如 int、str、list 等）、用户自定义类或抽象基类。

返回值 issubclass() 函数返回一个布尔值。如果 class 是 classinfo 的子类（或 classinfo 是 class 的元组中的一个类），则返回 True；否则返回 False。

示例

pythonCopy codeclass MyBaseClass:
    pass

class MyDerivedClass(MyBaseClass):
    pass

class MyOtherClass:
    pass

print(issubclass(MyDerivedClass, MyBaseClass))   # True
print(issubclass(MyDerivedClass, MyOtherClass))  # False
print(issubclass(MyBaseClass, MyDerivedClass))   # False
print(issubclass(MyBaseClass, (MyDerivedClass, MyOtherClass)))  # False

在上面的示例中，定义了一个名为 MyBaseClass 的基类和一个名为 MyDerivedClass 的派生类，以及一个名为 MyOtherClass 的其他类。

使用 issubclass() 函数检查了不同类之间的继承关系。issubclass(MyDerivedClass, MyBaseClass) 返回 True，因为 MyDerivedClass 是 MyBaseClass 的子类。issubclass(MyDerivedClass, MyOtherClass) 返回 False，因为 MyDerivedClass 不是 MyOtherClass 的子类。issubclass(MyBaseClass, MyDerivedClass) 返回 False，因为 MyBaseClass 不是 MyDerivedClass 的子类。issubclass(MyBaseClass, (MyDerivedClass, MyOtherClass)) 返回 False，因为 MyBaseClass 不是 (MyDerivedClass, MyOtherClass) 中的任何一个类的子类。

issubclass() 函数对于检查类之间的继承关系非常有用，可以在编写可复用的代码时进行继承关系的判断和处理。

iter()

返回一个可迭代对象的迭代器

iter() 函数是 Python 内置函数之一，用于获取可迭代对象的迭代器。

语法

pythonCopy code
iter(object, sentinel)

参数

• object：表示一个可迭代对象，如列表、元组、字符串、字典等。
• sentinel（可选）：一个标记值，用于指定迭代的终止条件。当可迭代对象返回 sentinel 时，迭代终止。如果未提供 sentinel 参数，则 object 必须是一个实现了迭代器协议（即具有 __iter__() 方法）的对象。

返回值 iter() 函数返回一个迭代器对象。

示例

pythonCopy codemy_list = [1, 2, 3]
my_iter = iter(my_list)

print(next(my_iter))   # 1
print(next(my_iter))   # 2
print(next(my_iter))   # 3

在上面的示例中，首先创建了一个列表 my_list，其中包含整数元素 [1, 2, 3]。然后使用 iter() 函数将该列表转换为一个迭代器对象 my_iter。

通过调用内置函数 next()，可以依次从迭代器中获取下一个元素。next(my_iter) 返回迭代器中的下一个元素，即 1。再次调用 next(my_iter) 返回下一个元素 2。再次调用 next(my_iter) 返回下一个元素 3。

iter() 函数对于处理可迭代对象，并逐个访问其元素非常有用。通过获取迭代器对象，我们可以使用迭代器的 next() 方法按需获取下一个元素。

iter() 是一个内置函数，它用于获取一个迭代器对象。如果一个对象实现了 __iter__() 方法，那么它就是可迭代的，iter() 函数将返回一个迭代器对象，用于遍历这个可迭代对象。

iter() 函数的语法如下：

iter(iterable, sentinel=None)

• iterable 表示要获取迭代器的可迭代对象
  • 如果 iterable 是一个序列（如列表、元组、字符串等），那么 iter() 将返回一个序列的迭代器对象，用于遍历这个序列中的所有元素。
  • 如果 iterable 是一个自定义对象，它可以通过实现 __iter__() 方法来提供自己的迭代器对象。
• sentinel 表示一个标志值，用于表示迭代结束的条件，如果不指定，则默认为 None。

注意事项：

• 需要注意的是，如果一个对象既实现了 __iter__() 方法，又实现了 __next__() 方法，那么它就是一个迭代器对象，可以直接使用 next() 函数来遍历它，不需要再使用 iter() 函数获取迭代器对象。

范例

## 获取列表的迭代器
lst = [1, 2, 3]
it = iter(lst)
print(next(it))  # 输出 1
print(next(it))  # 输出 2
print(next(it))  # 输出 3

## 自定义可迭代对象
class MyIterable:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        return MyIterator(self.data)

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value

## 使用自定义迭代器遍历自定义可迭代对象
my_iterable = MyIterable([4, 5, 6])
my_iterator = iter(my_iterable)
print(next(my_iterator))  # 输出 4
print(next(my_iterator))  # 输出 5
print(next(my_iterator))  # 输出 6

len()

len() 函数是 Python 内置函数之一，用于返回对象的长度或元素个数。

len() 函数对于获取对象的长度或元素个数非常有用，可以用于字符串、列表、元组、字典、集合等各种数据类型的处理和判断。

语法

len(s)

参数

• s：表示要获取长度的对象，可以是字符串、列表、元组、字典、集合、字节对象等。

返回值

• len() 函数返回一个整数，表示对象的长度或元素个数。

示例

print(len("Hello"))           # 5

• len("Hello") 返回整数 5，因为字符串 "Hello" 包含 5 个字符。

print(len([1, 2, 3, 4, 5]))   # 5

• len([1, 2, 3, 4, 5]) 返回整数 5，因为列表 [1, 2, 3, 4, 5] 包含 5 个元素

print(len((1, 2, 3)))         # 3

• len((1, 2, 3)) 返回整数 3，因为元组 (1, 2, 3) 包含 3 个元素。

print(len({'a': 1, 'b': 2}))  # 2

• len({'a': 1, 'b': 2}) 返回整数 2，因为字典 {'a': 1, 'b': 2} 包含 2 个键值对。

memoryview()

返回一个内存视图对象

memoryview() 函数是 Python 内置函数之一，用于创建一个内存视图对象，它允许直接操作支持缓冲区协议的对象的内存。

语法

pythonCopy code
memoryview(obj)

参数

• obj：表示一个支持缓冲区协议的对象，如字节数组、字节对象、数组等。

返回值 memoryview() 函数返回一个内存视图对象，它允许对支持缓冲区协议的对象进行内存操作。

示例

pythonCopy code# 示例 1: 字节数组
data = bytearray(b'Hello')
mv = memoryview(data)
print(mv[1])        # 101 (ASCII 编码的 'e')
mv[0] = 72          # 修改字节数组的第一个字节
print(data)         # bytearray(b'Hello')

## 示例 2: 字节对象
message = b'Hello, World!'
mv = memoryview(message)
print(mv[7])        # 87 (ASCII 编码的 'W')
mv[0] = 72          # 报错，字节对象是不可变的

## 示例 3: 数组
import array
arr = array.array('i', [1, 2, 3, 4, 5])
mv = memoryview(arr)
print(mv[2])        # 3
mv[0] = 10          # 修改数组的第一个元素
print(arr)          # array('i', [10, 2, 3, 4, 5])

在上面的示例中，演示了使用 memoryview() 函数创建内存视图对象的不同情况。

示例 1 展示了如何创建一个内存视图对象 mv，该视图与字节数组 data 共享相同的内存。通过访问内存视图对象 mv 的索引，可以直接读取和修改字节数组中的数据。

示例 2 展示了如何创建一个内存视图对象 mv，该视图与字节对象 message 共享相同的内存。由于字节对象是不可变的，因此不能修改内存视图对象中的数据。

示例 3 展示了如何创建一个内存视图对象 mv，该视图与数组 arr 共享相同的内存。通过访问内存视图对象 mv 的索引，可以直接读取和修改数组中的元素。

memoryview() 函数对于需要直接操作支持缓冲区协议的对象的内存非常有用。它提供了一种高效的方式来处理和操作底层的二进制数据。

next()

从一个迭代器中获取下一个元素

next() 函数是 Python 内置函数之一，用于从迭代器中获取下一个元素。

语法

pythonCopy code
next(iterator, default)

参数

• iterator：表示一个迭代器对象，即实现了迭代器协议（具有 __next__() 方法）的对象。
• default（可选）：如果迭代器耗尽（没有更多的元素），则返回 default 的值。如果未提供 default 参数，则在迭代器耗尽时引发 StopIteration 异常。

返回值 next() 函数返回迭代器中的下一个元素。

示例

pythonCopy codemy_list = [1, 2, 3]
my_iter = iter(my_list)
print(next(my_iter))   # 1
print(next(my_iter))   # 2
print(next(my_iter))   # 3

my_tuple = (4, 5, 6)
my_iter = iter(my_tuple)
print(next(my_iter))   # 4
print(next(my_iter))   # 5
print(next(my_iter))   # 6

my_string = "Hello"
my_iter = iter(my_string)
print(next(my_iter))   # 'H'
print(next(my_iter))   # 'e'
print(next(my_iter))   # 'l'

在上面的示例中，首先创建了一个列表 my_list，一个元组 my_tuple 和一个字符串 my_string。

使用 iter() 函数将列表、元组和字符串转换为迭代器对象。然后通过调用 next() 函数，从迭代器中获取下一个元素。每次调用 next() 函数都会返回迭代器中的下一个元素。

在第一个示例中，迭代器 my_iter 用于遍历列表 my_list 中的元素。依次调用 next(my_iter)，返回列表中的元素 1、2、3。

在第二个示例中，迭代器 my_iter 用于遍历元组 my_tuple 中的元素。依次调用 next(my_iter)，返回元组中的元素 4、5、6。

在第三个示例中，迭代器 my_iter 用于遍历字符串 my_string 中的字符。依次调用 next(my_iter)，返回字符串中的字符 'H'、'e'、'l'。

next() 函数在处理迭代器时非常有用，可以逐个获取迭代器中的元素，并在需要时按需处理。当迭代器耗尽时，可以通过提供默认值来控制函数的行为，或者捕获 StopIteration 异常进行处理。

next() 是一个内置函数，用于获取迭代器中的下一个元素。如果迭代器中没有更多的元素，则抛出 StopIteration 异常。

next() 函数的语法如下：

next(iterator[, default])

• iterator 表示要获取下一个元素的迭代器对象
• default 表示一个默认值，用于在迭代器没有更多元素时返回。

范例

## 使用内置迭代器遍历列表
lst = [1, 2, 3]
it = iter(lst)
print(next(it))  # 输出 1
print(next(it))  # 输出 2
print(next(it))  # 输出 3
try:
    print(next(it))  # 抛出 StopIteration 异常
except StopIteration:
    print("StopIteration")

## 自定义迭代器遍历自定义可迭代对象
class MyIterable:
    def __init__(self, data):
        self.data = data

    def __iter__(self):
        return MyIterator(self.data)

class MyIterator:
    def __init__(self, data):
        self.data = data
        self.index = 0

    def __next__(self):
        if self.index >= len(self.data):
            raise StopIteration
        value = self.data[self.index]
        self.index += 1
        return value

my_iterable = MyIterable([4, 5, 6])
my_iterator = iter(my_iterable)
print(next(my_iterator))  # 输出 4
print(next(my_iterator))  # 输出 5
print(next(my_iterator))  # 输出 6
try:
    print(next(my_iterator))  # 抛出 StopIteration 异常
except StopIteration:
    print("StopIteration")

注意事项

需要注意的是，如果在调用 next() 函数时指定了 default 参数，那么在迭代器没有更多元素时不会抛出 StopIteration 异常，而是返回 default 参数指定的值。

示例：

## 在迭代器没有更多元素时返回默认值
lst = [1, 2, 3]
it = iter(lst)
print(next(it, 0))  # 输出 1
print(next(it, 0))  # 输出 2
print(next(it, 0))  # 输出 3
print(next(it, 0))  # 输出 0，没有更多元素，返回默认值

object()

Python 中所有类的基类，用于继承或创建空对象。

object() 是 Python 内置函数之一，用于创建一个新的对象。它是所有类的基类，也可以被用作默认的基类。

语法

pythonCopy code
object()

参数 object() 函数不接受任何参数。

返回值 object() 函数返回一个新创建的对象，它是所有类的基类。

示例

pythonCopy codeclass MyClass:
    pass

obj = object()
print(type(obj))   # <class 'object'>

my_obj = MyClass()
print(type(my_obj))   # <class '__main__.MyClass'>

在上面的示例中，首先使用 object() 函数创建一个新的对象 obj。通过调用 type(obj)，可以查看对象 obj 的类型，它是 object 类的实例。

然后定义了一个名为 MyClass 的类，并创建一个该类的实例 my_obj。通过调用 type(my_obj)，可以查看对象 my_obj 的类型，它是自定义类 MyClass 的实例。

object() 函数在某些情况下可以用作默认的基类，或者在不需要额外功能的对象创建时使用。

object() 是 Python 中所有类的基类。如果一个类没有指定父类，则默认继承自 object 类。

示例：

class MyClass:
    pass

print(isinstance(MyClass(), object))  # 输出 True

此外，object() 还可以用于创建一个空的对象。

示例：

obj = object()
print(obj)  # 输出 <object object at 0x7f0d4c1724b0>

需要注意的是，由于 object() 是所有类的基类，所以它并不会提供任何特别有用的功能，通常情况下我们并不会直接使用它。

ord()

返回字符的 Unicode 码位

ord() 函数是 Python 内置函数之一，用于返回给定字符的 Unicode 数值（码点）。

语法

pythonCopy code
ord(c)

参数

• c：表示一个字符。

返回值 ord() 函数返回一个整数，表示给定字符的 Unicode 数值（码点）。

示例

pythonCopy codeprint(ord('A'))     # 65
print(ord('a'))     # 97
print(ord('€'))     # 8364
print(ord('中'))    # 20013

在上面的示例中，ord('A') 返回字符 'A' 的 Unicode 数值，即整数 65。ord('a') 返回字符 'a' 的 Unicode 数值，即整数 97。ord('€') 返回欧元符号 '€' 的 Unicode 数值，即整数 8364。ord('中') 返回中文字符 '中' 的 Unicode 数值，即整数 20013。

ord() 函数对于需要获取字符的 Unicode 数值或进行字符编码相关操作非常有用。它可以帮助我们理解字符的底层表示和处理字符数据。

pow()

返回一个数的幂

pow() 函数是 Python 内置函数之一，用于计算一个数的幂。

语法

pythonCopy code
pow(x, y[, z])

参数

• x：表示底数（base）。
• y：表示指数（exponent）。
• z（可选）：表示取模（modulus）。

返回值 pow() 函数返回一个数的幂运算结果。如果提供了取模参数 z，则返回结果将是 x**y % z。

示例

pythonCopy codeprint(pow(2, 3))     # 8
print(pow(3, 2))     # 9
print(pow(2, 3, 5))  # 3 (8 % 5 = 3)

在上面的示例中，pow(2, 3) 计算底数为 2、指数为 3 的幂，结果为 8。pow(3, 2) 计算底数为 3、指数为 2 的幂，结果为 9。

pow(2, 3, 5) 计算底数为 2、指数为 3 的幂，并将结果取模 5，结果为 3。即 (2**3) % 5 的计算结果为 3。

pow() 函数提供了一种方便的方式来计算一个数的幂。如果提供了取模参数，可以在计算过程中进行取模运算。

print()

将一个对象打印到标准输出，通常是控制台。

语法

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

参数

• *objects（可选）：是可选参数，表示要输出的对象，可以是一个或多个对象。这些对象会被转换为字符串并按照顺序输出。如果省略 *objects，则仅输出一个空行。
• sep（可选）：表示用于分隔多个对象之间的字符串。默认为一个空格 ' '。
• end（可选）：表示在打印完成后要追加到输出的字符串。默认为一个换行符 '\n'。
• file（可选）：表示要将输出发送到的文件对象。默认为标准输出设备 sys.stdout。
• flush（可选）：表示是否立即刷新输出缓冲区。默认为 False，即不立即刷新。
• PS：
  • 如果需要在多行输出时保持输出的格式，可以使用三个引号（''' 或 """）来包含多行字符串，或使用字符串连接符（+）将多个字符串连接成一行输出。

返回值

• print() 函数不返回任何值，它只是将指定的对象输出到标准输出设备。

示例

print('Hello, World!')                 # Hello, World!

• 首先通过 print('Hello, World!') 将字符串 'Hello, World!' 输出到标准输出设备，即控制台。打印出 Hello, World!。

print('Hello', 'World', sep=', ')       # Hello, World

• 接下来通过 print('Hello', 'World', sep=', ') 打印多个对象，使用逗号和空格作为分隔符。结果为 Hello, World，即将字符串 'Hello' 和 'World' 以逗号和空格分隔输出。

print('Hello', 'World', sep='-', end='!')  # Hello-World!

• 然后通过 print('Hello', 'World', sep='-', end='!') 打印多个对象，使用连字符 '-' 作为分隔符，并将感叹号 '!' 作为结尾字符。结果为 Hello-World!，即将字符串 'Hello' 和 'World' 以连字符分隔输出，并在结尾追加感叹号。

print(1, 2, 3) # 1 2 3

print(1, 2, 3, [], [1,2,3]) # 1 2 3 [] [1, 2, 3]

• 默认以空格分割

print(1, 2, 3, sep=':')
## 1:2:3


## 元素中间会有分隔符，而末尾不会有分隔符，末尾符可以使用end来指定
print(1, 2, 3, sep=':\n') 
'''
1:
2:
3
'''


## 末尾符可以使用end来指定
print(1, 2, 3, sep=':\n', end='***') 
'''
1:
2:
3***
'''

• 自定义分隔符

print(1)
print(2)

## 输出结果为：
## 1
## 2

• 默认结尾字符使用换行符

print(1, end=' ')
print(2)

## 输出结果为：
## 1 2

• 自定义结尾字符

## 输出字符串
print("Hello, World!")


## 输出多个变量
x = 10
y = 20
print("x =", x, "y =", y)


## 自定义分隔符和结尾字符
print("x =", x, "y =", y, sep='|', end='***')


## 输出到文件
with open('output.txt', 'w') as f:
    print("Hello, World!", file=f)


## 强制刷新缓冲区
import time
for i in range(5):
    print(i)
    time.sleep(1)
    print("----", end='', flush=True)

• 其它示例

property()

返回一个属性对象

property() 是 Python 内置函数之一，用于创建属性（property）。

属性是一种特殊的对象特性，它可以像普通属性一样被访问和设置，但实际上是通过 getter（访问器）和 setter（设置器）方法进行操作。

语法

pythonCopy code
property(fget=None, fset=None, fdel=None, doc=None)

参数

• fget（可选）：表示获取属性值的方法（getter）。
• fset（可选）：表示设置属性值的方法（setter）。
• fdel（可选）：表示删除属性的方法（deleter）。
• doc（可选）：表示属性的文档字符串（docstring）。

返回值 property() 函数返回一个属性对象，可以将其绑定到类的属性上。

示例

pythonCopy codeclass Person:
    def __init__(self, name):
        self._name = name

    def get_name(self):
        return self._name

    def set_name(self, value):
        self._name = value

    def del_name(self):
        del self._name

    name = property(get_name, set_name, del_name, "Person's name")

person = Person("Alice")
print(person.name)      # Alice

person.name = "Bob"
print(person.name)      # Bob

del person.name
print(person.name)      # AttributeError: 'Person' object has no attribute '_name'

在上面的示例中，定义了一个 Person 类，并在类中使用 property() 函数创建了一个名为 name 的属性。

通过 property(get_name, set_name, del_name, "Person's name") 创建了一个属性对象，并将其绑定到 name 属性上。在此例中，get_name 方法用于获取属性值，set_name 方法用于设置属性值，del_name 方法用于删除属性。同时，指定了属性的文档字符串为 "Person's name"。

通过实例化 Person 类并创建 person 对象，可以像访问普通属性一样访问和设置 name 属性。在此示例中，首先打印出初始的 name 属性值 'Alice'。然后通过赋值语句 person.name = "Bob" 修改了 name 属性的值为 'Bob'。最后，通过 del person.name 删除了 name 属性。

property() 函数允许我们创建具有自定义访问和设置逻辑的属性。通过 getter、setter 和 deleter 方法，可以控制属性的行为和操作。属性使得我们可以通过点操作符直接访问和设置属性值，同时可以在属性访问和设置过程中执行额外的逻辑。

range()

返回一个范围对象

range() 函数是 Python 内置函数之一，用于生成一个整数序列。

语法

range(stop)
range(start, stop, step)

参数

• start（可选）：表示序列的起始值（默认为 0）。
• stop：表示序列的结束值，生成的整数序列不包括该值。
• step（可选）：表示序列的步长（默认为 1）。

返回值 range() 函数返回一个可迭代对象（range 对象），该对象代表一个整数序列。

示例

pythonCopy codefor i in range(5):
    print(i)    # 0, 1, 2, 3, 4

for i in range(2, 10, 2):
    print(i)    # 2, 4, 6, 8

在上面的示例中，展示了 range() 函数的两种常见用法。

在第一个示例中，通过 range(5) 创建了一个整数序列，从 0 到 4。通过 for 循环遍历该序列，并打印每个整数。

在第二个示例中，通过 range(2, 10, 2) 创建了一个整数序列，从 2 开始，以步长 2 递增，直到小于 10。通过 for 循环遍历该序列，并打印每个整数。

range() 函数常用于循环和迭代操作，它提供了一种简便的方式来生成整数序列。它的用法灵活，可以根据需要指定起始值、结束值和步长来生成不同的序列。由于 range() 返回的是一个可迭代对象，所以可以直接在循环中使用，或者使用 list() 函数将其转换为列表进行操作。

前包后不包

在 Python 中，range() 是一个用于生成整数序列的内置函数。range() 函数可以带有一个或多个参数，可以用来生成一定范围内的整数序列。下面是 range() 函数的语法：

range([start,] stop[, step])

• start：可选参数，指定序列中的起始值。如果未指定，则默认为 0。
• stop：必需参数，指定序列中的结束值（但不包括该值）。
• step：可选参数，指定连续数字之间的步长。默认为 1。

注意事项：

• range() 函数生成的是一个不可变的序列，因此不能对其进行修改。如果需要修改序列中的元素，可以使用列表或其他可变类型来存储生成的序列。
• range() 函数本身只是一个返回可迭代对象的函数，它本身并不会直接生成整数序列。因此，如果要使用 range() 函数生成整数序列，需要通过迭代器或循环语句来逐个获取其中的元素。

范例

range() 函数常用于计数器场景。range() 函数返回一个整数序列，可以用来迭代循环语句的计数器变量。例如，在Python中，可以使用range()函数来指定循环的次数，如下所示：

for i in range(10):
    print(i)

上述代码将输出0到9，因为range(10)返回的是一个包含0到9的整数序列。在这个例子中，range()函数充当了一个计数器的角色，帮助循环执行了10次。

range() 函数生成的是一个整数序列的迭代器，可以通过调用 next() 函数来获取下一个元素。

例如，以下代码使用 while 循环和 next() 函数来逐个获取 range() 函数生成的整数序列：

my_range = range(5)

iterator = iter(my_range)

while True:
    try:
        value = next(iterator)
        print(value)
    except StopIteration:
        break

输出为：

0
1
2
3
4

range() 函数会生成从 start 开始、到 stop 结束（不包括 stop）的整数序列，步长为 step。

例如，如果我们要生成 0 到 9 的整数序列，可以这样写：

for i in range(10):
    print(i)

输出为：

0
1
2
3
4
5
6
7
8
9

如果我们希望从 1 开始生成 10 个数字，可以这样写：

for i in range(1, 11):
    print(i)

输出为：

1
2
3
4
5
6
7
8
9
10

如果我们希望生成从 0 到 10 的偶数序列，可以这样写：

for i in range(0, 11, 2):
    print(i)

输出为：

0
2
4
6
8
10

如果我们希望生成从 1 到 9 的奇数序列，可以这样写：

• 和下面的方式相比效率最高，因为下面的方式都要从0到9进行计算

for i in range(1, 10, 2):
    print(i)

输出为：

1
3
5
7
9

如果我们希望生成从 1 到 9 的奇数序列，还可以这样写：

• 1除以2的余数是1，因为在进行整数除法时，如果商不是整数，应该向下取整，例如1除以2的商是0.5，向下取整后得到0。余数是指在整数除法中除不尽的部分，因此，1除以2的商是0，余数是1。
  • 被除数除以除数得到的结果称为商。例如，在算式6÷2=3中，6是被除数，2是除数，3是商。

for i in range(10):
    if i % 2 == 1:
        print(i)

如果我们希望生成从 1 到 9 的奇数序列，其它方式：

for i in range(10):
    if i % 2:
        print(i)

for i in range(10):
    if i % 2 != 0:
        print(i)

for i in range(10):
    if i & 1:
        print(i)

计算 10 以内的奇数之合

a = 0

for i in range(1, 10, 2):
    a += i

print(a) # 25

repr()

返回一个对象的字符串表示

repr() 函数是 Python 内置函数之一，用于返回一个对象的字符串表示形式（表示为可解释的形式）。

语法

pythonCopy code
repr(object)

参数

• object：表示要获取字符串表示形式的对象。

返回值 repr() 函数返回一个字符串，表示对象的可解释形式。

示例

pythonCopy codex = 10
print(repr(x))        # '10'

y = [1, 2, 3]
print(repr(y))        # '[1, 2, 3]'

z = {'name': 'Alice', 'age': 30}
print(repr(z))        # "{'name': 'Alice', 'age': 30}"

在上面的示例中，展示了 repr() 函数的几种用法。

首先通过 repr(x) 获取整数 x 的字符串表示形式。由于 x 是整数 10，所以返回的字符串为 '10'。

接下来通过 repr(y) 获取列表 y 的字符串表示形式。由于 y 是列表 [1, 2, 3]，所以返回的字符串为 '[1, 2, 3]'。

然后通过 repr(z) 获取字典 z 的字符串表示形式。由于 z 是字典 {'name': 'Alice', 'age': 30}，所以返回的字符串为 "{'name': 'Alice', 'age': 30}"。

repr() 函数通常用于调试和开发过程中，它返回的字符串表示形式可以提供关于对象的详细信息，并且通常可以通过 eval() 函数进行求值（即将字符串表示形式转换回原始对象）。每个对象的 repr() 结果可能会有所不同，具体取决于对象的类型和实现。

reversed()

返回一个反向迭代器

reversed() 函数是 Python 内置函数之一，用于返回一个反向迭代器对象，该对象可以用于迭代序列的元素。

语法

pythonCopy code
reversed(sequence)

参数

• sequence：表示要进行反向迭代的序列，可以是列表、元组、字符串或其他可迭代对象。

返回值 reversed() 函数返回一个反向迭代器对象，可以用于按照相反的顺序迭代序列的元素。

示例

pythonCopy codenumbers = [1, 2, 3, 4, 5]
for num in reversed(numbers):
    print(num)    # 5, 4, 3, 2, 1

text = "Hello, World!"
for char in reversed(text):
    print(char)   # '!', 'd', 'l', 'r', 'o', 'W', ' ', ',', 'o', 'l', 'l', 'e', 'H'

在上面的示例中，展示了使用 reversed() 函数进行反向迭代的几种用法。

首先通过 reversed(numbers) 创建一个反向迭代器对象，可以按照相反的顺序迭代列表 numbers 中的元素。通过 for 循环遍历该反向迭代器，并打印出每个元素。结果为 5, 4, 3, 2, 1，即按照相反的顺序打印出列表中的元素。

接下来通过 reversed(text) 创建一个反向迭代器对象，可以按照相反的顺序迭代字符串 text 中的字符。通过 for 循环遍历该反向迭代器，并打印出每个字符。结果为 '!', 'd', 'l', 'r', 'o', 'W', ' ', ',', 'o', 'l', 'l', 'e', 'H'，即按照相反的顺序打印出字符串中的字符。

reversed() 函数提供了一种方便的方式来按照相反的顺序迭代序列的元素。它返回一个反向迭代器对象，可以与 for 循环或其他迭代工具一起使用，以实现按照相反的顺序访问和处理序列的元素。

round()

对一个数进行四舍五入

round() 函数是 Python 内置函数之一，用于对数字进行四舍五入运算。

语法

pythonCopy code
round(number, ndigits=None)

参数

• number：表示要进行四舍五入的数字。
• ndigits（可选）：表示保留的小数位数。默认为 None，表示对整数部分进行四舍五入。

返回值 round() 函数返回一个浮点数，表示对给定数字进行四舍五入后的结果。

示例

pythonCopy codeprint(round(3.14159))        # 3
print(round(3.14159, 2))     # 3.14
print(round(3.14159, 3))     # 3.142
print(round(3.5))            # 4
print(round(3.5, 0))         # 4.0
print(round(1234, -2))       # 1200

在上面的示例中，展示了 round() 函数的几种用法。

首先通过 round(3.14159) 对浮点数 3.14159 进行四舍五入运算，返回整数 3。

接下来通过 round(3.14159, 2) 对浮点数 3.14159 进行四舍五入运算，保留两位小数，返回浮点数 3.14。

然后通过 round(3.14159, 3) 对浮点数 3.14159 进行四舍五入运算，保留三位小数，返回浮点数 3.142。

通过 round(3.5) 对浮点数 3.5 进行四舍五入运算，返回整数 4。

通过 round(3.5, 0) 对浮点数 3.5 进行四舍五入运算，保留零位小数，返回浮点数 4.0。

最后通过 round(1234, -2) 对整数 1234 进行四舍五入运算，保留到最近的百位，返回整数 1200。

round() 函数对于需要对数字进行四舍五入运算的场景非常有用。它可以指定保留的小数位数，也可以省略小数位数，对整数部分进行四舍五入。

在 Python 中，round() 函数用于将数字四舍五入到指定的小数位数。它的基本语法是：

round(number, ndigits=None)

• number 是要四舍五入的数字。
• ndigits 是可选参数，表示要保留的小数位数。如果省略 ndigits，则默认为 0，表示将 number 四舍五入到最接近的整数。

注意事项：

• 需要注意的是，round() 函数的返回值是一个整数或浮点数，而不是一个字符串。如果需要将其转换为字符串，则可以使用 str() 函数进行转换。

• 此外，由于浮点数在计算机内部是以二进制方式存储的，因此在进行四舍五入时可能会出现意外结果。例如，round(0.5) 的结果为 0，而不是 1。为了避免这种情况，可以使用 decimal 模块中的 Decimal 类来进行精确计算。

• 在 Python 中，round() 函数默认采用“银行家舍入法”对数值进行舍入。

• 这种舍入方式会根据小数点后一位的值和前一位的奇偶性来进行舍入，以达到更好的舍入效果。

• 具体而言，如果小数点后一位的值大于等于 5，则向上进位；否则向下舍入。

• 如果小数点后一位的值恰好为 5，则根据前一位的奇偶性来判断，如果前一位为偶数，则向下舍入，否则向上进位。

## 1.5因为小数点前面是奇数，所以向上进位为2了
## 2.5因为小数点前面是偶数，所以向下舍入（舍去）为2了
print(round(0.5), round(1.5), round(2.5), round(3.5)) # 0 2 2 4

print(round(-0.5), round(-1.5), round(-2.5), round(-3.5)) # 0 -2 -2 -4

• round 正好.5的时候，找离它最近的偶数，四舍六入五取偶

• 是的，当要舍入的数值恰好为 .5 时，Python 中的 round() 函数采用“四舍六入五取偶”的规则进行舍入。这个规则也被称为“银行家舍入法”或“四舍五入到偶数”。具体来说，这个规则有以下几个步骤：

  1. 如果要舍入的数值小数点后的第一位是 0、1、2、3 或 4，则直接舍去这一位，保留整数部分不变。
  2. 如果要舍入的数值小数点后的第一位是 6、7、8 或 9，则将整个数值加上 1，再舍去小数部分，保留整数部分。
  3. 如果要舍去的小数部分恰好为 0.5，则将整数部分除以 2，如果余数为 0，则直接舍去小数部分，保留整数部分；如果余数为 1，则将整个数值加上 1，再舍去小数部分，保留整数部分。

  例如，如果要将 2.5 舍入到整数，根据四舍六入五取偶的规则，离它最近的偶数是 2，因此 round(2.5) 的结果为 2。而如果要将 3.5 舍入到整数，离它最近的偶数是 4，因此 round(3.5) 的结果为 4。

• 其他示例

## 四舍五入到整数
print(round(2.4))  # 2
print(round(2.6))  # 3

## 四舍五入到指定小数位数
print(round(2.12345, 2))  # 2.12
print(round(2.12345, 3))  # 2.123

replace()

replace()函数用于字符串操作，用于替换字符串中的指定子字符串为新的字符串。

replace()函数接受两个参数：要被替换的子字符串和替换后的新字符串。

下面是对replace()函数的详细解释：

语法：

new_string = original_string.replace(old, new, count)

参数：

• old：要被替换的子字符串。
• new：用于替换的新字符串。
• count（可选）：指定替换的次数。如果不指定，将会替换所有匹配项。

返回值：

• replace()函数返回一个新的字符串，其中所有匹配的子字符串都被替换为新的字符串。

注意事项：

• 需要注意的是，replace()函数返回一个新的字符串，而不会修改原始字符串。这是因为字符串在Python中是不可变的，一旦创建就不能被修改。因此，replace()函数不会对原始字符串产生任何影响，它只是返回一个替换后的新字符串。

• 另外，replace()函数区分大小写。如果要执行不区分大小写的替换，可以使用正则表达式或将字符串转换为统一的大小写，然后执行替换操作。

示例1：

original_string = "Hello, World! Hello!"

new_string = original_string.replace("Hello", "Hi")

print(new_string)

"""
Hi, World! Hi!
"""

示例2（指定替换次数）：

original_string = "one one one one one"

new_string = original_string.replace("one", "two", 2)

print(new_string)
"""
two two one one one
"""

set()

创建一个集合

set() 是 Python 内置函数之一，用于创建一个无序且不重复的集合（set）对象。

语法

pythonCopy code
set(iterable)

参数

• iterable：表示可迭代对象，例如列表、元组、字符串等。

返回值 set() 函数返回一个新的集合对象，其中包含了给定可迭代对象中的唯一元素。

示例

pythonCopy codeset1 = set([1, 2, 3, 4, 4])
print(set1)      # {1, 2, 3, 4}

set2 = set('hello')
print(set2)      # {'l', 'h', 'o', 'e'}

set3 = set((1, 2, 3))
print(set3)      # {1, 2, 3}

在上面的示例中，展示了 set() 函数的几种用法。

通过 set([1, 2, 3, 4, 4]) 创建了一个集合 set1，其中包含了列表 [1, 2, 3, 4, 4] 中的唯一元素。由于集合是无序的，并且不包含重复元素，所以输出结果为 {1, 2, 3, 4}。

通过 set('hello') 创建了一个集合 set2，其中包含了字符串 'hello' 中的唯一字符。由于集合是无序的，并且不包含重复元素，所以输出结果为 {'l', 'h', 'o', 'e'}。

通过 set((1, 2, 3)) 创建了一个集合 set3，其中包含了元组 (1, 2, 3) 中的唯一元素。由于集合是无序的，并且不包含重复元素，所以输出结果为 {1, 2, 3}。

set() 函数是创建集合的常用方法，它可以从可迭代对象中提取唯一的元素，并创建一个集合对象。集合提供了高效的成员检查操作，可以用于去除列表或字符串中的重复元素，或者用于集合操作，例如求交集、并集、差集等。

setattr()

设置对象的属性值

setattr() 函数是 Python 内置函数之一，用于设置对象的属性值。

语法

pythonCopy code
setattr(object, name, value)

参数

• object：表示要设置属性的对象。
• name：表示属性的名称。
• value：表示要设置的属性值。

返回值 setattr() 函数没有返回值。它会在指定对象上设置属性的值。

示例

pythonCopy codeclass Person:
    pass

person = Person()
setattr(person, 'name', 'Alice')
print(person.name)    # Alice

setattr(person, 'age', 30)
print(person.age)     # 30

在上面的示例中，首先定义了一个 Person 类，然后创建了一个 person 对象。

通过 setattr(person, 'name', 'Alice') 将对象 person 的 'name' 属性设置为 'Alice'。可以通过 person.name 访问该属性，并打印出 'Alice'。

接下来通过 setattr(person, 'age', 30) 将对象 person 的 'age' 属性设置为 30。可以通过 person.age 访问该属性，并打印出 30。

setattr() 函数提供了一种方便的方式来动态设置对象的属性值。它接受对象、属性名称和属性值作为参数，并将属性值设置到对象上。这对于需要在运行时根据不同条件设置属性的情况非常有用。请注意，使用 setattr() 设置属性时，属性名作为字符串传递给函数。

slice()

返回一个切片对象

slice() 是 Python 内置函数之一，用于创建切片对象，用于从序列中获取指定范围的元素。

语法

pythonCopy codeslice(stop)
slice(start, stop, step)

参数

• start（可选）：表示切片的起始位置（默认为 None）。
• stop：表示切片的结束位置。
• step（可选）：表示切片的步长（默认为 None）。

返回值 slice() 函数返回一个切片对象，用于表示指定的切片范围。

示例

pythonCopy codenumbers = [1, 2, 3, 4, 5]
s = slice(2, 4)
print(numbers[s])        # [3, 4]

text = "Hello, World!"
s = slice(7)
print(text[s])           # Hello, 

s = slice(0, 12, 2)
print(text[s])           # HloWrd

在上面的示例中，展示了使用 slice() 函数创建切片对象的几种用法。

通过 slice(2, 4) 创建了一个切片对象 s，用于表示从索引 2 到索引 4（不包括）的切片范围。通过 numbers[s] 获取切片范围内的元素，结果为 [3, 4]，即获取了列表 numbers 中索引 2 和 3 的元素。

通过 slice(7) 创建了一个切片对象 s，用于表示从索引 0 到索引 7（不包括）的切片范围。通过 text[s] 获取切片范围内的字符，结果为 'Hello, '，即获取了字符串 text 中索引 0 到 6 的字符。

通过 slice(0, 12, 2) 创建了一个切片对象 s，用于表示从索引 0 到索引 12（不包括），以步长 2 进行切片。通过 text[s] 获取切片范围内的字符，结果为 'HloWrd'，即获取了字符串 text 中索引 0、2、4、6、8 和 10 的字符。

slice() 函数可以用于创建切片对象，以便在序列上进行切片操作。切片对象可以用于提取序列中指定范围的元素，从而实现灵活的数据访问和处理。

sorted()

对一个可迭代对象进行排序

sorted() 函数是 Python 内置函数之一，用于对可迭代对象进行排序操作。

sorted() 函数提供了一种方便的方式来对可迭代对象进行排序。它返回一个新的排序后的列表，不会修改原始对象。可以通过设置键函数和反向排序来进行定制化的排序操作。

语法

sorted(iterable, *, key=None, reverse=False)

参数

• iterable：表示要进行排序的可迭代对象，例如列表、元组、字符串等。
• key（可选）：表示用于排序的键函数，它会应用于可迭代对象的每个元素，并返回用于排序的键值。
• reverse（可选）：表示是否进行反向排序，默认为 False，表示按照升序进行排序。

返回值

• sorted() 函数返回一个新的列表，其中包含了对可迭代对象进行排序后的元素。

示例

numbers = [5, 2, 3, 1, 4]
sorted_numbers = sorted(numbers)
print(sorted_numbers)    # [1, 2, 3, 4, 5]

• 通过 sorted(numbers) 对列表 numbers 进行排序，返回一个新的排序后的列表。结果为 [1, 2, 3, 4, 5]，即按照升序对列表中的元素进行排序。

text = "hello"
sorted_text = sorted(text)
print(sorted_text)       # ['e', 'h', 'l', 'l', 'o']

• 通过 sorted(text) 对字符串 text 进行排序，返回一个新的排序后的列表。由于字符串是可迭代对象，所以按照字符的顺序进行排序。结果为 ['e', 'h', 'l', 'l', 'o']，即按照字母顺序对字符串中的字符进行排序。

words = ["apple", "banana", "cherry", "date"]
sorted_words = sorted(words, key=len)
print(sorted_words)      # ['date', 'apple', 'banana', 'cherry']

• 通过 sorted(words, key=len) 对列表 words 进行排序，使用 len 函数作为键函数，按照元素的长度进行排序。结果为 ['date', 'apple', 'banana', 'cherry']，即按照元素的长度从小到大对列表中的元素进行排序。

numbers = [5, 2, 3, 1, 4]
reverse_sorted_numbers = sorted(numbers, reverse=True)
print(reverse_sorted_numbers)    # [5, 4, 3, 2, 1]

• 通过 sorted(numbers, reverse=True) 对列表 numbers 进行反向排序，返回一个新的反向排序后的列表。结果为 [5, 4, 3, 2, 1]，即按照降序对列表中的元素进行排序。

staticmethod()

将一个方法转换为静态方法

staticmethod() 函数是 Python 内置函数之一，用于将一个方法转换为静态方法。

静态方法是类中的一种特殊方法，与类的实例无关，可以通过类本身直接调用，而无需创建类的实例。静态方法通常用于执行与类相关但不依赖于实例的操作。

语法

pythonCopy code
staticmethod(function)

参数

• function：表示要转换为静态方法的函数或方法。

返回值 staticmethod() 函数返回一个静态方法对象。

示例

pythonCopy codeclass MathUtils:
    @staticmethod
    def add(x, y):
        return x + y

result = MathUtils.add(3, 4)
print(result)   # 7

在上面的示例中，定义了一个 MathUtils 类，并使用 @staticmethod 装饰器将 add() 方法转换为静态方法。

通过 MathUtils.add(3, 4) 直接调用静态方法 add()，并传递参数 3 和 4。静态方法不需要创建类的实例，因此可以直接通过类名调用。结果为 7，即静态方法执行了加法操作并返回结果。

静态方法在类中通常用于实现与类相关但不依赖于实例的功能。它们可以直接通过类名访问，无需创建对象实例。静态方法不可以访问类的实例变量或调用实例方法，因为它们与实例无关。通过使用 staticmethod() 函数，可以将一个方法转换为静态方法，并将其定义在类中。

sum()

返回可迭代对象中的所有元素的和

sum() 是 Python 内置函数之一，用于对可迭代对象进行求和操作。

语法

pythonCopy code
sum(iterable, start=0)

参数

• iterable：表示要进行求和的可迭代对象，例如列表、元组、集合等。
• start（可选）：表示求和的初始值，默认为 0。

返回值 sum() 函数返回一个数字，表示对可迭代对象进行求和后的结果。

示例

pythonCopy codenumbers = [1, 2, 3, 4, 5]
result = sum(numbers)
print(result)      # 15

numbers_tuple = (1, 2, 3, 4, 5)
result_tuple = sum(numbers_tuple)
print(result_tuple)      # 15

numbers_set = {1, 2, 3, 4, 5}
result_set = sum(numbers_set)
print(result_set)        # 15

result_start = sum(numbers, start=10)
print(result_start)      # 25

在上面的示例中，展示了 sum() 函数的几种用法。

通过 sum(numbers) 对列表 numbers 进行求和操作，返回求和后的结果 15。

通过 sum(numbers_tuple) 对元组 numbers_tuple 进行求和操作，返回求和后的结果 15。

通过 sum(numbers_set) 对集合 numbers_set 进行求和操作，返回求和后的结果 15。

通过 sum(numbers, start=10) 对列表 numbers 进行求和操作，并指定初始值为 10。在求和时，初始值 10 会与列表中的元素进行累加。返回求和后的结果 25，即初始值 10 加上列表中的元素求和的结果。

sum() 函数是对可迭代对象进行求和的方便方法。它可以用于求和数字序列的元素，以及其他可迭代对象中可相加的元素。通过指定初始值，还可以在求和操作中加入额外的起始值。

super()

返回一个父类的代理对象

super() 是 Python 内置函数之一，用于调用父类的方法。

在面向对象编程中，子类可以继承父类的属性和方法。当子类需要调用父类的方法时，可以使用 super() 函数来实现。

语法

pythonCopy code
super().method(args)

参数

• method：表示要调用的父类方法的名称。
• args：表示要传递给父类方法的参数。

返回值 super() 函数返回一个特殊的对象，该对象用于调用父类的方法。

示例

pythonCopy codeclass Parent:
    def __init__(self):
        self.name = "Parent"
    
    def say_hello(self):
        print(f"Hello, I'm {self.name}")

class Child(Parent):
    def __init__(self):
        super().__init__()
        self.name = "Child"

    def say_hello(self):
        super().say_hello()
        print("I'm a child")

child = Child()
child.say_hello()

在上面的示例中，定义了一个 Parent 父类和一个 Child 子类。

在子类的构造函数 __init__() 中，通过 super().__init__() 调用了父类的构造函数，以初始化父类的属性。

在子类的方法 say_hello() 中，通过 super().say_hello() 调用了父类的 say_hello() 方法，以执行父类的行为。然后在子类方法中添加了额外的打印语句。

创建了 Child 类的实例 child，调用 child.say_hello() 方法。在输出中，首先调用了父类的 say_hello() 方法，输出 “Hello, I’m Parent”，然后输出 “I’m a child”。

super() 函数提供了一种方便的方式来调用父类的方法。它返回一个特殊的对象，该对象允许调用父类的方法，并且可以根据方法解析顺序正确地找到正确的父类方法。通过 super()，可以实现在子类中扩展父类的方法，添加额外的行为或修改父类方法的执行。

split()

split()是Python中的另一个内建函数，用于将字符串分割成子字符串列表（子串的集合），并返回这个列表。

split()函数在处理字符串分割和解析时非常有用，可以方便地从一个字符串中提取出所需的信息。

语法：

substrings_list = string.split(separator, maxsplit)

参数：

• separator：用于分割字符串的分隔符。默认情况下，会使用空格作为分隔符。
• maxsplit（可选）：指定最大分割次数。如果不指定，则会对整个字符串进行分割。

返回值：

• split()函数返回一个包含分割后子字符串的列表。

注意事项：

• 需要注意的是，split()函数默认使用空格作为分隔符。如果不提供分隔符参数，它会自动根据空格、制表符和换行符等进行分割。你也可以指定自定义的分隔符，比如逗号、冒号等。
• 如果分割次数达到了maxsplit指定的次数，剩余的部分会被视为单独的一个子字符串。

示例1：

sentence = "Hello, how are you?"

words = sentence.split()  # 默认使用空格分割

print(words)
"""
['Hello,', 'how', 'are', 'you?']
"""

示例2：

date = "2023-08-08"

year, month, day = date.split("-")

print("Year:", year)
"""
Year: 2023
"""

print("Month:", month)
"""
Month: 08
"""

print("Day:", day)
"""
Day: 08
"""

示例3：

csv_data = "Alice,25,Engineer"

fields = csv_data.split(",")

print(fields)
"""
['Alice', '25', 'Engineer']
"""

strip()

strip()是Python中的字符串方法，用于去除字符串开头和结尾的指定字符（默认为空格）。

语法：

new_string = string.strip(characters)

参数：

• characters（可选）：指定要从字符串开头和结尾去除的字符。如果不指定，默认去除空格。

返回值：

• strip()方法返回一个新的字符串，该字符串是原始字符串去除指定字符后的结果。

注意事项：

• 需要注意的是，strip()方法只会去除字符串开头和结尾的指定字符，不会影响字符串内部的字符。如果你需要删除字符串内部的特定字符，可以使用replace()方法或其他适当的方法。

示例-1：

text = "   Hello, World!   "

new_text = text.strip()

print(new_text)
"""
Hello, World!
"""

示例-2：

text = "***Python***"
new_text = text.strip("*")
print(new_text)
"""
Python
"""

示例-3：

text = "###123###"

new_text = text.strip("#")

print(new_text)
"""
123
"""

tuple()

将一个可迭代对象转换为元组

tuple() 是 Python 内置函数之一，用于创建一个元组对象。

语法

pythonCopy code
tuple(iterable)

参数

• iterable：表示要创建元组的可迭代对象，例如列表、字符串等。

返回值 tuple() 函数返回一个新的元组对象，其中包含了可迭代对象中的元素。

示例

pythonCopy codenumbers = [1, 2, 3, 4, 5]
tuple_numbers = tuple(numbers)
print(tuple_numbers)      # (1, 2, 3, 4, 5)

text = "hello"
tuple_text = tuple(text)
print(tuple_text)         # ('h', 'e', 'l', 'l', 'o')

set_numbers = {1, 2, 3, 4, 5}
tuple_set = tuple(set_numbers)
print(tuple_set)          # (1, 2, 3, 4, 5)

在上面的示例中，展示了 tuple() 函数的几种用法。

通过 tuple(numbers) 将列表 numbers 转换为元组。由于 numbers 是列表 [1, 2, 3, 4, 5]，所以返回的元组为 (1, 2, 3, 4, 5)。

通过 tuple(text) 将字符串 text 转换为元组。由于字符串是可迭代对象，所以转换后的元组包含了字符串中的每个字符。返回的元组为 ('h', 'e', 'l', 'l', 'o')。

通过 tuple(set_numbers) 将集合 set_numbers 转换为元组。由于集合是可迭代对象，所以转换后的元组包含了集合中的每个元素。返回的元组为 (1, 2, 3, 4, 5)。

tuple() 函数可以将不同类型的可迭代对象转换为元组。元组是不可变的序列，可以包含任意类型的元素。元组提供了一种有序且不可修改的数据结构，常用于存储和传递数据。

type()

返回一个对象的类型

type() 是 Python 内置函数之一，用于返回给定对象的类型。

语法

pythonCopy code
type(object)

参数

• object：表示要获取类型的对象。

返回值 type() 函数返回一个类型对象，表示给定对象的类型。

示例

pythonCopy codex = 10
print(type(x))        # <class 'int'>

y = [1, 2, 3]
print(type(y))        # <class 'list'>

z = {'name': 'Alice', 'age': 30}
print(type(z))        # <class 'dict'>

在上面的示例中，展示了 type() 函数的几种用法。

通过 type(x) 获取变量 x 的类型，返回 <class 'int'>，表示 x 是一个整数。

通过 type(y) 获取列表 y 的类型，返回 <class 'list'>，表示 y 是一个列表。

通过 type(z) 获取字典 z 的类型，返回 <class 'dict'>，表示 z 是一个字典。

type() 函数用于获取对象的类型，返回一个表示类型的对象。这在需要判断对象的类型或进行类型检查时非常有用。可以与 if 语句或其他条件判断结构一起使用，以根据对象的类型执行不同的逻辑。

• type()是Python内置函数，可以用于获取一个对象的数据类型。

范例

a = 1
b = 1.1
c = 'abc'
d = str
e = []
f = ()

print(type(a)) # <class 'int'>
print(type(b)) # <class 'float'>
print(type(c)) # <class 'str'>
print(type(d)) # <class 'type'>
print(type(e)) # <class 'list'>
print(type(f)) # <class 'tuple'>

• a的数据类型为整数类型，因此type(a)的结果为<class 'int'>。
• b的数据类型为浮点数类型，因此type(b)的结果为<class 'float'>。
• c的数据类型为字符串类型，因此type(c)的结果为<class 'str'>。
• d的数据类型为类型类型，因为str是Python内置类型，因此type(d)的结果为<class 'type'>。

a = 1

## 错误
type(a) == 'int'

## 正确
type(a) == int

• 注意：因为type函数获取的是类型，因此不能和字符串相比较

print(1 + True) # 2
print(type(1 + True)) # <class 'int'>


print(1 + True + 2.1) # 4.1
print(type(1 + True + 2.1)) # <class 'float'>

• 在 Python 中，布尔类型的值 True 和 False 可以被视为整数类型的值，其中 True 被视为整数 1，False 被视为整数 0。因此，当我们执行 1 + True 时，实际上是将整数值 1 和整数值 1 相加，结果为整数值 2。这就是为什么 print(1 + True) 输出的是 2。
• 同时，当我们对一个布尔值进行算术运算时，Python 会自动将其转换为相应的整数值。在这个例子中，True 被转换为整数 1，然后与整数 1 相加，最终得到整数 2。
• 另外，type(1 + True) 返回的是一个类型对象 <class 'int'>，这表示整数类型。这是因为 1 + True 的结果是一个整数值，因此其类型为整数类型。

vars()

返回对象的属性字典

vars() 是 Python 内置函数之一，用于返回对象的属性和属性值的字典。

语法

pythonCopy code
vars(object)

参数

• object：表示要获取属性的对象。

返回值 vars() 函数返回一个字典，其中包含了对象的属性和属性值。

示例

pythonCopy codeclass Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

person = Person("Alice", 30)
print(vars(person))    # {'name': 'Alice', 'age': 30}

在上面的示例中，定义了一个 Person 类，并创建了一个 person 对象。

通过 vars(person) 获取 person 对象的属性和属性值的字典表示形式。返回的字典为 {'name': 'Alice', 'age': 30}，其中键为属性名，值为属性值。

vars() 函数对于获取对象的属性和属性值非常方便。它返回一个字典，可以用于检查对象的状态或动态获取对象的属性信息。请注意，vars() 函数只能用于普通对象（实例对象或类对象），不能用于内置类型对象（如整数、字符串等）。

—

bool()

将给定的值转换为布尔类型（bool）。它根据值的真假情况返回相应的布尔值。

语法

bool(x)

参数

• x：要转换为布尔类型的值。

返回值

• bool() 函数返回一个布尔值，如果 x 的值为假（例如 0、空字符串、空列表等），则返回 False；如果 x 的值为真（非零、非空、非空字符串等），则返回 True。
• 注意，大多数非零数值和非空容器（如非空字符串、非空列表）都被视为真值。

示例

print(bool(0))           # False，因为整数 0 被视为假值。

print(bool(1))           # True，因为整数 1 被视为真值。

print(bool(-10))         # True，因为整数 -10 被视为真值。

print(bool(''))          # False，因为空字符串被视为假值。

print(bool('Hello'))     # True，因为非空字符串 'Hello' 被视为真值。

print(bool([]))          # False，因为空列表被视为假值。

print(bool([1, 2, 3]))   # True，因为非空列表 [1, 2, 3] 被视为真值。

float()

将指定的参数转换为浮点数（即带有小数部分的数值）。

语法

float([x])

参数

• x（可选）：要转换为浮点数的参数。可以是整数、浮点数、字符串、布尔值等。

返回值

• float() 函数返回一个浮点数。

示例

print(float(10))         # 10.0

print(float(3.14))       # 3.14

print(float('3.14'))     # 3.14

print(float(True))       # 1.0

print(float(False))      # 0.0

print(float('inf'))      # inf

print(float('-inf'))     # -inf

print(float('nan'))      # nan

print(float('not a number'))  # ValueError: could not convert string to float: 'not a number'

在上面的示例中，float() 函数被用于将不同类型的参数转换为浮点数。float(10) 返回 10.0，将整数 10 转换为浮点数。float(3.14) 返回 3.14，将浮点数 3.14 转换为浮点数（实际上不会改变）。float('3.14') 返回 3.14，将字符串 '3.14' 转换为浮点数。float(True) 返回 1.0，将布尔值 True 转换为浮点数 1.0。float(False) 返回 0.0，将布尔值 False 转换为浮点数 0.0。

另外，float('inf') 返回正无穷大（正无穷大用 'inf' 表示），float('-inf') 返回负无穷大（负无穷大用 '-inf' 表示），float('nan') 返回非数值（NaN，用 'nan' 表示）。

需要注意的是，如果尝试将无法转换为浮点数的字符串作为参数传递给 float() 函数，将引发 ValueError 异常。

int()

将一个字符串或数字转换为整数

int() 函数是 Python 内置函数之一，用于将指定的参数转换为整数（或整数对象）。

语法

int(x, base=10)

参数

• x：要转换为整数的参数。可以是数字、字符串或其他对象。
• base（可选）：转换的基数（进制）。默认为 10。

返回值

• int() 函数返回一个整数对象。

示例

print(int(10))        # 10

print(int(3.14))      # 3

print(int(3.9))      # 3，不会四舍五入，而是截断小数部分

print(int('42'))      # 42

print(int('1010', 2)) # 10

在上面的示例中，int() 函数被用于将不同类型的参数转换为整数。int(10) 返回整数 10，将整数参数保持不变。int(3.14) 返回整数 3，将浮点数参数截断为整数部分。int('42') 返回整数 42，将字符串参数解析为整数。int('1010', 2) 返回整数 10，将二进制字符串 '1010' 解析为十进制整数。

int() 函数提供了一种方便的方式来将参数转换为整数，可用于处理数字、字符串和其他需要整数类型的情况。需要注意的是，如果字符串参数不符合数字的格式，或者指定了非法的进制，则会引发 ValueError 异常。

str()

将对象转换为字符串表示形式。

语法

str(object)

参数

• object：表示要转换为字符串的对象。

返回值

• str() 函数返回一个字符串，表示给定对象的字符串表示形式。

示例

x = 10
x_str = str(x)
print(x_str)      # '10'
print(type(x_str))    # <class 'str'>

y = [1, 2, 3]
y_str = str(y)
print(y_str)      # '[1, 2, 3]'
print(type(y_str))    # <class 'str'>

z = {'name': 'Alice', 'age': 30}
z_str = str(z)
print(z_str)      # "{'name': 'Alice', 'age': 30}"
print(type(z_str))    # <class 'str'>