郑州市城乡建设规划网站,ui培训学校,深圳市建设厅官方网站,公司官网如何制作概述 为了方便程序员快速编写Python脚本程序#xff0c;Python提供了很多好用的功能模块#xff0c;它们内置于Python系统#xff0c;也称为内置函数(Built-in Functions#xff0c;BlF)#xff0c;Python 内置函数是 Python 解释器提供的一组函数#xff0c;无需额外导…概述 为了方便程序员快速编写Python脚本程序Python提供了很多好用的功能模块它们内置于Python系统也称为内置函数(Built-in FunctionsBlF)Python 内置函数是 Python 解释器提供的一组函数无需额外导入模块即可直接使用。这些函数提供了丰富的功能涵盖了各种常见的任务和操作
我们可以使用print(dir(__builtins__))输出所有的内置类型框中为内置函数 可以使用help函数打印函数的帮助信息
print(help(dir)) 下面是这些函数大致介绍
输入输出函数print(), input(), format(), open(), input(), exit(), quit() 等。类型转换函数int(), float(), str(), bool(), list(), tuple(), dict(), set() 等。数学函数abs(), round(), max(), min(), sum(), pow(), divmod(), complex() 等。序列和集合操作len(), range(), sorted(), enumerate(), zip(), reversed() 等。逻辑和比较函数all(), any(), bool(), isinstance(), callable(), getattr(), setattr(), hasattr(), delattr(), dir(), id() 等。异常处理函数try, except, raise, assert 等。文件和IO操作函数open(), read(), write(), close(), flush(), seek(), tell(), input(), print() 等。高阶函数map(), filter(), reduce(), lambda 表达式等。其他工具函数sum(), sorted(), reversed(), enumerate(), zip(), format(), eval(), exec() 等。
表格形式简介如下
函数名意义abs返回一个数的绝对值all判断可迭代对象中所有元素是否为真any判断可迭代对象中是否存在一个元素为真ascii返回一个可打印对象的可打印字符串表示bin将整数转换为二进制字符串bool将一个值转换为布尔值True 或 Falsebytearray返回一个新的字节数组bytes返回一个新的字节数组callable检查对象是否可调用chr返回 Unicode 码点对应的字符classmethod将方法转换为类方法compile将字符串编译为代码对象complex返回一个复数delattr删除对象的属性dict创建一个字典dir返回对象的属性和方法列表divmod返回两个数的商和余数enumerate返回一个枚举对象eval执行一个字符串表达式并返回表达式的值exec执行字符串或编译过的代码对象filter过滤出可迭代对象中满足条件的元素float将一个字符串或数字转换为浮点数format格式化字符串frozenset返回一个冻结的集合不可更改getattr返回对象指定属性的值globals返回当前全局符号表的字典hasattr检查对象是否具有指定的属性hash返回对象的哈希值help调用 Python 帮助系统hex将整数转换为十六进制字符串id返回对象的唯一标识符内存地址input从标准输入读取一行字符串int将一个字符串或数字转换为整数isinstance检查对象是否是一个类的实例issubclass检查一个类是否是另一个类的子类iter返回一个迭代器len返回对象的长度元素个数list将一个可迭代对象转换为列表locals返回当前局部符号表的字典map对可迭代对象中的每个元素应用函数max返回可迭代对象中的最大值memoryview返回一个 memoryview 对象min返回可迭代对象中的最小值next返回可迭代对象的下一个项目object创建一个空对象oct将整数转换为八进制字符串open打开文件并返回文件对象ord返回一个字符的 Unicode 码点数值pow返回 x 的 y 次方或返回 x 的 y 次方再对 z 求余print将对象转换为字符串并打印到标准输出设备property返回属性值range返回一个序列的数字repr返回一个对象的字符串表示reversed返回一个反转的迭代器round返回浮点数的四舍五入值set创建一个集合setattr设置对象的属性值slice返回一个切片对象sorted返回一个排序后的列表staticmethod将方法转换为静态方法str将对象转换为字符串sum返回可迭代对象的总和super返回父类的委托对象tuple将一个可迭代对象转换为元组type返回对象的类型vars返回对象的 __dict__ 属性zip将可迭代对象中对应的元素打包成元组并返回迭代 下面是在官方文档基础上增加了一些自己的理解和demo自己理解再前面demo在后面保留了官方的 abs(x)
返回一个数的绝对值。 参数可以是整数、浮点数或任何实现了 __abs__() 的对象。 如果参数是一个复数则返回它的模。
aiter(async_iterable)
函数是一个异步操作其作用是获取一个异步可迭代对象的异步迭代器实际上等效于调用 async_iterable.__aiter__() 方法。
异步可迭代对象是指实现了 __aiter__() 方法的对象而异步迭代器则是异步版本的迭代器它的 __anext__() 方法返回一个 awaitable 对象可以在异步上下文中进行迭代操作。
返回 asynchronous iterable 的 asynchronous iterator 。相当于调用 x.__aiter__()。
注意与 iter() 不同aiter() 没有两个参数的版本。
在 3.10 版本加入.
import asyncioasync def async_iterable():for i in range(3):yield iawait asyncio.sleep(1)async def main():async_iter async_iterable()async_iterator aiter(async_iter)async for item in async_iterator:print(item)asyncio.run(main())all(iterable)
如果 iterable 的所有元素均为真值或可迭代对象为空则返回 True 。 等价于
def all(iterable):for element in iterable:if not element:return Falsereturn Trueawaitable anext(async_iterator)
awaitable anext(async_iterator, default)
当进入 await 状态时从给定 asynchronous iterator 返回下一数据项迭代完毕则返回 default。
这是内置函数 next() 的异步版本类似于
调用 async_iterator 的 __anext__() 方法返回一个 awaitable。等待返回迭代器的下一个值。若有给出 default则在迭代完毕后会返回给出的值否则会触发 StopAsyncIteration。
在 3.10 版本加入.
any(iterable)
如果 iterable 的任一元素为真值则返回 True。 如果可迭代对象为空返回 False。 等价于:
def any(iterable):for element in iterable:if element:return Truereturn False可迭代对象iterable是 Python 中一种能够被迭代遍历的对象比如列表、元组、字典、集合、字符串等。这些对象都可以使用 for 循环进行遍历。 lst1 [True, True, True] # 所有元素都为 True
lst2 [True, False, True] # 存在至少一个 Trueprint(all(lst1)) # 输出 True因为所有元素都为 True
print(all(lst2)) # 输出 False因为存在一个 Falseprint(any(lst1)) # 输出 True因为至少有一个 True
print(any(lst2)) # 输出 True因为至少有一个 Trueascii(object)
函数用于返回一个对象的 ASCII 表示。
如果对象实现了 __repr__() 方法并返回一个可以用 ASCII 字符表示的字符串则 ascii() 返回这个字符串。否则它返回一个带引号的字符串其中包含对象的 repr() 表示所有不可打印的 ASCII 字符都被转义成 \x、\u 或 \U 形式的转义序列。
下面是一个简单的示例
print(ascii(hello)) # 输出hello
print(ascii(你好)) # 输出\u4f60\u597d
print(ascii(123)) # 输出123
print(ascii([1, 2, 3])) # 输出[1, 2, 3]在这个示例中字符串 hello 和列表 [1, 2, 3] 都有可打印的 ASCII 表示因此 ascii() 直接返回它们。而字符串 你好 则会被转义成 Unicode 字符串的形式。
bin(x)
将一个整数转换为带前缀 0b 的二进制数字符串。 结果是一个合法的 Python 表达式。 如果 x 不是一个 Python int 对象则它必须定义返回一个整数的 __index__() 方法。 下面是一些例子: bin(3)
0b11bin(-10)
-0b1010若要控制是否显示前缀“0b”可以采用以下两种方案 format(14, #b), format(14, b)
(0b1110, 1110)f{14:#b}, f{14:b}
(0b1110, 1110)另见 format() 获取更多信息。
class bool(xFalse)
函数的意义是将值转换为布尔类型返回布尔值即 True 或 False 两者之一。 x 将使用标准的 真值测试过程 来转换。 如果 x 为假值或者被省略则返回 False在其他情况下将返回 True。 bool 类是 int 的子类 (参见 数字类型 --- int, float, complex)。 它不能被继续子类化。 它只有 False 和 True 两个实例 (参见 布尔类型 - bool)。
print(bool(0)) # 输出False
print(bool(1)) # 输出True
print(bool([])) # 输出False
print(bool([1,2])) # 输出True在 3.7 版本发生变更: x 现在只能作为位置参数。
breakpoint(*args, **kws)
此函数会在调用点进入调试器。具体来说它调用 sys.breakpointhook() 直接传递 args 和 kws 。默认情况下 sys.breakpointhook() 调用 pdb.set_trace() 且没有参数。在这种情况下它纯粹是一个便利函数因此您不必显式导入 pdb 且键入尽可能少的代码即可进入调试器。但是 sys.breakpointhook() 可以设置为其他一些函数并被 breakpoint() 自动调用以允许进入你想用的调试器。如果 sys.breakpointhook() 不可访问这个函数将会引发 RuntimeError。
在默认情况下breakpoint() 的行为可使用 PYTHONBREAKPOINT 环境变量来改变。 请参阅 sys.breakpointhook() 了解详细用法。
请注意这并不保证 sys.breakpointhook() 会被替换。
引发一个 审计事件 builtins.breakpoint 并附带参数 breakpointhook。
在 3.7 版本加入.
class bytearray(sourceb)
class bytearray(source, encoding)
class bytearray(source, encoding, errors)
返回一个新的 bytes 数组。 bytearray 类是一个可变序列包含范围为 0 x 256 的整数。它有可变序列大部分常见的方法见 可变序列类型 的描述同时有 bytes 类型的大部分方法参见 bytes 和 bytearray 操作。
可选形参 source 可以用不同的方式来初始化数组 如果是一个 string您必须提供 encoding 参数errors 参数仍是可选的bytearray() 会使用 str.encode() 方法来将 string 转变成 bytes。 如果是一个 integer会初始化大小为该数字的数组并使用 null 字节填充。 如果是一个遵循 缓冲区接口 的对象该对象的只读缓冲区将被用来初始化字节数组。 如果是一个 iterable 可迭代对象它的元素的范围必须是 0 x 256 的整数它会被用作数组的初始内容。
如果没有实参则创建大小为 0 的数组。
另见 二进制序列类型 --- bytes, bytearray, memoryview 和 bytearray 对象。
class bytes(sourceb)
class bytes(source, encoding)
class bytes(source, encoding, errors)
返回一个新的“bytes”对象这是一个不可变序列包含范围为 0 x 256 的整数。bytes 是 bytearray 的不可变版本——带有同样不改变序列的方法支持同样的索引、切片操作。
因此构造函数的实参和 bytearray() 相同。
字节对象还可以用字面值创建参见 字符串与字节串字面值。
另见 二进制序列类型 --- bytes, bytearray, memoryviewbytes 对象 和 bytes 和 bytearray 操作。
arr bytearray(bhello)
arr.append(33)
print(arr) # 输出bytearray(bhello!)
print(arr.decode(utf-8)) # 输出hello!callable(object)
如果 object 参数是可调用的则返回 True否则返回 False。 如果返回 True调用仍可能失败但如果返回 False则调用 object 肯定不会成功。 请注意类是可调用的调用类将返回一个新的实例如果实例所属的类有 __call__() 方法则它就是可调用的。
在 3.2 版本加入: 这个函数一开始在 Python 3.0 被移除了但在 Python 3.2 被重新加入。
x 5
print(callable(x)) # 输出Falsedef func():print(Hello!)print(callable(func)) # 输出Truechr(i)
返回 Unicode 码位为整数 i 的字符的字符串格式。例如chr(97) 返回字符串 achr(8364) 返回字符串 €。这是 ord() 的逆函数。
实参的合法范围是 0 到 1,114,11116 进制表示是 0x10FFFF。如果 i 超过这个范围会触发 ValueError 异常。
classmethod
把一个方法封装成类方法。
类方法隐含的第一个参数就是类就像实例方法接收实例作为参数一样。要声明一个类方法按惯例请使用以下方案
class C:classmethoddef f(cls, arg1, arg2): ...classmethod 这样的形式称为函数的 decorator -- 详情参阅 函数定义。
类方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。 其所属类以外的类实例会被忽略。 如果类方法在其所属类的派生类上调用则该派生类对象会被作为隐含的第一个参数被传入。
类方法与 C 或 Java 中的静态方法不同。 如果你需要后者请参阅本节中的 staticmethod()。 有关类方法的更多信息请参阅 标准类型层级结构。
在 3.9 版本发生变更: 类方法现在可以包装其他 描述器 例如 property()。
在 3.10 版本发生变更: 类方法现在继承了方法的属性 __module__、 __name__、 __qualname__、 __doc__ 和 __annotations__并拥有一个新的 __wrapped__ 属性。
在 3.11 版本发生变更: 类方法不再可以包装其他 descriptors 例如 property()。
compile(source, filename, mode, flags0, dont_inheritFalse, optimize-1)
将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。source 可以是常规的字符串、字节字符串或者 AST 对象。参见 ast 模块的文档了解如何使用 AST 对象。
filename 实参需要是代码读取的文件名如果代码不需要从文件中读取可以传入一些可辨识的值经常会使用 string。
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 的支持。
code print(Hello, world!)
compiled_code compile(code, string, exec)
exec(compiled_code) # 输出Hello, world!class complex(real0, imag0)
class complex(string)
返回值为 real imag*1j 的复数或将字符串或数字转换为复数。如果第一个形参是字符串则它被解释为一个复数并且函数调用时必须没有第二个形参。第二个形参不能是字符串。每个实参都可以是任意的数值类型包括复数。如果省略了 imag则默认值为零构造函数会像 int 和 float 一样进行数值转换。如果两个实参都省略则返回 0j。
对于一个普通 Python 对象 xcomplex(x) 会委托给 x.__complex__()。 如果 __complex__() 未定义则将回退至 __float__()。 如果 __float__() 未定义则将回退至 __index__()。
备注 当从字符串转换时字符串在 或 - 的周围必须不能有空格。例如 complex(12j) 是合法的但 complex(1 2j) 会触发 ValueError 异常。
数字类型 --- int, float, complex 描述了复数类型。
在 3.6 版本发生变更: 您可以使用下划线将代码文字中的数字进行分组。
在 3.8 版本发生变更: 如果 __complex__() 和 __float__() 均未定义则回退至 __index__()。
x complex(1, 2)
print(x) # 输出(12j)delattr(object, name)
这是 setattr() 的相关函数。 其参数是一个对象和一个字符串。 其中字符串必须是对象的某个属性的名称。 该函数会删除指定的属性如果对象允许这样做的话。 例如delattr(x, foobar) 等价于 del x.foobar。 name 不要求必须是 Python 标识符 (参见 setattr())。
class MyClass:x 10obj MyClass()
print(obj.x) # 输出10
delattr(MyClass, x)
print(obj.x) # AttributeError: MyClass object has no attribute xclass dict(**kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)
创建一个新的字典。dict 对象是一个字典类。参见 dict 和 映射类型 --- dict 了解这个类。
其他容器类型请参见内置的 list、set 和 tuple 类以及 collections 模块。
d dict([(a, 1), (b, 2), (c, 3)])
print(d) # 输出{a: 1, b: 2, c: 3}dir()
dir(object)
如果没有实参则返回当前本地作用域中的名称列表。如果有实参它会尝试返回该对象的有效属性列表。
如果对象有一个名为 __dir__() 的方法则该方法将被调用并且必须返回由属列组成的列表。 这允许实现自定义This allows objects that implement a custom __getattr__() 或 __getattribute__() 函数的对象能够定制 dir() 报告其属性的方式。
如果对象未提供 __dir__()该函数会尽量从对象所定义的 __dict__ 属性和其类型对象中收集信息。 结果列表不一定是完整的并且当对象具有自定义的 __getattr__() 时还可能是不准确的。
默认的 dir() 机制对不同类型的对象行为不同它会试图返回最相关而不是最全的信息 如果对象是模块对象则列表包含模块的属性名称。 如果对象是类型或类对象则列表包含它们的属性名称并且递归查找所有基类的属性。 否则列表包含对象的属性名称它的类属性名称并且递归查找它的类的所有基类的属性。
返回的列表按字母表排序。例如 import structdir() # show the names in the module namespace
[__builtins__, __name__, struct]dir(struct) # show the names in the struct module
[Struct, __all__, __builtins__, __cached__, __doc__, __file__,__initializing__, __loader__, __name__, __package__,_clearcache, calcsize, error, pack, pack_into,unpack, unpack_from]class Shape:
... def __dir__(self):
... return [area, perimeter, location]
...s Shape()dir(s)
[area, location, perimeter]备注 因为 dir() 主要是为了便于在交互式时使用所以它会试图返回人们感兴趣的名字集合而不是试图保证结果的严格性或一致性它具体的行为也可能在不同版本之间改变。例如当实参是一个类时metaclass 的属性不包含在结果列表中。 divmod(a, b)
函数的意义是返回两个数的商和余数的元组。以两个非复数数字为参数在作整数除法时返回商和余数。若操作数为混合类型则适用二进制算术运算符的规则。对于整数而言结果与 (a // b, a % b) 相同。对于浮点数则结果为 (q, a % b)其中 q 通常为 math.floor(a / b)但可能比它小 1。在任何情况下 q * b a % b 都非常接近 a如果 a % b 非零则结果符号与 b 相同并且 0 abs(a % b) abs(b)。
print(divmod(10, 3)) # 输出(3, 1)enumerate(iterable, start0)
返回一个枚举对象。iterable 必须是一个序列或 iterator或其他支持迭代的对象。 enumerate() 返回的迭代器的 __next__() 方法返回一个元组里面包含一个计数值从 start 开始默认为 0和通过迭代 iterable 获得的值。 seasons [Spring, Summer, Fall, Winter]list(enumerate(seasons))
[(0, Spring), (1, Summer), (2, Fall), (3, Winter)]list(enumerate(seasons, start1))
[(1, Spring), (2, Summer), (3, Fall), (4, Winter)]等价于:
def enumerate(iterable, start0):n startfor elem in iterable:yield n, elemn 1eval(expression, globalsNone, localsNone)
执行一个字符串表达式并返回表达式的值。
实参是一个字符串以及可选的 globals 和 locals。globals 实参必须是一个字典。locals 可以是任何映射对象。
表达式解析参数 expression 并作为 Python 表达式进行求值从技术上说是一个条件列表采用 globals 和 locals 字典作为全局和局部命名空间。 如果存在 globals 字典并且不包含 __builtins__ 键的值则在解析 expression 之前会插入以该字符串为键以对内置模块 builtins 的字典的引用为值的项。 这样就可以在将 globals 传给 eval() 之前通过向其传入你自己的 __builtins__ 字典来控制可供被执行代码可以使用哪些内置模块。 如果 locals 字典被省略则它默认为 globals 字典。 如果两个字典都被省略则将使用调用 eval() 的环境中的 globals 和 locals 来执行该表达式。 注意eval() 无法访问闭包环境中的 嵌套作用域 (非局部变量)。
返回值就是表达式的求值结果。 语法错误将作为异常被报告。 例如
x 10
print(eval(x 5)) # 输出15该函数还可用于执行任意代码对象比如由 compile() 创建的对象。 这时传入的是代码对象而非一个字符串了。如果代码对象已用参数为 mode 的 exec 进行了编译那么 eval() 的返回值将为 None。
提示 exec() 函数支持语句的动态执行。 globals() 和 locals() 函数分别返回当前的全局和本地字典可供传给 eval() 或 exec() 使用。
如果给出的源数据是个字符串那么其前后的空格和制表符将被剔除。
另外可以参阅 ast.literal_eval()该函数可以安全执行仅包含文字的表达式字符串。
引发一个 审计事件 exec 附带参数 code_object。
exec(object, globalsNone, localsNone, /, *, closureNone)
执行字符串或编译过的代码对象
这个函数支持动态执行 Python 代码。 object 必须是字符串或者代码对象。 如果是字符串那么该字符串将被解析为一系列 Python 语句并执行除非发生语法错误。 [1] 如果是代码对象它将被直接执行。 在任何情况下被执行的代码都应当是有效的文件输入见参考手册中的 文件输入 一节。 请注意即使在传递给 exec() 函数的代码的上下文中nonlocal, yield 和 return 语句也不能在函数定义以外使用。 该函数的返回值是 None。
无论在什么情况下如果省略了可选部分代码将运行于当前作用域中。如果只提供了 globals则必须为字典对象而不能是字典的子类同时用于存放全局变量和局部变量。如果提供了 globals 和 locals则将分别用于全局变量和局部变量。locals 可以是任意字典映射对象。请记住在模块级别globals 和 locals 是同一个字典。如果 exec 获得两个独立的对象作为 globals 和 locals代码执行起来就像嵌入到某个类定义中一样。
如果 globals 字典不包含 __builtins__ 键值则将为该键插入对内建 builtins 模块字典的引用。因此在将执行的代码传递给 exec() 之前可以通过将自己的 __builtins__ 字典插入到 globals 中来控制可以使用哪些内置代码。
closure 参数指定一个闭包 -- 即由 cellvar 组成的元组。 它仅在 object 是一个包含自由变量的代码对象时才可用。 该元组的长度必须与代码对象所引用的自由变量的数量完全一致。
引发一个 审计事件 exec 附带参数 code_object。
备注 内置 globals() 和 locals() 函数各自返回当前的全局和本地字典因此可以将它们传递给 exec() 的第二个和第三个实参。
备注 默认情况下locals 的行为如下面 locals() 函数描述的一样不要试图改变默认的 locals 字典。 如果您需要在 exec() 函数返回时查看代码对 locals 的影响请明确地传递 locals 字典。
在 3.11 版本发生变更: 添加了 closure 参数。
code print(Hello, world!)
exec(code) # 输出Hello, world!filter(function, iterable)
构造一个迭代器根据指定的函数过滤出元素。
使用 iterable 中 function 返回真值的元素构造一个迭代器。 iterable 可以是一个序列一个支持迭代的容器或者一个迭代器。 如果 function 为 None则会使用标识号函数也就是说iterable 中所有具有假值的元素都将被移除。
请注意 filter(function, iterable) 相当于一个生成器表达式当 function 不是 None 的时候为 (item for item in iterable if function(item))function 是 None 的时候为 (item for item in iterable if item) 。
请参阅 itertools.filterfalse() 来了解返回 iterable 中 function 返回假值的元素的补充函数。
def is_even(n):return n % 2 0numbers [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
even_numbers list(filter(is_even, numbers))
print(even_numbers) # 输出[2, 4, 6, 8, 10]class float(x0.0)
返回从数字或字符串 x 生成的浮点数。
如果该参数是一个字符串则它应当包含一个十进制数字前面可以选择带一个符号也可以选择嵌入空格。 可选的符号可以为 或 - 符号对所产生的值没有影响。 该参数还可以是一个代表 NaN (not-a-number) 或正负无穷大的字符串。 更确切地说在去除前导和尾随的空格之后输入必须为符合以下语法的 floatvalue 产生规则:
sign :: | -
infinity :: Infinity | inf
nan :: nan
digit :: a Unicode decimal digit, i.e. characters in Unicode general category Nd
digitpart :: digit ([_] digit)*
number :: [digitpart] . digitpart | digitpart [.]
exponent :: (e | E) [ | -] digitpart
floatnumber :: number [exponent]
floatvalue :: [sign] (floatnumber | infinity | nan)大小写是无影响的因此举例来说inf, Inf, INFINITY 和 iNfINity 都是正无穷可接受的拼写形式。
另一方面如果实参是整数或浮点数则返回具有相同值在 Python 浮点精度范围内的浮点数。如果实参在 Python 浮点精度范围外则会触发 OverflowError。
对于一个普通 Python 对象 xfloat(x) 会委托给 x.__float__()。 如果 __float__() 未定义则将回退至 __index__()。
如果没有实参则返回 0.0 。
示例: float(1.23)
1.23float( -12345\n)
-12345.0float(1e-003)
0.001float(1E6)
1000000.0float(-Infinity)
-inf数字类型 --- int, float, complex 描述了浮点类型。
在 3.6 版本发生变更: 您可以使用下划线将代码文字中的数字进行分组。
在 3.7 版本发生变更: x 现在只能作为位置参数。
在 3.8 版本发生变更: 如果 __float__() 未定义则回退至 __index__()。
format(value, format_spec)
将 value 转换为“格式化后”的形式格式由 format_spec 进行控制。format_spec 的解释方式取决于 value 参数的类型但大多数内置类型使用一种标准的格式化语法 格式规格迷你语言。
默认的 format_spec 是一个空字符串它通常给出与调用 str(value) 相同的结果。
对 format(value, format_spec) 的调用会转写为 type(value).__format__(value, format_spec)这样在搜索值的 __format__() 方法时将绕过实例字典。 如果方法搜索到达 object 并且 format_spec 不为空或者如果 format_spec 或返回值不为字符串则会引发 TypeError 异常。
在 3.4 版本发生变更: 当 format_spec 不是空字符串时 object().__format__(format_spec) 会触发 TypeError。
age 30
name Alice
print(Her name is {1} and she is {0} years old..format(age, name))
# 输出Her name is Alice and she is 30 years old.class frozenset(iterableset())
返回一个新的 frozenset 对象它包含可选参数 iterable 中的元素。 frozenset 是一个内置的类。有关此类的文档请参阅 frozenset 和 集合类型 --- set, frozenset。
请参阅内建的 set、list、tuple 和 dict 类以及 collections 模块来了解其它的容器。
s frozenset([1, 2, 3])
print(s) # 输出frozenset({1, 2, 3})getattr(object, name)
getattr(object, name, default)
object 中指定名称的属性的值。 name 必须是字符串。 如果该字符串是对象的某一属性的名称则结果将为该属性的值。 例如getattr(x, foobar) 等同于 x.foobar。 如果指定名称的属性不存在则如果提供了 default 则返回该值否则将引发 AttributeError。 name 不必是一个 Python 标识符 (参见 setattr())。
备注
由于 私有名称混合 发生在编译时因此必须手动混合私有属性以两个下划线打头的属性名称以使用 getattr() 来提取它。
class MyClass:x 10obj MyClass()
print(getattr(obj, x)) # 输出10globals()
返回实现当前模块命名空间的字典。对于函数内的代码这是在定义函数时设置的无论函数在哪里被调用都保持不变。
x10
print(globals())
输出
{__name__: __main__, __doc__: None, __package__: None, __loader__: _frozen_importlib_external.SourceFileLoader object at 0x000002A6BB8B3DC0, __spec__: None, __annotations__: {}, __builtins__: module builtins (built-in), __file__: d:\\python\\test\\test_bif.py, __cached__: None, x: 10}
hasattr(object, name)
该实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称则返回 True否则返回 False。此功能是通过调用 getattr(object, name) 看是否有 AttributeError 异常来实现的。
hash(object)
返回该对象的哈希值如果它有的话。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值即使它们类型不同如 1 和 1.0。
备注
对于具有自定义 __hash__() 方法的对象请注意 hash() 会根据宿主机的字长来截断返回值。
help()
help(request)
启动内置的帮助系统此函数主要在交互式中使用。如果没有实参解释器控制台里会启动交互式帮助系统。如果实参是一个字符串则在模块、函数、类、方法、关键字或文档主题中搜索该字符串并在控制台上打印帮助信息。如果实参是其他任意对象则会生成该对象的帮助页。
请注意如果在调用 help() 时目标函数的形参列表中存在斜杠/则意味着斜杠之前的参数只能是位置参数。详情请参阅 有关仅限位置形参的 FAQ 条目。
该函数通过 site 模块加入到内置命名空间。
在 3.4 版本发生变更: pydoc 和 inspect 的变更使得可调用对象的签名信息更加全面和一致。
hex(x)
将整数转换为带前缀 0x 前缀的小写十六进制数字符串。 如果 x 不是一个 Python int 对象则它必须定义返回一个整数的 __index__() 方法。 下面是一些例子: hex(255)
0xffhex(-42)
-0x2a如果要将整数转换为大写或小写的十六进制字符串并可选择有无“0x”前缀则可以使用如下方法 %#x % 255, %x % 255, %X % 255
(0xff, ff, FF)format(255, #x), format(255, x), format(255, X)
(0xff, ff, FF)f{255:#x}, f{255:x}, f{255:X}
(0xff, ff, FF)另见 format() 获取更多信息。
另请参阅 int() 将十六进制字符串转换为以 16 为基数的整数。
备注 如果要获取浮点数的十六进制字符串形式请使用 float.hex() 方法。
id(object)
返回对象的“标识值”。该值是一个整数在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() 值。
CPython 实现细节 这是对象在内在中的地址。
引发一个 审计事件 builtins.id附带参数 id。
input()
input(prompt)
如果存在 prompt 实参则将其写入标准输出末尾不带换行符。接下来该函数从输入中读取一行将其转换为字符串除了末尾的换行符并返回。当读取到 EOF 时则触发 EOFError。例如: s input(-- )
-- Monty Pythons Flying Circuss
Monty Pythons Flying Circus如果加载了 readline 模块input() 将使用它来提供复杂的行编辑和历史记录功能。
引发一个 审计事件 builtins.input 附带参数 prompt。 在成功读取输入之后引发一个 审计事件 builtins.input/result 附带结果。 class int(x0)
class int(x, base10)
返回一个基于数字或字符串 x 构造的整数对象或者在未给出参数时返回 0。 如果 x 定义了 __int__()则 int(x) 将返回 x.__int__()。 如果 x 定义了 __index__()则将返回 x.__index__()。 如果 x 定义了 __trunc__()则将返回 x.__trunc__()。 对于浮点数这将向零方向截断。
如果 x 不是一个数字或者如果给定了 base则 x 必须是一个表示以 base 为基数的整数的字符串、bytes 或 bytearray 实例。 字符串前面还能加上可选的 或 - (中间没有空格)带有前导的零带有两侧的空格并可带有数位之间的单个下划线。
一个以 n 为基数的整数字符串包含多个数位每个数位代表从 0 到 n-1 范围内的值。 0--9 的值可以用任何 Unicode 十进制数码来表示。 10--35 的值可以用 a 到 z (或 A 到 Z) 来表示。 默认的 base 为 10。 允许的基数为 0 和 2--36。 对于基数 2, -8 和 -16 来说字符串前面还能加上可选的 0b/0B, 0o/0O 或 0x/0X 前缀就像代码中的整数字面值那样。 对于基数 0 来说字符串会以与 代码中的整数字面值 类似的方式来解读即实际的基数将由前缀确定为 2, 8, 10 或 16。 基数为 0 还会禁用前导的零: int(010, 0) 将是无效的而 int(010) 和 int(010, 8) 则是有效的。
整数类型定义请参阅 数字类型 --- int, float, complex 。
在 3.4 版本发生变更: 如果 base 不是 int 的实例但 base 对象有 base.__index__ 方法则会调用该方法来获取进制数。以前的版本使用 base.__int__ 而不是 base.__index__。
在 3.6 版本发生变更: 您可以使用下划线将代码文字中的数字进行分组。
在 3.7 版本发生变更: x 现在只能作为位置参数。
在 3.8 版本发生变更: 如果 __int__() 未定义则回退至 __index__()。
在 3.11 版本发生变更: 委托给 __trunc__() 的做法已被弃用。
在 3.11 版本发生变更: int 字符串输入和字符串表示形式可受到限制以帮助避免拒绝服务攻击。 当将一个字符串 x 转换为 int 或者当将一个 int 转换为字符串的操作超出限制则会引发 ValueError。 请参阅 整数字符串转换长度限制 文档。
isinstance(object, classinfo)
函数的意义是检查一个对象是否是一个类的实例。如果 object 参数是 classinfo 参数的实例或者是其 (直接、间接或 虚拟) 子类的实例则返回 True。 如果 object 不是给定类型的对象则该函数总是返回 False。 如果 classinfo 是由类型对象结成的元组 (或是由其他此类元组递归生成) 或者是多个类型的 union 类型则如果 object 是其中任一类型的实例时将会返回 True。 如果 classinfo 不是一个类型或类型元组及此类元组则会引发 TypeError 异常。 如果之前的检查成功执行则可以不会为无效的类型引发 TypeError。
在 3.10 版本发生变更: classinfo 可以是一个 union 类型。
x 5
print(isinstance(x, int)) # 输出Truelst [1, 2, 3]
print(isinstance(lst, list)) # 输出Trueissubclass(class, classinfo)
如果 class 是 classinfo 的子类直接、间接或 虚的 则返回 True。类将视为自己的子类。classinfo 可为类对象的元组或递归地其他这样的元组或 union 类型这时如果 class 是 classinfo 中任何条目的子类则返回 True 。任何其他情况都会触发 TypeError 异常。
在 3.10 版本发生变更: classinfo 可以是一个 union 类型。
iter(object)
iter(object, sentinel)
返回一个 iterator 对象。 根据是否存在第二个参数对第一个参数的解读会有很大的不同。 如果没有第二个参数object 必须是一个支持 iterable 协议 (有 __iter__() 方法) 的多项集对象或者必须支持序列协议 (有 __getitem__() 方法并使用从 0 开始的整数参数)。 如果它不支持这些协议则会引发 TypeError。 如果给出了第二个参数 sentinel则 object 必须是一个可调用对象。 在这种情况下创建的迭代器将针对每次调用其 __next__() 方法不带参数地调用 object如果返回的值等于 sentinel则会引发 StopIteration否则将返回该值。
另请参阅 迭代器类型。
适合 iter() 的第二种形式的应用之一是构建块读取器。 例如从二进制数据库文件中读取固定宽度的块直至到达文件的末尾:
from functools import partial
with open(mydata.db, rb) as f:for block in iter(partial(f.read, 64), b):process_block(block)len(s)
返回对象的长度元素个数。实参可以是序列如 string、bytes、tuple、list 或 range 等或集合如 dictionary、set 或 frozen set 等。
CPython 实现细节 len 对于大于 sys.maxsize 的长度如 range(2 ** 100) 会引发 OverflowError。
class list
class list(iterable)
虽然被称为函数list 实际上是一种可变序列类型详情请参阅 列表 和 序列类型 --- list, tuple, range。
locals()
更新并返回表示当前本地符号表的字典。 在函数代码块但不是类代码块中调用 locals() 时将返回自由变量。 请注意在模块层级上locals() 和 globals() 是同一个字典。
备注 不要更改此字典的内容更改不会影响解释器使用的局部变量或自由变量的值。
map(function, iterable, *iterables)
返回一个将 function 应用于 iterable 的每一项并产生其结果的迭代器。 如果传入了额外的 iterables 参数则 function 必须接受相同个数的参数并被用于到从所有可迭代对象中并行获取的项。 当有多个可迭代对象时当最短的可迭代对象耗尽则整个迭代将会停止。 对于函数的输入已经是参数元组的情况请参阅 itertools.starmap()。
max(iterable, *, keyNone)
max(iterable, *, default, keyNone)
max(arg1, arg2, *args, keyNone)
返回可迭代对象中最大的元素或者返回两个及以上实参中最大的。
如果只提供了一个位置参数它必须是非空 iterable返回可迭代对象中最大的元素如果提供了两个及以上的位置参数则返回最大的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空并且没有给 default 则会触发 ValueError。
如果有多个最大元素则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, keykeyfunc, reverseTrue)[0] 和 heapq.nlargest(1, iterable, keykeyfunc) 保持一致。
在 3.4 版本发生变更: 增加了 default 仅限关键字形参。
在 3.8 版本发生变更: key 可以为 None。
class memoryview(object)
返回由给定实参创建的“内存视图”对象。有关详细信息请参阅 内存视图。
min(iterable, *, keyNone)
min(iterable, *, default, keyNone)
min(arg1, arg2, *args, keyNone)
返回可迭代对象中最小的元素或者返回两个及以上实参中最小的。
如果只提供了一个位置参数它必须是 iterable返回可迭代对象中最小的元素如果提供了两个及以上的位置参数则返回最小的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空并且没有给 default 则会触发 ValueError。
如果有多个最小元素则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, keykeyfunc)[0] 和 heapq.nsmallest(1, iterable, keykeyfunc) 保持一致。
在 3.4 版本发生变更: 增加了 default 仅限关键字形参。
在 3.8 版本发生变更: key 可以为 None。
next(iterator)
next(iterator, default)
通过调用 iterator 的 __next__() 方法获取下一个元素。如果迭代器耗尽则返回给定的 default如果没有默认值则触发 StopIteration。
class object
函数的意义是创建一个空对象返回一个不带特征的新对象。object 是所有类的基类。它带有所有 Python 类实例均通用的方法。本函数不接受任何参数。
备注
由于 object 没有 __dict__因此无法将任意属性赋给 object 的实例。
oct(x)
函数的意义是将整数转换为八进制字符串将整数转换为带前缀 0o 的八进制数字符串。 结果是一个合法的 Python 表达式。 如果 x 不是一个 Python int 对象则它必须定义返回一个整数的 __index__() 方法。 例如: oct(8)
0o10oct(-56)
-0o70若要将整数转换为八进制字符串并可选择是否带有“0o”前缀可采用如下方法 %#o % 10, %o % 10
(0o12, 12)format(10, #o), format(10, o)
(0o12, 12)f{10:#o}, f{10:o}
(0o12, 12)另见 format() 获取更多信息。
open(file, moder, buffering-1, encodingNone, errorsNone, newlineNone, closefdTrue, openerNone)
函数的意义是打开文件并返回文件对象。打开 file 并返回对应的 file object。 如果该文件不能被打开则引发 OSError。 请参阅 读写文件 获取此函数的更多用法示例。
file 是一个 path-like object表示将要打开的文件的路径绝对路径或者相对当前工作目录的路径也可以是要封装文件对应的整数类型文件描述符。如果给出的是文件描述符则当返回的 I/O 对象关闭时它也会关闭除非将 closefd 设为 False 。
mode 是一个指明文件打开模式的可选字符串。 它默认为 r 表示以文本模式读取。 其他常见模式有表示写入的 w (若文件已存在则将其清空)表示独占创建的 x以及表示追加写入的 a (在 某些 Unix 系统上这意味着无论当前查找位置在哪里 所有 写入操作都将追加到文件末尾)。 在文本模式下如果未指定 encoding 则所使用的编码格式将依赖于具体平台: locale.getencoding() 会被调用以获取当前语言区域的编码格式。 (对于读取和写入原始字节数据请使用二进制模式并且不要指定 encoding。) 可用的模式有: 字符 含意 r 读取默认 w 写入并先截断文件 x 排它性创建如果文件已存在则失败 a 打开文件用于写入如果文件存在则在末尾追加 b 二进制模式 t 文本模式默认 打开用于更新读取与写入
默认模式为 r 打开文件用于读取文本与 rt 同义。w 和 wb 模式将打开文件并清空内容。而 r 和 rb 模式将打开文件但不清空内容。
正如在 概述 中提到的Python区分二进制和文本I/O。以二进制模式打开的文件包括 mode 参数中的 b 返回的内容为 bytes 对象不进行任何解码。在文本模式下默认情况下或者在 mode 参数中包含 t 时文件内容返回为 str 首先使用指定的 encoding 如果给定或者使用平台默认的的字节编码解码。
备注 Python不依赖于底层操作系统的文本文件概念;所有处理都由Python本身完成因此与平台无关。
buffering 是一个可选的整数用于设置缓冲策略。 传入 0 来关闭缓冲仅在二进制模式下允许传入 1 来选择行缓冲仅在文本模式下写入时可用传一个整数 1 来表示固定大小的块缓冲区的字节大小。 注意这样指定缓冲区的大小适用于二进制缓冲的 I/O,但 TextIOWrapper (即用 moder 打开的文件) 会有另一种缓冲。 要禁用 TextIOWrapper 中的缓冲请考虑为 io.TextIOWrapper.reconfigure() 使用 write_through 旗标。 当没有给出 buffering 参数时默认的缓冲策略规则如下: 二进制文件以固定大小的块进行缓冲缓冲区的大小是使用启发方式来尝试确定底层设备的“块大小”并会回退至 io.DEFAULT_BUFFER_SIZE。 在许多系统上缓冲区的长度通常为 4096 或 8192 字节。 “交互式”文本文件 isatty() 返回 True 的文件使用行缓冲。其他文本文件使用上述策略用于二进制文件。
encoding 是用于编码或编码文件的编码格式名称。 这应当只有文本模式下使用。 默认的编码格式依赖于具体平台 (即 locale.getencoding() 所返回的值)但是任何 Python 支持的 text encoding 都可以被使用。 请参阅 codecs 模块获取受支持的编码格式列表。
errors 是一个可选的字符串参数用于指定如何处理编码和解码错误 - 这不能在二进制模式下使用。可以使用各种标准错误处理程序列在 错误处理方案 但是使用 codecs.register_error() 注册的任何错误处理名称也是有效的。标准名称包括: 如果存在编码错误strict 会引发 ValueError 异常。 默认值 None 具有相同的效果。 ignore 忽略错误。请注意忽略编码错误可能会导致数据丢失。 replace 会将替换标记例如 ? 插入有错误数据的地方。 surrogateescape 将把任何不正确的字节表示为 UDC80 至 UDCFF 范围内的下方替代码位。 当在写入数据时使用 surrogateescape 错误处理句柄时这些替代码位会被转回到相同的字节。 这适用于处理具有未知编码格式的文件。 xmlcharrefreplace 仅在写入文件时才受到支持。 编码格式不支持的字符将被替换为相应的 XML 字符引用 #nnn;。 backslashreplace 用Python的反向转义序列替换格式错误的数据。 namereplace 也只在编写时支持用 \N{...} 转义序列替换不支持的字符。
newline 决定如何解析来自流的换行符。 它可以为 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 来使用自定义开启器。然后通过使用参数 fileflags 调用 opener 获得文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符使用 os.open as opener 时与传递 None 的效果相同。
新创建的文件是 不可继承的。
下面的示例使用 os.open() 函数的 dir_fd 的形参从给定的目录中用相对路径打开文件: import osdir_fd os.open(somedir, os.O_RDONLY)def opener(path, flags):
... return os.open(path, flags, dir_fddir_fd)
...with open(spamspam.txt, w, openeropener) as f:
... print(This will be written to somedir/spamspam.txt, filef)
...os.close(dir_fd) # dont leak a file descriptoropen() 函数所返回的 file object 类型取决于所用模式。 当使用 open() 以文本模式 (w, r, wt, rt 等) 打开文件时它将返回 io.TextIOBase (具体为 io.TextIOWrapper) 的一个子类。 当使用缓冲以二进制模式打开文件时返回的类是 io.BufferedIOBase 的一个子类。 具体的类会有多种在只读的二进制模式下它将返回 io.BufferedReader在写入二进制和追加二进制模式下它将返回 io.BufferedWriter而在读/写模式下它将返回 io.BufferedRandom。 当禁用缓冲时则会返回原始流即 io.RawIOBase 的一个子类 io.FileIO。
另请参阅文件操作模块如 fileinput、io 声明了 open()、os、os.path、tempfile 和 shutil。
引发一个 审计事件 open 附带参数 file, mode, flags。
mode 与 flags 参数可以在原始调用的基础上被修改或传递。
在 3.3 版本发生变更: 增加了 opener 形参。 增加了 x 模式。 过去触发的 IOError现在是 OSError 的别名。 如果文件已存在但使用了排它性创建模式 x 现在会触发 FileExistsError。
在 3.4 版本发生变更: 文件现在禁止继承。
在 3.5 版本发生变更: 如果系统调用被中断但信号处理程序没有触发异常此函数现在会重试系统调用而不是触发 InterruptedError 异常 (原因详见 PEP 475)。 增加了 namereplace 错误处理接口。
在 3.6 版本发生变更: 增加对实现了 os.PathLike 对象的支持。 在 Windows 上打开一个控制台缓冲区将返回 io.RawIOBase 的子类而不是 io.FileIO。
在 3.11 版本发生变更: U 模式已被移除。
ord(c)
函数的意义是返回一个字符的 Unicode 码点数值。对表示单个 Unicode 字符的字符串返回代表它 Unicode 码点的整数。例如 ord(a) 返回整数 97 ord(€) 欧元符号返回 8364 。这是 chr() 的逆函数。
pow(base, exp, modNone)
返回 base 的 exp 次幂如果 mod 存在则返回 base 的 exp 次幂对 mod 取余比 pow(base, exp) % mod 更高效。 两参数形式 pow(base, exp) 等价于乘方运算符: base**exp。
参数必须为数值类型。 对于混用的操作数类型则适用二元算术运算符的类型强制转换规则。 对于 int 操作数结果具有与操作数相同的类型转换后除非第二个参数为负值在这种情况下所有参数将被转换为浮点数并输出浮点数结果。 例如pow(10, 2) 返回 100但 pow(10, -2) 返回 0.01。 对于 int 或 float 类型的负基和一个非整数的指数会产生一个复数作为结果。 例如 pow(-9, 0.5) 返回一个接近于 3j 的值。
对于 int 操作数 base 和 exp如果给出 mod则 mod 必须为整数类型并且 mod 必须不为零。 如果给出 mod 并且 exp 为负值则 base 必须相对于 mod 不可整除。 在这种情况下将会返回 pow(inv_base, -exp, mod)其中 inv_base 为 base 的倒数对 mod 取余。
下面的例子是 38 的倒数对 97 取余: pow(38, -1, mod97)
2323 * 38 % 97 1
True在 3.8 版本发生变更: 对于 int 操作数三参数形式的 pow 现在允许第二个参数为负值即可以计算倒数的余数。
在 3.8 版本发生变更: 允许关键字参数。 之前只支持位置参数。
print(*objects, sep , end\n, fileNone, flushFalse)
将 objects 打印输出至 file 指定的文本流以 sep 分隔并在末尾加上 end。 sep 、 end 、 file 和 flush 必须以关键字参数的形式给出。
所有非关键字参数都会被转换为字符串就像是执行了 str() 一样并会被写入到流以 sep 分隔并在末尾加上 end。 sep 和 end 都必须为字符串它们也可以为 None这意味着使用默认值。 如果没有给出 objects则 print() 将只写入 end。
file 参数必须是一个具有 write(string) 方法的对象如果参数不存在或为 None则将使用 sys.stdout。 由于要打印的参数会被转换为文本字符串因此 print() 不能用于二进制模式的文件对象。 对于这些对象应改用 file.write(...)。
输出缓冲通常由 file 确定。 但是如果 flush 为真值流将被强制刷新。
在 3.3 版本发生变更: 增加了 flush 关键字参数。
class property(fgetNone, fsetNone, fdelNone, docNone)
返回 property 属性。
fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。
一个典型的用法是定义一个托管属性 x:
class C:def __init__(self):self._x Nonedef getx(self):return self._xdef setx(self, value):self._x valuedef delx(self):del self._xx property(getx, setx, delx, Im the x property.)如果 c 为 C 的实例c.x 将调用 getterc.x value 将调用 setter del c.x 将调用 deleter。
如果给出doc 将成为该 property 属性的文档字符串。 否则该 property 将拷贝 fget 的文档字符串如果存在。 这令使用 property() 作为 decorator 来创建只读的特征属性可以很容易地实现:
class Parrot:def __init__(self):self._voltage 100000propertydef voltage(self):Get the current voltage.return self._voltageproperty 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性 getter并将 voltage 的文档字符串设为 Get the current voltage.
getter
setter
deleter
特征属性对象具有 getter, setter 和 deleter 方法它们可用作装饰器来创建该特征属性的副本并将相应的访问函数设为所装饰的函数。 这最好是用一个例子来说明
class C:def __init__(self):self._x Nonepropertydef x(self):Im the x property.return self._xx.setterdef x(self, value):self._x valuex.deleterdef x(self):del self._x上述代码与第一个例子完全等价。 注意一定要给附加函数与原始的特征属性相同的名称 (在本例中为 x。)
返回的特征属性对象同样具有与构造器参数相对应的属性 fget, fset 和 fdel。
在 3.5 版本发生变更: 特征属性对象的文档字符串现在是可写的。
class range(stop)
class range(start, stop, step1)
虽然被称为函数但 range 实际上是一个不可变的序列类型参见在 range 对象 与 序列类型 --- list, tuple, range 中的文档说明。
repr(object)
函数的意义是返回一个对象的字符串表示。返回包含一个对象的可打印表示形式的字符串。 对于许多类型而言此函数会尝试返回一个具有与传给 eval() 时相同的值的字符串在其他情况下其表示形式将为一个包含对象类型名称和通常包括对象名称和地址的额外信息的用尖括号括起来的字符串。 一个类可以通过定义 __repr__() 方法来控制此函数为其实例所返回的内容。 如果 sys.displayhook() 不可访问则此函数将会引发 RuntimeError。
reversed(seq)
返回一个反向的 iterator。 seq 必须是一个具有 __reversed__() 方法或是支持序列协议具有 __len__() 方法和从 0 开始的整数参数的 __getitem__() 方法的对象。
lst [1, 2, 3, 4, 5]
rev_lst list(reversed(lst))
print(rev_lst) # 输出[5, 4, 3, 2, 1]round(number, ndigitsNone)
返回 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。 这不算是程序错误这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。 请参阅 浮点算术争议和限制 了解更多信息。
class set
class set(iterable)
返回一个新的 set 对象可以选择带有从 iterable 获取的元素。 set 是一个内置类型。 请查看 set 和 集合类型 --- set, frozenset 获取关于这个类的文档。
有关其他容器请参看内置的 frozenset, list, tuple 和 dict 类以及 collections 模块。
setattr(object, name, value)
本函数与 getattr() 相对应。其参数为一个对象、一个字符串和一个任意值。字符串可以为某现有属性的名称或为新属性。只要对象允许函数会将值赋给属性。如 setattr(x, foobar, 123) 等价于 x.foobar 123。
name 无需为在 标识符和关键字 中定义的 Python 标识符除非对象选择强制这样做例如在一个自定义的 __getattribute__() 中或是通过 __slots__。 一个名称不为标识符的属性将不可使用点号标记来访问但是可以通过 getattr() 等来访问。
备注 由于 私有名称混合 发生在编译时因此必须手动混合私有属性以两个下划线打头的属性名称以便使用 setattr() 来设置它。
class slice(stop)
class slice(start, stop, stepNone)
返回一个表示由 range(start, stop, step) 指定的索引集的 slice 对象。 start 和 step 参数默认为 None。
start
stop
step
切片对象具有只读的数据属性 start, stop 和 step它们将简单地返回相应的参数值或其默认值。 它们没有其他显式的功能但是它们会被 NumPy 和其他第三方包所使用。
当使用扩展索引语法时也会生成切片对象。 例如: a[start:stop:step] 或 a[start:stop, i]。 请参阅 itertools.islice() 了解返回 iterator 的替代版本。
在 3.12 版本发生变更: Slice 对象现在将为 hashable (如果 start, stop 和 step 均为可哈希对象)。
sorted(iterable, /, *, keyNone, reverseFalse)
根据 iterable 中的项返回一个新的已排序列表。
具有两个可选参数它们都必须指定为关键字参数。
key 指定带有单个参数的函数用于从 iterable 的每个元素中提取用于比较的键 (例如 keystr.lower)。 默认值为 None (直接比较元素)。
reverse 为一个布尔值。 如果设为 True则每个列表元素将按反向顺序比较进行排序。
使用 functools.cmp_to_key() 可将老式的 cmp 函数转换为 key 函数。
内置的 sorted() 确保是稳定的。 如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的 --- 这有利于进行多重排序例如先按部门、再按薪级排序。
排序算法只使用 在项目之间比较。 虽然定义一个 __lt__() 方法就足以进行排序但 PEP 8 建议实现所有六个 富比较 。 这将有助于避免在与其他排序工具如 max() 使用相同的数据时出现错误这些工具依赖于不同的底层方法。实现所有六个比较也有助于避免混合类型比较的混乱因为混合类型比较可以调用反射到 __gt__() 的方法。
有关排序示例和简要排序教程请参阅 排序的技巧 。
staticmethod
将方法转换为静态方法。
静态方法不会接收隐式的第一个参数。要声明一个静态方法请使用此语法
class C:staticmethoddef f(arg1, arg2, argN): ...staticmethod 这样的形式称为函数的 decorator -- 详情参阅 函数定义。
静态方法既可以由类中调用如 C.f()也可以由实例中调用如 C().f()。此外还可以作为普通的函数进行调用如 f()。
Python 的静态方法与 Java 或 C 类似。另请参阅 classmethod() 可用于创建另一种类构造函数。
像所有装饰器一样也可以像常规函数一样调用 staticmethod 并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。对于这些情况请使用此语法:
def regular_function():...class C:method staticmethod(regular_function)想了解更多有关静态方法的信息请参阅 标准类型层级结构 。
在 3.10 版本发生变更: 静态方法继承了方法的多个属性 __module__、 __name__、 __qualname__、 __doc__ 和 __annotations__还拥有一个新的 __wrapped__ 属性并且现在还可以作为普通函数进行调用。
class str(object)
class str(objectb, encodingutf-8, errorsstrict)
返回一个 str 版本的 object 。有关详细信息请参阅 str() 。
str 是内置字符串 class 。更多关于字符串的信息查看 文本序列类型 --- str。
sum(iterable, /, start0)
从 start 开始自左向右对 iterable 的项求和并返回总计值。 iterable 的项通常为数字而 start 值则不允许为字符串。
对某些用例来说存在 sum() 的更好替代。 拼接字符串序列的更好更快方式是调用 .join(sequence)。 要以扩展精度对浮点值求和请参阅 math.fsum()。 要拼接一系列可迭代对象请考虑使用 itertools.chain()。
在 3.8 版本发生变更: start 形参可用关键字参数形式来指定。
在 3.12 版本发生变更: 浮点数的加总已切换为一种可在大多数构建版本上给出更高精度的算法。
class super
class super(type, object_or_typeNone)
返回一个代理对象它会将方法调用委托给 type 的父类或兄弟类。 这对于访问已在类中被重写的继承方法很有用。
object_or_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 可用来引用父类而不必显式地指定它们的名称从而令代码更易维护。 这种用法与其他编程语言中 super 的用法非常相似。
第二个用例是在动态执行环境中支持协作多重继承。 此用例为 Python 所独有而不存在于静态编码语言或仅支持单继承的语言当中。 这使用实现“菱形图”成为可能即有多个基类实现相同的方法。 好的设计强制要求这样的方法在每个情况下都具有相同的调用签名因为调用顺序是在运行时确定的也因为这个顺序要适应类层级结构的更改还因为这个顺序可能包括在运行时之前未知的兄弟类。
对于以上两个用例典型的超类调用看起来是这样的:
class C(B):def method(self, arg):super().method(arg) # This does the same thing as:# super(C, self).method(arg)除了方法查找之外super() 也可用于属性查找。 一个可能的应用场合是在上级或同级类中调用 描述器。
请注意 super() 被实现为为显式的带点号属性查找的绑定过程的组成部分例如 super().__getitem__(name)。 它做到这一点是通过实现自己的 __getattribute__() 方法以便能够按支持协作多重继承的可预测的顺序来搜索类。 相应地super() 在像 super()[name] 这样使用语句或运算符进行隐式查找时则是未定义的。
还要注意的是除了零个参数的形式以外super() 并不限于在方法内部使用。 两个参数的形式明确指定参数并进行相应的引用。 零个参数的形式仅适用于类定义内部因为编译器需要填入必要的细节以正确地检索到被定义的类还需要让普通方法访问当前实例。
对于有关如何使用 super() 来如何设计协作类的实用建议请参阅 使用 super() 的指南。
class tuple
class tuple(iterable)
虽然被称为函数但 tuple 实际上是一个不可变的序列类型参见在 元组 与 序列类型 --- list, tuple, range 中的文档说明。
class type(object)
class type(name, bases, dict, **kwds)
传入一个参数时返回 object 的类型。 返回值是一个 type 对象通常与 object.__class__ 所返回的对象相同。
推荐使用 isinstance() 内置函数来检测对象的类型因为它会考虑子类的情况。
传入三个参数时返回一个新的 type 对象。 这在本质上是 class 语句的一种动态形式name 字符串即类名并会成为 __name__ 属性bases 元组包含基类并会成为 __bases__ 属性如果为空则会添加所有类的终极基类 object。 dict 字典包含类主体的属性和方法定义它在成为 __dict__ 属性之前可能会被拷贝或包装。 下面两条语句会创建相同的 type 对象: class X:
... a 1
...X type(X, (), dict(a1))另请参阅 类型对象。
提供给三参数形式的关键字参数会被传递给适当的元类机制 (通常为 __init_subclass__())相当于类定义中关键字 (除了 metaclass) 的行为方式。
另请参阅 自定义类创建。
在 3.6 版本发生变更: type 的子类如果未重写 type.__new__将不再能使用一个参数的形式来获取对象的类型。
vars()
vars(object)
返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。
模块和实例这样的对象具有可更新的 __dict__ 属性但是其它对象的 __dict__ 属性可能会设为限制写入例如类会使用 types.MappingProxyType 来防止直接更新字典。
不带参数时vars() 的行为类似 locals()。 请注意locals 字典仅对于读取起作用因为对 locals 字典的更新会被忽略。
如果指定了一个对象但它没有 __dict__ 属性例如当它所属的类定义了 __slots__ 属性时则会引发 TypeError 异常。
zip(*iterables, strictFalse)
函数的意义是将可迭代对象中对应的元素打包成一个元组然后返回这些元组的迭代器。在多个迭代器上并行迭代从每个迭代器返回一个数据项组成元组。
示例: for item in zip([1, 2, 3], [sugar, spice, everything nice]):
... print(item)
...
(1, sugar)
(2, spice)
(3, everything nice)更正式的说法 zip() 返回元组的迭代器其中第 i 个元组包含的是每个参数迭代器的第 i 个元素。
不妨换一种方式认识 zip() 它会把行变成列把列变成行。这类似于 矩阵转置 。
zip() 是延迟执行的直至迭代时才会对元素进行处理比如 for 循环或放入 list 中。
值得考虑的是传给 zip() 的可迭代对象可能长度不同有时是有意为之有时是因为准备这些对象的代码存在错误。Python 提供了三种不同的处理方案 默认情况下zip() 在最短的迭代完成后停止。较长可迭代对象中的剩余项将被忽略结果会裁切至最短可迭代对象的长度 list(zip(range(3), [fee, fi, fo, fum]))
[(0, fee), (1, fi), (2, fo)]通常 zip() 用于可迭代对象等长的情况下。这时建议用 strictTrue 的选项。输出与普通的 zip() 相同。 list(zip((a, b, c), (1, 2, 3), strictTrue))
[(a, 1), (b, 2), (c, 3)]与默认行为不同如果一个可迭代对象在其他几个之前被耗尽则会引发 ValueError: for item in zip(range(3), [fee, fi, fo, fum], strictTrue):
... print(item)
...
(0, fee)
(1, fi)
(2, fo)
Traceback (most recent call last):...
ValueError: zip() argument 2 is longer than argument 1如果未指定 strictTrue 参数所有导致可迭代对象长度不同的错误都会被抑制这可能会在程序的其他地方表现为难以发现的错误。 为了让所有的可迭代对象具有相同的长度长度较短的可用常量进行填充。这可由 itertools.zip_longest() 来完成。
极端例子是只有一个可迭代对象参数zip() 会返回一个一元组的迭代器。如果未给出参数则返回一个空的迭代器。
小技巧 可确保迭代器的求值顺序是从左到右的。这样就能用 zip(*[iter(s)]*n, strictTrue) 将数据列表按长度 n 进行分组。这将重复 相同 的迭代器 n 次输出的每个元组都包含 n 次调用迭代器的结果。这样做的效果是把输入拆分为长度为 n 的块。 zip() 与 * 运算符相结合可以用来拆解一个列表: x [1, 2, 3]y [4, 5, 6]list(zip(x, y))
[(1, 4), (2, 5), (3, 6)]x2, y2 zip(*zip(x, y))x list(x2) and y list(y2)
True在 3.10 版本发生变更: 增加了 strict 参数。
__import__(name, globalsNone, localsNone, fromlist(), level0)
备注 与 importlib.import_module() 不同这是一个日常 Python 编程中不需要用到的高级函数。
此函数会由 import 语句发起调用。 它可以被替换 (通过导入 builtins 模块并赋值给 builtins.__import__) 以便修改 import 语句的语义但是 强烈 不建议这样做因为使用导入钩子 (参见 PEP 302) 通常更容易实现同样的目标并且不会导致代码问题因为许多代码都会假定所用的是默认实现。 同样也不建议直接使用 __import__() 而应该用 importlib.import_module()。
本函数会导入模块 name利用 globals 和 locals 来决定如何在包的上下文中解释该名称。fromlist 给出了应从 name 模块中导入的对象或子模块的名称。标准的实现代码完全不会用到 locals 参数只用到了 globals 用于确定 import 语句所在的包上下文。
level 指定是使用绝对还是相对导入。 0 (默认值) 意味着仅执行绝对导入。 level 为正数值表示相对于模块调用 __import__() 的目录将要搜索的父目录层数 (详情参见 PEP 328)。
当 name 变量的形式为 package.module 时通常将会返回最高层级的包第一个点号之前的名称而 不是 以 name 命名的模块。 但是当给出了非空的 fromlist 参数时则将返回以 name 命名的模块。
例如语句 import spam 的结果将为与以下代码作用相同的字节码:
spam __import__(spam, globals(), locals(), [], 0)语句 import spam.ham 的结果将为以下调用:
spam __import__(spam.ham, globals(), locals(), [], 0)请注意在这里 __import__() 是如何返回顶层模块的因为这是通过 import 语句被绑定到特定名称的对象。
另一方面语句 from spam.ham import eggs, sausage as saus 的结果将为
_temp __import__(spam.ham, globals(), locals(), [eggs, sausage], 0)
eggs _temp.eggs
saus _temp.sausage在这里 spam.ham 模块会由 __import__() 返回。 要导入的对象将从此对象中提取并赋值给它们对应的名称。
如果您只想按名称导入模块可能在包中请使用 importlib.import_module()
在 3.3 版本发生变更: level 的值不再支持负数默认值也修改为0。
在 3.9 版本发生变更: 当使用了命令行参数 -E 或 -I 时环境变量 PYTHONCASEOK 现在将被忽略。 参考
内置函数 — Python 3.12.2 文档
