python内置函数 C

python内置函数 C

Python 解释器内置了很多函数和类型，任何时候都能使用。

C

callable(object)

如果 object 参数是可调用的则返回 True，否则返回 False。 如果返回 True，调用仍可能失败，但如果返回 False，则调用 object 肯定不会成功。 请注意类是可调用的（调用类将返回一个新的实例）；如果实例所属的类有 __call__() 方法则它就是可调用的。

在 3.2 版本加入: 这个函数一开始在 Python 3.0 被移除了，但在 Python 3.2 被重新加入。

# 定义一个普通的函数  
def my_function():  
    pass  
  
# 检查函数是否可调用  
print(callable(my_function))  # 输出: True  
  
# 定义一个类  
class MyClass:  
    def __call__(self):  
        print("Instance is called!")  
  
# 创建类的实例  
my_instance = MyClass()  
  
# 检查类的实例是否可调用  
print(callable(my_instance))  # 输出: True  
  
# 创建一个普通的对象（没有 __call__ 方法）  
my_object = object()  
  
# 检查对象是否可调用  
print(callable(my_object))  # 输出: False  
  
# 检查内置函数是否可调用  
print(callable(print))  # 输出: True  
  
# 检查字符串是否可调用  
print(callable("Hello"))  # 输出: False
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

chr(i)

返回 Unicode 码位为整数 i 的字符的字符串格式。例如，chr(97) 返回字符串 'a'，chr(8364) 返回字符串 '€'。这是 ord() 的逆函数。

实参的合法范围是 0 到 1,114,111（16 进制表示是 0x10FFFF）。如果 i 超过这个范围，会触发 ValueError 异常。

# 将Unicode码点65转换为字符'A'
print(chr(65))  # 输出: 'A'

# 将Unicode码点97转换为字符'a'
print(chr(97))  # 输出: 'a'

# 将Unicode码点32转换为空格字符
print(chr(32))  # 输出: ' '

# 也可以用于非ASCII字符
# 将Unicode码点20013转换为字符'中'（在中文中代表'中'）
print(chr(20013))  # 输出: '中'
1
2
3
4
5
6
7
8
9
10
11
12

@classmethod

把一个方法封装成类方法。

类方法隐含的第一个参数就是类，就像实例方法接收实例作为参数一样。要声明一个类方法，按惯例请使用以下方案：

class C:
    @classmethod
    def f(cls, arg1, arg2): ...
1
2
3

@classmethod 这样的形式称为函数的 decorator – 详情参阅 函数定义。

类方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。 其所属类以外的类实例会被忽略。 如果类方法在其所属类的派生类上调用，则该派生类对象会被作为隐含的第一个参数被传入。

类方法与 C++ 或 Java 中的静态方法不同。 如果你需要后者，请参阅本节中的 staticmethod()。 有关类方法的更多信息，请参阅 标准类型层级结构。

在 3.9 版本发生变更: 类方法现在可以包装其他 描述器 例如 property()。

在 3.10 版本发生变更: 类方法现在继承了方法的属性（ __module__、 __name__、 __qualname__、 __doc__ 和 __annotations__），并拥有一个新的 __wrapped__ 属性。

在 3.11 版本发生变更: 类方法不再可以包装其他 descriptors 例如 property()。

class MyClass:  
    class_variable = "I am a class variable"  
  
    @classmethod  
    def print_class_variable(cls):  
        print(cls.class_variable)  
  
    @classmethod  
    def create_instance(cls, value):  
        return cls(value)  
  
    def __init__(self, value):  
        self.instance_variable = value  
  
    def print_instance_variable(self):  
        print(self.instance_variable)  
  
# 使用类方法打印类变量  
MyClass.print_class_variable()  # 输出: I am a class variable  
  
# 使用类方法创建类的实例  
instance = MyClass.create_instance(42)  
  
# 使用实例方法打印实例变量  
instance.print_instance_variable()  # 输出: 42
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

类方法的一个常见用途是工厂方法，用于创建类的不同实例或返回特定类型的对象。它们也常用于实现单例模式，确保一个类只有一个实例存在。

注意，尽管类方法可以在没有创建实例的情况下被调用，但它们仍然是通过类本身来调用的，而不是通过单独的函数。这意味着它们可以访问和修改类的状态，但不能直接访问实例的状态（除非通过实例对象本身）。

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

compile()是一个内置函数，用于将源代码字符串编译为字节码对象。这个字节码对象可以被Python虚拟机执行。compile()函数通常用于动态地创建和执行代码，或者用于实现更高级的编程模式，如元编程。

参数说明：

• source：一个字符串或者AST（抽象语法树）对象，代表要编译的源代码。
• filename：源代码的文件名，如果源代码不是从文件读取，可以是一个任意的字符串，通常使用或者。
• mode：指定编译代码的种类，可以是以下字符串之一：'exec'（表示一个模块、可执行语句或交互式命令的序列）、'eval'（表示一个单独的表达式）或'single'（表示单个交互式语句）。
• flags：可选参数，用于修改编译器标志。
• dont_inherit：如果为True，编译的代码不会继承当前的编译环境标志。
• optimize：指定编译器的优化级别。

将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。source 可以是常规的字符串、字节字符串，或者 AST 对象。参见 ast 模块的文档了解如何使用 AST 对象。

filename 实参需要是代码读取的文件名；如果代码不需要从文件中读取，可以传入一些可辨识的值（经常会使用 ''）。

mode 实参指定了编译代码必须用的模式。如果 source 是语句序列，可以是 'exec'；如果是单一表达式，可以是 'eval'；如果是单个交互式语句，可以是 'single'。（在最后一种情况下，如果表达式执行结果不是 None 将会被打印出来。）

