python内置函数详细描述与实例演示

python有许多内置函数，列出表格如下

|||内置函数||
:-|:-|:-|:-
abs()|delattr()|hash()|memoryview()|set()
all()|dict()|help()|min()|setattr()
any()|dir()|hex()|next()|slice()
ascii()|divmod()|id()|object()|sorted()
bin()|enumerate()|input()|oct()|staticmethod()
bool()|eval()|int()|open()|str()
bytearray()|filter()|issubclass()|pow()|super()
bytes()|float()|iter()|print()|tuple()
callable()|format()|len()|property()|type()
chr()|frozenset()|list()|range()|vars()
compile()|globals()|map()|reversed()|__import__()
complex()|hasattr()|max()|round()|

一一解释各个函数的功能

借鉴于内置函数 — Python 3.7.3 文档

abs(x)

返回数字的绝对值。参数可以是整数或浮点数。如果参数是一个复数，则返回其大小
用法示例

# 整数
abs(-12)
# 浮点数
abs(-12.577)
# 复数
abs(-12+5j)

结果

# 整数
12
# 浮点数
12.577
# 复数
13.0

all(iterable)

如果可迭代对象里的所有元素都为真或者可迭代对象为空则返回真
用法示例

a = [1, 2, 3, 4, 5]
all(a)
b = []
all(b)
c = [0, 1, 2, 3]
all(c)

结果

True
True
False

any(iterable)

如果可迭代对象里面有一个元素为真则返回真，如果可迭代对象为空则返回假
用法示例

a = [1, 0, 0, 0, '']
any(a)
b = [0, 0, 0, 0, '']
any(b)
c = []
any(c)

结果

True
False
False

ascii(object)

将内存数据对象转化为可打印的str形式
用法示例

def foo():
  print('balabalabala')

ascii(foo)

class A(object):
  def foo(self):
    print('balabalabala')

ascii(A)

结果

'<function foo at 0x0000022A77E34620>'
"<class '__main__.A'>"

bin(x)

将整数转换为前缀为‘ob’的二进制字符串。如果x不是int格式，则需要定义一个__index__()返回一个整数的方法
用法示例

bin(3)
bin(-10)
format(14, '#b'), format(14, 'b')
f'{14:#b}', f'{14:b}'

结果

'0b11'
'-0b1010'
('0b1110', '1110')
('0b1110', '1110')

bool([x])

返回一个布尔值，即True或False
用法示例

a = [1, 2, 3, 4]
bool(a)
b = ''
bool(b)
c = [0, 1, 2, 3]
bool(c)

结果

True
False
True

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

bytearray() 方法返回一个新字节数组。这个数组里的元素是可变的，并且每个元素的值范围:0 <= x < 256。
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果 source 为与 buffer 接口一致的对象，则此对象也可以被用于初始化 bytearray。
如果没有输入任何参数，默认就是初始化数组为0个元素。
用法示例

a = []
b = [1, 2, 3]
c = 'hello,python'
d = 1
bytearray()
bytearray(a)
bytearray(b)
bytearray(c, encoding='utf-8')
bytearray(d)

结果

bytearray(b'')
bytearray(b'')
bytearray(b'\x01\x02\x03')
bytearray(b'hello,python')
bytearray(b'\x00')

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

返回一个新的“bytes”对象，它是范围0<=x<256的不可变整数序列。字节是bytearray的不可变版本，它具有相同的非变异方法和相同的索引和切片行为。
相应地，构造函数参数解释为bytearray()
用法示例

a = []
b = [1, 2, 3]
c = 'hello, python'
d = 1
bytes(a)
bytes(b)
bytes(c, encoding='utf-8')
bytes(d)

结果

b''
b'\x01\x02\x03'
b'hello, python'
b'\x00'

callable(object)

如果参数对象显示为可调用，则返回True，否则返回False，如果返回True则调用仍可能失败，但如果返回False，则调用对象永远不会成功。
类是可调用的，如果实例的类有一个__call__方法，则实例为可调用
用法示例

class A(object):
  def foo(self):
    print('balabalabala')

class B(object):
  def foo(self):
    print('balabalabala')
  def __call__(self):
    return 'hello,python'

a = A()
b = B()
callable(A)
callable(a)
callable(b)

结果

True
False
True

chr(i)

返回表示其Unicode码位为整数i的字符的字符串。例如，chr(97)返回字符串“a”，而chr(8364)返回字符串“€”。这与ord()函数相反。
用法示例

chr(98)
chr(110)

结果

'b'
'n'

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

