内置函数

# 内置函数

Python 解释器内置了很多函数和类型，您可以在任何时候使用它们。以下按字母表顺序列出它们。

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

# 使用方法

# `abs`(x)

返回一个数的绝对值。参数可以是一个整数或浮点数。如果参数是一个复数，则返回它的模。如果 x 定义了

>>> abs(-1)
1
>>> abs(-1.2)
1.2

1
2
3
4

# `all`(iterable)

如果 iterable 的所有元素均为真值（或可迭代对象为空）则返回 True

>>> li = [1, 2, 3, 0]
>>> all(li)
False

1
2
3

# `any`(iterable)

如果 iterable 的任一元素为真值则返回 True。如果可迭代对象为空，返回 False

>>> li = [1, 2, 3, 0]
>>> any(li)
True

1
2
3

# `ascii`(object)

就像函数 repr() (opens new window)，返回一个对象可打印的字符串，但是 repr() (opens new window) 返回的字符串中非 ASCII 编码的字符，会使用 \x、\u 和 \U 来转义。生成的字符串和 Python 2 的 repr() (opens new window) 返回的结果相似。

>>> ascii("a")
"'a'"
>>> ascii(10)
'10'

1
2
3
4

# `bin`(x)

将一个整数转变为一个前缀为“0b”的二进制字符串。结果是一个合法的 Python 表达式。如果 x 不是 Python 的 int (opens new window) 对象，那它需要定义 __index__() (opens new window) 方法返回一个整数。

>>> bin(3)
'0b11'
>>> bin(-10)
'-0b1010'

1
2
3
4

如果不一定需要前缀“0b”，还可以使用如下的方法。

>>> format(14, '#b'), format(14, 'b')
('0b1110', '1110')
>>> f'{14:#b}', f'{14:b}'
('0b1110', '1110')

1
2
3
4

# class `bool`([x])

返回一个布尔值，True 或者 False。 x 使用标准的真值测试过程 (opens new window) 来转换。如果 x 是假的或者被省略，返回 False；其他情况返回 True。bool (opens new window) 类是 int (opens new window) 的子类（参见数字类型 --- int, float, complex (opens new window)）。其他类不能继承自它。它只有 False 和 True 两个实例（参见布尔值 (opens new window)）。

>>> bool(10)
True
>>> bool(0)
False

1
2
3
4

# `breakpoint`(**args*, ***kws*)

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

引发一个审计事件 (opens new window) builtins.breakpoint 并附带参数 breakpointhook。

# class `bytearray`

class bytearray([source[, encoding[, errors]]])

返回一个新的 bytes 数组。 bytearray (opens new window) 类是一个可变序列，包含范围为 0 <= x < 256 的整数。它有可变序列大部分常见的方法，见可变序列类型 (opens new window) 的描述；同时有 bytes (opens new window) 类型的大部分方法，参见 bytes 和 bytearray 操作 (opens new window)。

可选形参 source 可以用不同的方式来初始化数组：

如果是一个 string，您必须提供 encoding 参数（errors 参数仍是可选的）；bytearray() (opens new window) 会使用 str.encode() (opens new window) 方法来将 string 转变成 bytes。
如果是一个 integer，会初始化大小为该数字的数组，并使用 null 字节填充。
如果是一个符合 buffer 接口的对象，该对象的只读 buffer 会用来初始化字节数组。
如果是一个 iterable 可迭代对象，它的元素的范围必须是 0 <= x < 256 的整数，它会被用作数组的初始内容。

如果没有实参，则创建大小为 0 的数组。

>>> bytearray()
bytearray(b'')

