python3.9.5内置函数教程

若有 bug 或疑问，就在评论区告诉我吧 ฅ( ̳• ◡ • ̳)ฅ♪

abs()函数

语法

abs(x, /)

功能

传入不同的数据类型的参数，abs()实现的功能不同：

参数的数据类型	功能
整数、浮点数	返回参数的绝对值
复数	返回参数的模
自定义了__abs__()的对象	执行自定义的__abs__()代码

示例：参数是整数或浮点数

a=3
print(abs(a))
a=-3
print(abs(a))
a=3.3
print(abs(a))
a=-3.3
print(abs(a))

3
3
3.3
3.3

示例：参数是复数

a=3+2j
print(abs(a))
a=-3-2j
print(abs(a))

3.605551275463989
3.605551275463989

示例：参数是自定义了__abs__()的对象

class a:
    def __abs__(self):
        return 999
b=a()
print(abs(b))

999

all()函数

语法

all(iterable, /)

功能

参数 iterable 应当是序列类型。

若参数 iterable 中的每个元素转换为逻辑值后，都为True，则返回True，否则返回False。

其功能等价于函数：

def all(a):
    for element in a:
        if not element:
            return False
    return True
    

注意：非逻辑对象转换成逻辑值的规则，可参见此文章中的bool()类。

示例

a=[True,True,False,True]
print(all(a))
a=[-2,-1,0,1]
print(all(a))
a=[True,True,True,True]
print(all(a))
a=[-1,-2,-3,-4]
print(all(a))

False
False
True
True

any()函数

语法

any(iterable, /)

功能

参数应当是可迭代的类型，比如字符串、列表。

若参数中任一元素转换为逻辑值后为True，则返回True，否则返回False。

若参数中没有元素，则返回False。

其功能等价于函数：

def any(a):
    for element in a:
        if element:
            return True
    return False
    

注意：非逻辑对象转换成逻辑值的规则，可参见此文章中的bool()类。

示例

a=[False,False,True,False]
print(any(a))
a=[0,0,3,0] # 整数转换为布尔，0为False，其它数为True
print(any(a))
a=[False,False,False,False]
print(any(a))
a=[0,0,0,0]
print(any(a))

True
True
False
False

ascii()函数

语法

ascii(obj, /)

功能

使用 ASCII 编码，将参数转换为字符串。

对于参数中 ASCII 编码不可打印的内容，此函数处理方式如下：

• 对于属于ASCII编码但不可打印的字符（比如空格、制表符、换行符），将使用转义符来表示。
• 对于不属于 ASCII 编码的字符，会根据参数使用的不同编码方式，分别使用 \x、\u和\U来转义。

示例：默认编码的字符串

hello world!和世界你好！之间的换行，被转换为了转义符\n。

世界你好！不属于ASCII 编码的字符，使用\u转义了每个字符。（此处感叹号是中文感叹号，ASCII中的感叹号是英文感叹号）

a='''hello world!
世界你好！'''
print(ascii(a))

'hello world!\n\u4e16\u754c\u4f60\u597d\uff01'

示例：指定为 utf-8 编码的字符串

a='''hello world!
世界你好！'''.encode('utf-8')
print(ascii(a))

b'hello world!\n\xe4\xb8\x96\xe7\x95\x8c\xe4\xbd\xa0\xe5\xa5\xbd\xef\xbc\x81'

示例：列表类型

a=[1,2,3]
print(ascii(a))

[1, 2, 3]

示例：数字类型

a=3
print(ascii(a))

3

bin()函数

语法

bin(number, /)

功能

传入不同数据类型的参数，bin()实现的功能不同：

参数的数据类型	功能
整数	将一个整数转变为一个前缀为“0b”的二进制字符串。
自定义了__index__()的对象	将__index__()的返回值转变为一个前缀为“0b”的二进制字符串。 __index__()的返回值必须是整数类型。

示例：整数

a=3
print(bin(a))
a=-3
print(bin(a))

0b11
-0b11

示例：自定义了__index__()的对象

class a:
    def __index__(self):
        return 123 # 返回整数类型的数据
b=a()
print(bin(b))

0b1111011

bool()类

语法

bool(obj, /)

功能

将参数转换为布尔值。参数的默认值是False。

转换规律：任何对象都可以进行逻辑值的检测。该对象在以下情况将被视为假值，其它情况均被视为真值：

• 被定义为假值的常量: None 和 False。
• 任何数值类型的零: 0, 0.0, 0j, Decimal(0), Fraction(0, 1)
• 空的序列和多项集: ‘’, (), [], {}, set(), range(0)
• 对象被调用时其所属类定义了__bool__()方法且返回False或是定义了__len__()方法且返回0。(两个方法都有时，优先判断__bool__()方法)

注意：

• bool()是类，不是函数。我们像函数一样使用它，因为我们需要的只是它返回的实例。
• bool()有且仅有两个实例，分别是True和False。

示例

print(bool())
a=3
print(bool(a))
a=0
print(bool(a))
a='aaa'
print(bool(a))
class b1:
    def __bool__(self):
        return False
class b2:
    def __len__(self):
        return 0
class b3:
    def __bool__(self):
        return True
    def __len__(self):
        return 0
class b4:
    def __bool__(self):
        return False
    def __len__(self):
        return 1
class b5:
    pass
print('以下是特别定义的类测试')
a=b1()
print(bool(a))
a=b2()
print(bool(a))
a=b3()
print(bool(a))
a=b4()
print(bool(a))
a=b5()
print(bool(a))

False
True
False
True
以下是特别定义的类测试
False
False
True
False
True

breakpoint()函数

语法

breakpoint(*args, **kws)

功能

此函数会在调用时将你陷入调试器中。它不处理参数，它调用sys.breakpointhook()，并直接传递args和kws。默认情况下，sys.breakpointhook()调用pdb.set_trace()且没有参数。在这种情况下，它纯粹是一个便利函数，因此您不必显式导入pdb且键入尽可能少的代码即可进入调试器。但是，sys.breakpointhook()可以设置为其他一些函数并被breakpoint()自动调用，以允许进入你想用的调试器。

此函数还会引发一个审计事件builtins.breakpoint并附带参数breakpointhook。

示例：在breakpoint()函数处暂停代码执行并进入调试器

print(bool())
a=3
print(bool(a))
breakpoint()
a=0
print(bool(a))
a='aaa'
print(bool(a))

False
True
> c:\users\zzs\desktop\a.py(5)<module>()
-> a=0
(Pdb) 

bytearray()类

语法

函数定义：

bytearray(source=None, encoding=None, errors='strict')

此函数有以下使用方式：

bytes(iterable_of_ints)
bytes(string, encoding[, errors])
bytes(bytes_or_buffer)
bytes(int)
bytes()

功能

虽然bytearray()是类，但我们只需像函数一样使用它。

不同数据类型的 source 参数，此函数的功能不同：

source 参数的数据类型	功能
迭代器对象	迭代器中的每个元素必须是 0 <= x < 256 的整数 此迭代器中的元素的值将被用作数组的内容。
字符串	此时必须使用 encoding 参数，但 errors 参数可有可无。 encoding 参数是字符串的编码方式。
遵循“缓冲区接口”的对象	该对象的只读缓冲区将被用来初始化字节数组。
整数	返回一个新的bytes类型的可变序列。 数组的元素数量由 source 参数指定。 且返回的序列中，每个元素的值都为零。
未给出参数	返回一个新的bytes类型的可变序列，且其元素数量为零。

errors参数可以接受一个字符串，用于指定处理解码错误的错误处理方案，该参数可以是以下值：

• 默认值为’strict’，表示解码错误会引发UnicodeDecodeError。
• 'ignore’意思是忽略错误格式的数据并且不加进一步通知就继续执行。
• ‘replace’，使用适当的替换标记进行替换；Python 内置编解码器将在解码时使用官方 U+FFFD 替换字符，而在编码时使用 ‘?’ 。 在replace_errors()中实现。
• 在codecs.register_error中注册的任何其他可处理UnicodeDecodeErrors的名称。

示例：未给出参数

因为bytearray()是类，所以a是实例。 print输出bytearray实例自带的内容。如果返回的列表中有元素，则bytearray(b’’)的单引号中会显示元素。

a=bytearray()
print(a)

bytearray(b'')