将source编译为代码或AST对象。代码对象可以由exec()或eval()执行。source可以是常规字符串、字节字符串或AST对象。有关如何使用AST对象的信息，请参阅ast模块文档。
参数(filename)应该给出代码读取的文件名；如果代码不需要从文件中读取，则传递一些可识别的值（例如string）。
参数(mode)指定必须编译什么类型的代码；如果source由一系列语句组成，则它可以是“exec”；如果source由单个表达式组成，则它可以是“eval”；如果source由单个交互语句组成，则它可以是“single”（在后一种情况下，将打印计算结果为非“none”的表达式语句）。
参数(flags)与(dont_inherit)控制在编译 source 时要用到哪个 future 语句。如果两者都未提供（或两者都为零），则会使用调用 compile() 的代码中有效的 future 语句来编译代码。 如果给出了 flags 参数但没有给出 dont_inherit 参数(或为零) ，那么 flags 参数所指定的 以及那些无论如何都有效的 future 语句会被使用。如果 dont_inherit 为一个非零整数，则只使用 flags 参数 -- 在调用外围有效的 future 语句将被忽略。
Future语句由bits指定，这些bits可以按 ORed 一起指定多个语句。具体特性的bits可以通过 __future__ 模块中的 _Feature 类的实例的 compiler_flag 属性来获得。
参数(optimize)指定编译器的优化级别；默认值 -1 选择与解释器的 -O 选项相同的优化级别。显式级别为 0 （没有优化；__debug__ 为真）、1 （断言被删除， __debug__ 为假）或 2 （文档字符串也被删除）。
如果编译的source无效，则此函数将引发SyntaxError错误；如果source包含空字节，则此函数将引发ValueError错误。
如果要将python代码解析为其ast表示形式，请参见ast.parse()。
注意

• 在“single”或“eval”模式下编译具有多行代码的字符串时，输入必须以至少一个换行符结尾。这有助于在代码模块中检测不完整和完整的语句。

用法示例

a = 'print(3 if 1+2>4 else 0)'
b = '''
class D():
  def foo(self):
    print('balabalabala')
D().foo()
'''
compile(a, '', 'eval')
c = compile(a, '', 'eval')
eval(c)
d = compile(c, '', 'exec')
exec(d)

结果

<code object <module> at 0x000001E3032954B0, file "", line 1>
0
balabalabala

complex([real[, imag]])

返回值为real+imag*1j的复数，或将字符串或数字转换为复数。如果第一个参数是字符串，它将被解释为复数，并且必须在没有第二个参数的情况下调用函数。第二个参数不能是字符串。每个参数可以是任何数值类型（包括复数）。如果省略imag，它将默认为零，并且构造函数充当像int和float这样的数字转换。如果两个参数都被省略，则返回0j。
注意

• 从字符串转换时，字符串不能在中央+或-运算符周围包含空格。例如complex('1+2j')不会报错，但complex('1 + 2j')会引发valueerror。

**用法示例 **

complex('3+4j')
complex(3, 4)
complex('3 + 4j')

结果

(3+4j)
(3+4j)
ValueError: complex() arg is a malformed string

delattr(object, name)

参数是一个对象和一个字符串。字符串必须是对象属性之一的名称。如果对象允许，函数将删除命名属性。
用法示例

class A(object):
  def __init__(self):
    super(A, self).__init__()
    self.name = 'Jack'
a = A()
print(a.name)
delattr(a, 'name')
print(a.name)  # 不存在则会报错

结果

Jack
AttributeError: 'A' object has no attribute 'name'

dir([object])

如果没有参数，则返回当前本地作用域中的名称列表。使用参数，尝试返回该对象的有效属性列表。
如果对象有一个名为__dir__()的方法，则将调用此方法，并且必须返回属性列表。这允许实现自定义__getattr__()或__getattribute__()函数的对象自定义dir()函数报告属性的方式。
如果对象不提供__dir__()，那么函数将尽最大努力从对象的__dict__属性（如果定义）和类型对象中收集信息。结果列表不一定完整，并且当对象具有自定义的__getAttr__()函数结果可能不准确。
默认dir()机制对于不同类型的对象的行为不同，因为它生成的是最相关而不是最完整的信息

• 如果对象是模块对象，则列表包含模块属性的名称。
• 如果对象是一个类型对象或类对象，则列表包含其属性的名称，以及其基的属性的递归名称。
• 如果属于其他对象，该列表包含对象的属性名称、类属性的名称以及类的基类属性的递归名称。
  结果列表按字母顺序排序