>>> bytearray(10)
bytearray(b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')

>>> bytearray("python")
Traceback (most recent call last):
  File "<pyshell#42>", line 1, in <module>
    bytearray("python")
TypeError: string argument without an encoding
    
>>> bytearray("python", encoding='utf-8')
bytearray(b'python')

>>> bytearray(b'python')
bytearray(b'python')

>>> bytearray([1, 2, 3])
bytearray(b'\x01\x02\x03')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

# class `bytes`

class bytes([source[, encoding[, errors]]])

返回一个新的“bytes”对象，是一个不可变序列，包含范围为 0 <= x < 256 的整数。bytes (opens new window) 是 bytearray (opens new window) 的不可变版本 - 它有其中不改变序列的方法和相同的索引、切片操作。

因此，构造函数的实参和 bytearray() (opens new window) 相同

>>> bytes()
b''
>>> bytes(10)
b'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
>>> bytes('python')
Traceback (most recent call last):
  File "<pyshell#47>", line 1, in <module>
    bytes('python')
TypeError: string argument without an encoding
>>> bytes('python', encoding='utf-8')
b'python'

>>> bytes([1, 2, 3])
b'\x01\x02\x03'

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# `callable`(object)

**如果参数 object 是可调用的就返回 True，否则返回False。** 如果返回True，调用仍可能失败，但如果返回False，则调用 *object* 将肯定不会成功。请注意类是可调用的（调用类将返回一个新的实例）；如果实例所属的类有 [call()`](https://docs.python.org/zh-cn/3/reference/datamodel.html#object.call) 则它就是可调用的。

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

>>> def demo():
	print('callable')

>>> callable(demo)
True

>>> a = 'python'
>>> callable(a)
False

1
2
3
4
5
6
7
8
9

# `chr`(i)

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

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

>>> chr(97)
'a'
>>> chr(121)
'y'

1
2
3
4

对应的是ord(i)

>>> ord('a')
97
>>> ord('y')
121

1
2
3
4

# `@classmethod`

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

一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。请用以下习惯来声明类方法:

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

1
2
3

# `compile()`

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

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

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

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

可选参数 flags 和 dont_inherit 控制在编译 source 时要用到哪个 future 语句 (opens new window)。如果两者都未提供（或都为零）则会使用调用 compile() (opens new window) 的代码中有效的 future 语句来编译代码。如果给出了 flags 参数但没有 dont_inherit (或是为零) 则 flags 参数所指定的以及那些无论如何都有效的 future 语句会被使用。如果 dont_inherit 为一个非零整数，则只使用 flags 参数 -- 在调用外围有效的 future 语句将被忽略。

Future 语句使用比特位来指定，多个语句可以通过按位或来指定。具体特性的比特位可以通过 __future__ (opens new window) 模块中的 _Feature 类的实例的 compiler_flag 属性来获得。

可选参数 flags 还会控制是否允许编译的源码中包含最高层级 await, async for 和 async with。当设定了比特位 ast.PyCF_ALLOW_TOP_LEVEL_AWAIT 时，所返回代码对象在 co_code 中设定了 CO_COROUTINE，并可通过 await eval(code_object) 交互式地执行。

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

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

>>> x = compile('print(78)', 'test', 'eval')

>>> exec(x)
78

1
2
3
4

# class `complex`()

class complex([real[, imag]])

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

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

>>> complex(12, 2)
(12+2j)

>>> complex('1+2j')
(1+2j)

>>> complex('1 + 2j')
Traceback (most recent call last):
  File "<pyshell#69>", line 1, in <module>
    complex('1 + 2j')
ValueError: complex() arg is a malformed string

1
2
3
4
5
6
7
8
9
10
11

# delattr(object, name)

setattr()相关的函数。实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。例如delattr(x, 'foobar') 等价于del x.foobar。

class Coordinate:
    x = 10
    y = -5
    z = 0
 
point1 = Coordinate() 
 
print('x = ',point1.x)
print('y = ',point1.y)
print('z = ',point1.z)
 
delattr(Coordinate, 'z')
 
print('--删除 z 属性后--')
print('x = ',point1.x)
print('y = ',point1.y)
 
# 触发错误
print('z = ',point1.z)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# class dict()

class dict(***kwarg)
class dict(mapping, **kwarg)
class dict(iterable, **kwarg)

创建一个新的字典。dict 对象是一个字典类。参见 dict 和映射类型 --- dict 了解这个类。

其他容器类型，请参见内置的 list、set 和 tuple 类，以及 collections 模块。

>>> dict()   # 创建空字典
{}

>>> dict(a='a', b='b', t='t')# 传入关键字
{'a': 'a', 'b': 'b', 't': 't'}

>>> dict(zip(['one', 'two', 'three'], [1, 2, 3])) # 映射函数方式来构造字典
{'one': 1, 'two': 2, 'three': 3}

>>> dict([('one', 1), ('two', 2), ('three', 3)])  # 可迭代对象方式来构造字典
{'one': 1, 'two': 2, 'three': 3}

1
2
3
4
5
6
7
8
9
10
11

# `dir`([object])

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

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

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

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

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

返回的列表按字母表排序。例如：

>>> dir() #获取当前模块的属性名称
['Dog', '__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__', 'a', 'demo', 'x']


>>> class Shape:
	def __dir__(self): #自定义dir
		return ['area', 'perimeter', 'location']

	
>>> s = Shape()
>>> dir(s) 
['area', 'location', 'perimeter']

1
2
3
4
5
6
7
8
9
10
11
12

# `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) 。

>>> divmod(1, 2)
(0, 1)
>>> divmod(10, 2)
(5, 0)

1
2
3
4

# `enumerate`()

enumerate(iterable, start=0)

返回一个枚举对象。iterable 必须是一个序列，或 iterator (opens new window)，或其他支持迭代的对象。 enumerate() (opens new window) 返回的迭代器的 __next__() (opens new window) 方法返回一个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。

等价于：

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

1
2
3
4
5

>>> seasons = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(seasons))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(seasons, start=1))
[(1, 'Spring'), (2, 'Summer'), (3, 'Fall'), (4, 'Winter')]

1
2
3
4
5

# `eval`()

eval(expression[, globals[, locals]])

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

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

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

>>> x = 1
>>> eval('x+1')
2

>>> eval('print("python")')
python

1
2
3
4
5
6

# `exec`()

exec(object[, globals[, locals]])

这个函数支持动态执行 Python 代码。object 必须是字符串或者代码对象。如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。1 (opens new window) 如果是代码对象，它将被直接执行。在任何情况下，被执行的代码都需要和文件输入一样是有效的（见参考手册中关于文件输入的章节）。请注意即使在传递给 exec() (opens new window) 函数的代码的上下文中，return (opens new window) 和 yield (opens new window) 语句也不能在函数定义之外使用。该函数返回值是 None 。

>>>exec('print("Hello World")')
Hello World
# 单行语句字符串
>>> exec("print ('python')")
python
 
#  多行语句字符串
>>> exec ("""for i in range(5):
...     print ("iter time: %d" % i)
... """)
iter time: 0
iter time: 1
iter time: 2
iter time: 3
iter time: 4

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# `filter`()

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() (opens new window) 了解，只有 function 返回 false 时才选取 iterable 中元素的补充函数。

#过滤出列表中的所有奇数
>>> def is_odd(n):
	return n % 2 == 1

>>> list(filter(is_odd, [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]))
[1, 3, 5, 7, 9]

1
2
3
4
5
6
7
8

# class `float`([x])

返回从数字或字符串 x 生成的浮点数。

>>> float(121)
121.0
>>> float(-1)
-1.0

>>> float('+1.23')
1.23
>>> float('   -12345\n')
-12345.0
>>> float('1e-003')
0.001
>>> float('+1E6')
1000000.0
>>> float('-Infinity')
-inf

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# `format`()

format(value[, format_spec])

将 value 转换为 format_spec 控制的**“格式化”**表示。format_spec 的解释取决于 value 实参的类型，但是大多数内置类型使用标准格式化语法：格式规格迷你语言 (opens new window)。

默认的 format_spec 是一个空字符串，它通常和调用 str(value) (opens new window) 的结果相同。

调用 format(value, format_spec) 会转换成 type(value).__format__(value, format_spec) ，所以实例字典中的 __format__() (opens new window) 方法将不会调用。如果搜索到 object (opens new window) 有这个方法但 format_spec 不为空，format_spec 或返回值不是字符串，会触发 TypeError (opens new window) 异常。

不设置参数：

>>>"{} {}".format("hello", "world")    # 不设置指定位置，按默认顺序
'hello world'
 