示例：第一个参数是整数

bytearray()返回的数组有4个元素，每个元素的值都是零。

a=bytearray(4)
for i in a:
    print(i)

0
0
0
0

示例：第一个参数是字符串

字符串45在utf-8编码下，4和5分别用数字52和53来表示。（兼容ASCII码表示方式）

a=bytearray('45','utf-8','strict')
for i in a:
    print(i)

52
53

示例：第一个参数是遵循“缓冲区接口”的对象

变量c为一串字节数据，变量b为创建的缓冲区，此缓冲区中的数据将被用作数组的内容。

a、b、c分别用数字表示为97、98、99。（兼容ASCII码表示方式）

c=b'abc'
b=memoryview(c)
a=bytearray(b)
for i in a:
    print(i)

97
98
99

示例：第一个参数是迭代器对象

bytearray()返回的数组中元素的数量，和迭代器中元素的数量相同，并且值也相同。

it=iter([1,2,3])
a=bytearray(it)
for i in a:
    print(i)

1
2
3

bytes()类

语法

函数定义：

bytes(value=b'', encoding=None, errors='strict')

此函数有以下使用方式：

bytes(iterable_of_ints)
bytes(string, encoding[, errors])
bytes(bytes_or_buffer)
bytes(int)
bytes()

功能

功能几乎和bytearray()相同，两者区别：

• bytes()返回的是不可变序列。
• bytearray()返回的是可变序列。

示例

此函数使用方式几乎和bytearray()相同，详见bytearray()的示例。

callable()函数

语法

callable(obj, /)

功能

判断参数 obj 是否可调用。若可调用则返回 True，否则返回 False。

此函数只检查参数 obj 本身是否可调用，但在实际调用时可能受到变量、环境等等多方面影响。因此，若返回 True，调用仍可能失败；但若返回 False，则调用 object 必然失败。

类属于可调用的（调用类将返回一个新的实例），但实例是否属于可以调用，取决于其所属的类是否有__call__()方法，若有，则实例就是可调用的，否则，就属于不可调用。

示例：类属于可调用的

class a:
    pass
print(callable(a))

True

示例：实例所属的类没有__call__()方法

class a:
    pass
b=a()
print(callable(b))

False

示例：实例所属的类有__call__()方法

class a:
    def __call__():
        pass
b=a()
print(callable(b))

True

chr()函数

语法

chr(i, /)

功能

返回 Unicode 码位为参数 i 的字符的字符串格式。

此函数是ord()函数的逆函数。

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

示例

print(chr(97))

a

print(chr(8364))

€

@classmethod装饰器

语法

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

功能

该装饰器，可以使类中的方法变成“类方法”。

类方法：类方法的调用，除了可以在实例上进行，例如C().f()，也可以在类上进行，例如C.f()。 使用时，类方法把类自己作为第一个参数self，就像一个实例方法把实例自己作为第一个参数self。注意：类方法的第一个参数self是类，不是实例。

示例

class a:
    aa=0
    def __init__(self):
        print('__init__')
    @classmethod
    def aaa(self):
        print('aaa')
        return self
c=a.aaa()
print(c.aa)

aaa
0

注意：类方法的第一个参数self是类，不是实例，所以我们无法直接使用其中的方法，因为没有实例可以传给参数self。以下代码将报错：

class a:
    aa=0
    def __init__(self):
        print('__init__')
    @classmethod
    def aaa(self):
        print('aaa')
        return self
    def aaaa(self):
        print('aaaa')
c=a.aaa()
c.aaaa()

aaa
Traceback (most recent call last):
  File "C:\Users\zzs\Desktop\b.py", line 12, in <module>
    c.aaaa()
TypeError: aaaa() missing 1 required positional argument: 'self'

compile()函数

语法

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

功能

compile() 函数将参数 source 作为代码 AST 对象返回，并准备执行。代码 AST 对象可以被exec()或eval()执行。

参数说明：

参数名	说明
source	要编译的资源。 可以是常规的字符串、字节字符串，或者 AST 对象。
filename	记录代码文件的文件名。 可以从此函数返回的对象的 co_filename 属性中查看传入的文件名。 如果代码不需要从文件中读取，也可以传入一些可辨识的值（如空字符串）。
mode	指定了编译代码的模式。 如果 source 是语句序列，则传入'exec'； 如果 source 是单一表达式，则传入 'eval'； 如果 source 是单个交互式语句，则传入'single'。 （在传入'single'时，如果表达式执行结果不是 None 将会被打印出来。）
flags 和 dont_inherit	这两个参数控制应当激活哪个编译器选项，以及应当允许哪个 future 特性。有以下几种情况： 1. 若两参数都未提供（或都为零），则代码会应用与调用 compile() 的代码相同的旗标来编译。 2. 若给出了 flags 参数而未给出 dont_inherit (或者为零)，则不仅会使用旗标，还会额外使用 flags 参数所指定的编译器选项和 future 语句。 3. 若 dont_inherit 为非零整数，则只使用 flags 参数，而外围代码中的旗标 (future 特性和编译器选项) 会被忽略。 另外，编译器选项和 future 语句是由比特位来指明的。比特位可以通过按位 OR 来使用多个选项。 指明 future 特性所需的比特位可以在 future 模块的 Feature 实例的 compiler_flag 属性中找到。 编译器旗标 可以在 ast 模块中查找带有 PyCF 前缀的名称。
optimize	指定编译器的优化级别，可传入的值： 值为-1，此为默认值，选择与解释器的-O选项相同的优化级别。 值为 0 ，没有优化；debug 为真； 值为1 ，断言被删除， debug 为假； 值为 2 ，文档字符串也被删除。

注意：

• 如果编译的源码不合法，此函数会触发 SyntaxError 异常；如果源码包含 null 字节，则会触发 ValueError 异常。
• 在 ‘single’ 或 ‘eval’ 模式编译多行代码字符串时，输入必须以至少一个换行符结尾。 这使 code 模块更容易检测语句的完整性。
• 在将足够大或者足够复杂的字符串编译成 AST 对象时，Python 解释器有可能因为 Python AST 编译器的栈深度限制而崩溃。

示例：编译source参数中的代码

在shell工具中操作，效果如下：

>>> a=compile('print("编译程序")\n', r'C:\Users\zzs\Desktop\a.py', 'exec')
>>> exec(a)
编译程序
>>> a.co_filename
'C:\\Users\\zzs\\Desktop\\a.py'
>>> 

complex()类

语法

complex(real=0, imag=0)

功能

从实部和可选的虚部创建一个复数，等效于（real + imag * 1j），或将字符串或数字转换为复数。

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

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

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

示例：传入字符串形式的复数

print(complex("3+5j"))

(3+5j)

示例：传入数字形式的复数

print(complex(3,8))

(3+8j)

delattr()函数

语法

delattr(obj, name, /)

功能

实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。

此函数等价于del,例如 delattr(x, ‘foobar’) 等价于 del x.foobar 。。

示例

使用被删除的属性，将会报错。

class a:
    aa=99
b=a()
print(b.aa)
delattr(b,aa)
print(b.aa)

99
Traceback (most recent call last):
  File "C:\Users\zzs\Desktop\a.py", line 5, in <module>
    delattr(b,aa)
NameError: name 'aa' is not defined

dict()类

语法

函数定义：

dict(*args, **kwargs)

此函数有以下使用方式：

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

功能

使用参数的里的数据来创建一个字典类。

示例

a=dict()
print(a)
a=dict(a='aa', b='bb', c='cc')
print(a)
a=dict([('a',2), ('b',1), ('c',3)])
print(a)
a=dict({'a':1, 'b':2, 'c':3}, d=4, e=5)
print(a)
a=map(lambda x: (x,x**2), range(1,5))
a=dict(a)
print(a)