注意

• 因为dir()主要是为了方便在交互提示下使用而提供的，所以它应当提供一组有趣的名称，而不是提供一组严格或一致定义的名称，而且它的详细行为可能会在不同版本之间发生变化。例如，当参数是class时，metaclass属性不在结果列表中。

用法示例

import struct
dir()
dir(struct)
class Shape(object):
  def __dir__(self):
    return ['area', 'perimeter', 'location']
s = Shape()
dir(s)

结果

['__builtins__', '__name__', 'struct']
['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__',
 '__initializing__', '__loader__', '__name__', '__package__',
 '_clearcache', 'calcsize', 'error', 'pack', 'pack_into',
 'unpack', 'unpack_from']
['area', 'location', 'perimeter']

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(3, 4)
divmod(3.4, 5)
divmod(4+2j, 4+2)  # 复数会报错

结果

(0, 3)  # 返回商和余数,类似于(a//b, a%b)
(0.0, 3.4)
TypeError: can't take floor or mod of complex number.

enumerate(iterable, start=0)

返回枚举对象。iterable必须是序列、迭代器或其他支持迭代的对象。enumerate()返回的迭代器的__next__（）方法返回一个包含计数（从开始时默认为0）和通过迭代iterable获得的值的元组。
用法示例

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

结果

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

eval(expression, globals=None, locals=None)

参数可以是字符串、可选的全局变量和局部变量（全局变量必须是字典，局部变量可以是任何映射对象）
用法示例

a = 1
str = '2 if a>0 else 3'
eval(str)

结果

2

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

此函数支持python代码的动态执行。object必须是字符串(string)或代码对象(code object)。
如果是字符串，则将该字符串解析为一组python语句，然后执行该语句（除非出现语法错误）。
如果它是一个代码对象，则只需执行即可。
在任何情况下，被执行的代码都需要和文件输入一样是有效的
需要注意的是，即使在传递给exec()函数的代码上下文中，return 和 yield 语句也不能在函数定义之外使用。

**注意 **

• 内置函数globals()和locals()分别返回当前的全局和本地字典，这对于传递用作exec()的第二个和第三个参数可能很有用。

用法示例

str = '''
class A(object):
  def foo(self):
    print('balabalabala')
A().foo()
'''
exec(str)

结果

balabalabala

filter(function, iterable)

从可迭代对象中的元素构造一个迭代器，函数返回true。可迭代对象可以是序列、支持迭代的容器或迭代器。
注意

• 如果函数不是None，则该函数等效于生成器表达式

用法示例

b = filter(lambda a: a>4, range(10))
print([i for i in b])

结果

[5, 6, 7, 8, 9]

float([x])

返回由数字或字符串x构造的浮点数字。
用法示例

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

结果

1.23
-12345.0
0.001
1000000.0
-inf

format(value[, format_spec])

将value转换为“格式化的”表示形式，由format_spec控制。format_spec的解释将取决于值参数的类型，但是大多数内置类型都使用标准格式语法：Format Specification Mini-Language
默认format_spec是一个空字符串，通常与调用str(value)的效果相同。
对format(value，format_spec)的调用被转换为type(value).__format__()方法，所以实例字典中的 __format__() 方法将不会调用。如果搜索到 object 有这个方法但 format_spec 不为空，format_spec 或返回值不是字符串，会触发 TypeError 异常。
用法示例

format(255, '#x'), format(255, 'x'), format(255, 'X')
format(255, '#b'), format(255, 'b')
"{} {}".format("hello", "world")
"{0} {1}".format("hello", "world")
"{1} {0}".format("hello", "world")
"{one} {two}".format(one="hello", two="world")
class A(object):
  def __init__(self, name):
    super(A, self).__init__()
    self.name = name
a = A('Jack')
print('name is {0.name}'.format(a))
"{:.2f}".format(3.1415926535)  # 保留两位有效数字
"{:+.2f}".format(3.1415926535)  # 带符号保留两位有效数字
"{:.0f}".format(3.1415926535)  # 不保留小数
"{:0>4d}".format(3)  # 数字左边补零，宽度为4(包含数字)
"{:x<4d}".format(3)  # 数字右边补x，宽度为4(包含数字)
"{:,}".format(100000)  # 用逗号分割数字
"{:.2%}".format(0.34)  # 百分比格式表示数字
"{:.2e}".format(1000000)  # 指数形式表示数字
"{:8d}".format(123)  # 右对齐（默认），宽度为8（包含数字）
"{:<8d}".format(123)   # 左对齐，宽度为8（包含数字）
"{:^8d}".format(123)  # 居中对齐，宽度为8(包含数字)
"{:b}".format(13)  # 二进制
"{:d}".format(13)  # 十进制
"{:o}".format(13)  # 八进制
"{:x}".format(13)  # 十六进制
"{:#x}".format(13)  
"{:#X}".format(13)