>>> "{0} {1}".format("hello", "world")  # 设置指定位置
'hello world'
 
>>> "{1} {0} {1}".format("hello", "world")  # 设置指定位置
'world hello world'

1
2
3
4
5
6
7
8

设置参数：

>>> print("url:{path}, author:{name}".format(name='xql', path='xuqilong.top'))
url:xuqilong.top, author:xql
   
# 通过字典设置参数
>>> print("网站名:{name}, 地址: {url}".format(**site))
网站名:xql, 地址: www.xuqilong.com
>>> my_list = ['xql', 'www.xuqilong.com']

# 通过列表索引设置参数
>>> print("网站名:{0[0]}, 地址:{0[1]}".format(my_list))
网站名:xql, 地址:www.xuqilong.com

1
2
3
4
5
6
7
8
9
10
11

也可以向 str.format() 传入对象：

class AssignValue(object):
    def __init__(self, value):
        self.value = value
my_value = AssignValue(6)
print('value 为: {0.value}'.format(my_value))  # "0" 是可选的

1
2
3
4
5

数字格式化

下表展示了 str.format() 格式化数字的多种方法：

>>> print("{:.2f}".format(3.1415926));
3.14

1
2

数字	格式	输出	描述
3.1415926	{:.2f}	3.14	保留小数点后两位
3.1415926	{:+.2f}	+3.14	带符号保留小数点后两位
-1	{:+.2f}	-1.00	带符号保留小数点后两位
2.71828	{:.0f}	3	不带小数
5	{:0>2d}	05	数字补零 (填充左边, 宽度为2)
5	{:x<4d}	5xxx	数字补x (填充右边, 宽度为4)
10	{:x<4d}	10xx	数字补x (填充右边, 宽度为4)
1000000	{:,}	1,000,000	以逗号分隔的数字格式
0.25	{:.2%}	25.00%	百分比格式
1000000000	{:.2e}	1.00e+09	指数记法
13	{:>10d}	13	右对齐 (默认, 宽度为10)
13	{:<10d}	13	左对齐 (宽度为10)
13	{:^10d}	13	中间对齐 (宽度为10)
11	`'{:b}'.format(11) '{:d}'.format(11) '{:o}'.format(11) '{:x}'.format(11) '{:#x}'.format(11) '{:#X}'.format(11)`	`1011 11 13 b 0xb 0XB`	进制

^, <, > 分别是居中、左对齐、右对齐，后面带宽度， : 号后面带填充的字符，只能是一个字符，不指定则默认是用空格填充。

+ 表示在正数前显示 +，负数前显示 -；（空格）表示在正数前加空格

b、d、o、x 分别是二进制、十进制、八进制、十六进制。

此外我们可以使用大括号 {} 来转义大括号，如下实例：

>>> print ("{} 对应的位置是 {{0}}".format("xuqilong"))
xuqilong 对应的位置是 {0}

1
2

# class `frozenset`([iterable])

返回一个新的 frozenset (opens new window) 对象，它包含可选参数 iterable 中的元素。 frozenset 是一个内置的类。有关此类的文档，请参阅 frozenset (opens new window) 和集合类型 --- set, frozenset (opens new window)。

frozenset() 返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。

>>> a = frozenset(range(10))     # 生成一个新的不可变集合
>>> a
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> b = frozenset('xuqilong')
>>> b
frozenset({'l', 'i', 'u', 'g', 'q', 'x', 'o', 'n'})  # 创建不可变集合

1
2
3
4
5
6

# `getattr`()

getattr(object, name[, default])

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

>>> class A:
	bar = 1

	
>>> a = A()
>>> getattr(a, 'bar')   	 # 获取属性 bar 值
1
>>> getattr(a, 'bar2')  	 # 属性 bar2 不存在，触发异常
Traceback (most recent call last):
  File "<pyshell#26>", line 1, in <module>
    getattr(a, 'bar2')
AttributeError: 'A' object has no attribute 'bar2'
    
>>> getattr(a, 'bar2', 3)    # 属性 bar2 不存在，但设置了默认值
3

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# `globals`()

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

>>> x = 'xuqilong'
>>> globals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'x': 'xuqilong'}

1
2
3

# `hasattr`()

hasattr(object, name)

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

>>> class A:
	dog = 'dog'
	cat = 'cat'

	
>>> a = A()
>>> hasattr(a, 'dog')
True
>>> hasattr(a, 'cat')    #有该属性
True
>>> hasattr(a, 'person') # 没有该属性
False

1
2
3
4
5
6
7
8
9
10
11
12

# `hash`(object)

返回该对象的哈希值（如果它有的话）。哈希值是整数。它们在字典查找元素时用来快速比较字典的键。相同大小的数字变量有相同的哈希值（即使它们类型不同，如 1 和 1.0）

注解:如果对象实现了自己的 __hash__() (opens new window) 方法，请注意，hash() (opens new window) 根据机器的字长来截断返回值。另请参阅 __hash__() (opens new window)。

hash() 函数可以应用于数字、字符串和对象，不能直接应用于 list、set、dictionary。

在 hash() 对对象使用时，所得的结果不仅和对象的内容有关，还和对象的 id()，也就是内存地址有关。

hash() 函数的对象字符不管有多长，返回的 hash 值都是固定长度的，也用于校验程序在传输过程中是否被第三方（木马）修改，如果程序（字符）在传输过程中被修改hash值即发生变化，如果没有被修改，则 hash 值和原始的 hash 值吻合，只要验证 hash 值是否匹配即可验证程序是否带木马（病毒)

>>> hash(1)
1
>>> hash(1.0)
1
>>> hash('python')
7437175883549891322

>>> hash(str([1,2,3]))
-4247514693075746618

>>> hash(str(sorted({'1':1})))
-5676264212747345357

1
2
3
4
5
6
7
8
9
10
11
12

# `help`([object])

启动内置的帮助系统（此函数主要在交互式中使用）。如果没有实参，解释器控制台里会启动交互式帮助系统。如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。如果实参是其他任意对象，则会生成该对象的帮助页。

进入帮助文档：

>>> help()

