Python3 内置函数

本文详细介绍了Python内置的数学函数如绝对值、除法余数、幂运算、舍入、字符转换、进制转换等,以及转换函数如字符串格式化、ASCII编码、布尔转换等,适合深入理解Python基础操作。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

Python 内置函数

官方手册:https://docs.python.org/zh-cn/3/library/functions.html

数学函数

# 绝对值
abs(x)

abs(-32)     # 32
abs(-3.2)    # 3.2
abs(-3+2j)   # 3.605551275463989  # 这是什么?
abs(-True)   # 1



# 计算两数相除的商和余数
divmod(a, b)

divmod(5, 3)          # (1, 2)
a, b = divmod(5, 3)



# 计算 base**exp 或 (base**exp) % mod
pow(base, exp[, mod])

pow(2, 10)        # 1024
pow(2, 10, 100)   # 24



# 将 number 舍入到小数点后 ndigits 位,ndigits 默认为 None
# 不要苛求最后一位的精确度,因为大多数十进制小数不能以浮点数精确地表示。
round(number[, ndigits])

round(0.25,  1)   # 0.2
round(0.225, 2)   # 0.23

转换函数

# 字符转 Unicode 码点/Unicode 码点转字符
ord(c)
chr(i)

ord('好')    # 22909
chr(22909)   # '好'



# 整数转二进制/八进制/十六进制字符串(带有 0b/0o/0x)
bin(x)
oct(x)
hex(x)

bin(60)   # '0b111100'
oct(60)   # '0o74'
hex(60)   # '0x3c'



# 将单个对象格式化为字符串
format(value[, format_spec])

format(60, 'b')      # '111100'
format(60, 'o')      # '74'
format(60, 'x')      # '3c'
format(60, '.3f')    # '60.000'
format(60, '_^8d')   # '___60___'



# 将对象转换为 ASCII 字符串
ascii(object)

ascii('Hello 世界!')   # "'Hello \\u4e16\\u754c\\uff01'"
ascii(object())         # '<object object at 0x7f83876cb520>'



# 将对象转换为整数/浮点数/复数
class int([x])
class float([x])
class complex([real[, imag]])

int()                  # 0
int(3.2)               # 3
int('3.2')             # 失败
int('32') +1           # 33

float()                # 0.0
float('3.2') + 1       # 4.2
float(32)              # 32.0

complex()              # 0j
complex(3.2, -3.2)     # (3.2-3.2j)
complex('3.2, -3.2')   # (3.2-3.2j)
complex('3.2', -3.2)   # 失败
complex('3.2-3.2j')    # (3.2-3.2j)
complex('3.2-3.2')     # 失败
 


# 将对象转换为布尔值
class bool([x])

bool()                # False
bool(0)               # False
bool(0j)              # False
bool('')              # False
bool(None)            # False
bool([])              # False

bool(100)             # True
bool(3+2j)            # True
bool('Hello World!')  # True
bool(object())        # True
bool([1,2,3])         # True



# 将字符串转换为整数,指定進位制
class int(x, base=10)

int('0xFF', 16)    # 255
int('FF', 16)      # 255
int('ZZ', 36)      # 1295



# 将对象转换为字符串
# errors 是错误处理函数(字符串)
class str(object='')
class str(object=b'', encoding='utf-8', errors='strict')

str(3.2) + 'abc'               # '3.2abc'
str('Hello \n World!')         # 'Hello \n World!'
str(b'\xe5\xa5\xbd', 'utf8')   # 好



# 将对象转换为字符串,其中的转义字符会被特殊处理
repr(object)

repr(3.2) + 'abc'         # '3.2abc'
repr('Hello \n World!')   # "'Hello \\n World!'"
repr('''Hello 
 World!''')               # "'Hello \\n World!'"
repr(b'\xe5\xa5\xbd')     # "b'\\xe5\\xa5\\xbd'"



# 将对象转换为字节串(只读)
class bytes([source[, encoding[, errors]]])

bytes('好', 'utf8')   # b'\xe5\xa5\xbd'



# 将对象转换为字节串(读写)
class bytearray([source[, encoding[, errors]]])

