Python 常用内置函数

文章目录

• 常用内置函数
• • 内置函数整理
  • [- int()](#- int())
  • [- float()](#- float())
  • [- bool()](#- bool())
  • [- str()](#- str())
  • [- complex()](#- complex())
  • [- bytearray()](#- bytearray())
  • [- bytes()](#- bytes())
  • [- list()](#- list())
  • [- dict()](#- dict())
  • [- set()](#- set())
  • [- tuple()](#- tuple())
  • [- frozenset()](#- frozenset())
  • [- len()](#- len())
  • [- sorted()](#- sorted())
  • [- reversed()](#- reversed())
  • [- range()](#- range())
  • [- zip()](#- zip())
  • [- enumerate()](#- enumerate())
  • [- map()](#- map())
  • [- filter()](#- filter())
  • [- sum()](#- sum())
  • [- max()](#- max())
  • [- min()](#- min())
  • [- iter()](#- iter())
  • [- next()](#- next())
  • [- slice()](#- slice())
  • [- id()](#- id())
  • [- type()](#- type())
  • [- repr()](#- repr())
  • [- getattr()](#- getattr())
  • [- setattr()](#- setattr())
  • [- delattr()](#- delattr())
  • [- hasattr()](#- hasattr())
  • [- object()](#- object())
  • [- hash()](#- hash())
  • [- vars()](#- vars())
  • [- dir()](#- dir())
  • [- super()](#- super())
  • [- locals()](#- locals())
  • [- globals()](#- globals())
  • [- all()](#- all())
  • [- any()](#- any())
  • [- isinstance()](#- isinstance())
  • [- issubclass()](#- issubclass())
  • [- callable()](#- callable())
  • [- abs()](#- abs())
  • [- divmod()](#- divmod())
  • [- pow()](#- pow())
  • [- round()](#- round())
  • [- hex()](#- hex())
  • [- bin()](#- bin())
  • [- oct()](#- oct())
  • [- chr()](#- chr())
  • [- ord()](#- ord())
  • [- ascii()](#- ascii())
  • [- format()](#- format())
  • [- staticmethod()](#- staticmethod())
  • [- classmethod()](#- classmethod())
  • [- property()](#- property())
  • [- input()](#- input())
  • [- print()](#- print())
  • [- open()](#- open())
  • [- eval()](#- eval())
  • [- exec()](#- exec())
  • [- compile()](#- compile())
  • [- breakpoint()](#- breakpoint())
  • [- help()](#- help())

---

常用内置函数

内置函数整理

函数名	描述
类型转换操作
int()	将对象转换为整数类型
float()	将对象转换为浮动小数类型
bool()	将对象转换为布尔值，True 或 False
str()	将对象转换为字符串类型
complex()	将对象转换为复数，返回实部和虚部的复数形式
bytearray()	创建一个可变的字节数组
bytes()	创建一个不可变的字节数组
list()	将可迭代对象转换为列表
dict()	创建一个字典，或将可迭代对象转换为字典
set()	创建一个集合，去除重复元素
tuple()	创建一个不可变的元组
frozenset()	创建一个不可变的集合
序列和迭代器操作
len()	返回对象（如字符串、列表、元组、字典等）的长度或元素个数
sorted()	返回排序后的可迭代对象的新列表（不修改原始对象）
reversed()	返回一个反向的迭代器，迭代时按相反顺序遍历元素
range()	返回一个可迭代的整数序列，常用于循环控制
zip()	将多个可迭代对象的元素打包成元组，常用于并行迭代
enumerate()	返回一个包含元素及其索引的迭代器，常用于同时获取元素及其索引
map()	将指定函数应用到可迭代对象的每个元素，并返回一个新的迭代器
filter()	使用指定的条件函数过滤可迭代对象，返回符合条件的元素
sum()	返回可迭代对象中所有元素的和
max()	返回可迭代对象中的最大值
min()	返回可迭代对象中的最小值
iter()	返回一个迭代器对象，用于遍历可迭代对象
next()	返回迭代器的下一个元素，如果没有则抛出StopIteration
slice()	返回一个切片对象，用于获取序列的子集（指定起始、结束及步长）
对象和属性操作
id()	返回对象的唯一标识符，通常是对象在内存中的地址。
type()	返回对象的类型，通常是该对象所属的类。
repr()	返回对象的字符串表示，通常是一个有效的 Python 表达式，能够重新构造该对象。
getattr()	获取对象的指定属性值，如果属性不存在，则可以指定一个默认值。
setattr()	设置对象的指定属性值，如果该属性不存在，则会创建该属性。
delattr()	删除对象的指定属性，若该属性不存在，则会抛出异常。
hasattr()	检查对象是否有指定的属性，返回布尔值 True 或 False。
object()	返回一个新的空对象，通常用于类继承体系中的基类实例化。
hash()	返回对象的哈希值，适用于可哈希的对象（如不可变类型）。
vars()	返回对象的 __dict__ 属性，包含对象的可变属性（即实例变量）。
dir()	返回对象的属性和方法列表（包括实例方法和类方法）。
super()	返回父类的对象，通常在子类中用于调用父类的方法。
locals()	返回当前局部符号表（一个字典），包含局部变量的名称和值。
globals()	返回当前全局符号表（一个字典），包含全局变量的名称和值。
逻辑判断操作
all()	判断可迭代对象中的所有元素是否都为真值（即是否都为非零、非空或非 False）
any()	判断可迭代对象中是否至少有一个元素为真值
isinstance()	判断对象是否是指定类或其子类的实例
issubclass()	判断一个类是否是另一个类的子类（包括间接子类关系）
callable()	判断对象是否可调用（即是否是函数、方法或实现了 __call__ 的对象）
数值运算操作
abs()	返回数字的绝对值。
divmod()	返回两个数相除的商和余数，结果以元组形式返回。
pow()	返回 x 的 y 次方；如果提供第三个参数 z，返回 x^y % z。
round()	四舍五入，返回四舍五入后的数值。
hex()	将整数转换为十六进制字符串，前缀为 0x。
bin()	将整数转换为二进制字符串，前缀为 0b。
oct()	将整数转换为八进制字符串，前缀为 0o。
字符串与字符操作
chr()	将整数转换为对应的字符
ord()	将字符转换为对应的整数
ascii()	返回对象的 ASCII 字符串表示
format()	格式化字符串，支持复杂的格式化操作
函数、类与方法相关操作
staticmethod()	定义静态方法，类中不需要访问实例属性或方法
classmethod()	定义类方法，类方法第一个参数是类本身 cls
property()	创建属性，使方法可以像属性一样访问
输入、输出、文件操作
input()	接收用户输入的字符串
print()	打印对象到标准输出
open()	打开文件并返回文件对象
eval()	执行一个字符串表达式，并返回表达式的结果
exec()	执行一个字符串形式的代码块
调试与错误处理
compile()	编译字符串形式的代码为字节码对象，可以在以后通过 exec() 或 eval() 执行。
breakpoint()	在代码中插入断点，暂停程序执行并进入交互式调试模式（通常需要调试器支持）。
help()	返回一个对象的帮助信息，或者在交互模式下显示指定模块、类、函数的文档。

- int()

将一个对象转换为整数类型。

示例：

# 将字符串转换为整数
x = int("123")
print(x)  # 输出: 123

# 将浮动小数转换为整数（会截断小数部分）
y = int(12.56)
print(y)  # 输出: 12

# 传递一个二进制字符串
z = int("1010", 2)  # 2表示将字符串视为二进制
print(z)  # 输出: 10

- float()

将一个对象转换为浮动小数类型。

示例：

# 将字符串转换为浮动小数
x = float("12.34")
print(x)  # 输出: 12.34

# 将整数转换为浮动小数
y = float(42)
print(y)  # 输出: 42.0

# 处理包含科学计数法的字符串
z = float("1e3")
print(z)  # 输出: 1000.0

- bool()

将对象转换为布尔值，False 表示假值，True 表示真值。空字符串、0、None、空列表等都被视为 False，其他则为 True。

示例：

# 空字符串转换为布尔值
x = bool("")
print(x)  # 输出: False

# 非空字符串转换为布尔值
y = bool("hello")
print(y)  # 输出: True

# 数字0和非0值的转换
z = bool(0)
print(z)  # 输出: False

w = bool(5)
print(w)  # 输出: True

- str()

将对象转换为字符串类型。

示例：

# 将整数转换为字符串
x = str(123)
print(x)  # 输出: '123'

# 将浮动小数转换为字符串
y = str(12.34)
print(y)  # 输出: '12.34'

# 将列表转换为字符串
z = str([1, 2, 3])
print(z)  # 输出: '[1, 2, 3]'

- complex()

将一个对象转换为复数类型，或者创建一个指定实部和虚部的复数。

示例：

# 创建复数，传入实部和虚部
x = complex(2, 3)
print(x)  # 输出: (2+3j)

# 从字符串创建复数
y = complex("4+5j")
print(y)  # 输出: (4+5j)

# 仅传入一个数字作为实部，虚部默认为0
z = complex(7)
print(z)  # 输出: (7+0j)

- bytearray()

创建一个可变的字节数组。

示例：

# 创建一个空的字节数组
x = bytearray()
print(x)  # 输出: bytearray(b'')

# 创建一个字节数组，传入一个字符串
y = bytearray("hello", "utf-8")
print(y)  # 输出: bytearray(b'hello')

# 修改字节数组的内容
y[0] = 72  # 修改第一个字节（对应ASCII值为72的字母H）
print(y)  # 输出: bytearray(b'Hello')

- bytes()

创建一个不可变的字节数组。

示例：

# 创建一个空的字节对象
x = bytes()
print(x)  # 输出: b''

# 创建一个字节对象，传入字符串并指定编码
y = bytes("hello", "utf-8")
print(y)  # 输出: b'hello'

# 通过传入整数生成指定长度的字节对象
z = bytes([65, 66, 67])  # 65, 66, 67对应ASCII的 'A', 'B', 'C'
print(z)  # 输出: b'ABC'

- list()

将可迭代对象（如字符串、元组等）转换为列表。

示例：

# 将字符串转换为列表
x = list("hello")
print(x)  # 输出: ['h', 'e', 'l', 'l', 'o']

# 将元组转换为列表
y = list((1, 2, 3))
print(y)  # 输出: [1, 2, 3]

# 将集合转换为列表
z = list({1, 2, 3})
print(z)  # 输出: [1, 2, 3] (顺序不确定)

- dict()

创建一个空字典，或者将可迭代对象转换为字典。

示例：

# 创建一个空字典
x = dict()
print(x)  # 输出: {}

# 从元组列表创建字典
y = dict([('a', 1), ('b', 2)])
print(y)  # 输出: {'a': 1, 'b': 2}

# 使用关键字参数创建字典
z = dict(a=1, b=2)
print(z)  # 输出: {'a': 1, 'b': 2}

- set()

创建一个集合，集合中不允许有重复元素。

示例：

# 从列表创建集合（会去重）
x = set([1, 2, 2, 3, 3])
print(x)  # 输出: {1, 2, 3}

# 从字符串创建集合（去掉重复的字符）
y = set("hello")
print(y)  # 输出: {'h', 'e', 'l', 'o'}

# 创建空集合
z = set()
print(z)  # 输出: set()

- tuple()

创建一个不可变的元组。

示例：

# 从列表创建元组
x = tuple([1, 2, 3])
print(x)  # 输出: (1, 2, 3)

# 从字符串创建元组
y = tuple("hello")
print(y)  # 输出: ('h', 'e', 'l', 'l', 'o')

# 创建空元组
z = tuple()
print(z)  # 输出: ()

- frozenset()

创建一个不可变的集合。

示例：

# 创建不可变集合
x = frozenset([1, 2, 3, 3, 2])
print(x)  # 输出: frozenset({1, 2, 3})

# frozenset本身是不可变的，无法修改
try:
    x.add(4)
except AttributeError as e:
    print(e)  # 输出: 'frozenset' object has no attribute 'add'

- len()

返回对象的长度或元素个数。

示例：

# 对于字符串
s = "Hello, World!"
print(len(s))  # 输出: 13

# 对于列表
lst = [1, 2, 3, 4, 5]
print(len(lst))  # 输出: 5

• len() 返回对象中元素的数量，对于字符串是字符数，对于列表、元组、字典等是元素个数。

- sorted()

返回排序后的可迭代对象的新列表，原对象不变。

示例：

lst = [3, 1, 4, 1, 5, 9, 2, 6]
sorted_lst = sorted(lst)
print(sorted_lst)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]
print(lst)  # 输出: [3, 1, 4, 1, 5, 9, 2, 6]，原列表未改变

• sorted() 返回一个排序后的列表，并不会改变原列表。如果需要降序排序，可以传递 reverse=True 参数。

- reversed()

返回一个反向的迭代器，遍历时按相反顺序返回元素。

示例：

lst = [1, 2, 3, 4]
reversed_lst = reversed(lst)
print(list(reversed_lst))  # 输出: [4, 3, 2, 1]

• reversed() 返回一个迭代器，不会直接改变原列表，若需要输出列表形式，可以使用 list() 函数将其转换为列表。

- range()

返回一个可迭代的整数序列，常用于 for 循环。

示例：

for i in range(5):
    print(i)
# 输出:
# 0
# 1
# 2
# 3
# 4

• range() 生成从 0 到指定的上限（不包括上限）的整数序列。可以指定起始值、终止值和步长，如 range(1, 10, 2) 生成 1, 3, 5, 7, 9。

- zip()

将多个可迭代对象的元素打包成元组，返回一个新的迭代器。

示例：

names = ['Alice', 'Bob', 'Charlie']
ages = [24, 30, 22]
zipped = zip(names, ages)
print(list(zipped))  # 输出: [('Alice', 24), ('Bob', 30), ('Charlie', 22)]

• zip() 将多个可迭代对象按顺序打包为元组，直到最短的可迭代对象耗尽。如果需要分别获取各个元素的列，可以使用 zip(*iterables) 进行解压。

- enumerate()

返回一个带有索引的迭代器，常用于同时获取元素及其索引。

示例：

fruits = ['apple', 'banana', 'cherry']
for index, fruit in enumerate(fruits):
    print(f"Index: {index}, Fruit: {fruit}")
# 输出:
# Index: 0, Fruit: apple
# Index: 1, Fruit: banana
# Index: 2, Fruit: cherry

• enumerate() 返回一个迭代器，生成一个元组，其中包含元素的索引和对应的元素值。

- map()

将指定函数应用到可迭代对象的每个元素，返回新的迭代器。

示例：

def square(x):
    return x * x

numbers = [1, 2, 3, 4]
squared = map(square, numbers)
print(list(squared))  # 输出: [1, 4, 9, 16]

• map() 需要一个函数和一个或多个可迭代对象作为参数，它会将该函数应用到可迭代对象的每个元素上，并返回一个新的迭代器。

- filter()

使用指定的函数过滤可迭代对象，返回符合条件的元素。

示例：

def is_even(x):
    return x % 2 == 0

numbers = [1, 2, 3, 4, 5, 6]
even_numbers = filter(is_even, numbers)
print(list(even_numbers))  # 输出: [2, 4, 6]

• filter() 根据给定的函数（一个返回布尔值的函数）筛选可迭代对象中的元素，返回符合条件（返回 True）的元素。

- sum()

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

示例：

numbers = [1, 2, 3, 4, 5]
total = sum(numbers)
print(total)  # 输出: 15

• sum() 对可迭代对象的所有元素求和，适用于整数、浮点数等数值类型。

- max()

返回可迭代对象中的最大值。

示例：

numbers = [1, 2, 3, 4, 5]
maximum = max(numbers)
print(maximum)  # 输出: 5

• max() 返回可迭代对象中的最大值，适用于数值类型。

- min()

返回可迭代对象中的最小值。

示例：

numbers = [1, 2, 3, 4, 5]
minimum = min(numbers)
print(minimum)  # 输出: 1

• min() 返回可迭代对象中的最小值，适用于数值类型。

- iter()

返回一个迭代器对象，支持遍历可迭代对象。

示例：

lst = [1, 2, 3, 4]
iterator = iter(lst)
print(next(iterator))  # 输出: 1
print(next(iterator))  # 输出: 2

• iter() 返回一个迭代器对象，支持通过 next() 获取序列中的下一个元素。

- next()

返回迭代器的下一个元素，如果没有元素，则抛出 StopIteration 异常。

示例：

lst = [10, 20, 30]
iterator = iter(lst)
print(next(iterator))  # 输出: 10
print(next(iterator))  # 输出: 20
print(next(iterator))  # 输出: 30
print(next(iterator))  # 触发 StopIteration 异常

• next() 用于从迭代器中获取下一个元素。如果迭代器已耗尽，则会抛出 StopIteration 异常。

- slice()

返回一个切片对象，用于指定序列的子集（指定起始、结束及步长）。

示例：

lst = [10, 20, 30, 40, 50]
sliced = slice(1, 4)  # 获取索引从 1 到 3 的元素
print(lst[sliced])  # 输出: [20, 30, 40]

• slice() 返回一个切片对象，表示序列的部分。你可以指定起始位置、结束位置和步长来获取子序列。

- id()

返回对象的唯一标识符，通常是对象在内存中的地址。

示例：

a = 42
b = a
print(id(a))  # 返回 a 对象的唯一标识符
print(id(b))  # 返回 b 对象的唯一标识符，与 a 相同

• id() 返回一个唯一标识符，该标识符通常是对象的内存地址。两个变量指向相同对象时，它们的 id() 值相同。

- type()

返回对象的类型。

示例：

a = 42
print(type(a))  # <class 'int'>

• type() 返回一个对象的类型。在这个例子中，a 是一个整数，返回 <class 'int'>。

- repr()

返回对象的字符串表示，通常是一个合法的 Python 表达式。

示例：

a = [1, 2, 3]
print(repr(a))  # 输出 '[1, 2, 3]'

• repr() 返回对象的"官方"字符串表示，通常是一个合法的 Python 表达式，可以用来重新构造该对象。

- getattr()

获取对象的指定属性值。如果属性不存在，可以指定默认值。

示例：

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

p = Person("Alice")
print(getattr(p, 'name'))  # Alice
print(getattr(p, 'age', 30))  # 30，默认值

• getattr() 用来获取对象的属性。如果属性不存在，可以指定一个默认值，否则会抛出 AttributeError。

- setattr()

设置对象的指定属性值。如果属性不存在，会自动创建。

示例：

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

p = Person("Alice")
setattr(p, 'age', 25)
print(p.age)  # 25

• setattr() 可以动态地为对象设置属性，如果该属性不存在，setattr() 会创建它。

- delattr()

删除对象的指定属性，如果属性不存在，抛出异常。

示例：

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

p = Person("Alice")
delattr(p, 'name')
# print(p.name)  # 这里会抛出 AttributeError，因为 'name' 属性已被删除

• delattr() 用来删除对象的属性。如果属性不存在，抛出 AttributeError。

- hasattr()

检查对象是否有指定的属性，返回布尔值。

示例：

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

p = Person("Alice")
print(hasattr(p, 'name'))  # True
print(hasattr(p, 'age'))  # False

• hasattr() 用来检查对象是否具有指定的属性，返回 True 或 False。

- object()

返回一个新的空对象，通常用于基类实例化。

示例：

o = object()
print(o)  # <object object at 0x00000000>

• object() 创建并返回一个新的空对象。通常它作为其他类的基类使用，或者在动态创建实例时使用。

- hash()

返回对象的哈希值。哈希值通常用于集合或字典的键。

示例：

a = (1, 2, 3)
print(hash(a))  # 哈希值

• hash() 返回一个对象的哈希值。该值通常用于集合、字典等数据结构中，以支持高效的查找。

- vars()

返回对象的 dict 属性，包含对象的可变属性（即实例变量）。

示例：

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

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

• vars() 返回对象的 dict 属性，包含对象的所有实例变量。

- dir()

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

示例：

a = [1, 2, 3]
print(dir(a))  # 列出列表对象的所有方法和属性

• dir() 返回对象的所有属性和方法，通常用于查看一个对象的功能。

- super()

返回父类的对象，通常在子类中用于调用父类的方法。

示例：

class Animal:
    def speak(self):
        print("Animal speaks")

class Dog(Animal):
    def speak(self):
        super().speak()  # 调用父类的方法
        print("Dog barks")

d = Dog()
d.speak()

• super() 用于调用父类的方法或属性。它通常用于子类中，允许子类调用父类的实现。

- locals()

返回当前局部符号表（一个字典）。

示例：

def func():
    x = 10
    print(locals())  # 返回局部符号表 {'x': 10}

func()

• locals() 返回当前局部作用域的符号表，通常是一个字典，包含当前函数内所有局部变量及其值。

- globals()

返回当前全局符号表（一个字典）。

示例：

x = 10
def func():
    print(globals())  # 返回全局符号表，包含变量 x

func()

• globals() 返回当前全局作用域的符号表，通常是一个字典，包含全局变量及其值。

- all()

判断可迭代对象中的所有元素是否都为真值（即是否都为非零、非空或非 False）。如果可迭代对象为空，all() 返回 True。

示例：

# 示例 1: 所有元素为真
numbers = [1, 2, 3]
print(all(numbers))  # 输出: True，因为所有元素都为非零

# 示例 2: 包含假值
values = [0, 1, 2]
print(all(values))  # 输出: False，因为 0 是假值

# 示例 3: 空列表
empty = []
print(all(empty))  # 输出: True，因为没有元素违反条件

• all() 会检查每个元素，如果所有元素都为真值（即非 False, 非 0, 非空值），则返回 True。
• 如果任一元素为假值（例如 False, None, 0, ''），则返回 False。
• 空的可迭代对象默认返回 True，因为没有元素违反"所有为真"的条件。

- any()

判断可迭代对象中是否至少有一个元素为真值。如果可迭代对象为空，any() 返回 False。

示例：

# 示例 1: 至少有一个元素为真
numbers = [0, 1, 2]
print(any(numbers))  # 输出: True，因为 1 和 2 为真值

# 示例 2: 全部为假
values = [0, False, None]
print(any(values))  # 输出: False，因为没有任何元素为真值

# 示例 3: 空列表
empty = []
print(any(empty))  # 输出: False，因为没有元素

• any() 会检查每个元素，如果有任何一个元素为真值（即非 False, 非 0, 非空值），则返回 True。
• 如果所有元素都为假值，返回 False。
• 空的可迭代对象返回 False，因为没有任何元素为真。

- isinstance()

判断对象是否是指定类或其子类的实例。

示例：

# 示例 1: 对象是指定类的实例
class Animal:
    pass

class Dog(Animal):
    pass

d = Dog()
print(isinstance(d, Dog))     # 输出: True，因为 d 是 Dog 的实例
print(isinstance(d, Animal))  # 输出: True，因为 Dog 是 Animal 的子类

# 示例 2: 对象不是指定类的实例
a = Animal()
print(isinstance(a, Dog))  # 输出: False，因为 a 不是 Dog 的实例

• isinstance() 用于检查一个对象是否是指定类的实例，或者是否是指定类及其子类的实例。
• 它可以用于类型检查，帮助判断一个对象的类型，确保其符合预期。

- issubclass()

判断一个类是否是另一个类的子类（包括间接子类关系）。

示例：

# 示例 1: 类是子类
class Animal:
    pass

class Dog(Animal):
    pass

print(issubclass(Dog, Animal))  # 输出: True，因为 Dog 是 Animal 的子类
print(issubclass(Dog, object))  # 输出: True，因为所有类都是 object 的子类

# 示例 2: 类不是子类
class Cat:
    pass

print(issubclass(Cat, Dog))  # 输出: False，因为 Cat 不是 Dog 的子类

• issubclass() 用于检查一个类是否是另一个类的子类，或者是否是该类的间接子类。
• 例如，Dog 是 Animal 的子类，因此 issubclass(Dog, Animal) 返回 True。
• 还可以用于检查一个类是否是基类 object 的子类，所有类在 Python 中都继承自 object。

- callable()

判断对象是否可调用（即是否是函数、方法或实现了 call 方法的对象）。

示例：

# 示例 1: 可调用对象
def greet():
    return "Hello"

class Person:
    def __call__(self):
        return "I am callable"

print(callable(greet))       # 输出: True，因为 greet 是一个函数
print(callable(Person))      # 输出: True，因为 Person 是一个类，可以实例化
print(callable(Person()))    # 输出: True，因为 Person 的实例实现了 __call__()

# 示例 2: 不可调用对象
x = 42
print(callable(x))  # 输出: False，因为 x 不是函数或类实例化对象

• callable() 用于检查对象是否可以被调用（即是否是函数、方法，或是否实现了 call 方法）。
• 在示例中，greet() 是一个函数，所以 callable(greet) 返回 True；Person 是一个类，类本身不是可调用的，但它的实例 Person() 是可调用的，因为该类实现了 call 方法。
• 如果对象不是函数、方法或实现了 call 方法的类实例，callable() 返回 False。

- abs()

返回数字的绝对值

示例：

# 示例 1: 正数的绝对值
num1 = 5
print(abs(num1))  # 输出: 5，因为绝对值就是数字本身

# 示例 2: 负数的绝对值
num2 = -7
print(abs(num2))  # 输出: 7，因为负数的绝对值是正数

# 示例 3: 浮动数的绝对值
num3 = -3.14
print(abs(num3))  # 输出: 3.14，浮动数也可以取绝对值

• abs() 会返回一个数字的绝对值，输入可以是整数、浮动数或复数。
• 对于负数，返回其相反数；对于正数或零，返回其本身。

- divmod()

返回商和余数的元组 (商, 余数)。

示例：

# 示例 1: 正整数的商和余数
quotient, remainder = divmod(17, 5)
print(quotient)   # 输出: 3，17 除以 5 商是 3
print(remainder)  # 输出: 2，17 除以 5 余数是 2

# 示例 2: 负数的商和余数
quotient, remainder = divmod(-17, 5)
print(quotient)   # 输出: -4，因为商会向负方向取整
print(remainder)  # 输出: 3，余数调整为非负数

• divmod(a, b) 返回的是 (商, 余数) 元组，a 除以 b 得到的商和余数。
• 负数除法时，商会向负方向取整，而余数始终保持非负。

- pow()

返回 x 的 y 次方，或计算 x^y % z。

示例：

# 示例 1: x 的 y 次方
result = pow(2, 3)
print(result)  # 输出: 8，因为 2^3 = 8

# 示例 2: x 的 y 次方并取模 z
result = pow(2, 3, 5)
print(result)  # 输出: 3，因为 2^3 = 8，8 % 5 = 3

• pow(x, y) 计算 x 的 y 次方。
• pow(x, y, z) 计算 (x^y) % z，即 x 的 y 次方对 z 取模。

- round()

返回四舍五入后的数值。

示例：

# 示例 1: 四舍五入到整数
num1 = 4.6
print(round(num1))  # 输出: 5，因为 4.6 四舍五入到 5

# 示例 2: 四舍五入到指定的小数位数
num2 = 3.14159
print(round(num2, 2))  # 输出: 3.14，保留两位小数

# 示例 3: 四舍五入到整数
num3 = 2.5
print(round(num3))  # 输出: 2，Python 默认四舍五入时是向最近的偶数舍入

• round() 用于对浮动数进行四舍五入。
• round(number, ndigits) 可以指定保留小数位数，如果不指定，默认四舍五入到整数。
• 如果数字正好在两个整数中间，Python 会向最近的偶数舍入（即 "银行家舍入法"）。

- hex()

将整数转换为十六进制字符串，前缀为 0x。

示例：

# 示例 1: 正整数转换为十六进制
num1 = 255
print(hex(num1))  # 输出: '0xff'

# 示例 2: 负整数转换为十六进制
num2 = -255
print(hex(num2))  # 输出: '-0xff'

• hex() 将整数转换为十六进制字符串。
• 结果会带有 '0x' 前缀表示十六进制，负数会带有 '-' 前缀。

- bin()

将整数转换为二进制字符串，前缀为 0b。

示例：

# 示例 1: 正整数转换为二进制
num1 = 5
print(bin(num1))  # 输出: '0b101'

# 示例 2: 负整数转换为二进制
num2 = -5
print(bin(num2))  # 输出: '-0b101'

• bin() 将整数转换为二进制字符串。
• 结果会带有 '0b' 前缀表示二进制，负数会带有 '-' 前缀。

- oct()

将整数转换为八进制字符串，前缀为 0o。

示例：

# 示例 1: 正整数转换为八进制
num1 = 8
print(oct(num1))  # 输出: '0o10'

# 示例 2: 负整数转换为八进制
num2 = -8
print(oct(num2))  # 输出: '-0o10'

• oct() 将整数转换为八进制字符串。
• 结果会带有 '0o' 前缀表示八进制，负数会带有 '-' 前缀。

- chr()

接受一个整数参数，返回与该整数对应的 Unicode 字符。整数值必须在 0 到 1114111 之间。

示例：

print(chr(65))  # 输出: 'A'（65 对应字符 'A'）
print(chr(97))  # 输出: 'a'（97 对应字符 'a'）

- ord()

接受一个字符，返回其对应的 Unicode 码点（整数值）。字符应该是一个长度为 1 的字符串。

示例：

print(ord('A'))  # 输出: 65（字符 'A' 对应的 Unicode 码点是 65）
print(ord('a'))  # 输出: 97（字符 'a' 对应的 Unicode 码点是 97）

- ascii()

返回对象的 ASCII 字符串表示。如果对象包含非 ASCII 字符（即码点大于 127），这些字符会被转义为 \u 表示。例如，字符 'é' 会被表示为 \u00e9。

示例：

print(ascii('abc'))   # 输出: 'abc'
print(ascii('éclair')) # 输出: '\xe9clair'

• ascii() 的结果总是以 ASCII 编码的形式返回，可以用于调试和查看非 ASCII 字符的转义。

- format()

用于格式化字符串，可以通过占位符和格式规范来插入变量。支持多种复杂的格式化操作，如指定浮点数精度、日期格式、对齐方式等。

示例：

name = "Alice"
age = 30
print("Name: {}, Age: {}".format(name, age))  # 输出: Name: Alice, Age: 30

# 使用位置参数
print("{0} is {1} years old.".format(name, age))  # 输出: Alice is 30 years old.

# 使用关键字参数
print("{name} is {age} years old.".format(name="Bob", age=25))  # 输出: Bob is 25 years old.

# 格式化数字
pi = 3.14159
print("Pi to two decimal places: {:.2f}".format(pi))  # 输出: Pi to two decimal places: 3.14

- staticmethod()

用于定义静态方法，它不需要访问类的实例属性或方法，也不需要访问类本身。

静态方法通常用于执行一些独立于类和实例的操作，属于类的一部分但不与实例或类的状态相关。

示例：

class MyClass:
    @staticmethod
    def greet(name):
        print(f"Hello, {name}!")

MyClass.greet("Alice")  # 输出: Hello, Alice!

- classmethod()

用于定义类方法。类方法的第一个参数是类本身，通常命名为 cls。

它可以访问类的属性和方法，但不能访问实例的属性。类方法常用于操作类的状态或创建类的实例（例如，使用 cls 作为工厂方法）。

示例：

class MyClass:
    class_name = "MyClass"

    @classmethod
    def print_class_name(cls):
        print(f"Class name is {cls.class_name}")

MyClass.print_class_name()  # 输出: Class name is MyClass

- property()

用于将方法转换为属性，使得该方法可以像访问普通属性一样被访问。

通过 @property 装饰器，方法可以作为属性被获取、设置或删除，允许对属性的访问进行更精细的控制。可以定义 getter、setter 和 deleter 方法。

示例：

class MyClass:
    def __init__(self, value):
        self._value = value

    @property
    def value(self):
        return self._value

    @value.setter
    def value(self, new_value):
        if new_value < 0:
            raise ValueError("Value cannot be negative.")
        self._value = new_value

obj = MyClass(10)
print(obj.value)  # 输出: 10

obj.value = 20    # 设置新值
print(obj.value)  # 输出: 20

# obj.value = -5  # 这将引发 ValueError: Value cannot be negative.

- input()

从用户输入中读取一行数据，返回输入内容作为字符串。

通常用于获取用户的输入。

示例：

name = input("Enter your name: ")
print(f"Hello, {name}!")

- print()

将一个或多个对象打印到标准输出（通常是终端或控制台）。

可以打印字符串、数字、列表等，也支持自动添加换行符和定制分隔符。

示例：

print("Hello, world!")
print("The answer is", 42)

- open()

用于打开文件，返回一个文件对象。可以指定文件的打开模式（如读取模式 'r'、写入模式 'w' 等）。

文件对象提供了对文件内容的读写操作。

示例：

with open('example.txt', 'r') as file:
    content = file.read()
    print(content)

- eval()

接收一个字符串形式的Python表达式并执行该表达式，返回表达式的结果。

适用于计算简单的表达式，例如数学计算。

示例：

result = eval("3 + 5")
print(result)  # 输出: 8

- exec()

执行字符串形式的Python代码块。

与 eval() 类似，但 exec() 可以执行多行代码和更复杂的结构（如函数定义、类定义等），不返回结果。

示例：

code = """
def greet(name):
    return f"Hello, {name}"

print(greet("Alice"))
"""
exec(code)  # 输出: Hello, Alice

- compile()

将字符串形式的代码编译为字节码对象，可以在稍后的时间通过 exec() 或 eval() 执行。

compile() 允许动态地创建和执行代码，适用于需要在运行时动态构建和执行代码的场景。

示例：

code = "a = 5 + 3"
compiled_code = compile(code, "<string>", "exec")
exec(compiled_code)  # 执行编译后的代码，a = 5 + 3
print(a)  # 输出: 8

- breakpoint()

用于在代码中插入一个断点，暂停程序的执行并启动调试器，进入交互式调试状态。

通常结合调试工具（如 pdb）使用，用于在调试期间检查变量值、执行跟踪等操作。默认情况下，breakpoint() 会调用 Python 的内置调试器 pdb。

示例：

def calculate_sum(a, b):
    breakpoint()  # 在这里暂停执行，进入调试模式
    return a + b
calculate_sum(2, 3)

- help()

返回一个对象的帮助信息，或者在交互模式下显示模块、类、函数等的文档说明。

可以用于探索模块或类的使用方法，通常在交互式环境中使用。

示例：

help(str)  # 获取关于字符串类型的帮助信息
help(print)  # 获取关于 print 函数的帮助信息