可选参数 flags 和 dont_inherit 控制应当激活哪个 编译器选项 以及应当允许哪个 future 特性。 如果两者都未提供 (或都为零) 则代码会应用与调用 compile() 的代码相同的旗标来编译。 如果给出了 flags 参数而未给出 dont_inherit (或者为零) 则会在无论如何都将被使用的旗标之外还会额外使用 flags 参数所指定的编译器选项和 future 语句。 如果 dont_inherit 为非零整数，则只使用 flags 参数 – 外围代码中的旗标 (future 特性和编译器选项) 会被忽略。

编译器选项和 future 语句是由比特位来指明的。 比特位可以通过一起按位 OR 来指明多个选项。 指明特定 future 特性所需的比特位可以在 __future__ 模块的 _Feature 实例的 compiler_flag 属性中找到。 编译器旗标 可以在 ast 模块中查找带有 PyCF_ 前缀的名称。

optimize 实参指定编译器的优化级别；默认值 -1 选择与解释器的 -O 选项相同的优化级别。显式级别为 0 （没有优化；__debug__ 为真）、1 （断言被删除， __debug__ 为假）或 2 （文档字符串也被删除）。

如果编译的源码不合法，此函数会触发 SyntaxError 异常；如果源码包含 null 字节，则会触发 ValueError 异常。

如果您想分析 Python 代码的 AST 表示，请参阅 ast.parse()。

引发一个 审计事件 compile 附带参数 source, filename。

备注：在 'single' 或 'eval' 模式编译多行代码字符串时，输入必须以至少一个换行符结尾。 这使 code 模块更容易检测语句的完整性。

警告：在将足够大或者足够复杂的字符串编译成 AST 对象时，Python 解释器有可能因为 Python AST 编译器的栈深度限制而崩溃。

在 3.2 版本发生变更: Windows 和 Mac 的换行符均可使用。而且在 'exec' 模式下的输入不必再以换行符结尾了。另增加了 optimize 参数。

在 3.5 版本发生变更: 之前 source 中包含 null 字节的话会触发 TypeError 异常。

在 3.8 版本加入: ast.PyCF_ALLOW_TOP_LEVEL_AWAIT 现在可在旗标中传入以启用对最高层级 await, async for 和 async with 的支持。

# 编译一个简单的表达式  
expr_code = compile('2 + 2', '', 'eval')
result = eval(expr_code)
print(result)  # 输出: 4  

# 编译一段可执行代码  
exec_code = compile('''  
def hello(name):  
    print(f'Hello, {name}!')  
hello('world')  
''', '', 'exec')
exec(exec_code)  # 输出: Hello, world!  

# 编译一个交互式的代码块  
single_code = compile('name = "Alice"', '', 'single')
exec(single_code)
print(name)  # 输出: Alice
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

compile()函数只是将源代码编译为字节码对象，并不会执行它。要执行编译后的代码，你需要使用exec()函数（对于'exec'模式）或eval()函数（对于'eval'模式）。

使用compile()函数时要特别小心，因为它允许执行动态生成的代码，这可能带来安全风险，特别是当代码来源不可控时。确保不要执行来自不受信任源的编译代码。

complex(real=0, imag=0)

class complex(real=0, imag=0)

class complex(string)

返回值为 real + *imag**1j 的复数，或将字符串或数字转换为复数。如果第一个形参是字符串，则它被解释为一个复数，并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型（包括复数）。如果省略了 imag，则默认值为零，构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略，则返回 0j。

对于一个普通 Python 对象 x，complex(x) 会委托给 x.__complex__()。 如果 __complex__() 未定义则将回退至 __float__()。 如果 __float__() 未定义则将回退至 __index__()。

备注：当从字符串转换时，字符串在 + 或 - 的周围必须不能有空格。例如 complex('1+2j') 是合法的，但 complex('1 + 2j') 会触发 ValueError 异常。

数字类型 — int, float, complex 描述了复数类型。

在 3.6 版本发生变更: 您可以使用下划线将代码文字中的数字进行分组。

在 3.8 版本发生变更: 如果 __complex__() 和 __float__() 均未定义则回退至 __index__()。

complex()是一个内置函数，用于创建复数。复数是包含实部和虚部的数字，通常用于表示在二维平面上的点，或在某些数学和科学计算中。

complex()函数可以接受多种形式的参数来创建复数：

1. 两个参数，分别表示复数的实部和虚部：

   c = complex(real, imag)
   1

   其中real是实部，imag是虚部。

2. 一个字符串，表示复数的形式（如'3+4j'）：

   c = complex('3+4j')
   1

   这里的'j'表示虚数单位，相当于数学中的i。

   # 使用两个参数创建复数
   c1 = complex(3, 4)
   print(c1)  # 输出: (3+4j)
   
   # 使用字符串创建复数
   c2 = complex('2-3j')
   print(c2)  # 输出: (2-3j)
   
   # 访问复数的实部和虚部
   real_part = c1.real
   imag_part = c1.imag
   print(real_part)  # 输出: 3.0
   print(imag_part)  # 输出: 4.0
   
   # 复数的运算
   c3 = c1 + c2  # 加法
   c4 = c1 * c2  # 乘法
   print(c3)  # 输出: (5+1j)
   print(c4)  # 输出: (18-1j)
   1
   2
   3
   4
   5
   6
   7
   8
   9
   10
   11
   12
   13
   14
   15
   16
   17
   18
   19

   在复数的表示中，j或J被用作虚数单位的标识。当你使用complex()函数时，可以传递一个包含这两个字符的字符串来创建复数。如果传递的字符串格式不正确（例如，没有包含j或J），则会引发ValueError。

参考：内置函数 — Python 3.12.2 文档