bytearray('好', 'utf8')   # bytearray(b'\xe5\xa5\xbd')



# 将对象转换为内存视图(指针)
class memoryview(obj)

memoryview(bytes())      # <memory at 0x7f8387558940>
memoryview(bytearray())  # <memory at 0x7f8387558a00>

可迭代对象

# 返回一个迭代器对象
# 如果没有第二个参数,则 object 必须是支持迭代协议(有 __iter__() 方法)的对象,
# 或支持序列协议(有 __getitem__() 方法,且数字参数从 0 开始)的对象。
# 如果不支持这些协议,则会触发 TypeError。
# 如果有第二个参数,则 object 必须是可调用对象。这种情况下,每次迭代时都会调用 object,
# 如果 object 返回 sentinel 则触发 StopIteration,否则返回 object 的结果。
iter(object[, sentinel])

# 获取迭代器的下一个元素
# 如果迭代器耗尽,则返回 default,如果没有 default 则触发 StopIteration。
next(iterator[, default])

# 示例1:通过字符串实现迭代器,迭代器耗尽会触发 StopIteration,会被 next 捕捉
r = iter('Hello World!')
# next 捕捉到 StopIteration,会返回 None
e = next(r, None)
while e:
    print(e)
    e = next(r, None)

# 示例2:通过函数实现迭代器
def data(n):
    def f():
        nonlocal n
        n -= 1
        return n
    return f   # 返回闭包函数

# 如果 data 返回 0 则触发 StopIteration,表示迭代器耗尽
r = iter(data(10), 0)
for e in r:
    print(e)



# 将 iterable 中的元素依次交给 function 处理,用返回真的那些元素构建一个新的迭代器。
filter(function, iterable)

# 示例:过滤偶数
def f(i):
    return not (i % 2)

r = filter(f, range(1, 10))
list(r)   # [2, 4, 6, 8]



# 将 iterable 中的元素依次交给 function 处理,用返回值构建一个新的迭代器。
# 如果传入了多个的 iterable 参数,则 function 必须接受所有的 iterable 参数。
# 当有多个可迭代对象时,最短的可迭代对象耗尽则整个迭代就将结束。
map(func, *iterables)

# 示例1:将 ASCII 码转换为字符
r = map(chr, range(65, 72))
list(r)
# ['A', 'B', 'C', 'D', 'E', 'F', 'G']

# 示例2:拼接多个序列
def f(a, b, c):
    return a + b + c
r = map(f, (1,2,3), (4,5,6), (7,8,9))
list(r)   # [12, 15, 18]   # 1+4+7=12  2+5+8=15  3+6+9=18



# 返回一个迭代器,其中第 i 个元素包含了来自每个参数的第 i 个元素。
# 当参数中最短的一个被耗尽时,迭代器将停止迭代。
# 如果你关心较长参数尾部不匹配的值,则应改用 itertools.zip_longest()。
zip(*iterables)

# 示例
x = [1, 2, 3, 4, 5]
y = ['a', 'b', 'c']
z = zip(x, y)
list(z)   # [(1, 'a'), (2, 'b'), (3, 'c')]



# 排序,返回一个列表
# key 是一个函数,用于从 iterable 中依次提取元素并转换后進行比较
# reverse 表示是否反转结果
sorted(iterable, *, key=None, reverse=False)

sorted('World')                               # ['W', 'd', 'l', 'o', 'r']
sorted('World', key=str.lower)                # ['d', 'l', 'o', 'r', 'W']
sorted('World', key=str.lower, reverse=True)  # ['W', 'r', 'o', 'l', 'd']



# 反转序列,返回一个可迭代对象
reversed(seq)

list(reversed('Hello'))   # ['o', 'l', 'l', 'e', 'H']



# 序列求和,start 是额外要相加的数
# 拼接字符串序列的更好更快方式是调用 ''.join(sequence)。
# 要以扩展精度对浮点值求和,请参阅 math.fsum()。
# 要拼接一系列可迭代对象,请考虑使用 itertools.chain()。
sum(iterable, start=0)

sum((1,3,5,7,9))      # 25
sum((1,3,5,7,9), 5)   # 30