Welcome to Python 3.8'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.8/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> os

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

查看具体的帮助文档：

>>> import os
>>> help(os)

1
2
3

# `hex`(x)

将整数转换为以“0x”为前缀的小写十六进制字符串。如果 x 不是 Python int (opens new window) 对象，则必须定义返回整数的 __index__() (opens new window) 方法。

>>> hex(255)
'0xff'
>>> hex(-32)
'-0x20'
>>> hexo(10)
>>> hex(10)
'0xa'
>>> type(hex(10))
<class 'str'>

1
2
3
4
5
6
7
8
9
10

# `id`(object)

返回对象的“标识值”。该值是一个整数，在此对象的生命周期中保证是唯一且恒定的。两个生命期不重叠的对象可能具有相同的 id() (opens new window) 值。

>>> id(1)
140708311848608

>>> a = 2
>>> id(a)
140708311848640

>>> b = 2
>>> id(b)
140708311848640

1
2
3
4
5
6
7
8
9
10
11

# `input`([prompt])

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

>>> a = input()
python
>>> a
'python'

>>> s = input('--> ')
--> python
>>> s
'python'

1
2
3
4
5
6
7
8
9

# class `int`([x])

class int(x, base=10)

返回一个基于数字或字符串 x 构造的整数对象，或者在未给出参数时返回 0。如果 x 定义了 __int__() (opens new window)，int(x) 将返回 x.__int__()。如果 x 定义了 __index__() (opens new window)，它将返回 x.__index__()。如果 x 定义了 __trunc__() (opens new window)，它将返回 x.__trunc__()。对于浮点数，它将向零舍入。

如果 x 不是数字，或者有 base 参数，x 必须是字符串、bytes (opens new window)、表示进制为 base 的整数字面值 (opens new window) 的 bytearray (opens new window) 实例。该文字前可以有 + 或 - （中间不能有空格），前后可以有空格。一个进制为 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) 是合法的。

>>> int()     # 不传入参数时，得到结果0
0
>>> int(3)
3
>>> int(3.6)
3
>>> int('12', 16)    # 如果是带参数base的话，12要以字符串的形式进行输入，12 为 16进制
18
>>> int('0x1', 16)
1
>>> int('10', 8)
8

1
2
3
4
5
6
7
8
9
10
11
12

# `isinstance`(object, classinfo)

如果参数 object 是参数 classinfo 的实例或者是其 (直接、间接或虚拟 (opens new window)) 子类则返回 True。如果 object 不是给定类型的对象，函数将总是返回 False。如果 classinfo 是类型对象元组（或由其他此类元组递归组成的元组），那么如果 object 是其中任何一个类型的实例就返回 True。如果 classinfo 既不是类型，也不是类型元组或类型元组的元组，则将引发 TypeError (opens new window) 异常。

>>> isinstance(1, int)
True

>>> isinstance(1, str)
False

>>> isinstance(1, (str, int, list))  # 是元组中的一个返回 True
True

1
2
3
4
5
6
7
8

# `issubclass`(class, classinfo)

如果 class 是 classinfo 的 (直接、间接或虚拟 (opens new window)) 子类则返回 True。类会被视作其自身的子类。 classinfo 也以是类对象的元组，在此情况下 classinfo 中的每个条目都将被检查。在任何其他情况下，都将引发 TypeError (opens new window) 异常。

>>> class A:
	pass

>>> class B(A):
	pass

>>> issubclass(B, A)
True

1
2
3
4
5
6
7
8

# `iter`(object[, sentinel])

**返回一个 iterator (opens new window) 对象。**根据是否存在第二个实参，第一个实参的解释是非常不同的。如果没有第二个实参，object 必须是支持迭代协议（有 __iter__() (opens new window) 方法）的集合对象，或必须支持序列协议（有 __getitem__() (opens new window) 方法，且数字参数从 0 开始）。如果它不支持这些协议，会触发 TypeError (opens new window)。如果有第二个实参 sentinel，那么 object 必须是可调用的对象。这种情况下生成的迭代器，每次迭代调用它的 __next__() (opens new window) 方法时都会不带实参地调用 object；如果返回的结果是 sentinel 则触发 StopIteration (opens new window)，否则返回调用结果。

另请参阅迭代器类型 (opens new window)。

适合 iter() (opens new window) 的第二种形式的应用之一是构建块读取器。例如，从二进制数据库文件中读取固定宽度的块，直至到达文件的末尾:

from functools import partial
with open('mydata.db', 'rb') as f:
    for block in iter(partial(f.read, 64), b''):
        process_block(block)

1
2
3
4

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

	
1
2
3

1
2
3
4
5
6
7
8

# `len`(s)

返回对象的长度（元素个数）。实参可以是序列（如 string、bytes、tuple、list 或 range 等）或集合（如 dictionary、set 或 frozen set 等）。

>>> st = 'python'
>>> len(st)
6

1
2
3

# class `list`([iterable])

虽然被称为函数，list (opens new window) 实际上是一种可变序列类型，详情请参阅列表 (opens new window) 和序列类型 --- list, tuple, range (opens new window)。

>>> st = 'python'
>>> list(st)
['p', 'y', 't', 'h', 'o', 'n']

1
2
3

# `locals`()

更新并返回表示当前本地符号表的字典。在函数代码块但不是类代码块中调用 locals() (opens new window) 时将返回自由变量。请注意在模块层级上，locals() (opens new window) 和 globals() (opens new window) 是同一个字典。

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

>>> locals()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}

1
2

# `map`(function, iterable, ...)

返回一个将 function 应用于 iterable 中每一项并输出其结果的迭代器。如果传入了额外的 iterable 参数，function 必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。对于函数的输入已经是参数元组的情况，请参阅 itertools.starmap() (opens new window)。

>>> def square(x):   # 计算平方数
	return x ** 2

>>> map(square, [1, 2, 3, 4, 5, 6])
<map object at 0x0000023855B6CC40>

>>> list(map(square, [1, 2, 3, 4, 5, 6]))  # 计算列表各个元素的平方
[1, 4, 9, 16, 25, 36]