结果

('0xff', 'ff', 'FF')
('0b11111111', '11111111')
'hello world'
'hello world'
'world hello'
'hello world'
'name is Jack'
'3.14'
'+3.14'
'3'
'0003'
'3xxx'
'100,000'
'34.00%'
'1.00e+06'
'     123'
'123     '
'  123   '
'1101'
'13'
'15'
'd'
'0xd'
'0XD'

frozenset([iterable])

返回一个新的 frozenset 对象，它包含可选参数 iterable 中的元素，表示不可变集合
参数 表示可迭代对象，包括列表、字典、元祖等等,不传参则创建一个空集合
用法示例

a = frozenset(range(5))
b = frozenset('China')
a
b
a.update([5, 6, 7]])
a.add('0')
len(b)

结果

frozenset({0, 1, 2, 3, 4})
frozenset({'n', 'h', 'i', 'C', 'a'})
AttributeError: 'frozenset' object has no attribute 'update'  # 报错
AttributeError: 'frozenset' object has no attribute 'add'  # 报错
5

getattr(object, name[, default])

返回对象命名属性的值。name 必须是字符串。如果该字符串是对象的属性之一，则返回该属性的值。
如果指定的属性不存在，且提供了 default 值，则返回它，否则触发 AttributeError。
用法示例

class A(object):
  attr = 'Chinese'
a = A()
getattr(a, 'attr')
getattr(a, 'name')
getattr(a, 'name', 'Jack')

结果

'Chinese'
AttributeError: 'A' object has no attribute 'name'  # 报错
'Jack'

globals()

返回表示当前全局符号表的字典。
用法示例

globals()
a = 1
b = 2
globals()

结果

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'a': 1, 'b': 2}  # 添加变量之后

hasattr(object, name)

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

class A(object):
  attr = 'country'
  def foo(self):
    print('balabalabala')
a = A()
print(hasattr(a, 'attr'))
print(hasattr(a, 'name'))
print(hasattr(a, 'foo'))

结果

True
False
True

hash(object)

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

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

用法示例

a = 1
b = 1.00
c = 'Jack'
hash(a)
print(hash(a) == hash(b))
hash(c)

结果

1
True
2543588440950493049

hex(x)

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

hex(255)
hex(-42)
'%#x' % 255, '%x' % 255, '%X' % 255
format(255, '#x'), format(255, 'x'), format(255, 'X')
f'{255:#x}', f'{255:x}', f'{255:X}'

结果

'0xff'
'-0x2a'
('0xff', 'ff', 'FF')
('0xff', 'ff', 'FF')
('0xff', 'ff', 'FF')

id(object)

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

input([prompt])

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

>>> s = input('--> ')  
--> Monty Python's Flying Circus
>>> s  
"Monty Python's Flying Circus"

int(x, base=10)

返回一个使用数字或字符串 x 生成的整数对象，或者没有实参的时候返回 0 。如果 x 定义了 __int__()，int(x) 返回 x.__int__() 。如果 x 定义了 __trunc__()，它返回 x.__trunc__() 。对于浮点数，它向零舍入。
如果 x 不是数字，或者有 base 参数，x 必须是字符串、bytes、表示进制为 base 的 整数字面值 的 bytearray 实例。该文字前可以有 + 或 - （中间不能有空格），前后可以有空格。一个进制为 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) 是合法的。
注意

• 在 3.4 版更改: 如果 base 不是 int 的实例，但 base 对象有 base.__index__ 方法，则会调用该方法来获取进制数。以前的版本使用 base.__int__ 而不是 base.__index__。

• 在 3.6 版更改: 您可以使用下划线将代码文字中的数字进行分组。

• 在 3.7 版更改: x 现在只能作为位置参数。

用法示例

int(1.34)
int('32')
int('0110', 2)

结果

1
32
6

isinstance(object, classinfo)

如果 object 实参是 classinfo 实参的实例，或者是（直接、间接或 虚拟）子类的实例，则返回 true。如果 object 不是给定类型的对象，函数始终返回 false。如果 classinfo 是对象类型（或多个递归元组）的元组，如果 object 是其中的任何一个的实例则返回 true。 如果 classinfo 既不是类型，也不是类型元组或类型的递归元组，那么会触发 TypeError 异常。
用法示例