# 是否所有元素都为真(无元素则返回 True)
all(iterable)

all(())                    # True
all((1, True, 'a', 3.0))   # True
all((1, True, 'a', None))  # False



# 是否有一个元素为真(无元素则返回 False)
any(iterable)

any(())                        # False
any((0, False, '', None))      # False
any((0, False, '', object()))  # True



# 返回参数中最大的元素
# key 是一个函数,用于从 iterable 中依次提取元素并转换后進行比较。
# default 表示当 iterable 为空时返回的值。
# 如果 iterable 为空,并且没有给 default,则会触发 ValueError。
# 如果有多个最大元素,则返回第一个找到的。
max(iterable, *[, key, default])
max(arg1, arg2, *args[, key])

max('Hello World!')                  # 'r'
max('Hello World!', key=str.lower)   # 'W'
max(-1, 3, -5, 7, -9)                # 7
max(-1, 3, -5, 7, -9, key=abs)       # -9
max('', default=0)                   # 0



# 返回参数中最小的元素
min(iterable, *[, key, default])
min(arg1, arg2, *args[, key])



# 将对象转换为元组/列表/集合/冻结集合
class tuple([iterable])
class list([iterable])
class set([iterable])
class frozenset([iterable])

# 集合中重复的元素会被合并:1 == 1.0 == True   0 = False
set((1, 1.0, True, 0, False, '', None))         # {0, 1, None, ''}
frozenset((1, 1.0, True, 0, False, '', None))   # frozenset({0, 1, None, ''})



# 创建字典对象
class dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

dict(a=1, b=2, c=3)                 # {'a': 1, 'b': 2, 'c': 3}
dict((['a',1], ['b',2], ['c',3]))   # {'a': 1, 'b': 2, 'c': 3}
dict(zip('abc', [1, 2, 3]))         # {'a': 1, 'b': 2, 'c': 3}
dict({'a':1, 'b':2}, c=3, d=4)      # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
dict(zip('ab', [1,2]), c=3, d=4)    # {'a': 1, 'b': 2, 'c': 3, 'd': 4}



# 创建一个 range 对象
class range(stop)
class range(start, stop[, step])

range(0, 5)             # range(0, 5)
list(range(0, 5))       # [0, 1, 2, 3, 4]
list(range(0, 5, -1))   # []
list(range(5, 0, -1))   # [5, 4, 3, 2, 1]



# 创建一个切片对象。切片对象可以当做下标使用
class slice(stop)
class slice(start, stop[, step])

s = slice(2, 5)
s      # slice(2, 5, None)
a = [*'Hello World!']
a      # ['H', 'e', 'l', 'l', 'o', ' ', 'W', 'o', 'r', 'l', 'd', '!']
a[s]   # ['l', 'l', 'o']



# 返回一个枚举对象。iterable 必须是一个序列,或 iterator,或其他支持迭代的对象
enumerate(iterable, start=0)

list(enumerate('abc', 10))   # [(10, 'a'), (11, 'b'), (12, 'c')]

# 批量修改列表元素
r = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
for k, v in enumerate(r):
    r[k] = v+1;
r   # [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]



# 返回对象的长度
len(s)

len('Hello World!')    # 12  # 字符串
len({'a':1, True:2})   # 2   # 字典
len({1, 1.0True})   # 1   # 集合 1 == 1.0 == True 合并了
len(range(5))          # 5   # range 对象

输入输出

# 从标准输入中读取一行文本,如果遇到 EOF 则触发 EOFError
# prompt 是提示信息
input([prompt])

# 将 objects 打印到 file 指定的文本流,以 sep 分隔并在末尾加上 end。
# 如果 flush 关键字参数为真值,流会被强制刷新。
# sep, end, file 和 flush 如果存在,它们必须以关键字参数的形式给出。
print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)

类和对象

# 返回一个没有特征的新对象。
# object 是所有类的基类。它具有所有 Python 类实例的通用方法。
# 由于 object 没有 __dict__,因此无法将任意属性赋给 object 的实例。
class object()

dir(object())
# ['__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__']