>>> list(map(lambda x: x ** 2, [1, 2, 3, 4, 5, 6]))  # 使用 lambda 匿名函数
[1, 4, 9, 16, 25, 36]

# 提供了两个列表，对相同位置的列表数据进行相加
>>> list(map(lambda x, y: x + y, [1, 3, 5, 7, 9], [2, 4, 6, 8, 10]))
[3, 7, 11, 15, 19]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# `max`()

max(iterable, ***[, key, default])

max(arg1, arg2, *args[, key])

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

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

>>> max([1, 2, 4, 3, 19, 21, 2])
21

1
2

# class `memoryview`(obj)

返回由给定实参创建的“内存视图”对象，即返回给定参数的内存查看对象(memory view)。

所谓内存查看对象，是指对支持缓冲区协议的数据进行包装，在不需要复制对象基础上允许Python代码访问。

>>>v = memoryview(bytearray("abcefg", 'utf-8'))
>>> print(v[1])
98
>>> print(v[-1])
103
>>> print(v[1:4])
<memory at 0x10f543a08>
>>> print(v[1:4].tobytes())
b'bce'
>>>

1
2
3
4
5
6
7
8
9
10

# `min`()

min(iterable, ***[, key, default])

min(arg1, arg2, *args[, key])

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

# `next`(iterator[, default])

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

next() 函数要和生成迭代器的iter() 函数一起使用。

>>> it = iter([1, 2, 3, 4, 5])  # 首先获得Iterator对象
>>> while True:
	try:
		x = next(it) # 获得下一个值
		print(x)

	except StopIteration: # 遇到StopIteration就退出循环
		break

	
1
2
3
4
5

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

# class `object`

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

由于 object (opens new window) 没有 __dict__ (opens new window)，因此无法将任意属性赋给 object (opens new window) 的实例。

# `oct`(x)

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

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70'

1
2
3
4

如果要将整数转换为八进制字符串，并可选择有无“0o”前缀，则可以使用如下方法：

>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

1
2
3
4
5
6

# `open()`

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

file: 必需，文件路径（相对或者绝对路径）。
mode: 可选，文件打开模式
buffering: 设置缓冲
encoding: 一般使用utf8
errors: 报错级别
newline: 区分换行符
closefd: 传入的file参数类型
opener

打开 file 并返回对应的 file object (opens new window)。如果该文件不能被打开，则引发 OSError (opens new window)。请参阅读写文件 (opens new window) 获取此函数的更多用法示例。

file 是一个 path-like object (opens new window)，表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径），也可以是要被封装的整数类型文件描述符。（如果是文件描述符，它会随着返回的 I/O 对象关闭而关闭，除非 closefd 被设为 False 。）

mode 是一个可选字符串，用于指定打开文件的模式。默认值是 'r' ，这意味着它以文本模式打开并读取。其他常见模式有：写入 'w' （截断已经存在的文件）；排它性创建 'x' ；追加写 'a' （在一些 Unix 系统上，无论当前的文件指针在什么位置，所有写入都会追加到文件末尾）。在文本模式，如果 encoding 没有指定，则根据平台来决定使用的编码：使用 locale.getpreferredencoding(False) 来获取本地编码。（要读取和写入原始字节，请使用二进制模式并不要指定 encoding。）可用的模式有：

字符	含义
`'r'`	读取（默认）
`'w'`	写入，并先截断文件
`'x'`	排它性创建，如果文件已存在则失败
`'a'`	写入，如果文件存在则在末尾追加
`'b'`	二进制模式
`'t'`	文本模式（默认）
`'+'`	打开用于更新（读取与写入）

式	描述
t	文本模式 (默认)。
x	写模式，新建一个文件，如果该文件已存在则会报错。
b	二进制模式。
+	打开一个文件进行更新(可读可写)。
U	通用换行模式（不推荐）。
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。一般用于非文本文件如图片等。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。一般用于非文本文件如图片等。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。一般用于非文本文件如图片等。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

默认模式为 'r' (打开用于读取文本，与 'rt' 同义)。模式 'w+' 与 'w+b' 将打开文件并清空内容。模式 'r+' 与 'r+b' 将打开文件并不清空内容。

