内置函数 abs()，Python 官方文档描述如下：
help(abs)
Help on built-in function abs in module builtins:
abs(x, /)
Return the absolute value of the argument.
返回一个数的绝对值，参数可以是整数、浮点数或任何实现了 __abs__() 的对象。如果参数是一
个复数，则返回它的模。
abs(-1)
1
abs(-3.14)
3.14
abs(3+4j)
5.0
内置函数 all()，Python 官方文档描述如下：
help(all)
Help on built-in function all in module builtins:
all(iterable, /)
Return True if bool(x) is True for all values x in the iterable.
If the iterable is empty, return True.
如果可迭代对象（iterable）的所有元素均为真值（或可迭代对象为空）则返回 True 。
all('0123') # 字符串 '0' 是真值
True
all([0,1,2,3])
False
all({})
True
all({1:[], 2:0 })
True
内置函数 any()，Python 官方文档描述如下：
help(any)
Help on built-in function any in module builtins:
any(iterable, /)
Return True if bool(x) is True for any x in the iterable.
If the iterable is empty, return False.
如果可迭代对象（iterable）的任一元素为真值则返回 True。如果可迭代对象为空，返回 False。
any([0,1])
True
any((None, [], range(1,1)))
False
内置函数 ascii()，Python 官方文档描述如下：
help(ascii)
Help on built-in function ascii in module builtins:
ascii(obj, /)
Return an ASCII-only representation of an object.
As repr(), return a string containing a printable representation of an
object, but escape the non-ASCII characters in the string returned by
repr() using \\x, \\u or \\U escapes. This generates a string similar
to that returned by repr() in Python 2.
就像函数 repr()，返回一个对象可打印的字符串，但是非 ASCII 编码的字符，会使用 \x、\u 和 \U 来转义。
ascii(123)
'123'
ascii(None)
'None'
ascii('python')
"'python'"
ascii('嗨')
"'\\u55e8'"
repr('嗨')
"'嗨'"
'\u55e8' # 16 位十六进制数 55e8 码位的字符
'嗨'
内置函数 bin()，Python 官方文档描述如下：
help(bin)
Help on built-in function bin in module builtins:
bin(number, /)
Return the binary representation of an integer.
>>> bin(2796202)
'0b1010101010101010101010'
返回给定整数的二进制表示形式的字符串。
bin(123)
'0b1111011'
0b1111011
123
内置函数（类） bool，Python 官方文档描述如下：
help(bool)
Help on class bool in module builtins:
class bool(int)
| bool(x) -> bool
|
| Returns True when the argument x is true, False otherwise.
| The builtins True and False are the only two instances of the class bool.
| The class bool is a subclass of the class int, and cannot be subclassed.
|
| Method resolution order:
| bool
| int
| object
|
返回对象 x 的布尔值。省略 x 则返回 False。对象的真值、假值规则如下：
一个对象在默认情况下均被视为真值，除非当该对象被调用时其所属类定义了 __bool__() 方法且返回 False 或是定义了 __len__() 方法且返回零。
下面基本完整地列出了会被视为假值的内置对象:
type(bool)
type
bool()
False
bool(None)
False
bool('0')
True
bool(' ')
True
内置函数（类）bytes，Python 官方文档描述如下：
help(bytes)
Help on class bytes in module builtins:
class bytes(object)
| bytes(iterable_of_ints) -> bytes
| bytes(string, encoding[, errors]) -> bytes
| bytes(bytes_or_buffer) -> immutable copy of bytes_or_buffer
| bytes(int) -> bytes object of size given by the parameter initialized with null bytes
| bytes() -> empty bytes object
|
| Construct an immutable array of bytes from:
| - an iterable yielding integers in range(256)
| - a text string encoded using the specified encoding
| - any object implementing the buffer API.
| - an integer
|
| Methods defined here:
|
返回一个新的二进制序列 bytes 对象。参数可以是：
type(bytes)
type
bytes([1,2,3])
b'\x01\x02\x03'
bytes('嗨', 'utf-8')
b'\xe5\x97\xa8'
bytes(3)
b'\x00\x00\x00'
bytes()
b''
内置函数 callable()，Python 官方文档描述如下：
help(callable)
Help on built-in function callable in module builtins:
callable(obj, /)
Return whether the object is callable (i.e., some kind of function).
Note that classes are callable, as are instances of classes with a
__call__() method.
如果 obj 是可调用对象就返回 True，否则返回 False。如果返回 True，调用仍可能失败，但如果返回 False，则调用将肯定不会成功。
函数、方法、类以及实现了 __call__() 方法的类的实例是可调用的。
callable(1)
False
callable(int)
True
class Myint(int):
def __call__(self):
pass
num = Myint(1)
num
1
callable(num)
True
callable(lambda: 1)
True
内置函数 chr()，Python 官方文档描述如下：
help(chr)
Help on built-in function chr in module builtins:
chr(i, /)
Return a Unicode string of one character with ordinal i; 0 <= i <= 0x10ffff.
返回 Unicode 码位对应的字符的字符串格式。码位范围是 0~1114111（16 进制表示是 0x10FFFF），超过这个范围，会触发 ValueError 异常。该函数是 ord() 的逆函数。
chr(97)
'a'
ord('a')
97
chr(1114111)
'\U0010ffff'
chr(1114112)
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-5-4857faf08086> in <module>
----> 1 chr(1114112)
ValueError: chr() arg not in range(0x110000)
内置函数（类）classmethod，Python 官方文档描述如下：
help(classmethod)
Help on class classmethod in module builtins:
class classmethod(object)
| classmethod(function) -> method
|
| Convert a function to be a class method.
|
| A class method receives the class as implicit first argument,
| just like an instance method receives the instance.
| To declare a class method, use this idiom:
|
| class C:
| @classmethod
| def f(cls, arg1, arg2, ...):
| ...
|
把一个函数封装成类方法。一个类方法把类自己作为第一个实参，就像一个实例方法把实例自己作为第一个实参。
可将函数作为参数来声明类方法，但请用习惯的装饰器形式（@classmethod）来声明类方法。
type(classmethod)
type
class A:
print_itself = classmethod(print)
A.print_itself()
<class '__main__.A'>
class A:
@classmethod
def print_itself(cls):
print(cls)
A.print_itself()
<class '__main__.A'>
内置函数 compile()，Python 官方文档描述如下：
help(compile)
Help on built-in function compile in module builtins:
compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)
Compile source into a code object that can be executed by exec() or eval().
The source code may represent a Python module, statement or expression.
The filename will be used for run-time error messages.
The mode must be 'exec' to compile a module, 'single' to compile a
single (interactive) statement, or 'eval' to compile an expression.
The flags argument, if present, controls which future statements influence
the compilation of the code.
The dont_inherit argument, if true, stops the compilation inheriting
the effects of any future statements in effect in the code calling
compile; if absent or false these statements do influence the compilation,
in addition to any features explicitly specified.
将 source 编译成代码或 AST 对象。代码对象可以被 exec() 或 eval() 执行。
参数说明：
source = 'for i in range(3):print(i)'
code = compile(source,'null','exec')
code
<code object <module> at 0x000001E999B07780, file "null", line 1>
exec(code)
0
1
2
eval(code)
0
1
2
内置函数（类）complex，Python 官方文档描述如下：
help(complex)
Help on class complex in module builtins:
class complex(object)
| complex(real=0, imag=0)
|
| Create a complex number from a real part and an optional imaginary part.
|
| This is equivalent to (real + imag*1j) where imag defaults to 0.
|
| Methods defined here:
|
| __abs__(self, /)
| abs(self)
|
| __add__(self, value, /)
| Return self+value.
|
| __bool__(self, /)
| self != 0
|
| __divmod__(self, value, /)
| Return divmod(self, value).
|
| __eq__(self, value, /)
| Return self==value.
|
| __float__(self, /)
| float(self)
|
| __floordiv__(self, value, /)
| Return self//value.
|
| __format__(...)
| complex.__format__() -> str
|
| Convert to a string according to format_spec.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getnewargs__(...)
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __int__(self, /)
| int(self)
|
| __le__(self, value, /)
| Return self<=value.
|
| __lt__(self, value, /)
| Return self<value.
|
| __mod__(self, value, /)
| Return self%value.
|
| __mul__(self, value, /)
| Return self*value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __neg__(self, /)
| -self
|
| __pos__(self, /)
| +self
|
| __pow__(self, value, mod=None, /)
| Return pow(self, value, mod).
|
| __radd__(self, value, /)
| Return value+self.
|
| __rdivmod__(self, value, /)
| Return divmod(value, self).
|
| __repr__(self, /)
| Return repr(self).
|
| __rfloordiv__(self, value, /)
| Return value//self.
|
| __rmod__(self, value, /)
| Return value%self.
|
| __rmul__(self, value, /)
| Return value*self.
|
| __rpow__(self, value, mod=None, /)
| Return pow(value, self, mod).
|
| __rsub__(self, value, /)
| Return value-self.
|
| __rtruediv__(self, value, /)
| Return value/self.
|
| __sub__(self, value, /)
| Return self-value.
|
| __truediv__(self, value, /)
| Return self/value.
|
| conjugate(...)
| complex.conjugate() -> complex
|
| Return the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| imag
| the imaginary part of a complex number
|
| real
| the real part of a complex number
返回值为 real + imag*1j 的复数，或将字符串或数字转换为复数。
type(complex)
type
complex('1')
(1+0j)
complex('1+2j')
(1+2j)
complex(1j, 2j)
(-2+1j)
complex(1j)
1j
complex()
0j
complex('1 + 2j')
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-7-fd0fa4b53d7c> in <module>
----> 1 complex('1 + 2j')
ValueError: complex() arg is a malformed string
内置函数 delattr()，Python 官方文档描述如下：
help(delattr)
Help on built-in function delattr in module builtins:
delattr(obj, name, /)
Deletes the named attribute from the given object.
delattr(x, 'y') is equivalent to ``del x.y''
实参是一个对象和一个字符串。该字符串必须是对象的某个属性。如果对象允许，该函数将删除指定的属性。delattr(x, 'y') 等价于 del x.y。
class A:
y = 0
x = A
x.y
0
delattr(x,'y')
x.y
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-12-3552434a3e61> in <module>
----> 1 x.y
AttributeError: type object 'A' has no attribute 'y'
内置函数（类）dict，Python 官方文档描述如下：
help(dict)
Help on class dict in module builtins:
class dict(object)
| dict() -> new empty dictionary
| dict(mapping) -> new dictionary initialized from a mapping object's
| (key, value) pairs
| dict(iterable) -> new dictionary initialized as if via:
| d = {}
| for k, v in iterable:
| d[k] = v
| dict(**kwargs) -> new dictionary initialized with the name=value pairs
| in the keyword argument list. For example: dict(one=1, two=2)
|
创建一个新字典。参数说明：
type(dict)
type
dict()
{}
dict({'a':1})
{'a': 1}
d = zip('abc',[1,2,3])
dict(d)
{'a': 1, 'b': 2, 'c': 3}
dict([('a', 1), ('b', 2)])
{'a': 1, 'b': 2}
dict(a=1,b=2)
{'a': 1, 'b': 2}
内置函数 dir()，Python 官方文档描述如下：
help(dir)
Help on built-in function dir in module builtins:
dir(...)
dir([object]) -> list of strings
If called without an argument, return the names in the current scope.
Else, return an alphabetized list of names comprising (some of) the attributes
of the given object, and of attributes reachable from it.
If the object supplies a method named __dir__, it will be used; otherwise
the default dir() logic is used and returns:
for a module object: the module's attributes.
for a class object: its attributes, and recursively the attributes
of its bases.
for any other object: its attributes, its class's attributes, and
recursively the attributes of its class's base classes.
如果没有实参，则返回当前作用域中的名称列表。如果有实参，它会尝试返回该对象的有效属性列表。
dir()
['In',
'Out',
'_',
'__',
'___',
'__builtin__',
'__builtins__',
'__doc__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_dh',
'_i',
'_i1',
'_i2',
'_ih',
'_ii',
'_iii',
'_oh',
'exit',
'get_ipython',
'quit']
如果对象有一个名为 __dir__() 的方法，那么该方法将被调用，并且必须返回一个属性列表。这允许实现自定义 dir() 来报告它的属性。
class A:
def __dir__(self):
return ['area', 'perimeter', 'location']
a = A()
dir(a)
['area', 'location', 'perimeter']
如果对象不提供 __dir__()，默认的 dir() 机制对不同类型的对象行为不同，它会试图返回最相关而不是最全的信息：
import string
dir(string)
['Formatter',
'Template',
'_ChainMap',
'_TemplateMetaclass',
'__all__',
'__builtins__',
'__cached__',
'__doc__',
'__file__',
'__loader__',
'__name__',
'__package__',
'__spec__',
'_re',
'_string',
'ascii_letters',
'ascii_lowercase',
'ascii_uppercase',
'capwords',
'digits',
'hexdigits',
'octdigits',
'printable',
'punctuation',
'whitespace']
dir(int)
['__abs__',
'__add__',
'__and__',
'__bool__',
'__ceil__',
'__class__',
'__delattr__',
'__dir__',
'__divmod__',
'__doc__',
'__eq__',
'__float__',
'__floor__',
'__floordiv__',
'__format__',
'__ge__',
'__getattribute__',
'__getnewargs__',
'__gt__',
'__hash__',
'__index__',
'__init__',
'__init_subclass__',
'__int__',
'__invert__',
'__le__',
'__lshift__',
'__lt__',
'__mod__',
'__mul__',
'__ne__',
'__neg__',
'__new__',
'__or__',
'__pos__',
'__pow__',
'__radd__',
'__rand__',
'__rdivmod__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__rfloordiv__',
'__rlshift__',
'__rmod__',
'__rmul__',
'__ror__',
'__round__',
'__rpow__',
'__rrshift__',
'__rshift__',
'__rsub__',
'__rtruediv__',
'__rxor__',
'__setattr__',
'__sizeof__',
'__str__',
'__sub__',
'__subclasshook__',
'__truediv__',
'__trunc__',
'__xor__',
'bit_length',
'conjugate',
'denominator',
'from_bytes',
'imag',
'numerator',
'real',
'to_bytes']
dir(1)
['__abs__',
'__add__',
'__and__',
'__bool__',
'__ceil__',
'__class__',
'__delattr__',
'__dir__',
'__divmod__',
'__doc__',
'__eq__',
'__float__',
'__floor__',
'__floordiv__',
'__format__',
'__ge__',
'__getattribute__',
'__getnewargs__',
'__gt__',
'__hash__',
'__index__',
'__init__',
'__init_subclass__',
'__int__',
'__invert__',
'__le__',
'__lshift__',
'__lt__',
'__mod__',
'__mul__',
'__ne__',
'__neg__',
'__new__',
'__or__',
'__pos__',
'__pow__',
'__radd__',
'__rand__',
'__rdivmod__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__rfloordiv__',
'__rlshift__',
'__rmod__',
'__rmul__',
'__ror__',
'__round__',
'__rpow__',
'__rrshift__',
'__rshift__',
'__rsub__',
'__rtruediv__',
'__rxor__',
'__setattr__',
'__sizeof__',
'__str__',
'__sub__',
'__subclasshook__',
'__truediv__',
'__trunc__',
'__xor__',
'bit_length',
'conjugate',
'denominator',
'from_bytes',
'imag',
'numerator',
'real',
'to_bytes']
内置函数 divmod()，Python 官方文档描述如下：
help(divmod)
Help on built-in function divmod in module builtins:
divmod(x, y, /)
Return the tuple (x//y, x%y). Invariant: div*y + mod == x.
它将两个（非复数）数字作为实参，返回两个数字的（商,余数）元组。对于混合操作数类型，适用二元算术运算符的规则。
divmod(1,2)
(0, 1)
divmod(3.14, 2)
(1.0, 1.1400000000000001)
内置函数（类）enumerate，Python 官方文档描述如下：
help(enumerate)
Help on class enumerate in module builtins:
class enumerate(object)
| enumerate(iterable, start=0)
|
| Return an enumerate object.
|
| iterable
| an object supporting iteration
|
| The enumerate object yields pairs containing a count (from start, which
| defaults to zero) and a value yielded by the iterable argument.
|
| enumerate is useful for obtaining an indexed list:
| (0, seq[0]), (1, seq[1]), (2, seq[2]), ...
|
返回一个可迭代对象（iterable）的枚举对象。枚举对象是一个迭代器，迭代出来是一个个元组，里面包含一个计数值（从 start 开始，默认为 0）和通过迭代 iterable 获得的值。
type(enumerate)
type
e = enumerate({'a':1,'b':2,'c':3})
e
<enumerate at 0x200ccb71240>
next(e)
(0, 'a')
for i in e:
print(i)
(1, 'b')
(2, 'c')
e = enumerate('abc', 1)
list(e)
[(1, 'a'), (2, 'b'), (3, 'c')]
内置函数 eval()，Python 官方文档描述如下：
help(eval)
Help on built-in function eval in module builtins:
eval(source, globals=None, locals=None, /)
Evaluate the given source in the context of globals and locals.
The source may be a string representing a Python expression
or a code object as returned by compile().
The globals must be a dictionary and locals can be any mapping,
defaulting to the current globals and locals.
If only globals is given, locals defaults to it.
source 参数接受字符串（会作为一个 Python 表达式）或代码对象（可通过 compile() 创建），然后解析并求值，返回求值结果。
eval('{1 + 1}')
{2}
s = 'for i in range(3):print(i)'
code = compile(s,'','exec')
eval(code)
0
1
2
eval("__import__('math').sqrt(3**2+4**2)")
5.0
参数 globals 和 locals 作为 source 的全局和局部命名空间。如果省略 locals 字典则其默认值为 globals 字典。如果两个字典同时省略，则表达式执行时会使用 eval() 被调用的环境中的全局和局部名称。
如果 globals 字典存在且不包含以 __builtins__ 为键的值，则会在解析 source 之前插入以此为键的对内置模块 builtins 的引用。这意味着 source 通常具有对标准 builtins 模块的完全访问权限且受限的环境会被传播。
globals 实参必须是一个字典。locals 可以是任何映射对象。
x = 3
def f():
y = 4
code = "__import__('math').sqrt(x**2+y**2)"
z = eval(code,{'x':5},{'y':12})
print(f'x={x}, y={y}, z={z}')
f()
x=3, y=4, z=13.0
x = 3
def f():
y = 4
code = "__import__('math').sqrt(x**2+y**2)"
z = eval(code,{'x':5,'y':12})
print(f'x={x}, y={y}, z={z}')
f()
x=3, y=4, z=13.0
x = 3
def f():
y = 4
code = "__import__('math').sqrt(x**2+y**2)"
z = eval(code)
print(f'x={x}, y={y}, z={z}')
f()
x=3, y=4, z=5.0
内置函数 exec()，Python 官方文档描述如下：
help(exec)
Help on built-in function exec in module builtins:
exec(source, globals=None, locals=None, /)
Execute the given source in the context of globals and locals.
The source may be a string representing one or more Python statements
or a code object as returned by compile().
The globals must be a dictionary and locals can be any mapping,
defaulting to the current globals and locals.
If only globals is given, locals defaults to it.
这个函数支持动态执行 Python 代码。source 必须是字符串或者代码对象。
如果是字符串，那么该字符串将被解析为一系列 Python 语句并执行（除非发生语法错误）。
如果是代码对象，它将被直接执行。
该函数返回值为 None。
print(exec('{1 + 1}'))
None
s = 'for i in range(3):print(i)'
code = compile(s,'','exec')
exec(code)
0
1
2
参数 globals 和 locals 作为 source 的全局和局部命名空间。如果省略 locals 字典则其默认值为 globals 字典。如果两个字典同时省略，则表达式执行时会使用 eval() 被调用的环境中的全局和局部名称。
如果 globals 字典存在且不包含以 __builtins__ 为键的值，则将为该键插入对内建 builtins 模块字典的引用。因此，在将执行的代码传递给 exec() 之前，可以通过将自己的 __builtins__ 字典插入到 globals 中来控制可以使用哪些内置代码。
globals 实参必须是一个字典。locals 可以是任何映射对象。
x = 1
def f():
x = 2
code = "for i in range(x):print(i)"
exec(code,{'x':3},{'x':4})
f()
0
1
2
3
x = 1
def f():
x = 2
code = "for i in range(x):print(i)"
exec(code,{'x':3})
f()
0
1
2
x = 1
def f():
x = 2
code = "for i in range(x):print(i)"
exec(code)
f()
0
1
内置函数（类）filter，Python 官方文档描述如下：
help(filter)
Help on class filter in module builtins:
class filter(object)
| filter(function or None, iterable) --> filter object
|
| Return an iterator yielding those items of iterable for which function(item)
| is true. If function is None, return the items that are true.
|
返回可迭代对象（iterable）中那些传递给函数 function 计算之后，布尔值仍然为真的元素组成的迭代器。
如果 function 是 None，则会假设它是一个身份函数，即 iterable 中所有布尔值为假的元素会被移除。
type(filter)
type
f = filter(None,[0,1,2,1])
list(f)
[1, 2, 1]
f = filter(lambda x: x-1, [0,1,2,1])
list(f)
[0, 2]
list(filter(None,'0120'))
['0', '1', '2', '0']
list(filter(int,'0120'))
['1', '2']
内置函数（类）float，Python 官方文档描述如下：
help(float)
Help on class float in module builtins:
class float(object)
| float(x=0, /)
|
| Convert a string or number to a floating point number, if possible.
|
返回从数字或字符串 x 生成的浮点数。
如果实参是字符串:
如果实参是整数或浮点数，则返回具有相同值（在 Python 浮点精度范围内）的浮点数。如果实参在 Python 浮点精度范围外，则会触发OverflowError。
如果没有实参，则返回 0.0 。
type(float)
type
float()
0.0
float(1)
1.0
float(- 1.0)
-1.0
float(' -1.0 \n')
-1.0
float(' 01_2.1_4 ')
12.14
float('0001')
1.0
float('3.14e02')
314.0
float('-naN')
nan
float('-inf')
-inf
内置函数 format()，Python 官方文档描述如下：
help(format)
Help on built-in function format in module builtins:
format(value, format_spec='', /)
Return value.__format__(format_spec)
format_spec defaults to the empty string.
See the Format Specification Mini-Language section of help('FORMATTING') for
details.
将 value 转换为 format_spec 控制的 “格式化” 表示。format_spec 的解释取决于 value 实参的类型，但是大多数内置类型使用标准格式化语法：格式化迷你语言。详见 str.format 格式化。
默认的 format_spec 是一个空字符串，它通常和调用 str(value) 的结果相同。
format('嗨','>10')
' 嗨'
format('嗨','~^10')
'~~~~嗨~~~~~'
format(1,'05')
'00001'
format(3.14,'.3f')
'3.140'
format(123456789,'_')
'123_456_789'
format(123456789,'.2e')
'1.23e+08'
format(123456789)
'123456789'
内置函数（类）frozenset，Python 官方文档描述如下：
help(frozenset)
Help on class frozenset in module builtins:
class frozenset(object)
| frozenset() -> empty frozenset object
| frozenset(iterable) -> frozenset object
|
| Build an immutable unordered collection of unique elements.
|
将可迭代对象转换为集合，返回一个新的 frozenset 集合对象。可迭代对象为空，或不传参数，得到一个空集合。
type(frozenset)
type
frozenset()
frozenset()
frozenset([])
frozenset()
frozenset('0123')
frozenset({'0', '1', '2', '3'})
frozenset({'a':1,'b':2})
frozenset({'a', 'b'})
内置函数 getattr()，Python 官方文档描述如下：
help(getattr)
Help on built-in function getattr in module builtins:
getattr(...)
getattr(object, name[, default]) -> value
Get a named attribute from an object; getattr(x, 'y') is equivalent to x.y.
When a default argument is given, it is returned when the attribute doesn't
exist; without it, an exception is raised in that case.
返回对象给定的属性名指向的值。name 必须是字符串。如果该字符串是对象的属性名称之一，则返回该属性的值。例如，getattr(x, 'y') 等同于 x.y。如果指定的属性不存在，且提供了 default 值，则返回它，否则触发 AttributeError。
getattr(1,'imag')
0
getattr(1,'bool',True)
True
getattr(1,'bool')
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-6-524bb2b35e58> in <module>
----> 1 getattr(1,'bool')
AttributeError: 'int' object has no attribute 'bool'
class A:
y = 1
x = A()
x.y
1
getattr(x,'y')
1
内置函数 globals()，Python 官方文档描述如下：
help(globals)
Help on built-in function globals in module builtins:
globals()
Return the dictionary containing the current scope's global variables.
NOTE: Updates to this dictionary *will* affect name lookups in the current
global scope and vice-versa.
返回包含当前作用域的全局变量字典。这总是当前模块的字典（在函数或方法中，不是调用它的模块，而是定义它的模块）。
更新此字典 将 影响当前全局范围内的名称查找，反之亦然。
globals() 和 locals() 函数各自返回当前的全局和本地字典，因此可以将它们传递给 eval() 或 exec() 来使用。
globals()
{'__name__': '__main__',
'__doc__': 'Automatically created module for IPython interactive environment',
'__package__': None,
'__loader__': None,
'__spec__': None,
'__builtin__': <module 'builtins' (built-in)>,
'__builtins__': <module 'builtins' (built-in)>,
'_ih': ['', 'help(globals)', 'globals()'],
'_oh': {},
'_dh': ['D:\\Jupyter\\xuecn_books\\books\\xue_python_kp\\11_built-in_function'],
'In': ['', 'help(globals)', 'globals()'],
'Out': {},
'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x000001E15E70D748>>,
'exit': <IPython.core.autocall.ZMQExitAutocall at 0x1e160f63978>,
'quit': <IPython.core.autocall.ZMQExitAutocall at 0x1e160f63978>,
'_': '',
'__': '',
'___': '',
'_i': 'help(globals)',
'_ii': '',
'_iii': '',
'_i1': 'help(globals)',
'_i2': 'globals()'}
内置函数 hasattr()，Python 官方文档描述如下：
help(hasattr)
Help on built-in function hasattr in module builtins:
hasattr(obj, name, /)
Return whether the object has an attribute with the given name.
This is done by calling getattr(obj, name) and catching AttributeError.
该函数实参是一个对象和一个字符串。如果字符串是对象的属性之一的名称，则返回 True，否则返回 False。
hasattr('abc', 'join')
True
class A:
y = 1
hasattr(A, 'y')
True
内置函数 hash()，Python 官方文档描述如下：
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.
返回对象的哈希值（如果它有的话）。哈希值是整数。它们在集合或字典查找元素时用来快速比较集合的元素或字典的键。相同大小的数字有相同的哈希值。
可哈希对象必须具有相同的哈希值比较结果才会相同。
hash(1) == hash(1.0) == hash(True)
True
1 == 1.0 == True
True
hash('abc')
2812132477407752679
hash((1,2,3))
529344067295497451
hash([1,2,3])
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-5-35e31e935e9e> in <module>
----> 1 hash([1,2,3])
TypeError: unhashable type: 'list'
hash((1,2))
内置函数（帮助系统）help，Python 官方文档描述如下：
help(help)
Help on _Helper in module _sitebuiltins object:
class _Helper(builtins.object)
| Define the builtin 'help'.
|
| This is a wrapper around pydoc.help that provides a helpful message
| when 'help' is typed at the Python interactive prompt.
|
| Calling help() at the Python prompt starts an interactive help session.
| Calling help(thing) prints help for the python object 'thing'.
|
| Methods defined here:
|
| __call__(self, *args, **kwds)
| Call self as a function.
|
| __repr__(self)
| Return repr(self).
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| __dict__
| dictionary for instance variables (if defined)
|
| __weakref__
| list of weak references to the object (if defined)
启动内置的帮助系统（此函数主要在交互式中使用）。
如果没有实参，解释器控制台里会启动交互式帮助系统。
如果实参是一个字符串，则在模块、函数、类、方法、关键字或文档主题中搜索该字符串，并在控制台上打印帮助信息。
如果实参是其他任意对象，则会生成该对象的帮助页。
type(help)
_sitebuiltins._Helper
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> print
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
help> q
You are now leaving help and returning to the Python interpreter.
If you want to ask for help on a particular object directly from the
interpreter, you can type "help(object)". Executing "help('string')"
has the same effect as typing a particular string at the help> prompt.
help('list.append')
Help on method_descriptor in list:
list.append = append(self, object, /)
Append object to the end of the list.
help(list.append)
Help on method_descriptor:
append(self, object, /)
Append object to the end of the list.
内置函数 hex()，Python 官方文档描述如下：
help(hex)
Help on built-in function hex in module builtins:
hex(number, /)
Return the hexadecimal representation of an integer.
>>> hex(12648430)
'0xc0ffee'
将整数转换为以 0x 为前缀的小写十六进制整数的字符串形式。
hex(123)
'0x7b'
0x7b
123
内置函数 id()，Python 官方文档描述如下：
help(id)
Help on built-in function id in module builtins:
id(obj, /)
Return the identity of an object.
This is guaranteed to be unique among simultaneously existing objects.
(CPython uses the object's memory address.)
返回对象的唯一标识。该标识是一个整数，在此对象的生命周期中保证是唯一且恒定的。
CPython 中该标识是对象的内存地址。
id(1), id(1.0)
(140736642126656, 2785998726512)
1 == 1.0
True
# 两个变量引用了同一个值为 1 的对象
a = 1
b = int('01')
id(a), id(b)
(140736642126656, 140736642126656)
# 两个值为 1000 的不同对象
a = 1000
b = 1000
id(a), id(b)
(2785998745552, 2785998745360)
# 可变对象改变值，还是同一个对象
_list = [1,2,3]
print(id(_list),_list)
del _list[:]
print(id(_list),_list)
2785999307336 [1, 2, 3]
2785999307336 []
内置函数 input()，Python 官方文档描述如下：
help(input)
Help on method raw_input in module ipykernel.kernelbase:
raw_input(prompt='') method of ipykernel.ipkernel.IPythonKernel instance
Forward raw_input to frontends
Raises
------
StdinNotImplentedError if active frontend doesn't support stdin.
如果存在 prompt 实参，则作为提示信息输出。接下来，该函数将输入转换为字符串并返回。无输入则返回空字符串。
input('输入提示：')
输入提示： 1+1
'1+1'
input('输入提示：')
输入提示：
''
内置函数（类）int，Python 官方文档描述如下：
help(int)
Help on class int in module builtins:
class int(object)
| int([x]) -> integer
| int(x, base=10) -> integer
|
| Convert a number or string to an integer, or return 0 if no arguments
| are given. If x is a number, return x.__int__(). For floating point
| numbers, this truncates towards zero.
|
| If x is not a number or if base is given, then x must be a string,
| bytes, or bytearray instance representing an integer literal in the
| given base. The literal can be preceded by '+' or '-' and be surrounded
| by whitespace. The base defaults to 10. Valid bases are 0 and 2-36.
| Base 0 means to interpret the base from the string as an integer literal.
| >>> int('0b100', base=0)
| 4
|
| Built-in subclasses:
| bool
|
将一个数字，字符串或字节串转换为整数。参数说明：
type(int)
type
int()
0
int(3.18e01), int(10), int(0x10)
(31, 10, 16)
int(' -10 '), int(b' +10')
(-10, 10)
int('10',2), int('10',8), int('z',36)
(2, 8, 35)
int('001'), int('0b10',0)
(1, 2)
int('001',0) # 001 不是合法的整数
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-12-1cf9048a8c3e> in <module>
----> 1 int('001',0)
ValueError: invalid literal for int() with base 0: '001'
int('9', 8) # 8 进制没有 9
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-13-3558097bd025> in <module>
----> 1 int('9', 8)
ValueError: invalid literal for int() with base 8: '9'
int('3.14') # 不能是浮点数形式
---------------------------------------------------------------------------
ValueError Traceback (most recent call last)
<ipython-input-14-1456603af047> in <module>
----> 1 int('3.14')
ValueError: invalid literal for int() with base 10: '3.14'
内置函数 isinstance()，Python 官方文档描述如下：
help(isinstance)
Help on built-in function isinstance in module builtins:
isinstance(obj, class_or_tuple, /)
Return whether an object is an instance of a class or of a subclass thereof.
A tuple, as in ``isinstance(x, (A, B, ...))``, may be given as the target to
check against. This is equivalent to ``isinstance(x, A) or isinstance(x, B)
or ...`` etc.
如果对象 obj 是给定类的实例或者是其 (直接、间接或虚拟) 子类的实例则返回 True，不是则返回 False。给定的不是类则引发 TypeError 异常。
给定类可以以元组形式传参，obj 是其中任何一个类型的实例就返回 True。
isinstance(1, int)
True
isinstance('abc', (float, complex))
False
# bool 是 int 的子类型，但不是实例
isinstance(bool, int)
False
# True 是 int 的子类的实例
isinstance(True, int)
True
# bool 的实例只有 True 和 False
isinstance(1, bool)
False
# 所有的对象都是 object 的实例
isinstance(object, object)
True
import random # 模块
class A:pass # 自定义类
isinstance(1, object),\
isinstance(int, object),\
isinstance(list, object),\
isinstance(random, object),\
isinstance(A, object)
(True, True, True, True, True)
内置函数 issubclass()，Python 官方文档描述如下：
help(issubclass)
Help on built-in function issubclass in module builtins:
issubclass(cls, class_or_tuple, /)
Return whether 'cls' is a derived from another class or is the same class.
A tuple, as in ``issubclass(x, (A, B, ...))``, may be given as the target to
check against. This is equivalent to ``issubclass(x, A) or issubclass(x, B)
or ...`` etc.
如果类 cls 是给定类的 (直接、间接或虚拟) 子类则返回 True，不是则返回 False。给定的不是类则引发 TypeError 异常。
给定类可以以元组形式传参，cls 是其中任何一个类的子类就返回 True。
issubclass(1, int) # 1 不是类
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-2-257e7a8dbb04> in <module>
----> 1 issubclass(1, int)
TypeError: issubclass() arg 1 must be a class
issubclass(bool, int)
True
issubclass(bool, (set, str, list))
False
# 所有的类都是 object 的子类
class A:pass
issubclass(A, object),\
issubclass(str, object),\
issubclass(object, object)
(True, True, True)
内置函数 iter()，Python 官方文档描述如下：
help(iter)
Help on built-in function iter in module builtins:
iter(...)
iter(iterable) -> iterator
iter(callable, sentinel) -> iterator
Get an iterator from an object. In the first form, the argument must
supply its own iterator, or be a sequence.
In the second form, the callable is called until it returns the sentinel.
将一个可迭代对象（iterable）或可调用对象（callable）转换为一个迭代器。
当参数是可调用对象时，需要提供参数 sentinel，生成的迭代器，每次 迭代时都会不带实参地调用 callable，返回 sentinel 时则触 发 StopIteration。
a = iter('abcd')
a
<str_iterator at 0x1c7eea4f910>
next(a),next(a),next(a),next(a)
('a', 'b', 'c', 'd')
a = iter(int, 1)
for i in range(3):
print(next(a))
0
0
0
a = iter(int, 0)
next(a)
---------------------------------------------------------------------------
StopIteration Traceback (most recent call last)
<ipython-input-21-694e44f6d78c> in <module>
1 a = iter(int, 0)
----> 2 next(a)
StopIteration:
内置函数 len()，Python 官方文档描述如下：
help(len)
Help on built-in function len in module builtins:
len(obj, /)
Return the number of items in a container.
返回对象的长度（元素个数）。实参可以是序列（如 str、bytes、tuple、list 或 range 等的实例），集合（set 或 frozenset 的实例），或字典（dict 的实例）等。
len('123')
3
len('嗨')
1
len('嗨'.encode())
3
len([1,2,3])
3
len({'a':1,'b':2})
2
内置函数（类）list，Python 官方文档描述如下：
help(list)
Help on class list in module builtins:
class list(object)
| list(iterable=(), /)
|
| Built-in mutable sequence.
|
| If no argument is given, the constructor creates a new empty list.
| The argument must be an iterable if specified.
|
将一个可迭代对象转为列表。不传参数将得到空列表。
type(list)
type
list()
[]
list('123')
['1', '2', '3']
list({'a':1,'b':2})
['a', 'b']
内置函数 locals()，Python 官方文档描述如下：
help(locals)
Help on built-in function locals in module builtins:
locals()
Return a dictionary containing the current scope's local variables.
NOTE: Whether or not updates to this dictionary will affect name lookups in
the local scope and vice-versa is *implementation dependent* and not
covered by any backwards compatibility guarantees.
返回包含当前作用域的局部变量的字典。在模块层级上，locals() 和 globals() 是同一个字典。
globals() 和 locals() 函数各自返回当前的全局和本地字典，因此可以将它们传递给 eval() 或 exec() 来使用。
locals()
{'__name__': '__main__',
'__doc__': 'Automatically created module for IPython interactive environment',
'__package__': None,
'__loader__': None,
'__spec__': None,
'__builtin__': <module 'builtins' (built-in)>,
'__builtins__': <module 'builtins' (built-in)>,
'_ih': ['', 'help(locals)', 'locals()'],
'_oh': {},
'_dh': ['D:\\Jupyter\\xuecn_books\\books\\xue_python_kp\\11_built-in_function'],
'In': ['', 'help(locals)', 'locals()'],
'Out': {},
'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x0000023E24AE89B0>>,
'exit': <IPython.core.autocall.ZMQExitAutocall at 0x23e27368898>,
'quit': <IPython.core.autocall.ZMQExitAutocall at 0x23e27368898>,
'_': '',
'__': '',
'___': '',
'_i': 'help(locals)',
'_ii': '',
'_iii': '',
'_i1': 'help(locals)',
'_i2': 'locals()'}
def f():
a = 1
print(locals())
f()
{'a': 1}
内置函数（类）map，Python 官方文档描述如下：
help(map)
Help on class map in module builtins:
class map(object)
| map(func, *iterables) --> map object
|
| Make an iterator that computes the function using arguments from
| each of the iterables. Stops when the shortest iterable is exhausted.
|
| Methods defined here:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __iter__(self, /)
| Implement iter(self).
|
| __next__(self, /)
| Implement next(self).
|
| __reduce__(...)
| Return state information for pickling.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
返回一个将函数 func 应用于 iterable 中每一项并输出其结果的迭代器。
如果传入了额外的 iterable 参数，func 必须接受相同个数的实参并被应用于从所有可迭代对象中并行获取的项。
当有多个可迭代对象时，最短的可迭代对象耗尽则整个迭代就将结束。
type(map)
type
a = map(int, '1234')
a
<map at 0x16048be3828>
list(a)
[1, 2, 3, 4]
m = map(int,'abc',(16,16))
list(m)
[10, 11]
def f(x,y):
d = {}
d[x] = y
return d
m = map(f,'abc',(1,2))
list(m)
[{'a': 1}, {'b': 2}]
内置函数 max()，Python 官方文档描述如下：
help(max)
Help on built-in function max in module builtins:
max(...)
max(iterable, *[, default=obj, key=func]) -> value
max(arg1, arg2, *args, *[, key=func]) -> value
With a single iterable argument, return its biggest item. The
default keyword-only argument specifies an object to return if
the provided iterable is empty.
With two or more arguments, return the largest argument.
返回可迭代对象中最大的元素，或多个实参中最大的项。参数说明：
max('3142')
'4'
max([], default=0)
0
max(2,4,3,4)
4
max([2,1],[2,1,1])
[2, 1, 1]
max(('a','ab','bcd'),key=len)
'bcd'
内置函数 min()，Python 官方文档描述如下：
help(min)
Help on built-in function min in module builtins:
min(...)
min(iterable, *[, default=obj, key=func]) -> value
min(arg1, arg2, *args, *[, key=func]) -> value
With a single iterable argument, return its smallest item. The
default keyword-only argument specifies an object to return if
the provided iterable is empty.
With two or more arguments, return the smallest argument.
返回可迭代对象中最小的元素，或多个实参中最小的项。参数说明：
min('3142')
'1'
min([], default=0)
0
min(2,3,2,4)
2
min([2,1],[2,1,1])
[2, 1]
min(('a','ab','bcd'),key=len)
'a'
内置函数 next()，Python 官方文档描述如下：
help(next)
Help on built-in function next in module builtins:
next(...)
next(iterator[, default])
Return the next item from the iterator. If default is given and the iterator
is exhausted, it is returned instead of raising StopIteration.
返回迭代器（iterator）的下一个元素。如果迭代器耗尽，则返回给定的 default，如果没有默认值则触发 StopIteration。
i = iter('123')
next(i,'迭代结束')
'1'
next(i,'迭代结束')
'2'
next(i,'迭代结束')
'3'
next(i,'迭代结束')
'迭代结束'
next(i,'迭代结束')
'迭代结束'
内置函数（类）object，Python 官方文档描述如下：
help(object)
Help on class object in module builtins:
class object
| The most base type
当被调用时，它不接受任何参数，并返回一个新的无特性实例，并且不能给定任何实例属性。
object 是所有类的基类。它具有所有 Python 类实例的通用方法。
type(object)
type
object()
<object at 0x1de8bc75170>
dir(object)
['__class__',
'__delattr__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__getattribute__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__le__',
'__lt__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__']
内置函数 oct()，Python 官方文档描述如下：
help(oct)
Help on built-in function oct in module builtins:
oct(number, /)
Return the octal representation of an integer.
>>> oct(342391)
'0o1234567'
将一个整数转换为八进制整数的字符串形式。
oct(123)
'0o173'
0o173
123
oct(0x12)
'0o22'
0x12, 0o22
(18, 18)
内置函数 open()，Python 官方文档描述如下：
help(open)
Help on built-in function open in module io:
open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)
Open file and return a stream. Raise OSError upon failure.
file is either a text or byte string giving the name (and the path
if the file isn't in the current working directory) of the file to
be opened or an integer file descriptor of the file to be
wrapped. (If a file descriptor is given, it is closed when the
returned I/O object is closed, unless closefd is set to False.)
mode is an optional string that specifies the mode in which the file
is opened. It defaults to 'r' which means open for reading in text
mode. Other common values are 'w' for writing (truncating the file if
it already exists), 'x' for creating and writing to a new file, and
'a' for appending (which on some Unix systems, means that all writes
append to the end of the file regardless of the current seek position).
In text mode, if encoding is not specified the encoding used is platform
dependent: locale.getpreferredencoding(False) is called to get the
current locale encoding. (For reading and writing raw bytes use binary
mode and leave encoding unspecified.) The available modes are:
========= ===============================================================
Character Meaning
--------- ---------------------------------------------------------------
'r' open for reading (default)
'w' open for writing, truncating the file first
'x' create a new file and open it for writing
'a' open for writing, appending to the end of the file if it exists
'b' binary mode
't' text mode (default)
'+' open a disk file for updating (reading and writing)
'U' universal newline mode (deprecated)
========= ===============================================================
The default mode is 'rt' (open for reading text). For binary random
access, the mode 'w+b' opens and truncates the file to 0 bytes, while
'r+b' opens the file without truncation. The 'x' mode implies 'w' and
raises an `FileExistsError` if the file already exists.
Python distinguishes between files opened in binary and text modes,
even when the underlying operating system doesn't. Files opened in
binary mode (appending 'b' to the mode argument) return contents as
bytes objects without any decoding. In text mode (the default, or when
't' is appended to the mode argument), the contents of the file are
returned as strings, the bytes having been first decoded using a
platform-dependent encoding or using the specified encoding if given.
'U' mode is deprecated and will raise an exception in future versions
of Python. It has no effect in Python 3. Use newline to control
universal newlines mode.
buffering is an optional integer used to set the buffering policy.
Pass 0 to switch buffering off (only allowed in binary mode), 1 to select
line buffering (only usable in text mode), and an integer > 1 to indicate
the size of a fixed-size chunk buffer. When no buffering argument is
given, the default buffering policy works as follows:
* Binary files are buffered in fixed-size chunks; the size of the buffer
is chosen using a heuristic trying to determine the underlying device's
"block size" and falling back on `io.DEFAULT_BUFFER_SIZE`.
On many systems, the buffer will typically be 4096 or 8192 bytes long.
* "Interactive" text files (files for which isatty() returns True)
use line buffering. Other text files use the policy described above
for binary files.
encoding is the name of the encoding used to decode or encode the
file. This should only be used in text mode. The default encoding is
platform dependent, but any encoding supported by Python can be
passed. See the codecs module for the list of supported encodings.
errors is an optional string that specifies how encoding errors are to
be handled---this argument should not be used in binary mode. Pass
'strict' to raise a ValueError exception if there is an encoding error
(the default of None has the same effect), or pass 'ignore' to ignore
errors. (Note that ignoring encoding errors can lead to data loss.)
See the documentation for codecs.register or run 'help(codecs.Codec)'
for a list of the permitted encoding error strings.
newline controls how universal newlines works (it only applies to text
mode). It can be None, '', '\n', '\r', and '\r\n'. It works as
follows:
* On input, if newline is None, universal newlines mode is
enabled. Lines in the input can end in '\n', '\r', or '\r\n', and
these are translated into '\n' before being returned to the
caller. If it is '', universal newline mode is enabled, but line
endings are returned to the caller untranslated. If it has any of
the other legal values, input lines are only terminated by the given
string, and the line ending is returned to the caller untranslated.
* On output, if newline is None, any '\n' characters written are
translated to the system default line separator, os.linesep. If
newline is '' or '\n', no translation takes place. If newline is any
of the other legal values, any '\n' characters written are translated
to the given string.
If closefd is False, the underlying file descriptor will be kept open
when the file is closed. This does not work when a file name is given
and must be True in that case.
A custom opener can be used by passing a callable as *opener*. The
underlying file descriptor for the file object is then obtained by
calling *opener* with (*file*, *flags*). *opener* must return an open
file descriptor (passing os.open as *opener* results in functionality
similar to passing None).
open() returns a file object whose type depends on the mode, and
through which the standard file operations such as reading and writing
are performed. When open() is used to open a file in a text mode ('w',
'r', 'wt', 'rt', etc.), it returns a TextIOWrapper. When used to open
a file in a binary mode, the returned class varies: in read binary
mode, it returns a BufferedReader; in write binary and append binary
modes, it returns a BufferedWriter, and in read/write mode, it returns
a BufferedRandom.
It is also possible to use a string or bytearray as a file for both
reading and writing. For strings StringIO can be used like a file
opened in a text mode, and for bytes a BytesIO can be used like a file
opened in a binary mode.
打开文件 file 并返回对应的文件对象（file object）。
参数说明：
1，file 是将要打开的文件的路径（绝对路径或者当前工作目录的相对路径），也可以是要被封装的整数类型文件描述符。（如果是文件描述符，它会随着返回的 I/O 对象关闭而关闭，除非 closefd 被设为 False ）。
2，mode 是一个可选字符串，用于指定打开文件的模式。默认值是 ‘r’ ，这意味着它以文本模式打开并读取。在文本模式，如果 encoding 没有指定，则根据平台来决定使用的编码（要读取和写入原始字节，请使用二进制模式并不要指定 encoding）。可用的模式有：
模式 ‘r’，‘w’，‘x’，‘a’ 可以单独使用，也可与 ‘b’ 或 ‘+’，或两者同时组合使用。‘b’，’t’ 和 ‘+’ 不能单独使用。‘b’ 和 ’t’ 互斥，’t’ 默认省略。
默认模式为 ‘r’ (打开用于读取文本，与 ‘rt’ 同义)。模式 ‘w+’ 与 ‘w+b’ 打开文件并清空内容。模式 ‘r+’ 与 ‘r+b’ 打开文件并不清空内容。
以二进制模式打开的文件返回的内容为字节串，不进行任何解码。在文本模式下打开时，文件内容返回为字符串，首先使用指定的 encoding （如果给定）或者使用平台默认的的字节编码解码。
3，buffering 是一个可选的整数，用于设置缓冲策略。
4，encoding 是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。
5，errors 是一个可选的字符串参数，用于指定如何处理编码和解码错误。这不能在二进制模式下使用。
6，newline 控制通用换行模式如何生效（它仅适用于文本模式）。
7，如果 closefd 是 False 并且打开文件给出了文件描述符而不是文件名，那么当文件关闭时，底层文件描述符将保持打开状态。如果给出文件名则 closefd 必须为 True （默认值），否则将引发错误。
8，可以通过传递可调用的 opener 来使用自定义开启器。
with open('test.txt') as f:
print(f)
<_io.TextIOWrapper name='test.txt' mode='r' encoding='cp936'>
with open('test.txt',encoding='utf-8') as f:
print(f.read())
xue.cn
自学是门手艺
with open('test.txt','rb') as f:
print(f.read())
b'xue.cn\r\n\r\n\xe8\x87\xaa\xe5\xad\xa6\xe6\x98\xaf\xe9\x97\xa8\xe6\x89\x8b\xe8\x89\xba'
内置函数 ord()，Python 官方文档描述如下：
help(ord)
Help on built-in function ord in module builtins:
ord(c, /)
Return the Unicode code point for a one-character string.
返回单个字符 Unicode 码点的整数。这是 chr() 的逆函数。
ord('a')
97
chr(97)
'a'
内置函数 pow()，Python 官方文档描述如下：
help(pow)
Help on built-in function pow in module builtins:
pow(base, exp, mod=None)
Equivalent to base**exp with 2 arguments or base**exp % mod with 3 arguments
Some types, such as ints, are able to use a more efficient algorithm when
invoked using the three argument form.
返回 base 的 exp 次幂；如果 mod 存在，则返回 base 的 exp 次幂对 mod 取余（比 pow(base, exp) % mod 更高效）。
对于混用的操作数类型，则将应用双目算术运算符的类型强制转换规则。 对于 int 操作数，结果具有与操作数相同的类型（强制转换后），除非第二个参数为负值；在这种情况下，所有参数将被转换为浮点数并输出浮点数结果。
对于 int 操作数 base 和 exp，如果给出 mod，则 mod 必须为整数类型并且 mod 必须不为零。如果给出 mod 并且 exp 为负值，则 base 必须相对于 mod 不可整除。在这种情况下，将会返回 pow(inv_base, -exp, mod)，其中 inv_base 为 base 的倒数对 mod 取余。
在 3.8 版更改: 对于 int 操作数，三参数形式的 pow 现在允许第二个参数为负值，即可以计算倒数的余数；允许关键字参数。
pow(2, 3, 4)
0
pow(2.0, 3)
8.0
pow(2, -1)
0.5
pow(38, -1, 97) # 38 的倒数对 97 取余为 23
23
23 * 38 % 97 == 1
True
pow(38, -2, 97), pow(23, 2, 97)
(44, 44)
内置函数 print()，Python 官方文档描述如下：
help(print)
Help on built-in function print in module builtins:
print(...)
print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
Prints the values to a stream, or to sys.stdout by default.
Optional keyword arguments:
file: a file-like object (stream); defaults to the current sys.stdout.
sep: string inserted between values, default a space.
end: string appended after the last value, default a newline.
flush: whether to forcibly flush the stream.
将 value … 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。
所有非关键字参数都会被转换为字符串，就像是执行了 str() 一样，并会被写入到流。sep 和 end 都必须为字符串。sep 默认为一个空格 ’ ‘，end 默认为换行 ‘\n’。
如果没有给出 value …，则 print() 将只打印 end。
file 参数必须是一个具有 write(string) 方法的对象。如果参数不指定，则将使用解释器用于标准输出的文件对象 sys.stdout。
输出是否被缓存通常决定于 file，但如果 flush 关键字参数为真值，流会被强制刷新。
该函数返回值为 None。
print(1+1)
print('a','b')
2
a b
print('a',1,int, sep='-', end='end')
a-1-<class 'int'>end
print(end='end')
end
p = print('end')
print(p)
end
None
内置函数（类）property，Python 官方文档描述如下：
help(property)
Help on class property in module builtins:
class property(object)
| property(fget=None, fset=None, fdel=None, doc=None)
|
| Property attribute.
|
| fget
| function to be used for getting an attribute value
| fset
| function to be used for setting an attribute value
| fdel
| function to be used for del'ing an attribute
| doc
| docstring
|
| Typical use is to define a managed attribute x:
|
| class C(object):
| 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.")
|
| Decorators make defining new properties or modifying existing ones easy:
|
| class C(object):
| @property
| def x(self):
| "I am the 'x' property."
| return self._x
| @x.setter
| def x(self, value):
| self._x = value
| @x.deleter
| def x(self):
| del self._x
|
返回 property 属性。
fget 是获取属性值的函数。fset 是用于设置属性值的函数。fdel 是用于删除属性值的函数，doc 为属性对象创建文档字符串。
type(property)
type
dir(property)
['__class__',
'__delattr__',
'__delete__',
'__dir__',
'__doc__',
'__eq__',
'__format__',
'__ge__',
'__get__',
'__getattribute__',
'__gt__',
'__hash__',
'__init__',
'__init_subclass__',
'__isabstractmethod__',
'__le__',
'__lt__',
'__ne__',
'__new__',
'__reduce__',
'__reduce_ex__',
'__repr__',
'__set__',
'__setattr__',
'__sizeof__',
'__str__',
'__subclasshook__',
'deleter',
'fdel',
'fget',
'fset',
'getter',
'setter']
一个典型的用法是定义一个托管属性 x:
# 列一
class C:
def __init__(self,value):
self._x = value
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.")
如果 c 是 C 的实例，c.x 将调用 getter，c.x = value 将调用 setter，del c.x 将调用 deleter。
如果给出，doc 将成为该 property 属性的文档字符串。否则该 property 将拷贝 fget 的文档字符串（如果存在）。
c = C(1)
c.x
1
c.x = 2
c.x
2
del c.x
c.x
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-16-d32ce31f0255> in <module>
1 del c.x
----> 2 c.x
<ipython-input-10-eaaa1d84111b> in getx(self)
4
5 def getx(self):
----> 6 return self._x
7
8 def setx(self, value):
AttributeError: 'C' object has no attribute '_x'
这令使用 property() 作为装饰器来创建只读的特征属性可以很容易地实现:
class Parrot:
def __init__(self):
self._voltage = 100000
@property
def voltage(self):
"""Get the current voltage."""
return self._voltage
以上 @property 装饰器会将 voltage() 方法转化为一个具有相同名称的只读属性的 getter，并将 voltage 的文档字符串设置为 ‘Get the current voltage.’
p = Parrot()
p.voltage
100000
p.voltage = 100
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-20-50ba7917c8b5> in <module>
----> 1 p.voltage = 100
AttributeError: can't set attribute
特征属性对象具有 getter, setter 以及 deleter 方法，它们可用作装饰器来创建该特征属性的副本，并将相应的访问函数设为所装饰的函数。
class C:
def __init__(self,value):
self._x = value
@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
上述代码与 例一 完全等价。注意一定要给附加函数与原始的特征属性相同的名称。
c = C(1)
c.x
1
c.x = 2
c.x
2
del c.x
c.x
---------------------------------------------------------------------------
AttributeError Traceback (most recent call last)
<ipython-input-7-d32ce31f0255> in <module>
1 del c.x
----> 2 c.x
<ipython-input-4-356a299284e7> in x(self)
6 def x(self):
7 """I'm the 'x' property."""
----> 8 return self._x
9
10 @x.setter
AttributeError: 'C' object has no attribute '_x'
内置函数（类）range，Python 官方文档描述如下：
help(range)
Help on class range in module builtins:
class range(object)
| range(stop) -> range object
| range(start, stop[, step]) -> range object
|
| Return an object that produces a sequence of integers from start (inclusive)
| to stop (exclusive) by step. range(i, j) produces i, i+1, i+2, ..., j-1.
| start defaults to 0, and stop is omitted! range(4) produces 0, 1, 2, 3.
| These are exactly the valid indices for a list of 4 elements.
| When step is given, it specifies the increment (or decrement).
|
| Methods defined here:
|
| __bool__(self, /)
| self != 0
|
| __contains__(self, key, /)
| Return key in self.
|
| __eq__(self, value, /)
| Return self==value.
|
| __ge__(self, value, /)
| Return self>=value.
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __getitem__(self, key, /)
| Return self[key].
|
| __gt__(self, value, /)
| Return self>value.
|
| __hash__(self, /)
| Return hash(self).
|
| __iter__(self, /)
| Implement iter(self).
|
| __le__(self, value, /)
| Return self<=value.
|
| __len__(self, /)
| Return len(self).
|
| __lt__(self, value, /)
| Return self<value.
|
| __ne__(self, value, /)
| Return self!=value.
|
| __reduce__(...)
| Helper for pickle.
|
| __repr__(self, /)
| Return repr(self).
|
| __reversed__(...)
| Return a reverse iterator.
|
| count(...)
| rangeobject.count(value) -> integer -- return number of occurrences of value
|
| index(...)
| rangeobject.index(value, [start, [stop]]) -> integer -- return index of value.
| Raise ValueError if the value is not present.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
|
| ----------------------------------------------------------------------
| Data descriptors defined here:
|
| start
|
| step
|
| stop
虽然被称为函数，但 range 实际上是一个不可变的序列类型，参见 range 对象。
type(range)
type
list(range(3))
[0, 1, 2]
list(range(-5))
[]
list(range(1,5,2))
[1, 3]
list(range(0,-5,-1))
[0, -1, -2, -3, -4]
内置函数 repr()，Python 官方文档描述如下：
help(repr)
Help on built-in function repr in module builtins:
repr(obj, /)
Return the canonical string representation of the object.
For many object types, including most builtins, eval(repr(obj)) == obj.
返回包含一个对象的可打印表示形式的字符串。
对于许多类型来说，该函数会尝试返回的字符串将会与该对象被传递给 eval() 时所生成的对象具有相同的值，在其他情况下表示形式会是一个括在尖括号中的字符串，其中包含对象类型的名称与通常包括对象名称和地址的附加信息。
repr(1+1)
'2'
repr(int)
"<class 'int'>"
str('python\n')
'python\n'
repr('python\n')
"'python\\n'"
内置函数（类）reversed，Python 官方文档描述如下：
help(reversed)
Help on class reversed in module builtins:
class reversed(object)
| reversed(sequence, /)
|
| Return a reverse iterator over the values of the given sequence.
|
| Methods defined here:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __iter__(self, /)
| Implement iter(self).
|
| __length_hint__(...)
| Private method returning an estimate of len(list(it)).
|
| __next__(self, /)
| Implement next(self).
|
| __reduce__(...)
| Return state information for pickling.
|
| __setstate__(...)
| Set state information for unpickling.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
返回给定的序列逆置之后的迭代器。
type(reversed)
type
reversed('1234')
<reversed at 0x14b684fe460>
list(reversed('1234'))
['4', '3', '2', '1']
因为字典顺序会确保为插入顺序，字典和字典视图都是可逆的。3.8 新版可以返回一个逆序获取字典键的迭代器。
d = reversed({'a':1,'b':2,'c':3})
list(d)
['c', 'b', 'a']
内置函数 round()，Python 官方文档描述如下：
help(round)
Help on built-in function round in module builtins:
round(number, ndigits=None)
Round a number to a given precision in decimal digits.
The return value is an integer if ndigits is omitted or None. Otherwise
the return value has the same type as the number. ndigits may be negative.
返回 number 舍入到小数点后 ndigits 位精度的值。如果 ndigits 被省略或为 None，则返回最接近输入值的整数。
对于支持 round() 的内置类型，值会被舍入到最接近的 10 的负 ndigits 次幂的倍数；如果与两个倍数的距离相等，则选择偶数。
任何整数值都可作为有效的 ndigits (正数、零或负数)。如果 ndigits 被省略或为 None 则返回值将为整数。否则返回值与 number 的类型相同。
由于大多数十进制小数实际上都不能以浮点数精确地表示。返回值可能会不是预期的四舍五入结果。
round(3.14)
3
round(3.14, 3)
3.14
round(3.14, 0)
3.0
round(13.14,-1)
10.0
round(2.5), round(-2.5)
(2, -2)
round(1.5), round(-1.5)
(2, -2)
round(2.675, 2), round(2.665, 2)
(2.67, 2.67)
内置函数（类）set，Python 官方文档描述如下：
help(set)
Help on class set in module builtins:
class set(object)
| set() -> new empty set object
| set(iterable) -> new set object
|
| Build an unordered collection of unique elements.
|
将一个可迭代对象转换为集合。可迭代对象为空，或不传参数，将得到空集合。
type(set)
type
set([])
set()
set()
set()
set('1231')
{'1', '2', '3'}
set({'1':1, '2':2, '3':3})
{'1', '2', '3'}
内置函数 setattr()，Python 官方文档描述如下：
help(setattr)
Help on built-in function setattr in module builtins:
setattr(obj, name, value, /)
Sets the named attribute on the given object to the specified value.
setattr(x, 'y', v) is equivalent to ``x.y = v''
参数为一个对象、一个字符串和一个任意值。字符串指定一个现有属性或者新增属性。函数会将值赋给该属性，只要对象允许这种操作。
class A:
y = 1
x = A()
x.y
1
# 为实例 x 新增属性
setattr(x, 'y', 10)
x.y
10
A.y
1
# 修改类 A 的 y 属性
setattr(A, 'y', 100)
A.y
100
x.y
10
内置函数（类）slice，Python 官方文档描述如下：
help(slice)
Help on class slice in module builtins:
class slice(object)
| slice(stop)
| slice(start, stop[, step])
|
| Create a slice object. This is used for extended slicing (e.g. a[0:10:2]).
|
返回一个表示由 range(start, stop, step) 指定索引集的 slice 对象。其中 start 和 step 参数默认为 None。
切片对象具有仅会返回对应参数值（或其默认值）的只读数据属性 start, stop 和 step。它们没有其他的显式功能。
type(slice)
type
s = slice(3)
s
slice(None, 3, None)
a = list(range(5))
a[s]
[0, 1, 2]
slice(2,8,2)
slice(2, 8, 2)
list(range(10)[slice(2,8,2)])
[2, 4, 6]
内置函数 sorted()，Python 官方文档描述如下：
help(sorted)
Help on built-in function sorted in module builtins:
sorted(iterable, /, *, key=None, reverse=False)
Return a new list containing all items from the iterable in ascending order.
A custom key function can be supplied to customize the sort order, and the
reverse flag can be set to request the result in descending order.
根据 iterable 中的项返回一个新的已排序列表。
具有两个可选参数，它们都必须指定为关键字参数。
key 指定带有单个参数的函数，应用于 iterable 中的每个元素，将计算结果用来对原 iterable 排序。默认值为 None (直接比较)。
reverse 为一个布尔值。如果设为 True，则每个列表元素将按反向顺序比较进行排序。
sorted() 排序确保是稳定的。如果一个排序确保不会改变比较结果相等的元素的相对顺序就称其为稳定的 — 这有利于进行多重排序。
sorted({'b':1,'a':3,'c':2})
['a', 'b', 'c']
d = [{'age':18},{'age':30},{'age':26}]
sorted(d,key=lambda x:x['age'])
[{'age': 18}, {'age': 26}, {'age': 30}]
sorted([1.5,'2.0','1.5',3.14], key=float)
[1.5, '1.5', '2.0', 3.14]
sorted('3123', reverse=True)
['3', '3', '2', '1']
内置函数（类）staticmethod，Python 官方文档描述如下：
help(staticmethod)
Help on class staticmethod in module builtins:
class staticmethod(object)
| staticmethod(function) -> method
|
| Convert a function to be a static method.
|
| A static method does not receive an implicit first argument.
| To declare a static method, use this idiom:
|
| class C:
| @staticmethod
| def f(arg1, arg2, ...):
| ...
|
| It can be called either on the class (e.g. C.f()) or on an instance
| (e.g. C().f()). The instance is ignored except for its class.
|
| Static methods in Python are similar to those found in Java or C++.
| For a more advanced concept, see the classmethod builtin.
|
将函数转换为静态方法。
静态方法不会接收隐式的第一个参数。可以传递一个函数作为参数定义为静态方法，也可以使用装饰器的形式将一个自定义函数定义为静态方法。
type(staticmethod)
type
class A:
in_print = staticmethod(print)
a = A()
a.in_print('静态方法')
静态方法
class A:
@staticmethod
def in_print(value):
print(value)
a = A()
a.in_print('静态方法')
静态方法
内置函数（类）str，Python 官方文档描述如下：
help(str)
Help on class str in module builtins:
class str(object)
| str(object='') -> str
| str(bytes_or_buffer[, encoding[, errors]]) -> str
|
| Create a new string object from the given object. If encoding or
| errors is specified, then the object must expose a data buffer
| that will be decoded using the given encoding and error handler.
| Otherwise, returns the result of object.__str__() (if defined)
| or repr(object).
| encoding defaults to sys.getdefaultencoding().
| errors defaults to 'strict'.
|
返回对象 object 的字符串形式。如果未提供 object 则返回空字符串。
如果 encoding 或 errors 至少给出其中之一，则 bytes_or_buffer 应该是一个 bytes-like object (例如字节串或字节数组)。在此情况下，如果是一个字节串 (或字节数组) 对象，则 str(bytes, encoding, errors) 等价于 bytes.decode(encoding, errors)。否则的话，会在调用 bytes.decode() 之前获取缓冲区对象下层的 bytes 对象。
将一个 bytes 对象传入 str() 而不给出 encoding 或 errors 参数，将直接转 bytes 对象为字符串。
type(str)
type
str()
''
str(int)
"<class 'int'>"
str([1,2,3])
'[1, 2, 3]'
str(b'\xe8\x87\xaa\xe5\xad\xa6',encoding='utf-8')
'自学'
b'\xe8\x87\xaa\xe5\xad\xa6'.decode(encoding='utf-8')
'自学'
str(b'\xe8\x87\xaa\xe5\xad\xa6')
"b'\\xe8\\x87\\xaa\\xe5\\xad\\xa6'"
内置函数 sum()，Python 官方文档描述如下：
help(sum)
Help on built-in function sum in module builtins:
sum(iterable, start=0, /)
Return the sum of a 'start' value (default: 0) plus an iterable of numbers
When the iterable is empty, return the start value.
This function is intended specifically for use with numeric values and may
reject non-numeric types.
通常对一个以数字为元素的可迭代对象求和并返回和。如果指定 start 参数，和需要加上 start。
start 不能为字符串，拼接字符串 sum() 不支持，更好更快的方式是 str.join() 方法。
sum() 还支持其他序列（列表和元组）。
sum([1,2,3])
6
sum(range(4), 10)
16
sum([(1,2),(3,4)], (5,))
(5, 1, 2, 3, 4)
sum([[1,2],[3]],[0])
[0, 1, 2, 3]
内置函数（类）super，Python 官方文档描述如下：
help(super)
Help on class super in module builtins:
class super(object)
| super() -> same as super(__class__, <first argument>)
| super(type) -> unbound super object
| super(type, obj) -> bound super object; requires isinstance(obj, type)
| super(type, type2) -> bound super object; requires issubclass(type2, type)
| Typical use to call a cooperative superclass method:
| class C(B):
| def meth(self, arg):
| super().meth(arg)
| This works for class methods too:
| class C(B):
| @classmethod
| def cmeth(cls, arg):
| super().cmeth(arg)
|
返回一个代理对象，它会将方法调用委托给类 type 的父类或兄弟类。这对于访问已在类中被重载的继承方法很有用。
super() 和 super(__class__, <first argument>) 一样。super 有两个典型用例：
类或方法的 __mro__ 属性列出了 getattr() 和 super() 所共同使用的方法解析顺序（MRO）。该属性是动态的，可以在任何继承层级结构发生更新的时候被改变。
除了方法查找之外，super() 也可用于属性查找。一个可能的应用场合是在上级或同级类中调用描述器。
请注意 super() 是作为显式加点属性查找的绑定过程的一部分来实现的，例如 super().__getitem__(name)。它做到这一点是通过实现自己的 __getattribute__() 方法，这样就能以可预测的顺序搜索类，并且支持协作多重继承。
还要注意的是，除了零个参数的形式以外，super() 并不限于在方法内部使用。两个参数的形式明确指定参数并进行相应的引用。零个参数的形式仅适用于类定义内部，因为编译器需要填入必要的细节以正确地检索到被定义的类，还需要让普通方法访问当前实例。
方法调用委托给父类：
type(super)
type
class A:
def add(self, x):
y = x + x
print(y)
class B(A):
def add(self, x):
super().add(x) # super() 等价于 super(B,self)
b = B()
b.add(5)
10
初始化委托给父类：
class A:
def __init__(self):
self.a = '父类A'
print ('A')
def print_msg(self,a):
print (f'{a}来自A')
class B(A):
def __init__(self):
# super(B, self) 可写为 super()
super(B, self).__init__()
print ('B')
def print_msg(self,b):
super().print_msg(b)
print (f'{b}来自B')
print (self.a)
b = B()
b.print_msg('HelloWorld')
A
B
HelloWorld来自A
HelloWorld来自B
父类A
内置函数（类）tuple，Python 官方文档描述如下：
help(tuple)
Help on class tuple in module builtins:
class tuple(object)
| tuple(iterable=(), /)
|
| Built-in immutable sequence.
|
| If no argument is given, the constructor returns an empty tuple.
| If iterable is specified the tuple is initialized from iterable's items.
|
| If the argument is a tuple, the return value is the same object.
|
将可迭代对象转换为元组。可迭代对象为空或不传参数，返回空元组。
type(tuple)
type
tuple('')
()
tuple('123')
('1', '2', '3')
内置函数（类）type，Python 官方文档描述如下：
help(type)
Help on class type in module builtins:
class type(object)
| type(object_or_name, bases, dict)
| type(object) -> the object's type
| type(name, bases, dict) -> a new type
|
传入一个参数时，返回对象的类型。推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。
传入三个参数时，返回一个新的 type 对象。这在本质上是 class 语句的一种动态形式。name 参数是字符串即类名并且会成为 __name__ 属性；bases 元组列出基类并且会成为 __bases__ 属性；而 dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 __dict__ 属性。
type(type)
type
type(int), type(object)
(type, type)
isinstance(int, object)
True
class A:
a = 1
A.__name__, A.__bases__, A.__dict__
('A',
(object,),
mappingproxy({'__module__': '__main__',
'a': 1,
'__dict__': <attribute '__dict__' of 'A' objects>,
'__weakref__': <attribute '__weakref__' of 'A' objects>,
'__doc__': None}))
A = type('A', (object,), dict(a=1))
A.__name__, A.__bases__, A.__dict__
('A',
(object,),
mappingproxy({'a': 1,
'__module__': '__main__',
'__dict__': <attribute '__dict__' of 'A' objects>,
'__weakref__': <attribute '__weakref__' of 'A' objects>,
'__doc__': None}))
内置函数 vars()，Python 官方文档描述如下：
help(vars)
Help on built-in function vars in module builtins:
vars(...)
vars([object]) -> dictionary
Without arguments, equivalent to locals().
With an argument, equivalent to object.__dict__.
返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。
模块和实例这样的对象具有可更新的 __dict__ 属性；但是，其它对象的 __dict__ 属性可能会设为限制写入（例如，类会使用types.MappingProxyType 来防止直接更新字典）。
不带参数时，vars() 的行为类似 locals()。请注意，locals 字典仅对于读取起作用，因为对 locals 字典的更新会被忽略。
如果指定了一个对象但它没有 __dict__ 属性则会引发TypeError 异常。
vars()
{'__name__': '__main__',
'__doc__': 'Automatically created module for IPython interactive environment',
'__package__': None,
'__loader__': None,
'__spec__': None,
'__builtin__': <module 'builtins' (built-in)>,
'__builtins__': <module 'builtins' (built-in)>,
'_ih': ['', "get_ipython().run_line_magic('pinfo', 'vars')", 'vars()'],
'_oh': {},
'_dh': ['E:\\xue\\脚本\\kp_book\\11_built-in_function'],
'In': ['', "get_ipython().run_line_magic('pinfo', 'vars')", 'vars()'],
'Out': {},
'get_ipython': <bound method InteractiveShell.get_ipython of <ipykernel.zmqshell.ZMQInteractiveShell object at 0x00000189A6512310>>,
'exit': <IPython.core.autocall.ZMQExitAutocall at 0x189a65b32e0>,
'quit': <IPython.core.autocall.ZMQExitAutocall at 0x189a65b32e0>,
'_': '',
'__': '',
'___': '',
'_i': 'vars?',
'_ii': '',
'_iii': '',
'_i1': 'vars?',
'_i2': 'vars()'}
def f():pass
vars(f)
{}
f.__dict__['a'] = 1
f.a
1
vars(1)
---------------------------------------------------------------------------
TypeError Traceback (most recent call last)
<ipython-input-9-3391faf83557> in <module>
----> 1 vars(1)
TypeError: vars() argument must have __dict__ attribute
内置函数（类）zip，Python 官方文档描述如下：
help(zip)
Help on class zip in module builtins:
class zip(object)
| zip(iter1 [,iter2 [...]]) --> zip object
|
| Return a zip object whose .__next__() method returns a tuple where
| the i-th element comes from the i-th iterable argument. The .__next__()
| method continues until the shortest iterable in the argument sequence
| is exhausted and then it raises StopIteration.
|
| Methods defined here:
|
| __getattribute__(self, name, /)
| Return getattr(self, name).
|
| __iter__(self, /)
| Implement iter(self).
|
| __next__(self, /)
| Implement next(self).
|
| __reduce__(...)
| Return state information for pickling.
|
| ----------------------------------------------------------------------
| Static methods defined here:
|
| __new__(*args, **kwargs) from builtins.type
| Create and return a new object. See help(type) for accurate signature.
创建一个聚合了来自每个可迭代对象中的元素的迭代器。
返回一个元组的迭代器，其中的第 i 个元组包含来自每个可迭代对象的第 i 个元素。
当所输入可迭代对象中最短的一个被耗尽时，迭代器将停止迭代。
当只有一个可迭代对象参数时，它将返回一个单元组的迭代器。
不带参数时，它将返回一个空迭代器。
type(zip)
type
zip()
<zip at 0x2ac600edac8>
list(zip('123'))
[('1',), ('2',), ('3',)]
list(zip('123',{3,2,1}))
[('1', 1), ('2', 2), ('3', 3)]
list(zip([3,2,1],(1,2,3,4),'12'))
[(3, 1, '1'), (2, 2, '2')]
list(zip(*['abc','123']))
[('a', '1'), ('b', '2'), ('c', '3')]