# 返回对象的唯一编号
id(object)

id(object())   # 140202889491760
id(1)          # 140202889746736
id(int)        # 140202912493152



# 返回对象的 Hash 值
hash(object)

hash(object())   # 8762680593230
hash(0)          # 0
hash(1024)       # 1024
hash(3.2)        # 461168601842739203
hash(int)        # 8762682030822



# 获取一个对象的类型
class type(object)
class type(name, bases, dict)

# 只传入一个参数时,返回对象的类型,通常与 object.__class__ 所返回的对象相同。
# 推荐使用 isinstance() 内置函数来检测对象的类型,因为它会考虑子类的情况。
type(3) == int           # True   # 都是 int 类型
type(int) == type(str)   # True   # 都是 type 类型

# 传入三个参数时,返回一个新的类型。这在本质上是 class 语句的一种动态形式,
# name 字符串即类名并会成为 __name__ 属性;
# bases 元组包含基类并会成为 __bases__ 属性;如果为空则会添加 object。
# dict 字典包含类的属性和方法定义;它在成为 __dict__ 属性之前可能会被拷贝或包装。
# 下面两条语句会创建相同的类:
class X: a = 1
X                               # <class '__main__.X'>

Y = type('X', (), dict(a=1))
Y                               # <class '__main__.X'>

X == Y                          # False
id(X) == id(Y)                  # False



# 判断对象的属性是否存在
hasattr(object, name)
# 获取对象属性,如果属性不存在,则返回 default(未指定 default 则触发 AttributeError)
getattr(object, name[, default])
# 设置对象属性
setattr(object, name, value)
# 删除对象的指定属性
delattr(object, name)

# 示例:修改函数参数的默认值
def f(a=1, b=2): print(a+b)
f()   # 3
getattr(f, '__defaults__')          # (1, 2)   # 获取 f 的参数的默认值
setattr(f, '__defaults__', (3, 4))  # 修改 f 的参数的默认值
f()   # 7



# fget 是获取属性值的函数。fset 是设置属性值的函数。fdel 是删除属性值的函数。doc 是文档字符串。
class property(fget=None, fset=None, fdel=None, doc=None)

# 一个典型的用法是定义一个托管属性
# 如果 c 是 C 的实例,c.x 将调用getter,c.x = value 将调用setter, del c.x 将调用deleter。
class C:
    def __init__(self):    self._x = None
    def getx(self):        return self._x
    def setx(self, value): self._x = value
    def delx(self):        del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")

# 如果给出 doc,将成为该 property 的文档字符串。否则将拷贝 fget 的文档字符串(如果存在)。
# 这可以很容易地使用 property() 作为 decorator 来创建只读属性
class Parrot:
    def __init__(self):
        self._voltage = 100000

    # @property 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性的 'getter',
    # 并将 voltage 的文档字符串设置为 'Get the current voltage.'
    @property
    def voltage(self):
        '''Get the current voltage.'''
        return self._voltage

# property 对象具有 getter, setter 以及 deleter 方法,它们可用作装饰器来创建该 property 的副本,
# 并将相应的访问函数设为所装饰的函数:
class C:
    def __init__(self):
        self._x = None

    @property
    def x(self):
        '''I'm the 'x' property.'''
        return self._x

    @x.setter
    def x(self, value): self._x = value

    @x.deleter
    def x(self): del self._x
# 上述代码与第一个例子完全等价。注意一定要给附加函数与原始的 property 相同的名称 (在本例中为 x)
# 返回的 property 对象同样具有与构造器参数相对应的属性 fget, fset 和 fdel。



# 判断 object 是否为 classinfo 的实例或是其 (直接、间接或 虚拟) 子类。
isinstance(object, classinfo)

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



# 判断 object 是否为 classinfo 的 (直接、间接或 虚拟) 子类。
issubclass(class, classinfo)

issubclass(int, int)      # True
issubclass(bool, int)     # True
issubclass(int, bool)     # False



# 返回一个代理对象,它会将方法调用委托给 type 的父类或兄弟类。
super([type[, object-or-type]])

# 示例
class C(B):
    def method(self, arg):
        super().method(arg)    # 等同与 super(C, self).method(arg)