a = 1
isinstance(a, int)
isinstance(a, float)
isinstance(a, (int, float, str, ))
isinstance(a, (float, str, ))

结果

True
False
True
False

issubclass(class, classinfo)

如果 class 是 classinfo 的子类（直接、间接或 虚拟 的），则返回 true。classinfo 可以是类对象的元组，此时 classinfo 中的每个元素都会被检查。其他情况，会触发 TypeError 异常。与 isinstance 类似
用法示例

class A(object):
  pass
class B(A):
  pass
issubclass(A, object)
issubclass(B, A)
issubclass(B, (object, int, str, float))

结果

True
True
True

iter(object[, sentinel])

返回一个 iterator 对象。根据是否存在第二个实参，第一个实参的解释是不同的。

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

用法示例

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

结果

1
2
3
4
5

len(s)

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

list([iterable])

返回列表,除了是函数，list 也是可变序列类型。
用法示例

print(list('Jack'))
print(list(range(5)))
print(list((1, 2, 3, 4)))

结果

['J', 'a', 'c', 'k']
[0, 1, 2, 3, 4]
[1, 2, 3, 4]

locals()

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

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

用法示例

def foo():
  a = 1
  b = 2
  print(locals())
foo()
print(locals())

结果

{'b': 2, 'a': 1}
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'foo': <function foo at 0x000001C6AED61E18>}

map(function, iterable, ...)

产生一个将function应用于迭代器中所有元素并返回结果的迭代器。如果传递了额外的iterable实参，function必须接受相同个数的实参，并使用所有迭代器中并行获取的元素。当有多个迭代器时，最短的迭代器耗尽则整个迭代结束。
用法示例

b = map(lambda a:a**2, range(1, 4))
print([i for i in b])
c = map(lambda x, y:x+y, range(1, 4), range(4, 7))
print([i for i in c])

结果

[1, 4, 9]

[5, 7, 9]

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

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

返回可迭代对象中最大的元素，或者返回两个及以上实参中最大的。
如果只提供了一个位置参数，它必须是非空 iterable，返回可迭代对象中最大的元素；如果提供了两个及以上的位置参数，则返回最大的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。
如果有多个最大元素，则此函数将返回第一个找到的。这和其他稳定排序工具如 sorted(iterable, key=keyfunc, reverse=True)[0] 和 heapq.nlargest(1, iterable, key=keyfunc) 保持一致。

用法示例

max(120, 300, 400)
max({1:2,2:2,3:1,4:'aa'})
max('1,2,3,4')
max([1,2,3,4])
max([(2, 2), (3,4), (2,4), (5, 4), (5,6)])

结果

400
4
'4'
4
(5, 6)

memoryview(obj)

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

a = bytearray('Jack', encoding='utf-8')
b = memoryview(a)
b
print(b[0])
print(b.tobytes())

结果

<memory at 0x000001C6B0A3B108>
74
b'Jack'

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

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

返回可迭代对象中最小的元素，或者返回两个及以上实参中最小的。
如果只提供了一个位置参数，它必须是 iterable，返回可迭代对象中最小的元素；如果提供了两个及以上的位置参数，则返回最小的位置参数。
有两个可选只能用关键字的实参。key 实参指定排序函数用的参数，如传给 list.sort() 的。default 实参是当可迭代对象为空时返回的值。如果可迭代对象为空，并且没有给 default ，则会触发 ValueError。
如果有多个最小元素，则此函数将返回第一个找到的
用法示例
用法示例参照max()对比

next(iterator[, default])

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

a = iter(range(3))
next(a)
next(a)
next(a)
next(a)

结果

0
1
2
StopIteration  # 报错

object

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

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

oct(x)

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

>>> oct(8)
'0o10'
>>> oct(-56)
'-0o70
# 如果要将整数转换为八进制字符串，并可选择有无“0o”前缀，则可以使用如下方法：
>>> '%#o' % 10, '%o' % 10
('0o12', '12')
>>> format(10, '#o'), format(10, 'o')
('0o12', '12')
>>> f'{10:#o}', f'{10:o}'
('0o12', '12')

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

打开 file 并返回对应的 file object。如果该文件不能打开，则触发 OSError。