正如在概述 (opens new window) 中提到的，Python区分二进制和文本I/O。以二进制模式打开的文件（包括 mode 参数中的 'b' ）返回的内容为 bytes对象，不进行任何解码。在文本模式下（默认情况下，或者在 mode 参数中包含 ``'t'）时，文件内容返回为 [str`](https://docs.python.org/zh-cn/3/library/stdtypes.html#str) ，首先使用指定的 encoding （如果给定）或者使用平台默认的的字节编码解码。

此外还允许使用一个模式字符 'U'，该字符已不再具有任何效果，并被视为已弃用。之前它会在文本模式中启用 universal newlines (opens new window)，这在 Python 3.0 中成为默认行为。请参阅 newline (opens new window) 形参的文档了解更多细节。

Python不依赖于底层操作系统的文本文件概念;所有处理都由Python本身完成，因此与平台无关。

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

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

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

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

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

newline 控制 universal newlines (opens new window) 模式如何生效（它仅适用于文本模式）。它可以是 None，''，'\n'，'\r' 和 '\r\n'。它的工作原理:

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

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

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

新创建的文件是不可继承的 (opens new window)。

下面的示例使用 os.open() (opens new window) 函数的 dir_fd (opens new window) 的形参，从给定的目录中用相对路径打开文件:

>>>

>>> 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)  # don't leak a file descriptor

1
2
3
4
5
6
7
8
9

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

另请参阅文件操作模块，例如 fileinput (opens new window)、io (opens new window) （声明了 open() (opens new window)）、os (opens new window)、os.path (opens new window)、tempfile (opens new window) 和 shutil (opens new window)。

引发一个审计事件 (opens new window) open 附带参数 file, mode, flags。

mode 与 flags 参数可以在原始调用的基础上被修改或传递。

# `ord`(c)

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数。例如 ord('a') 返回整数 97， ord('€') （欧元符号）返回 8364 。这是 chr() (opens new window) 的逆函数

ord() 函数是 chr() 函数（对于 8 位的 ASCII 字符串）的配对函数

>>> ord('a')
97
>>> ord('$')
36

>>> chr(97)
'a'
>>> chr(36)
'$'

1
2
3
4
5
6
7
8
9

# `pow`(base, exp[, mod])

返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。两参数形式 pow(base, exp) 等价于乘方运算符: base**exp。

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

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

下面的例子是 38 的倒数对 97 取余:

>>> pow(38, -1, mod=97)
23
>>> 23 * 38 % 97 == 1
True

>>> pow(2, 2)
4
>>> pow(2, 10)
1024
>>> pow(2, 10, mod=100)
24

1
2
3
4
5
6
7
8
9
10
11

# print()

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

将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。

所有非关键字参数都会被转换为字符串，就像是执行了 str() (opens new window) 一样，并会被写入到流，以 sep 且在末尾加上 end。 sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。如果没有给出 objects，则 print() (opens new window) 将只写入 end。

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

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

>>> print('xuqilong.top')
xuqilong.top
>>> print('xql''top')
xqltop
>>> print('xql', 'top')
xql top
>>> print('xql', end='$$')
xql$$
>>> print('xql', 'top', sep='.')
xql.top

1
2
3
4
5
6
7
8
9
10

>>> import time
>>> print(' flush 关键字参数为真值，流会被强制刷新')
 flush 关键字参数为真值，流会被强制刷新
>>> print('Loading', end='')
Loading
>>> for i in range(20):
	print('.', end='', flush=True)
	time.sleep(0.5)

	
...................

1
2
3
4
5
6
7
8
9
10
11

# class `property`()

class property(fget=None, fset=None, fdel=None, doc=None)¶ (opens new window)

返回 property 属性。

fget 是获取属性值的函数。 fset 是用于设置属性值的函数。 fdel 是用于删除属性值的函数。并且 doc 为属性对象创建文档字符串。

一个典型的用法是定义一个托管属性 x:

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.")

1
2
3
4
5
6
7
8
9
10
11
12
13
14

如果 c 是 C 的实例，c.x 将调用getter，c.x = value 将调用setter， del c.x 将调用deleter。

如果给出，doc 将成为该 property 属性的文档字符串。否则该 property 将拷贝 fget 的文档字符串（如果存在）。这令使用 property() (opens new window) 作为 decorator (opens new window) 来创建只读的特征属性可以很容易地实现:

class Parrot:
    def __init__(self):
        self._voltage = 100000

    @property
    def voltage(self):
        """Get the current voltage."""
        return self._voltage

1
2
3
4
5
6
7
8

以上 @property 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性的 "getter"，并将 voltage 的文档字符串设置为 "Get the current voltage."

特征属性对象具有 getter, setter 以及 deleter 方法，它们可用作装饰器来创建该特征属性的副本，并将相应的访问函数设为所装饰的函数。这最好是用一个例子来解释:

    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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

上述代码与第一个例子完全等价。注意一定要给附加函数与原始的特征属性相同的名称 (在本例中为 x。)

返回的特征属性对象同样具有与构造器参数相对应的属性 fget, fset 和 fdel。

# class `range`()

class range(stop)

class range(start, stop[, step])

虽然被称为函数，但 range (opens new window) 实际上是一个不可变的序列类型，参见在 range 对象 (opens new window) 与序列类型 --- list, tuple, range (opens new window) 中的文档说明。

参数说明：

start: 计数从 start 开始。默认是从 0 开始。例如range（5）等价于range（0， 5）;
stop: 计数到 stop 结束，但不包括 stop。例如：range（0， 5）是[0, 1, 2, 3, 4]没有5
step：步长，默认为1。例如：range（0， 5）等价于 range(0, 5, 1)

>>> range(5)
range(0, 5)
>>> for i in range(5):
	print(i)

	
0
1
2
3
4

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

>>> list(range(0))
[]

>>> list(range(0, 30, 5))
[0, 5, 10, 15, 20, 25]

>>> list(range(0, -10, -1))
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

# `repr`(object)

返回包含一个对象的可打印表示形式的字符串(repr() 函数将对象转化为供解释器读取的形式)。对于许多类型来说，该函数会尝试返回的字符串将会与该对象被传递给 eval() (opens new window) 时所生成的对象具有相同的值，在其他情况下表示形式会是一个括在尖括号中的字符串，其中包含对象类型的名称与通常包括对象名称和地址的附加信息。类可以通过定义 __repr__() (opens new window) 方法来控制此函数为它的实例所返回的内容。

>>> s = 'python'
>>> repr(s)
"'python'"

>>> repr(dic)
"{'xql': 'xuqilong.top'}"

1
2
3
4
5
6

# `reversed`(seq)

返回一个反向的 iterator (opens new window)。 seq 必须是一个具有 __reversed__() (opens new window) 方法的对象或者是支持该序列协议（具有从 0 开始的整数类型参数的 __len__() (opens new window) 方法和 __getitem__() (opens new window) 方法）。

>>> a = [1, 2, 3, 4, 5]
>>> reversed(a)
<list_reverseiterator object at 0x00000247F7C5CA60>
>>> list(reversed(a))
[5, 4, 3, 2, 1]

1
2
3
4
5

# `round`(number[, ndigits])

返回浮点数 x 的四舍五入值，准确的说保留值将保留到离上一位更近的一端（四舍六入）。精度要求高的，不建议使用该函数。

number-- 数字表达式。
ndigits -- 表示从小数点位数，其中 x 需要四舍五入，默认值为 0。

>>> round(70.23456)
70
>>> round(56.659,1)
56.7
>>> round(56.659,1)
56.7
>>> round(-100.000056, 3)
-100.0

1
2
3
4
5
6
7
8

对浮点数执行 round() (opens new window) 的行为可能会令人惊讶：例如，round(2.675, 2) 将给出 2.67 而不是期望的 2.68。这不算是程序错误：这一结果是由于大多数十进制小数实际上都不能以浮点数精确地表示。请参阅浮点算术：争议和限制 (opens new window) 了解更多信息。

# class `set`([iterable])

返回一个新的 set (opens new window) 对象，可以选择带有从 iterable 获取的元素。 set 是一个内置类型。请查看 set (opens new window) 和集合类型 --- set, frozenset (opens new window) 获取关于这个类的文档。

set() 函数创建一个无序不重复元素集，可进行关系测试，删除重复数据，还可以计算交集、差集、并集等。

>>> set('python hhh')
{'o', 'y', ' ', 'h', 'p', 't', 'n'}

1
2

# `setattr`()

setattr(object, name, value)

此函数与 getattr() (opens new window) 两相对应。其参数为一个对象、一个字符串和一个任意值。字符串指定一个现有属性或者新增属性。函数会将值赋给该属性，只要对象允许这种操作。例如，setattr(x, 'foobar', 123) 等价于 x.foobar = 123。

>>>class A(object):
...     bar = 1
... 
>>> a = A()
>>> getattr(a, 'bar')          # 获取属性 bar 值
1
>>> setattr(a, 'bar', 5)       # 设置属性 bar 值
>>> a.bar
5

1
2
3
4
5
6
7
8
9

# class `slice`()

class slice(stop)

class slice(start, stop[, step])

返回一个表示由 range(start, stop, step) 所指定索引集的 slice (opens new window) 对象。其中 start 和 step 参数默认为 None。切片对象具有仅会返回对应参数值（或其默认值）的只读数据属性 start, stop 和 step。它们没有其他的显式功能；不过它们会被 NumPy 以及其他第三方扩展所使用。切片对象也会在使用扩展索引语法时被生成。例如: a[start:stop:step] 或 a[start:stop, i]。请参阅 itertools.islice() (opens new window) 了解返回迭代器的一种替代版本

>>>myslice = slice(5)    # 设置截取5个元素的切片
>>> myslice
slice(None, 5, None)
>>> arr = range(10)
>>> arr
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> arr[myslice]         # 截取 5 个元素
[0, 1, 2, 3, 4]
>>>

1
2
3
4
5
6
7
8
9

# sorted()

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

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

具有两个可选参数，它们都必须指定为关键字参数。

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

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

使用 functools.cmp_to_key() (opens new window) 可将老式的 cmp 函数转换为 key 函数。

内置的 sorted() (opens new window) 确保是稳定的。如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的 --- 这有利于进行多重排序（例如先按部门、再按薪级排序）

sort 与 sorted 区别：

sort 是应用在 list 上的方法，sorted 可以对所有可迭代的对象进行排序操作。

list 的 sort 方法返回的是对已经存在的列表进行操作，而内建函数 sorted 方法返回的是一个新的 list，而不是在原来的基础上进行的操作。

>>> sorted([5, 
            2, 3, 1, 4])
[1, 2, 3, 4, 5]
>>> sorted({1: 'D', 2: 'B', 3: 'B', 4: 'E', 5: 'A'})
[1, 2, 3, 4, 5]

>>> example_list = [5, 0, 6, 1, 2, 7, 3, 4]
>>> sorted(example_list, key=lambda x: x*-1)
[7, 6, 5, 4, 3, 2, 1, 0]

>>> sorted(example_list, reverse=True)
[7, 6, 5, 4, 3, 2, 1, 0]

1
2
3
4
5
6
7
8
9
10
11
12

# `@staticmethod`

将方法转换为静态方法。

静态方法不会接收隐式的第一个参数。要声明一个静态方法，请使用此语法

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

1
2
3

@staticmethod 这样的形式称为函数的 decorator (opens new window) -- 详情参阅函数定义 (opens new window)。

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

Python中的静态方法与Java或C ++中的静态方法类似。另请参阅 classmethod() (opens new window) ，用于创建备用类构造函数的变体。

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

class C:
    builtin_open = staticmethod(open)

1
2

# class `str`()

class str(object='')

class str(object=b'', encoding='utf-8', errors='strict')

返回一个 str (opens new window) 版本的 object 。有关详细信息，请参阅 str() (opens new window) 。

str 是内置字符串 class (opens new window) 。更多关于字符串的信息查看文本序列类型 --- str (opens new window)。

>>> str(1)
'1'

1
2

# `sum`(iterable, /, start=0)

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

对某些用例来说，存在 sum() (opens new window) 的更好替代。拼接字符串序列的更好更快方式是调用 ''.join(sequence)。要以扩展精度对浮点值求和，请参阅 math.fsum() (opens new window)。要拼接一系列可迭代对象，请考虑使用 itertools.chain() (opens new window)。

>>>sum([0,1,2])  
3  
>>> sum((2, 3, 4), 1)        # 元组计算总和后再加 1
10
>>> sum([0,1,2,3,4], 2)      # 列表计算总和后再加 2
12

1
2
3
4
5
6

# super()

super([type[, object-or-type]])

super() 函数是用于调用父类(超类)的一个方法。

super 是用来解决多重继承问题的，直接用类名调用父类方法在使用单继承的时候没问题，但是如果使用多继承，会涉及到查找顺序（MRO）、重复调用（钻石继承）等种种问题。

MRO 就是类的方法解析顺序表, 其实也就是继承父类方法时的顺序表。

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

1
2
3
4
5
6
7
8
9

class FooParent(object):
    def __init__(self):
        self.parent = 'I\'m the parent.'
        print ('Parent')
    
    def bar(self,message):
        print ("%s from Parent" % message)
 
class FooChild(FooParent):
    def __init__(self):
        # super(FooChild,self) 首先找到 FooChild 的父类（就是类 FooParent），然后把类 FooChild 的对象转换为类 FooParent 的对象
        super(FooChild,self).__init__()    
        print ('Child')
        
    def bar(self,message):
        super(FooChild, self).bar(message)
        print ('Child bar fuction')
        print (self.parent)
 
if __name__ == '__main__':
    fooChild = FooChild()
    fooChild.bar('HelloWorld')

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

# class `tuple`([iterable])

虽然被称为函数，但 tuple (opens new window) 实际上是一个不可变的序列类型，参见在元组 (opens new window) 与序列类型 --- list, tuple, range (opens new window) 中的文档说明。

>>> a = [1, 2, 3, 4, 5]
>>> tuple(a)
(1, 2, 3, 4, 5)

1
2
3

# class type()

class type(object)

class type(name, bases, dict)

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

isinstance() 与 type() 区别：

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

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

如果要判断两个类型是否相同推荐使用 isinstance()。

推荐使用 isinstance() (opens new window) 内置函数来检测对象的类型，因为它会考虑子类的情况。

传入三个参数时，返回一个新的 type 对象。这在本质上是 class (opens new window) 语句的一种动态形式。 name 字符串即类名并且会成为 __name__ (opens new window) 属性；bases 元组列出基类并且会成为 __bases__ (opens new window) 属性；而 dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 __dict__ (opens new window) 属性。例如，下面两条语句会创建相同的 type (opens new window) 对象:

class X:
    a = 1

X = type('X', (object,), dict(a=1))

1
2
3
4

# `vars`([object])

返回模块、类、实例或任何其它具有 __dict__ (opens new window) 属性的对象的 __dict__ (opens new window) 属性。

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

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

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

# `zip`(**iterables*)s

创建一个聚合了来自每个可迭代对象中的元素的迭代器。

返回一个元组的迭代器，其中的第 i 个元组包含来自每个参数序列或可迭代对象的第 i 个元素。当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。当只有一个可迭代对象参数时，它将返回一个单元组的迭代器。不带参数时，它将返回一个空迭代器。相当于:

def zip(*iterables):
    # zip('ABCD', 'xy') --> Ax By
    sentinel = object()
    iterators = [iter(it) for it in iterables]
    while iterators:
        result = []
        for it in iterators:
            elem = next(it, sentinel)
            if elem is sentinel:
                return
            result.append(elem)
        yield tuple(result)

1
2
3
4
5
6
7
8
9
10
11
12

函数会保证可迭代对象按从左至右的顺序被求值。使得可以通过 zip(*[iter(s)]*n) 这样的惯用形式将一系列数据聚类为长度为 n 的分组。这将重复 同样的 迭代器 n 次，以便每个输出的元组具有第 n 次调用该迭代器的结果。它的作用效果就是将输入拆分为长度为 n 的数据块。

当你不用关心较长可迭代对象末尾不匹配的值时，则 zip() (opens new window) 只须使用长度不相等的输入即可。如果那些值很重要，则应改用 itertools.zip_longest() (opens new window)。

zip() (opens new window) 与 * 运算符相结合可以用来拆解一个列表:

>>> x = [1, 2, 3]
>>> y = [4, 5, 6]
>>> zipped = zip(x, y)
>>> list(zipped)
[(1, 4), (2, 5), (3, 6)]

>>> x2, y2 = zip(*zip(x, y))
>>> x2
(1, 2, 3)
>>> y2
(4, 5, 6)

>>> x == list(x2) and y == list(y2)
True

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# `import()`

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

与 importlib.import_module() (opens new window) 不同，这是一个日常 Python 编程中不需要用到的高级函数。

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

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

以下实例展示了 import 的使用方法：

import os  
 
print ('在 a.py 文件中 %s' % id(os))

1
2
3

import sys  
__import__('a')        # 导入 a.py 模块

1
2

上次更新: 2024/05/29, 14:25:22

← python进阶

内置函数

# 内置函数

# 使用方法

# abs(x)

# all(iterable)

# any(iterable)

# ascii(object)

# bin(x)

# class bool([x])

# breakpoint(*args, **kws)

# class bytearray

# class bytes

# callable(object)

# chr(i)

# @classmethod

# compile()

# class complex()

# delattr(object, name)

# class dict()

# dir([object])

# divmod(a, b)

# enumerate()

# eval()

# exec()

# filter()

# class float([x])

# format()

# class frozenset([iterable])

# getattr()

# globals()

# hasattr()

# hash(object)

# help([object])

# hex(x)

# id(object)

# input([prompt])

# class int([x])

# isinstance(object, classinfo)

# issubclass(class, classinfo)

# iter(object[, sentinel])

# len(s)

# class list([iterable])

# locals()

# map(function, iterable, ...)

# max()

# class memoryview(obj)

# min()

# next(iterator[, default])

# class object

# oct(x)

# open()

# ord(c)

# pow(base, exp[, mod])

# print()

# class property()

# class range()

# repr(object)

# reversed(seq)

# round(number[, ndigits])

# class set([iterable])

# setattr()

# class slice()

# sorted()

# @staticmethod

# class str()

# sum(iterable, /, start=0)

# super()

# class tuple([iterable])

# class type()

# vars([object])

# zip(*iterables)s

# __import__()

评论

# `abs`(x)

# `all`(iterable)

# `any`(iterable)

# `ascii`(object)

# `bin`(x)

# class `bool`([x])

# `breakpoint`(**args*, ***kws*)

# class `bytearray`

# class `bytes`

# `callable`(object)

# `chr`(i)

# `@classmethod`

# `compile()`

# class `complex`()

# `dir`([object])

# `divmod`(a, b)

# `enumerate`()

# `eval`()

# `exec`()

# `filter`()

# class `float`([x])

# `format`()

# class `frozenset`([iterable])

# `getattr`()

# `globals`()

# `hasattr`()

# `hash`(object)

# `help`([object])

# `hex`(x)

# `id`(object)

# `input`([prompt])

# class `int`([x])

# `isinstance`(object, classinfo)

# `issubclass`(class, classinfo)

# `iter`(object[, sentinel])

# `len`(s)

# class `list`([iterable])

# `locals`()

# `map`(function, iterable, ...)

# `max`()

# class `memoryview`(obj)

# `min`()

# `next`(iterator[, default])

# class `object`

# `oct`(x)

# `open()`

# `ord`(c)

# `pow`(base, exp[, mod])

# class `property`()

# class `range`()

# `repr`(object)

# `reversed`(seq)

# `round`(number[, ndigits])

# class `set`([iterable])

# `setattr`()

# class `slice`()

# `@staticmethod`

# class `str`()

# `sum`(iterable, /, start=0)

# class `tuple`([iterable])

# `vars`([object])

# `zip`(**iterables*)s

# `import()`