{}
{'a': 'aa', 'b': 'bb', 'c': 'cc'}
{'a': 2, 'b': 1, 'c': 3}
{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
{1: 1, 2: 4, 3: 9, 4: 16}

dir()函数

语法

dir([object])

功能

如果没有实参，则返回当前本地作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。

如果对象有一个名为__dir__()的方法，那么该方法将被调用，并且必须返回一个属性列表。这允许实现自定义__getattr__()或__getattribute__()函数的对象能够自定义dir()来报告它们的属性。

如果对象不提供__dir__()，这个函数会尝试从对象已定义的__dict__属性和类型对象收集信息。结果列表并不总是完整的，如果对象有自定义__getattr__()，那结果可能不准确。

返回的列表会分类，并按字母表排序。

默认的 dir() 机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：

• 如果对象是模块对象，则列表包含模块的属性名称。
• 如果对象是类型或类对象，则列表包含它们的属性名称，并且递归查找所有基类的属性。
• 否则，列表包含对象的属性名称，它的类属性名称，并且递归查找它的类的所有基类的属性。

注意：因为 dir() 主要是为了便于在交互式时使用，所以它会试图返回人们感兴趣的名字集合，而不是试图保证结果的严格性或一致性，它具体的行为也可能在不同版本之间改变。例如，当实参是一个类时，metaclass 的属性不包含在结果列表中。

示例

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__']
>>> import struct
>>> dir()
['__annotations__', '__builtins__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', 'struct']
>>> dir(struct)
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__loader__', '__name__', '__package__', '__spec__', '_clearcache', 'calcsize', 'error', 'iter_unpack', 'pack', 'pack_into', 'unpack', 'unpack_from']
>>> 

divmod()函数

语法

divmod(x, y, /)

功能

它将两个（非复数）数字作为实参，并在执行整数除法时返回一对商和余数。

对于混合操作数类型，适用双目算术运算符的规则：

• 对于整数，结果和 (x // y, x % y) 一致。
• 对于浮点数，结果是 (q, x % y) ，q 通常是 mxth.floor(x / y) 但可能会比 1 小。
• 在任何情况下， q * y + x % y 和 x 基本相等；如果 x % y 非零，它的符号和 y 一样，并且 0 <= xys(x % y) < xys(y) 。

示例

a=divmod(5,2)
print(a)
a=divmod(3.4,2.1)
print(a)
a=divmod(1.8,2.1)
print(a)

(2, 1)
(1.0, 1.2999999999999998)
(0.0, 1.8)

enumerate()函数

语法

enumerate(iterable, start=0)

功能

返回一个枚举对象。

iterable 必须是一个序列，或迭代器类型，或其他支持迭代的对象。

enumerate() 返回的迭代器的 next() 方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。

此函数等价于：

def enumerate(sequence, start=0):
    n = start
    for elem in sequence:
        yield n, elem
        n += 1

示例

seasons = ['Spring', 'Summer', 'Fall', 'Winter']
print(list(enumerate(seasons)))
print(list(enumerate(seasons, start=1)))

[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

eval()函数

语法

eval(source, globals=None, locals=None, /)

功能

实参是一个字符串，以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。

source参数会作为一个 Python 表达式（从技术上说是一个条件列表）被解析并求值，并使用 globals 和 locals 字典作为全局和局部命名空间。 如果 globals 字典存在且不包含以 builtins 为键的值，则会在解析 source之前插入以此为键的对内置模块 builtins 的引用。 这意味着 source通常具有对标准 builtins 模块的完全访问权限且受限的环境会被传播。 如果省略 locals 字典则其默认值为 globals 字典。 如果两个字典同时省略，则表达式执行时会使用 eval() 被调用的环境中的 globals 和 locals。 请注意，eval() 并没有对外围环境下的 (非局部) 嵌套作用域 的访问权限。

返回值就是表达式的求值结果。 语法错误将作为异常被报告。

这个函数也可以用来执行任何代码对象（如 compile() 创建的）。这种情况下，参数是代码对象，而不是字符串。如果编译该对象时的 mode 实参是 ‘exec’ 那么 eval() 返回值为 None 。

注意：

• exec() 函数支持动态执行语句。 globals() 和 locals() 函数各自返回当前的全局和本地字典，因此您可以将它们传递给 eval() 或 exec() 来使用。
• 引发一个 审计事件 exec 附带参数 code_object。

示例：source 是一个 Python 表达式

x = 1
print(eval('x+1'))

2

实例：source 是代码对象

a=compile('print("编译程序")\n', r'C:\Users\zzs\Desktop\a.py', 'exec')
eval(a)

编译程序

exec()函数

语法

exec(source, globals=None, locals=None, /)

功能

这个函数支持动态执行 Python 代码。

source必须是字符串或者代码对象：

• 如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。
• 如果是代码对象，它将被直接执行。 在任何情况下，被执行的代码都应当是有效的文件输入。

该函数的返回值是 None。

如果省略了可选项，代码将在当前作用域内执行。 如果只提供了 globals，则它必须是一个字典（不能是字典的子类），该字典将同时被用于全局和局部变量。 如果同时提供了 globals 和 locals，它们会分别被用于全局和局部变量。 如果提供了 locals，则它可以是任何映射对象。 请记住在模块层级上，globals 和 locals 是同一个字典。 如果 exec 得到两个单独对象作为 globals 和 locals，则代码将如同嵌入类定义的情况一样执行。

如果 globals 字典不包含 builtins 键值，则将为该键插入对内建 builtins 模块字典的引用。因此，在将执行的代码传递给 exec() 之前，可以通过将自己的 builtins 字典插入到 globals 中来控制可以使用哪些内置代码。

注意：

• 即使在传递给 exec() 函数的代码的上下文中，nonlocal, yield 和 return 语句也不能在函数定义以外使用。
• 引发一个 审计事件 exec 附带参数 code_object。
• 内置 globals() 和 locals() 函数各自返回当前的全局和本地字典，因此可以将它们传递给 exec() 的第二个和第三个实参。
• 默认情况下，locals 的行为如下面 locals() 函数描述的一样：不要试图改变默认的 locals 字典。如果您想在 exec() 函数返回时知道代码对 locals 的变动，请明确地传递 locals 字典。

示例：source 是字符串

print(exec('print("测试")'))

测试
None

示例：source 是代码对象

a=compile('print("编译程序")\n', r'C:\Users\zzs\Desktop\a.py', 'exec')
exec(a)

编译程序

filter()函数

语法

filter(function or None, iterable)

功能

iterable 可以是一个序列，一个支持迭代的容器，或一个迭代器。

第一个参数的不同值，函数效果如下：

第一个参数的值	说明
None	会function假设是一个身份函数。 即 iterable 中所有返回假的元素会被移除，并返回移除后剩下的元素组成的迭代器。
函数	用 iterable 中的元素作为参数，传入此函数中，若其返回值为真，则记录该元素，最后用所有被记录组成一个新的迭代器，并返回该迭代器。

注意：filter(function, iterable) 相当于一个生成器表达式，当 function 不是 None 的时候为 (item for item in iterable if function(item))；function 是 None 的时候为 (item for item in iterable if item) 。

示例：第一个参数是 None

print(list(filter(None ,[True,True,False,True])))

[True, True, True]

示例：第一个参数是函数

def a(x):
    return True
print(list(filter(a ,[True,True,False,True])))

[True, True, False, True]

float()类

语法

float(x=0, /)

功能

将数字或字符转换成浮点数。

如果参数是字符串，则它必须是包含十进制数字的字符串，字符串前面可以有符号，之前也可以有空格。可选的符号有 ‘+’ 和 ‘-’ ； ‘+’ 对创建的值没有影响。参数也可以是 NaN（非数字）、正负无穷大的字符串。确切地说，除去首尾的空格后，输入必须遵循以下语法：

sign           ::=  "+" | "-"
infinity       ::=  "Infinity" | "inf"
nan            ::=  "nan"
numeric_value  ::=  floatnumber | infinity | nan
numeric_string ::=  [sign] numeric_value

语法中各项解释：

• inf、Infinity 表示无穷大。
• floatnumber 是 Python 浮点数的字符串形式。
• nan 表示不是数字。
• 各项的字母大小写都可以，例如，“inf”、“Inf”、“INFINITY”、“iNfINity” 都可以表示正无穷大。

另一方面，如果实参是整数或浮点数，则返回具有相同值（在 Python 浮点精度范围内）的浮点数。如果实参在 Python 浮点精度范围外，则会触发 OverflowError。

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

如果没有实参，则返回 0.0 。

示例

a=float('+1.23')
print(a)
a=float('   -12345\n')
print(a)
a=float('1e-003')
print(a)
a=float('+1E6')
print(a)
a=float('-Infinity')
print(a)

1.23
-12345.0
0.001
1000000.0
-inf

format()函数

语法

format(value, format_spec='', /)

功能

按照参数 format_spec 要求的格式（大部分数据类型支持“格式规格迷你语言”），将 value 转换成字符串。

当参数 format_spec 为空字符串时，调用format(value, format_spec)会转换成str(value)。

当参数 format_spec 不是空字符串时，调用format(value, format_spec)会转换成type(value).__format__(value, format_spec)。

以下情况将发生 TypeError 异常：

• value 有__format__方法，但 format_spec 不为空。
• format_spec 不是字符串。
• __format__方法的返回值不是字符串。

示例：format_spec 为空字符串

import datetime
a=datetime.time(1,2,3)
print(format(a,''))

01:02:03

示例：格式化时间类型的数据

import datetime
a=datetime.time(1,2,3)
print(format(a,'%H时%M分%S秒'))

01时02分03秒

示例：格式化小数为百分数

a=3.123456
print(format(a,'.2%'))

312.35%

示例：格式化数字为不同的进制

a=42
print(format(a,'d'))
print(format(a,'x'))
print(format(a,'o'))
print(format(a,'b'))

42
2a
52
101010

示例：格式化数字为有千位分隔符的数字

a=123456789
print(format(a,','))

123,456,789

frozenset()类

语法

frozenset(iterable=)

功能

返回一个新的 frozenset 对象，它包含可选参数 iterable 中的元素，若没有可选参数，则返回一个新的空 frozenset 对象。

要表示由集合对象构成的集合，所有的内层集合必须为 frozenset 对象。

示例

a=[1,2,3]
b=frozenset(a)
print(b)

frozenset({1, 2, 3})

getattr()函数

语法

getattr(object, name[, default])

功能

返回对象中某个属性的值。

name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。例如，getattr(x, 'foobar')等同于x.foobar。如果指定的属性不存在，且提供了 default 值，则返回它，否则触发 AttributeError。

示例

class a:
    aa=1
print(getattr(a,'aa'))
print(getattr(a,'bb','默认'))

1
默认

globals()函数

语法

globals()

功能

对！没看错！此函数不需要传入任何参数！

返回表示当前全局符号表的字典。这总是当前模块的字典（在函数或方法中，不是调用它的模块，而是定义它的模块）。

示例

class a:
    x=1
    xx=3
    def xxxx(self):
        pass
def aa():
    x=1
    xx=2
    pass
b=a()
print(globals())

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:\\Users\\zzs\\Desktop\\b.py', 'a': <class '__main__.a'>, 'aa': <function aa at 0x0000027E3DFB7820>, 'b': <__main__.a object at 0x0000027E3DFDAEE0>}

hasattr()函数

语法

hasattr(obj, name, /)

功能

obj 是一个对象或一个类；name 是一个字符串。

如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。（此功能是通过调用 getattr(object, name) 看是否有 AttributeError 异常来实现的。）

示例

class a:
    aa=1
b=a()
print(hasattr(a,'aa'))
print(hasattr(a,'aaa'))
print(hasattr(b,'aa'))
print(hasattr(b,'aaa'))

True
False
True
False

hash()函数

语法

hash(obj, /)

功能

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。

同一个对象的哈希值，并不是永远固定的。从程序打开到关闭，这个期间，同一个对象哈希值是相同
，当程序关闭后再打开，同一个哈希值就可能发生变化，但再新打开的这段时间（从打开到关闭），同一个对象的哈希值又是相同的。

注意：

• 相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）。
• 比较相等的两个对象也必然具有相同的哈希值，但是相反的情况不一定成立。
• 如果对象实现了自己的__hash__()方法，那么，hash() 根据机器的字长来截断返回值。

示例

print(hash(99))
print(hash(99.0))
print(hash(99.1))

99 
99
230584300921356387

help()函数

语法

help([object])

功能

启动内置的帮助系统（此函数主要在交互式中使用）或显示帮助信息。

传入不同的参数，对应的效果：

参数object的值	说明
不适用参数	解释器控制台里会启动交互式帮助系统。
一个字符串	在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。
字符串以外的其他任意对象	生成该对象的帮助页。

示例：未给出参数

help()

Welcome to Python 3.9's help utility!

If this is your first time using Python, you should definitely check out
the tutorial on the Internet at https://docs.python.org/3.9/tutorial/.

Enter the name of any module, keyword, or topic to get help on writing
Python programs and using Python modules.  To quit this help utility and
return to the interpreter, just type "quit".

To get a list of available modules, keywords, symbols, or topics, type
"modules", "keywords", "symbols", or "topics".  Each module also comes
with a one-line summary of what it does; to list the modules whose name
or summary contain a given string such as "spam", type "modules spam".

help> 

示例：使用参数

help(hash)

Help on built-in function hash in module builtins:

hash(obj, /)
    Return the hash value for the given object.
    
    Two objects that compare equal must also have the same hash value, but the
    reverse is not necessarily true.

>>> 

hex()函数

语法

hex(number, /)

功能

将整数 x 转换为以“0x”为前缀的小写十六进制字符串。

如果 x 不是 Python int 对象，则必须定义返回整数的__index__()方法。

示例

print(hex(255))
print(hex(-42))

0xff
-0x2a

id()函数

语法

id(obj, /)

功能

返回对象在内存中的地址，再python中又称为对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的id()值。

引发一个审计事件builtins.id，附带参数 id。

示例

a=123
b=456
c=a
print(id(a))
print(id(b))
print(id(c))

1656867346608
1656906215024
1656867346608

input()函数

语法

input(prompt=None, /)

功能

如果存在 prompt 实参，则将其写入标准输出，末尾不带换行符。接下来，该函数从输入中读取一行，将其转换为字符串（除了末尾的换行符）并返回。当读取到 EOF 时，则触发 EOFError。

如果加载了 readline 模块，input() 将使用它来提供复杂的行编辑和历史记录功能。

引发一个 审计事件 builtins.input 附带参数 prompt。

在成功读取输入之后引发一个审计事件 builtins.input/result 附带结果。

示例

s = input('输入内容并回车：')
print(s)

输入内容并回车：123abc
123abc

int()类

语法

此类有以下使用方式：

int([x])
int(x, base=10)

功能

将第一个参数的内容转换为整数。

根据第一个参数的值，此类的效果如下：

第一个参数的值	说明
未给出参数	返回 0。
x 是定义了__int__()的对象	int(x)将返回x.__int__()。
x 是定义了__index__()的对象	int(x)将返回x.__index__()。
x 是定义了__trunc__()的对象	int(x)将返回x.__trunc__()。
浮点数	返回其向零舍入的值。
字符串、 bytes、 bytearray 实例	此时必须有 base 参数，x 为表示进制为 base 的整数字面值。 该文字前可以有 + 或 - （中间不能有空格），前后可以有空格。 一个进制为 n 的数字包含 0 到 n-1 的数，其中 a 到 z （或 A 到 Z ）表示 10 到 35。默认的 base 为 10 ，允许的进制有 0、2-36。2、8、16 进制的数字可以在代码中用 0b/0B 、 0o/0O 、 0x/0X 前缀来表示。 进制为 0 将按照代码的字面量来精确解释，最后的结果会是 2、8、10、16 进制中的一个。所以int('010', 0)是非法的，但int('010')和int('010', 8)是合法的。

示例

class a:
    def __trunc__(self):
        return 123456
b=a()
print(int(b))
print(int())
print(int(1.3))
print(int('123ABC',16))

123456
0
1
1194684

isinstance()函数

语法

isinstance(obj, class_or_tuple, /)

功能

如果参数 object 是参数 classinfo 的实例或者是其 (直接、间接或 虚拟) 子类则返回 True。

如果 object 不是给定类型的对象，函数将总是返回 False。

如果 classinfo 是类型对象元组（或由其他此类元组递归组成的元组），那么如果 object 是其中任何一个类型的实例就返回 True。

注意：如果 classinfo 既不是类型，也不是类型元组或类型元组的元组，则将引发 TypeError 异常。

示例

class a:
    def __trunc__(self):
        return 123456
class b(a):
    def __trunc__(self):
        return 123456
class c(b):
    def __trunc__(self):
        return 123456
d=c()
print(isinstance(d,c))
print(isinstance(d,a))

True
True

issubclass()函数

语法

issubclass(cls, class_or_tuple, /)

功能

如果 class 是 classinfo 的 (直接、间接或 虚拟) 子类则返回 True。 类会被视作其自身的子类。

classinfo 也可以是类对象的元组，在此情况下 classinfo 中的每个条目都将被检查。

注意： 在任何以上所述的其他情况下，都将引发 TypeError 异常。

示例

class a:
    def __trunc__(self):
        return 123456
class b(a):
    def __trunc__(self):
        return 123456
class c(b):
    def __trunc__(self):
        return 123456

print(issubclass(c,a))
print(issubclass(a,a))

True
True

iter()函数

语法

此函数有以下用法：

iter(iterable)
iter(callable, sentinel)

功能

返回一个迭代器对象。

根据是否存在第二个实参，第一个实参的有着不同的解释：

是否有第二个实参
没有第二个实参	第一个实参必须是支持迭代协议（有 iter() 方法）的集合对象，或必须支持序列协议（有 getitem() 方法，且数字参数从 0 开始）。 如果它不支持这些协议，会触发 TypeError。
有第二个实参	第一个实参必须是可调用的对象。 这种情况下生成的迭代器，每次迭代调用它的 next() 方法时都会不带实参地调用 object；如果返回的结果是 sentinel 则触发 StopIteration，否则返回调用结果。

示例

lst = [1, 2, 3]
for i in iter(lst):
    print(i)

1
2
3

len()函数

语法

len(obj, /)

功能

返回容器中的项目数，或者说返回对象的长度（元素个数）。

实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

注意：len()对于大于sys.maxsize的长度如range(2 ** 100)会引发 OverflowError。

示例

a='1234567890'
print(len(a))
a=[1,2,3]
print(len(a))

10
3

list()函数

语法

list(iterable=(), /)

功能

此类实际上是一种可变序列类型。

传入一个迭代器类型的数据，将参数变为list类型的数据，并返回该参数。

示例

a=list([1,2,3])
print(a)

[1, 2, 3]

locals()类

语法

locals()

功能

更新并返回包含当前范围的局部变量的字典。

在函数代码块但不是类代码块中调用locals()时将返回自由变量。 请注意在模块层级上，locals() 和 globals() 是同一个字典。

注意：

• 不要更改此字典的内容。
• 更改不会影响解释器使用的局部变量或自由变量的值。

示例

class a:
    x=1
    xx=3
    def xxxx(self):
        print(locals())
        pass
    
def aa():
    x=1
    xx=2
    pass
b=a()
b.xxxx()

{'self': <__main__.a object at 0x0000020C4326DEE0>}

map()函数

语法

map(func, *iterables)

功能

func 是函数。

返回一个将 func 应用于 iterable 中每一项并输出其结果的迭代器。 如果传入了额外的 iterable 参数，function 必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。 当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。

示例

def a(aa):
    if aa>100:
        return True
    else:
        return False
print(list(map(a,[90,95,100,105,110])))

[False, False, False, True, True]

max()函数

语法

此函数有以下用法：

max(iterable, *[, default=obj, key=func])
max(arg1, arg2, *args, *[, key=func])

功能

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。

如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。

有两个可选只能用关键字的实参。key 参数传入函数，将对每个要比较大小的元素先使用key指定的函数来处理，然后再比较，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。

如果有多个最大元素，则此函数将返回第一个找到的。这和其他稳定排序工具如sorted(iterable, key=keyfunc, reverse=True)[0]和heapq.nlargest(1, iterable, key=keyfunc)保持一致。

示例：只有要比较的数据

print(max(80, 100, 1000))

1000

示例：有 key 参数

a = [9.2, 10, -20.3, -7.0, 9.999, 20.111]
print(max(a, key=abs))

-20.3

memoryview()类

语法

memoryview(object)

功能

返回由给定实参创建的“内存视图”对象。

示例

v = memoryview(bytearray("abcefg", 'utf-8'))
print(v[1])
print(v[1:4])
print(v[1:4].tobytes())

98
<memory at 0x000001EA4E273280>
b'bce'

min()函数

语法

min(iterable, *[, default=obj, key=func])
min(arg1, arg2, *args, *[, key=func])

功能

效果和使用方法都跟max()类似，区别是，此函数返回的是最小值。

示例

print(min(80, 100, 1000))
a = [9.2, 10, -20.3, -7.0, 9.999, 20.111]
print(min(a, key=abs))

80
-7.0

next()函数

语法

next(iterator[, default])

功能

通过调用 iterator 的__next__()方法获取下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。

示例

a = iter([1, 2, 3, 4, 5])
x = next(a,'结束')
print(x)
x = next(a,'结束')
print(x)
x = next(a,'结束')
print(x)
x = next(a,'结束')
print(x)
x = next(a,'结束')
print(x)
x = next(a,'结束')
print(x)

1
2
3
4
5
结束

object()类

语法

object(self, /, *args, **kwargs)

功能

返回一个没有特征的新对象。object 是所有类的基类。它具有所有 Python 类实例的通用方法。这个函数不接受任何实参。

注意：由于 object 没有__dict__，因此无法将任意属性赋给 object 的实例。

示例

这样使用即可获得一个新的对象：

a=object()

oct()函数

语法

oct(number, /)

功能

将一个整数转变为一个前缀为“0o”的八进制字符串。结果是一个合法的 Python 表达式。如果 number 不是 Python 的 int 对象，那它需要定义·index()·方法返回一个整数。

示例

print(oct(8))
print(oct(-56))

0o10
-0o70

open()函数

语法

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)

功能

打开 file 并返回对应的文件对象（file object）。 在文件打开成功后，就可以使用文件对象自带的操作进行读写。

参数 file是一个路径类对象（path-like object）：

• 可以是字符串，其表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径）。
• 可以是要被封装的整数类型文件描述符。（如果是文件描述符，它会随着返回的 I/O 对象关闭而关闭，除非 closefd 被设为 False 。）

参数 mode是一个可选字符串，用于指定打开文件的模式，值如下：（可一次使用多个值）

值	说明
r	以文本模式打开并读取（默认）
w	写入，并先截断文件
x	排它性创建，如果文件已存在则失败
a	写入，如果文件存在则在末尾追加。 （在 一些 Unix 系统上，无论当前的文件指针在什么位置，所有 写入都会追加到文件末尾）
b	二进制模式
t	文本模式（默认）。 如果 encoding 没有指定，则根据平台来决定使用的编码：使用locale.getpreferredencoding(False)来获取本地编码。 （要读取和写入原始字节，请使用二进制模式并不要指定 encoding。）
+	打开用于更新（读取与写入）

组合使用示例：默认模式为 ‘r’ (打开用于读取文本，与 ‘rt’ 同义)。 模式 ‘w+’ 与 ‘w+b’ 将打开文件并清空内容。 模式 ‘r+’ 与 ‘r+b’ 将打开文件并不清空内容。

Python区分二进制和文本I/O。以二进制模式打开的文件（包括 mode 参数中的 ‘b’ ）返回的内容为 bytes 对象，不进行任何解码。在文本模式下（默认情况下，或者在 mode 参数中包含 ‘t’ ）时，文件内容返回为 str ，首先使用指定的 encoding （如果给定）或者使用平台默认的的字节编码解码。

参数 buffering是一个可选的整数，用于设置缓冲策略。传递0以切换缓冲关闭（仅允许在二进制模式下），1选择行缓冲（仅在文本模式下可用），并且>1的整数以指示固定大小的块缓冲区的大小（以字节为单位）。如果没有给出 buffering 参数，则默认缓冲策略的工作方式如下:

• 二进制文件以固定大小的块进行缓冲；使用启发式方法选择缓冲区的大小，尝试确定底层设备的“块大小”或使用 io.DEFAULT_BUFFER_SIZE。在许多系统上，缓冲区的长度通常为4096或8192字节。
• “交互式”文本文件（ isatty() 返回 True 的文件）使用行缓冲。其他文本文件使用上述策略用于二进制文件。

参数 encoding是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。默认编码是依赖于平台的（不 管 locale.getpreferredencoding() 返回何值），但可以使用任何Python支持的 text encoding 。有关支持的编码列表，请参阅 codecs 模块。

参数 errors是一个可选的字符串参数，用于指定如何处理编码和解码错误，此参数不能在二进制模式下使用。可以使用各种标准错误处理程序，但是使用codecs.register_error()注册的任何错误处理名称也是有效的。标准名称包括:

• 如果存在编码错误，‘strict’ 会引发 ValueError 异常。 默认值 None 具有相同的效果。
• ‘ignore’ 忽略错误。请注意，忽略编码错误可能会导致数据丢失。
• ‘replace’ 会将替换标记（例如 ‘?’ ）插入有错误数据的地方。
• ‘surrogateescape’ 将表示任何不正确的字节作为Unicode专用区中的代码点，范围从U+DC80到U+DCFF。当在写入数据时使用 surrogateescape 错误处理程序时，这些私有代码点将被转回到相同的字节中。这对于处理未知编码的文件很有用。
• 只有在写入文件时才支持 ‘xmlcharrefreplace’。编码不支持的字符将替换为相应的XML字符引用&#nnn;。
• ‘backslashreplace’ 用Python的反向转义序列替换格式错误的数据。
• ‘namereplace’ （也只在编写时支持）用 \N{…} 转义序列替换不支持的字符。

参数 newline控制 universal newlines 模式如何生效（它仅适用于文本模式）。它可以是 None，’’，’\n’，’\r’ 和 ‘\r\n’。它的工作原理:

• 从流中读取输入时，如果 newline 为 None，则启用通用换行模式。输入中的行可以以 ‘\n’，’\r’ 或 ‘\r\n’ 结尾，这些行被翻译成 ‘\n’ 在返回呼叫者之前。如果它是 ‘’，则启用通用换行模式，但行结尾将返回给调用者未翻译。如果它具有任何其他合法值，则输入行仅由给定字符串终止，并且行结尾将返回给未调用的调用者。
• 将输出写入流时，如果 newline 为 None，则写入的任何 ‘\n’ 字符都将转换为系统默认行分隔符 os.linesep。如果 newline 是 ‘’ 或 ‘\n’，则不进行翻译。如果 newline 是任何其他合法值，则写入的任何 ‘\n’ 字符将被转换为给定的字符串。

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

参数 opener可以通过传递可调用的 opener 来使用自定义开启器。然后通过使用参数（ file，flags ）调用 opener 获得文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符（使用 os.open as opener 时与传递 None 的效果相同）。

open()函数所返回的 file object 类型取决于所用模式。 当使用 open() 以文本模式 (‘w’, ‘r’, ‘wt’, ‘rt’ 等) 打开文件时，它将返回 io.TextIOBase (特别是 io.TextIOWrapper) 的一个子类。 当使用缓冲以二进制模式打开文件时，返回的类是 io.BufferedIOBase 的一个子类。 具体的类会有多种：在只读的二进制模式下，它将返回 io.BufferedReader；在写入二进制和追加二进制模式下，它将返回 io.BufferedWriter，而在读/写模式下，它将返回 io.BufferedRandom。 当禁用缓冲时，则会返回原始流，即 io.RawIOBase 的一个子类 io.FileIO。

注意：

• 如果该文件不能被打开，则引发 OSError。
• Python不依赖于底层操作系统的文本文件概念;所有处理都由Python本身完成，因此与平台无关。
• 新创建的文件是不可继承的。
• 引发一个 审计事件 open 附带参数 file, mode, flags。
• mode 与 flags 参数可以在原始调用的基础上被修改或传递。

示例

在桌面新建python源文件a.py，并输入print('读写')回车。

另新建一个源文件，使用一下代码读取a.py：

f = open(r'C:\Users\zzs\Desktop\a.py', 'r', encoding='utf-8')
r = f.read()
print(r)
f.close()

print('读写')

写入a.py：

f = open(r'C:\Users\zzs\Desktop\a.py', 'w', encoding='utf-8')
w = f.write('# 写入')
f.close()
f = open(r'C:\Users\zzs\Desktop\a.py', 'r', encoding='utf-8')
r = f.read()
print(r)
f.close()

# 写入

ord()函数

语法

ord(c, /)

功能

参数 c 是表示单个 Unicode 字符的字符串，此函数返回代表它 Unicode 码点的整数。

这是 chr() 的逆函数。

示例

print(ord('a'))
print(ord('€'))

97
8364

pow()函数

语法

pow(base, exp, mod=None)

功能

返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂，再对 mod 取余（比 pow(base, exp) % mod 更高效）。

两参数形式 pow(base, exp) 等价于乘方运算符: base**exp。

参数必须具有数值类型。 对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。 对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。 例如，10**2 返回 100，但 10**-2 返回 0.01。

对于 int 操作数 base 和 exp，如果给出 mod，则 mod 必须为整数类型并且 mod 必须不为零。 如果给出 mod 并且 exp 为负值，则 base 必须相对于 mod 不可整除。 在这种情况下，将会返回 pow(inv_base, -exp, mod)，其中 inv_base 为 base 的倒数对 mod 取余。

示例

print(pow(38, -1, mod=97))

23

print()函数

语法

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

功能

将所有 objects 打印到 file 指定的文本流，同时用 sep 分割每个 objects 并在末尾加上 end。

sep、end、file、flush 必须以关键字参数的形式传递。

所有非关键字参数都会被转换为字符串，就像是执行了 str() 一样。sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。 如果没有给出 objects，则 print() 将只打印 end。

file 参数必须是一个具有 write(string) 方法的对象；如果参数不存在或为 None，则将使用 sys.stdout。 由于要打印的参数会被转换为文本字符串，因此 print() 不能用于二进制模式的文件对象。 对于这些对象，应改用 file.write(…)。

输出是否被缓存通常决定于 file，但如果 flush 关键字参数为真值，流会被强制刷新。

示例

print('1','2','3',sep='%',end='***')

1%2%3***

property()类

语法

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

功能

返回一个属性，对其获取值、设置值、删除时，将返回指定的函数的返回值。

fget 是获取属性值的函数。

fset 是用于设置属性值的函数。

fdel 是用于删除属性值的函数。

doc 为属性对象创建文档字符串。

注意：@property装饰器也能有相同的效果。

示例：定义一个托管属性 x

class C:
    def __init__(self):
        self._x = None
    def getx(self):
        print('执行了 gex 函数')
        return self._x
    def setx(self, value):
        print('执行了 setx 函数')
        self._x = value
    def delx(self):
        del self._x
    x = property(getx, setx, delx, "I'm the 'x' property.")
c=C()
c.x=111
print(c.x)

执行了 setx 函数
执行了 gex 函数
111

range()类

语法

此类有如下使用方法：

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

功能

返回一个不可变的序列类型。

range 构造器的参数必须为整数（可以是内置的 int 或任何实现了 index 特殊方法的对象）。

如果省略 step 参数，其默认值为 1。 如果省略 start 参数，其默认值为 0，如果 step 为零则会引发 ValueError。

如果 step 为正值，确定 range r 内容的公式为 r[i] = start + step*i 其中 i >= 0 且 r[i] < stop。

如果 step 为负值，确定 range 内容的公式仍然为 r[i] = start + step*i，但限制条件改为 i >= 0 且 r[i] > stop.

如果 r[0] 不符合值的限制条件，则该 range 对象为空。 range 对象确实支持负索引，但是会将其解读为从正索引所确定的序列的末尾开始索引。

元素绝对值大于 sys.maxsize 的 range 对象是被允许的，但某些特性 (例如 len()) 可能引发 OverflowError。

range 类型相比常规 list 或 tuple 的优势在于一个 range 对象总是占用固定数量的（较小）内存，不论其所表示的范围有多大（因为它只保存了 start, stop 和 step 值，并会根据需要计算具体单项或子范围的值）。

使用== 和!=检测 range 对象是否相等是将其作为序列来比较。 也就是说，如果两个 range 对象表示相同的值序列就认为它们是相等的。 （请注意比较结果相等的两个 range 对象可能会具有不同的 start, stop 和 step 属性，例如range(0) == range(2, 1, 3)而range(0, 3, 2) == range(0, 4, 2)。）

示例

print(list(range(10)))
print(list(range(1, 11)))
print(list(range(0, 30, 5)))
print(list(range(0, 10, 3)))
print(list(range(0, -10, -1)))
print(list(range(0)))
print(list(range(1, 0)))

[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
[0, 5, 10, 15, 20, 25]
[0, 3, 6, 9]
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
[]
[]

repr()函数

语法

repr(obj, /)

功能

返回包含一个对象的可打印表示形式的字符串。

对于许多类型来说，该函数会尝试返回的字符串将会与该对象被传递给 eval() 时所生成的对象具有相同的值，在其他情况下表示形式会是一个括在尖括号中的字符串，其中包含对象类型的名称与通常包括对象名称和地址的附加信息。

类可以通过定义__repr__()方法来控制此函数为它的实例所返回的内容。

示例

class a:
    def __repr__(self):
        return '111'
b=a()
print(repr(b))

111

reversed()函数

语法

reversed(sequence, /)

功能

返回一个反向的 iterator。

sequence 必须是一个具有__reversed__()方法的对象或者是支持该序列协议（具有从 0 开始的整数类型参数的__len__()方法和__getitem__()方法）。

示例

print(list(reversed([1,2,3])))
print(list(reversed('123')))

[3, 2, 1]
['3', '2', '1']

round()函数

语法

round(number, ndigits=None)

功能

返回 number 舍入到小数点后 ndigits 位精度的值。

如果 ndigits 被省略或为 None，则返回最接近输入值的整数。

对于支持 round() 的内置类型，值会被舍入到最接近的 10 的负 ndigits 次幂的倍数；如果与两个倍数的距离相等，则选择偶数 (因此，round(0.5) 和 round(-0.5) 均为 0 而 round(1.5) 为 2)。 任何整数值都可作为有效的 ndigits (正数、零或负数)。 如果 ndigits 被省略或为 None 则返回值将为整数。 否则返回值与 number 的类型相同。

对于一般的 Python 对象 number, round 将委托给 number.round。

注意：对浮点数执行 round() 的行为可能会令人惊讶：例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。 这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。

示例

print("round(80.23456, 2) : ", round(80.23456, 2))
print("round(100.000056, 3) : ", round(100.000056, 3))
print("round(-100.000056, 3) : ", round(-100.000056, 3))

round(80.23456, 2) :  80.23
round(100.000056, 3) :  100.0
round(-100.000056, 3) :  -100.0

set()类

语法

此类有以下用法：

set()
set(iterable)

功能

返回一个新的 set 对象，可以选择带有从 iterable 获取的元素，且不会获取 iterable 中的重复元素。

示例

x = set('runoob')
print(x)

{'r', 'n', 'b', 'o', 'u'}

setattr()函数

语法

setattr(obj, name, value, /)

功能

此函数与getattr()两相对应。

obj 为一个对象，name 为一个字符串，value 为一个任意值。

字符串指定一个现有属性或者新增属性。 函数会将值赋给该属性，只要对象允许这种操作。若属性不存在，则增加该属性。 例如，setattr(x, ‘foobar’, 123) 等价于 x.foobar = 123。

示例

class a(object):
    aa = 1
b = a()
setattr(b, 'aa', 5)
print(b.aa)
setattr(b, 'aaa', 10)
print(b.aaa)

5
10

slice()类

语法

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

功能

返回一个表示由 range(start, stop, step) 所指定索引集的切片对象（slice 对象），主要用在切片操作函数里的参数传递。

其中 start 和 step 参数默认为 None。

切片对象具有仅会返回对应参数值（或其默认值）的只读数据属性 start, stop 和 step。 它们没有其他的显式功能；不过它们会被 NumPy 以及其他第三方扩展所使用。 切片对象也会在使用扩展索引语法时被生成。 例如: a[start:stop:step] 或 a[start:stop, i]。

示例

a = slice(5)
print(a)
b = range(10)
print(b)
print(b[a])

slice(None, 5, None)
range(0, 10)
range(0, 5)

sorted()函数

语法

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

功能

根据 iterable 中的项返回一个新的已排序列表。

key 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。

reverse 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

示例

print(sorted([5, 2, 3, 1, 4]))
print(sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'}))
a = [('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]
def b(bb):
    return bb[2]
print(sorted(a, key=b, reverse=True) )

[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5]
[('john', 'A', 15), ('jane', 'B', 12), ('dave', 'B', 10)]

@staticmethod装饰器

语法

此装饰器的定义：

staticmethod(function)

要声明一个静态方法，请使用此语法：

class C:
    @staticmethod
    def f(arg1, arg2, ...): ...

像常规函数一样调用 staticmethod 时，请使用此语法：

class C:
    builtin_open = staticmethod(open)

功能

将方法转换为静态方法。

静态方法不会接收隐式的第一个参数。

静态方法的调用可以在类上进行 (例如C.f()) 也可以在实例上进行 (例如C().f())。

像所有装饰器一样，也可以像常规函数一样调用 staticmethod ，并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。

示例：声明一个静态方法

class C(object):
    @staticmethod
    def f():
        print('runoob');
 
C.f();
cobj = C()
cobj.f()   

runoob
runoob

示例：像常规函数一样调用 staticmethod

class C():
    def f():
        print('123')
        return '456'
    f = staticmethod(f)
j=C.f()
print(j)

123
456

问题：staticmethod()函数报错NameError: name 'f' is not defined

有可能的原因：

这是语法上的原因是staticmethod()对应的函数没有定义造成的。对应到实际代码中，原因是使用staticmethod()写在了函数的前面：

class C():
    f = staticmethod(f)
    def f():
        print('123')
        return '456'    
j=C.f()
print(j)

Traceback (most recent call last):
  File "C:\Users\zzs\Desktop\b.py", line 1, in <module>
    class C():
  File "C:\Users\zzs\Desktop\b.py", line 2, in C
    f = staticmethod(f)
NameError: name 'f' is not defined

遵从先定义再使用的语法要求，我们把staticmethod()改写到定义后面即可解决问题：

class C():
    def f():
        print('123')
        return '456'
    f = staticmethod(f)
j=C.f()
print(j)

123
456

str()类

语法

此类有以下用法：

str(object='')
str(bytes_or_buffer, encoding=sys.getdefaultencoding(), errors='strict']

功能

从给定的对象创建一个新的字符串对象，就将给定的对象转换为可打印的字符串内容。

如果指定了 encoding 或 errors，则对象必须给出一个数据缓冲区（参数bytes_or_buffer），该缓冲区将使用给定的 encoding 和 errors 进行解码，否则返回object .__ str __()（如果已定义）或repr（object）的结果。

参数 errors 是一个可选的字符串参数，可以是以下值：（此列表为 python 的错误处理方案，其他内置函数的 errors 参数也遵从此表）

值	说明
‘strict’	引发 UnicodeError (或其子类)；这是默认的方案。 在 strict_errors() 中实现。
‘ignore’	忽略错误格式的数据并且不加进一步通知就继续执行。 在 ignore_errors() 中实现。
‘replace’	使用适当的替换标记进行替换；Python 内置编解码器将在解码时使用官方 U+FFFD 替换字符，而在编码时使用 ‘?’ 。 在 replace_errors() 中实现。
‘xmlcharrefreplace’	使用适当的 XML 字符引用进行替换（仅在编码时）。 在 xmlcharrefreplace_errors() 中实现。
‘backslashreplace’	使用带反斜杠的转义序列进行替换。 在 backslashreplace_errors() 中实现。
‘namereplace’	使用 \N{…} 转义序列进行替换（仅在编码时）。 在 namereplace_errors() 中实现。
‘surrogateescape’	在解码时，将字节替换为 U+DC80 至 U+DCFF 范围内的单个代理代码。 当在编码数据时使用 ‘surrogateescape’ 错误处理方案时，此代理将被转换回相同的字节。 （请参阅 PEP 383 了解详情。）
‘surrogatepass’	编解码器：utf-8, utf-16, utf-32, utf-16-be, utf-16-le, utf-32-be, utf-32-le。允许编码和解码代理代码。 这些编解码器通常会将出现的代理代码视为错误。

示例：第一个参数是对象

a=str(123)
print(a)

123

示例：第一个参数是缓冲区

it=iter([50,51,52])
a=bytearray(it)
print(str(a,'ansi','strict'))

234

sum()函数

语法

sum(iterable, /, start=0)

功能

从 start 开始自左向右对 iterable 的项求和并返回总和值。 iterable 的项通常为数字，而 start 值则不允许为字符串。

示例

print(sum([0,1,2]))
print(sum((2, 3, 4), 1))
print(sum([0,1,2,3,4], 2))

3
10
12

super()函数

语法

此函数有以下用法：

super()
super(type)
super(type, obj)
super(type, type2)

功能

在子类中，调用父类中的方法。

实际上，super()返回一个代理对象，它会将方法调用委托给 type 的父类或兄弟类。 这对于访问已在类中被重载的继承方法很有用。

第二个参数确定用于搜索的方法解析顺序（method resolution order）。 搜索会从 type 之后的类开始。

举例来说，如果 object-or-type 的 mro 为 D -> B -> C -> A -> object 并且 type 的值为 B，则 super() 将会搜索 C -> A -> object。

object-or-type 的__mro__属性列出了getattr()和super()所共同使用的方法解析搜索顺序。 该属性是动态的，可以在任何继承层级结构发生更新的时候被改变。

如果省略第二个参数，则返回的超类对象是未绑定的。 如果第二个参数为一个对象，则isinstance(obj, type)必须为真值。 如果第二个参数为一个类型，则issubclass(type2, type)必须为真值（这适用于类方法）。

super 有两个典型用例：

• 在具有单继承的类层级结构中，super 可用来引用父类而不必显式地指定它们的名称，从而令代码更易维护。
• 第二个用例是在动态执行环境中支持协作多重继承。 此用例为 Python 所独有而不存在于静态编码语言或仅支持单继承的语言当中。 这使用实现“菱形图”成为可能，即有多个基类实现相同的方法。 好的设计强制要求这样的方法在每个情况下都具有相同的调用签名（因为调用顺序是在运行时确定的，也因为这个顺序要适应类层级结构的更改，还因为这个顺序可能包括在运行时之前未知的兄弟类）。
  除了方法查找之外，super() 也可用于属性查找。 一个可能的应用场合是在上级或同级类中调用 描述器。

请注意 super() 是作为显式加点属性查找的绑定过程的一部分来实现的，例如super().__getitem__(name)。 它做到这一点是通过实现自己的__getattribute__()方法，这样就能以可预测的顺序搜索类，并且支持协作多重继承。 对应地，super() 在像super()[name]这样使用语句或操作符进行隐式查找时则未被定义。

还要注意的是，除了零个参数的形式以外，super() 并不限于在方法内部使用。 两个参数的形式明确指定参数并进行相应的引用。 零个参数的形式仅适用于类定义内部，因为编译器需要填入必要的细节以正确地检索到被定义的类，还需要让普通方法访问当前实例。

示例

class A:
     def add(self, x):
         y = x+1
         print(y)
class B(A):
    def add(self, x):
        super().add(x)
b = B()
b.add(2)

3

tuple()类

语法

tuple(iterable=(), /)

功能

用的数据返回一个不可变的序列类型。

示例

print(tuple([1,2,3,4]))
print(tuple({1:2,3:4}))
a = [123, 'xyz', 'zara', 'abc'];
b = tuple(a)
print(b)

(1, 2, 3, 4)
(1, 3)
(123, 'xyz', 'zara', 'abc')

type()类

语法

此类有以下用法：

type(object)
type(name, bases, dict)

功能

只传入一个参数时，返回 object 的类型。 返回值是一个 type 对象，通常与object.__class__所返回的对象相同。

传入三个参数时，返回一个新的 type 对象。 这在本质上是 class 语句的一种动态形式，name 字符串即类名并会成为__name__属性；bases 元组包含基类并会成为__bases__属性；如果为空则会添加所有类的终极基类 object。 dict 字典包含类主体的属性和方法定义；它在成为__dict__属性之前可能会被拷贝或包装。

提供给三参数形式的关键字参数会被传递给适当的元类机制 (通常为 init_subclass())，相当于类定义中关键字 (除了 metaclass) 的行为方式。

和isinstance()的区别：

• type() 不会认为子类是一种父类类型，不考虑继承关系。
• isinstance() 会认为子类是一种父类类型，考虑继承关系。

示例：只使用一个参数

print(type(1))
print(type('runoob'))
print(type([2]))
print(type({0:'zero'}))
x = 1
print(type( x ) == int)

<class 'int'>
<class 'str'>
<class 'list'>
<class 'dict'>
True

示例：使用三个参数

class a(object):
    aa = 1
a = type('X', (object,), dict(aa=1))  # 产生一个新的类型 X
print(a)

<class '__main__.X'>

示例：type() 与 isinstance()区别

class A:
    pass
 
class B(A):
    pass
print(isinstance(A(), A))    
print(type(A()) == A)       
print(isinstance(B(), A))  
print(type(B()) == A)     

True
True
True
False

vars()函数

语法

vars([object])

功能

返回模块、类、实例或任何其它具有__dict__属性的对象的__dict__属性，即返回对象object的属性、属性值的所组成的字典对象。。

模块和实例这样的对象具有可更新的__dict__属性；但是，其它对象的__dict__属性可能会设为限制写入（例如，类会使用 types.MappingProxyType 来防止直接更新字典）。

不带参数时，vars() 的行为类似 locals()。 请注意，locals 字典仅对于读取起作用，因为对 locals 字典的更新会被忽略。

注意：如果指定了一个对象但它没有__dict__属性（例如，当它所属的类定义了__slots__属性时）则会引发 TypeError 异常。

示例：不使用参数

print(vars())

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, '__file__': 'C:\\Users\\zzs\\Desktop\\b.py'}

示例：使用参数

class Runoob:
    a = 1
print(vars(Runoob))
runoob = Runoob()
print(vars(runoob))

{'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'Runoob' objects>, '__weakref__': <attribute '__weakref__' of 'Runoob' objects>, '__doc__': None}
{}

zip()函数

语法

zip(*iterables)

功能

此函数可以传入多个参数，每个参数都是迭代器类型，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的列表。

如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

示例：聚合

a = [1,2,3]
b = [4,5,6]
c = [4,5,6,7,8]
d = zip(a,b)
print(list(d))
print(list(zip(a,c)))

[(1, 4), (2, 5), (3, 6)]
[(1, 4), (2, 5), (3, 6)]

示例：拆解

a = [1,2,3]
b = [4,5,6]
d = zip(a,b)
print(list(d))
d = zip(a,b)
print(list(zip(*d)))

[(1, 4), (2, 5), (3, 6)]
[(1, 2, 3), (4, 5, 6)]

__import__()函数

语法

__import__(name, globals=None, locals=None, fromlist=(), level=0)

功能

此函数用于动态加载类和函数 。如果一个模块经常变化，就可以使用__import__()来动态载入。

此函数会使用 import 语句发起调用。 它可以被替换 (通过导入 builtins 模块并赋值给 builtins.__import__) 以便修改 import 语句的语义，但是强烈不建议这样做，因为使用导入钩子通常更容易实现同样的目标，并且不会导致代码问题，因为许多代码都会假定所用的是默认实现。 同样也不建议直接使用__import__()而应该用importlib.import_module()。

该函数会导入 name 模块，有可能使用给定的 globals 和 locals 来确定如何在包的上下文中解读名称。 fromlist 给出了应该从由 name 指定的模块导入对象或子模块的名称。 标准实现完全不使用其 locals 参数，而仅使用 globals 参数来确定 import 语句的包上下文。

level 指定是使用绝对还是相对导入：

• level 为 0 (默认值) 意味着仅执行绝对导入。
• level 为正数值表示相对于模块调用__import__()的目录，将要搜索的父目录层数 。

当 name 变量的形式为 package.module 时，通常将会返回最高层级的包（第一个点号之前的名称），而 不是 以 name 命名的模块。 但是，当给出了非空的 fromlist 参数时，则将返回以 name 命名的模块。

示例：用此函数实现import语句的效果

语句import spam的结果将为与以下代码作用相同的字节码：

spam = __import__('spam', globals(), locals(), [], 0)

语句import spam.ham的结果将为以下调用：（__import__()通过 import 语句被绑定到特定名称的对象，以返回顶层模块。）

spam = __import__('spam.ham', globals(), locals(), [], 0)

语句 from spam.ham import eggs, sausage as saus 的效果为：（ spam.ham 模块会由__import__()返回。 要导入的对象将从此对象中提取并赋值给它们对应的名称。）

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)
eggs = _temp.eggs
saus = _temp.sausage