• file参数 是一个 path-like object，表示将要打开的文件的路径（绝对路径或者当前工作目录的相对路径），也可以是要被封装的整数类型文件描述符。（如果是文件描述符，它会随着返回的 I/O 对象关闭而关闭，除非 closefd 被设为 False 。）
• mode参数 是一个可选字符串，用于指定打开文件的模式。默认值是 'r'，在文本模式，如果 encoding 没有指定，则根据平台来决定使用的编码：使用 locale.getpreferredencoding(False) 来获取本地编码。（要读取和写入原始字节，请使用二进制模式并不要指定 encoding。）

可用的模式有：

字符	意义
'r'	读取（默认）
'w'	写入，并先截断文件
'x'	排它性创建，如果文件已存在则失败
'a'	写入，如果文件存在则在末尾追加
'b'	二进制模式
't'	文本模式（默认）
'+'	更新磁盘文件（读取并写入）
	默认的模式是 'r' （打开并读取文本，同 'rt' ）。对于二进制写入， 'w+b' 模式打开并把文件截断成 0 字节； 'r+b' 则不会截断。

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

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

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

• errors参数 是一个可选的字符串参数，用于指定如何处理编码和解码错误 - 这不能在二进制模式下使用。可以使用各种标准错误处理程序

• newline参数 控制 universal newlines 模式如何生效（它仅适用于文本模式）。它可以是 None，''，'\n'，'\r' 和 '\r\n'。

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

• opener参数 可以通过传递可调用的 opener 来使用自定义开启器。然后通过使用参数（ file，flags ）调用 opener 获得文件对象的基础文件描述符。 opener 必须返回一个打开的文件描述符

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

file object方法:

• file.read([size])：size 未指定则返回整个文件.
• file.readline()：返回一行。
• file.readlines([size]) ：返回包含size行的列表, size 未指定则返回全部行。
• for line in f: print line ：通过迭代器访问每一行
• f.write("hello\n")：写入
• f.tell()：返回一个整数,表示当前文件指针的位置(就是到文件头的比特数)。
• f.seek(偏移量,[起始位置])：用来移动文件指针。偏移量: 单位为比特，可正可负，起始位置: 0 - 文件头, 默认值; 1 - 当前位置; 2 - 文件尾
• f.close() 关闭文件

ord(c)

对表示单个 Unicode 字符的字符串，返回代表它 Unicode 码点的整数,是chr()的逆函数
用法示例

>>> ord('a')
97
>>> ord('€')
8364

pow(x, y[, z])

返回 x 的 y 次幂；如果 z 存在，则对 z 取余（比直接 pow(x, y) % z 计算更高效）。两个参数形式的 pow(x, y) 等价于幂运算符： x**y。
参数必须为数值类型。如果第二个参数为负值，则第三个参数必须省略。 如果存在 z，则 x 和 y 必须为整数类型，且 y 必须为非负数。
用法示例

pow(2, 2)
pow(2, 2, 3)
pow(2, -2, 3)

结果

4
1
ValueError: pow() 2nd argument cannot be negative when 3rd argument specified  # 报错

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

将 objects 打印到 file 指定的文本流，以 sep 分隔并在末尾加上 end。 sep, end, file 和 flush 如果存在，它们必须以关键字参数的形式给出。所有非关键字参数都会被转换为字符串sep 和 end 都必须为字符串；它们也可以为 None，这意味着使用默认值。 如果没有给出 objects，则 print() 将只写入 end。

• file 参数 必须是一个具有 write(string) 方法的对象；如果参数不存在或为 None，则将使用 sys.stdout。 由于要打印的参数会被转换为文本字符串，因此 print() 不能用于二进制模式的文件对象。 对于这些对象，应改用 file.write(...)。
  输出是否被缓存通常决定于 file，但如果 flush 关键字参数为真值，流会被强制刷新。

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

返回 property 属性

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

用法示例

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.")
c = C()
print(c.x)  # 将调用getter
c.x = 'Jack'  # 将调用setter
print(c.x)
del c.x  # 将调用deleter
priint(c.x)

class D:
    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
# 与上面的例子完全等价  
d = D()
print(d.x)
d.x = 'Petter'
print(d.x)
del d.x
print(d.x)

结果

None
Jack
AttributeError: 'C' object has no attribute '_x'  # 报错

None
Petter
AttributeError: 'D' object has no attribute '_x'  # 报错

range(stop)

range(start, stop[, step])

虽然被称为函数，但 range 实际上是一个不可变的序列类型
用法示例

a = range(5)
print([i for i in a])  # 或者print(list(a))
b = range(1, 5)
print([i for i in b])
c = range(1, 5, 2)
print([i for i in c])

结果