# 把一个方法转换为类方法。一个类方法把类自身作为第一个实参。
@classmethod

# 要声明一个类方法,请使用此语法
class C:
    @classmethod
    def f(cls, arg1, arg2, ...): ...



# 把一个方法转换为静态方法。静态方法不会接收第一个隐式参数。
@staticmethod

# 要声明一个静态方法,请使用此语法
class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

调用代码

# 判断对象是否可调用
callable(object)

callable(abs)   # True



# 执行单条 Python 表达式
# expression 是表达式字符串。
# globals 全局命名空间,如果被提供,则必须是一个字典对象。
# locals 局部命名空间,如果被提供,可以是任何映射对象。
eval(expression[, globals[, locals]])

eval('1+2')       # 3
eval('1+2; 3+4')  # 错误,只能执行一条语句

# 局部作用域会覆盖全局作用域
eval('a+b+c', {'a':1, 'b':2}, {'a':3, 'c':4})      # 9
eval('vars()', {'a':1, 'b':2}, {'a':3, 'c':4})     # {'a': 3, 'c': 4}
eval('globals()', {'a':1, 'b':2}, {'a':3, 'c':4})  # {'a': 1, 'b': 2, ... }

def f(): print('Hello World!')
eval(f.__code__)   # Hello World!



# 执行 Python 表达式
# object 是字符串或代码对象。
# globals 全局命名空间,如果被提供,则必须是一个字典对象。
# locals 局部命名空间,如果被提供,可以是任何映射对象。
exec(object[, globals[, locals]])

exec('1+2; 3+4')               # 不显示结果
exec('a=1; b=2; print(a+b)')   # 3

def f(): print('Hello World!')
exec(f.__code__)   # Hello World!



# 将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)

# source 可以是常规的字符串、字节字符串,或者 AST 对象。

# filename 是源文件路径,如果不是从文件读取源码,可设置为一些可辨识的值(经常会使用 '<string>')。

# mode 指定模式。如果 source 是语句序列,可以是 'exec';如果是单一表达式,可以是 'eval';如果是单个交互式语句,可以是 'single'。(在最后一种情况下,如果表达式执行结果不是 None 将会被打印出来。)

# flags:要附加的编译器选项和 future 语句
# dont_inherit:是否继承默认的编译器选项。
# 如果 flags 和 dont_inherit 都未提供(或都为零),则使用当前编译器选项。
# 编译器选项和 future 语句是由比特位通过“或运算”来指明的。
# https://docs.python.org/zh-cn/3/library/ast.html#ast-compiler-flags

# optimize 指定编译器的优化级别。
# -1:(默认值)选择与解释器的 -O 选项相同的优化级别。
#  0:没有优化;__debug__ 为真
#  1:断言被删除,__debug__ 为假
#  2:断言被删除,__debug__ 为假,文档字符串也被删除

c = compile('1+2', '', 'eval')
eval(c)   # 3
exec(c)   # 不显示结果

# 单条语句可以用 'eval' 模式
c = compile('print("Hello World!")', '', 'eval')
eval(c)   # Hello World!
exec(c)   # Hello World!

# 多条语句必须用 'exec' 模式
c = compile('for i in range(5):print(i)', '', 'exec')
eval(c)   # 0   1   2   3   4
exec(c)   # 0   1   2   3   4

文件

# 打开 file 并返回对应的 file object。如果该文件不能被打开,则引发 OSError。 
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

# file 是文件路径

# mode:'r' 读(默认)'w'清空写(或创建)'x'创建(存在则失败)'a'追加(或创建)'+'读写
# 'b'二进制't'文本模式(默认)

# buffering 缓冲策略,0 关闭缓冲(仅二进制模式),1 行缓冲(仅文本模式),>1 缓冲区大小(字节单位)。
# 如果没有给出 buffering,则默认缓冲策略的工作方式如下:
# 二进制文件以固定大小的块进行缓冲;使用启发式方法选择缓冲区的大小,尝试确定底层设备的“块大小”或
# 使用 io.DEFAULT_BUFFER_SIZE。在许多系统上,缓冲区的长度通常为 4096 或 8192 字节。
# “交互式”文本文件(isatty() 返回 True 的文件)使用行缓冲。其他文本文件使用上述二进制文件策略。