[0, 1, 2, 3, 4]
[1, 2, 3, 4]
[1, 3]

repr(object)

返回包含一个对象的可打印表示形式的字符串。类可以通过定义 __repr__() 方法来控制此函数为它的实例所返回的内容。
用法示例

str = 'Jack'
repr(str)
dic = {'zhangsan':'21', 'lisi':'20', 'wangwu':'30'}
repr(dic)
class A(object):
  pass
a = A()
repr(a)
class B(object):
  def __repr__(self):
    return 'In the B'
b = B()
repr(b)

结果

"'Jack'"
"{'zhangsan': '21', 'lisi': '20', 'wangwu': '30'}"
'<__main__.A object at 0x0000019C70433C88>'
'In the B'

reversed(seq)

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

str = 'Petter'
print(list(reversed(str)))
tup = (1, 2, 3, 4, 5)
print(list(reversed(tup)))
ran = range(5)
print(list(reversed(ran)))
lis = [1, 2, 3, 4, 5]
print(list(reversed(lis)))

结果

['r', 'e', 't', 't', 'e', 'P']
[5, 4, 3, 2, 1]
[4, 3, 2, 1, 0]
[5, 4, 3, 2, 1]

round(number[, ndigits])

返回 number 舍入到小数点后 ndigits 位精度的值。 如果 ndigits 被省略或为 None，则返回最接近输入值的整数。
对于一般的 Python 对象 number, round 将委托给 number.__round__。
注意

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

用法示例

print("round(3.1415926, 2)", round(3.1415926, 2))
print("round(1000.00001, 4)", round(1000.00001, 4))

结果

round(3.1415926, 2) 3.14
round(1000.00001, 4) 1000.0

set([iterable])

返回一个新的 set 对象，可以选择带有从 iterable 获取的元素。 set 是一个内置类型。
用法示例

>>> a = set('Petter')
>>> b = set('Jack')
>>> a, b
({'P', 'r', 'e', 't'}, {'a', 'k', 'c', 'J'})  # 去重
>>> a | b
{'a', 't', 'c', 'e', 'k', 'P', 'r', 'J'}  # 并集
>>> a & b  # 交集
set()
>>> a - b  # 差集
{'P', 'e', 'r', 't'}

setattr(object, name, value)

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

slice(stop)

slice(start, stop[, step])

返回一个表示由 range(start, stop, step) 所指定索引集的 slice 对象。
其中 start 和 step 参数默认为 None。
例如：a[start:stop:step] 或 a[start:stop, i]。

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

根据 iterable 中的项返回一个新的已排序列表。
具有两个可选参数，它们都必须指定为关键字参数。

• key参数 指定带有单个参数的函数，用于从 iterable 的每个元素中提取用于比较的键 (例如 key=str.lower)。 默认值为 None (直接比较元素)。
• reverse参数 为一个布尔值。 如果设为 True，则每个列表元素将按反向顺序比较进行排序。

用法示例

>>> a = [3,5,6,7,8,5]
>>> sorted(a)
[3, 5, 5, 6, 7, 8]
>>> lis = [(1,'s'), (3,'r'), (2, 't'), (2, 'f'), (7, 'e')]
>>> sorted(lis, key=lambda x:x[0])  # 升序
[(1, 's'), (2, 't'), (2, 'f'), (3, 'r'), (7, 'e')]
>>> sorted(lis, key=lambda x:x[0], reverse=True)  # 降序
[(7, 'e'), (3, 'r'), (2, 't'), (2, 'f'), (1, 's')]

@staticmethod

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

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

静态方法的调用可以在类上进行 (例如 C.f()) 也可以在实例上进行 (例如 C().f())。
Python中的静态方法与Java或C ++中的静态方法类似，用于创建备用类构造函数的变体。
像所有装饰器一样，也可以像常规函数一样调用 staticmethod ，并对其结果执行某些操作。比如某些情况下需要从类主体引用函数并且您希望避免自动转换为实例方法。对于这些情况，请使用此语法:

class C:
    builtin_open = staticmethod(open)

str(object='')

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

返回一个 str 版本的 object 。str 是内置字符串 class 。

sum(iterable[, start])

从 start 开始自左向右对 iterable 中的项求和并返回总计值。 start 默认为 0。 iterable 的项通常为数字，开始值不允许为字符串。
对某些用例来说，存在 sum() 的更好替代。 拼接字符串序列的更好更快方式是调用 ''.join(sequence)。要以扩展精度对浮点值求和，math.fsum()。要拼接一系列可迭代对象，itertools.chain()。
用法示例