# encoding 编码(用于文本文件)

# errors 错误处理函数(字符串)用于指定如何处理编码和解码错误

# newline 换行符格式,可以是 None、''、'\n'、'\r'、'\r\n'。它的工作原理:
# 从流中读取输入时,如果 newline 为 None,则启用通用换行模式。输入中的行结束符可以是 '\n'、'\r'、'\r\n',这些行在返回呼叫者之前被翻译成 '\n'。如果是 '',则启用通用换行模式,但行结束符将原样返回给调用者。否则输入中的行仅以给定的字符串终止,并且行结束符将返回给调用者。
# 将输出写入流时,如果 newline 为 None,则写入的任何 '\n' 都将转换为系统默认行结束符 os.linesep。如果 newline 是 '' 或 '\n',则不进行转换。否则写入的任何 '\n' 将被转换为给定的字符串。

# 如果 closefd 是 False 并且 file 给出了文件描述符而不是文件名,那么当文件关闭时,底层文件描述符将保持打开状态。如果 file 给出的是文件名,则 closefd 必须为 True (默认值),否则将引发错误。

# opener 是自定义开启器。通过使用参数(file,flags)调用 opener 获得文件对象的基础文件描述符。
# opener 必须返回一个打开的文件描述符(使用 os.open as opener 时与传递 None 的效果相同)。
# 当以文本模式 ('w', 'r', 'wt', 'rt' 等) 打开文件时,它将返回 io.TextIOBase(特别是 io.TextIOWrapper)的一个子类。

# 当使用缓冲以二进制模式打开文件时,返回的类是 io.BufferedIOBase 的一个子类。
# 在只读的二进制模式下,它将返回 io.BufferedReader;
# 在写入二进制和追加二进制模式下,它将返回 io.BufferedWriter;
# 而在读/写模式下,它将返回 io.BufferedRandom。
# 当禁用缓冲时,则会返回原始流,即 io.RawIOBase 的一个子类 io.FileIO。

# 创建文件并写入数据
f = open('test.txt', 'w', 1024, 'utf8')
f.write('Hello World!')   # 12
f.seek(0, 0)              # 0
f.readline()              # 不可读
f.close()


# 打开文件并读写数据(使用 with 语句时,文件会在最后自动关闭)
with open('test.txt', 'a+', 1024, 'utf8') as f:
    print('Hello Python', file=f)
    f.seek(0, 0)   # 0
    f.readline()   # 'Hello World!Hello Python\n'


# 下面的示例使用 os.open() 函数的 dir_fd 的形参,从给定的目录中用相对路径打开文件:
import os
dir_fd = os.open('somedir', os.O_RDONLY)

def opener(path, flags):
    return os.open(path, flags, dir_fd=dir_fd)

with open('spamspam.txt', 'w', opener=opener) as f:
    print('This will be written to somedir/spamspam.txt', file=f)

os.close(dir_fd)  # 别忘记关闭文件描述符

其它

# 内置帮助系统
help([object])
# 返回当前作用域(或指定对象)中的名称列表
dir([object])
# 返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。
vars([object])
# 返回当前全局符号表字典
globals()
# 返回当前本地符号表字典
locals()



# 下断点,進入调试器
# 具体来说,它调用 sys.breakpointhook() ,直接传递 args 和 kws。
breakpoint(*args, **kws)



# 此函数会由 import 语句发起调用。
# 它可以被替换(通过导入 builtins 模块并给 builtins.__import__ 赋值)以便修改 import 语句的语义,
# 但是强烈建议不要这样做,因为使用导入钩子通常更容易实现同样的目标,并且不会导致代码问题,
# 因为许多代码都会假定所用的是默认实现。
# 同样也不建议直接使用 __import__() 而应该用 importlib.import_module()。
# 这是一个日常 Python 编程中不需要用到的高级函数。
__import__(name, globals=None, locals=None, fromlist=(), level=0)
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值