>>> sum([1,2,3])
6
>>> sum((1,2,3), 4)  # 元祖计算结果后加4
10
>>> sum([1,2,3], 4)  # 列表计算结果后加4
10

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

返回一个代理对象，它会将方法调用委托给 type 指定的父类或兄弟类。这对于访问已在类中被重载的继承方法很有用。 搜索顺序与 getattr() 所使用的相同，只是 type 指定的类型本身会被跳过。
type 的 __mro__ 属性列出了 getattr() 和 super() 所使用的方法解析顺序。 该属性是动态的，可以在继承层级结构更新的时候任意改变。
如果省略第二个参数，则返回的超类对象是未绑定的。 如果第二个参数为一个对象，则 isinstance(obj, type) 必须为真值。 如果第二个参数为一个类型，则 issubclass(type2, type) 必须为真值（这适用于类方法）。
用法示例

class C(B):
    def method(self, arg):
        super().method(arg)  # 与super(C, self).method(arg)一致

tuple([iterable])

将可迭代对象转换为元祖，虽然被称为函数，但 tuple 实际上是一个不可变的序列类型

type(object)

type(name, bases, dict)

传入一个参数时，返回 object 的类型。 返回值是一个 type 对象，通常与 object.__class__ 所返回的对象相同。
推荐使用 isinstance() 内置函数来检测对象的类型，因为它会考虑子类的情况。
传入三个参数时，返回一个新的 type 对象。 这在本质上是 class 语句的一种动态形式。 name 字符串即类名并且会成为 __name__ 属性；bases 元组列出基类并且会成为 __bases__ 属性；而 dict 字典为包含类主体定义的命名空间并且会被复制到一个标准字典成为 __dict__ 属性。

• 在 3.6 版更改: type 的子类如果未重载 type.__new__，将不再能使用一个参数的形式来获取对象的类型。

用法示例

def foo(self):
  print('in the foo')

A = type('A', (object,), {'foo':foo})  # 创建一个类，继承自object

class B(object):
  def foo(self):
    print('in the foo')
a = A()  # 实例化A类
b = B()  # A与B一致

vars([object])

返回模块、类、实例或任何其它具有 __dict__ 属性的对象的 __dict__ 属性。
模块和实例这样的对象具有可更新的 __dict__ 属性；但是，其它对象的 __dict__ 属性可能会设为限制写入（例如，类会使用 types.MappingProxyType 来防止直接更新字典）。
不带参数时，vars() 的行为类似 locals()。 请注意，locals 字典仅对于读取起作用，因为对 locals 字典的更新会被忽略。
用法示例

print(vars())
class A(object):
  a = 1
print(vars(A))

结果

{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
{'__module__': '__main__', 'a': 1, '__dict__': <attribute '__dict__' of 'A' objects>, '__weakref__': <attribute '__weakref__' of 'A' objects>, '__doc__': None}

zip(*iterables)

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

>>> 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))  # zip() 与 * 运算符相结合可以用来拆解一个列表
>>> x == list(x2) and y == list(y2)
True

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

此函数会由 import 语句发起调用。 它可以被替换 (通过导入 builtins 模块并赋值给 builtins.__import__) 以便修改 import 语句的语义，但是 强烈 不建议这样做.
同样也不建议直接使用 __import__() 而应该用 importlib.import_module()。
该函数会导入 name 模块，有可能使用给定的 globals 和 locals 来确定如何在包的上下文中解读名称。 fromlist 给出了应该从由 name 指定的模块导入对象或子模块的名称。
level 指定是使用绝对还是相对导入。 0 (默认值) 意味着仅执行绝对导入。 level 为正数值表示相对于模块调用 __import__() 的目录，将要搜索的父目录层数
当 name 变量的形式为 package.module 时，通常将会返回最高层级的包（第一个点号之前的名称），而 不是 以 name 命名的模块。 但是，当给出了非空 的 fromlist 参数时，则将返回以 name 命名的模块。
注意

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

用法示例

spam = __import__('spam', globals(), locals(), [], 0)  # 与直接使用import spam一致
spam = __import__('spam.ham', globals(), locals(), [], 0)  # 与直接使用import spam.ham一致
_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)  # 与from spam.ham import eggs, sausage as saus一致
eggs = _temp.eggs
saus = _temp.sausage

import importlib
c = importlib.import_module('b.c.c')  # 绝对导入
c = importlib.import_module('.c.c',package='b')  # 相对导入
c.C().arg  # 直接取出类中的变量