Python3 内置函数

Python3 内置函数

---

为了方便我们使用，Python解释器内置了许多全局可用的函数和类型。
Python3英文官方文档详细说明：点击查看
在此将内置函数的总结记录下来，以便日后查看。

		内置函数
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()
breakpoint() 3.7+	exec()	isinstance()	ord()	sum()
bytearray()	filter()	issubclass()	pow()	super()
bytes()	float()	iter()	print()	tuple()
callable()	format()	len()	property()	type()
chr()	frozenset()	list()	range()	vars()
classmethod()	getattr()	locals()	repr()	zip()
compile()	globals()	map()	reversed()	__import__()
complex()	hasattr()	max()	round()

---

abs(x)

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

>>> abs(7)
7
>>> abs(-7)
7
>>> abs(7.7)
7.7
>>> abs(-7.7)
7.7
>>> abs(7.7+7j)
10.406248123122953
>>> abs(-7.7+7j)
10.406248123122953

---

all(iterable)

返回布尔值。参数是可迭代的对象。
如果对于可迭代对象中的所有值 x，bool（ x）都为True，则返回True。
如果iterable为空，则返回True。
否则返回False。

全真则真

>>> all("sfasdasd")
True
>>> all("")
True
>>> all([1,2,3,4,5,7,8,9,0])
False
>>> all([1,2,3,4,5,7,8,9])
True

---

any(iterable)

返回布尔值。参数是可迭代的对象。
如果对于可迭代对象中的任何一个值 x，bool（ x）都为True，则返回True。
如果iterable为空，则返回False。
否则返回False。

全假则假

>>> any([False,1,0])
True
>>> any([False,0])
False
>>> any([])
False
>>> any([False,0,None])
False

---

ascii(obj)

返回对象用ASCII码表示的字符串。
对象中的非ASCII码的字符，在返回的字符串中使用 \x，\ u 或 \ U 进行转义。

WIN系统下是使用 \\x，\\u 或 \\U 进行转义。

>>> ascii("abc123XYZ!@#中文OxFA2636è½½æ")
"'abc123XYZ!@#\\u4e2d\\u6587OxFA2636\\xe8\\xbd\\xbd\\xe6'"

---

bin(x)

返回将整数转换为前缀为“0b”的二进制字符串。参数是整数。

>>> bin(2983)
'0b101110100111'

---

bool(x)

返回一个布尔值，即 True 或者之一 False。
当参数 x 为真时返回 True，否则返回 False。
类 bool 的 唯一两个实例是内置的 True 和 False。

>>> bool(0)
False
>>> bool(1)
True
>>> bool(7)
True
>>> bool("h")
True
>>> bool(True)
True
>>> bool(False)
False
>>> bool(3==7)
False
>>> bool(3<7)
True
>>> bool(3>7)
False
>>> bool(0 or 1)
True
>>> bool(0 and 1)
False
>>> bool(not 1)
False
>>> bool(not 0)
True

---

breakpoint(* args，** kws)

设置断点，进入选择的调试器。

版本3.7中的新功能。

---

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

返回一个字节数组。这个数组里的元素是可变的，并且每个元素的值范围: 0 <= x < 256。
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果没有输入任何参数，默认就是初始化数组为0个元素。

>>> bytearray(7)
bytearray(b'\x00\x00\x00\x00\x00\x00\x00')
>>> bytearray("star","utf-8")
bytearray(b'star')
>>> bytearray([7,11,234])
bytearray(b'\x07\x0b\xea')
>>> bytearray()
bytearray(b'')

---

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

返回一个字节对象。该对象是一个 0 <= x < 256 区间内的整数不可变序列。它是 bytearray 的不可变版本。
如果 source 为整数，则返回一个长度为 source 的初始化数组；
如果 source 为字符串，则按照指定的 encoding 将字符串转换为字节序列；
如果 source 为可迭代类型，则元素必须为[0 ,255] 中的整数；
如果没有输入任何参数，默认就是初始化数组为0个元素。

>>> bytes(7)
b'\x00\x00\x00\x00\x00\x00\x00'
>>> bytes("star","utf-8")
b'star'
>>> bytes([7,11,234])
b'\x07\x0b\xea'
>>> bytes()
b''

---

callable(obj )

返回一个对象是否可调用（即某种函数）。
如果object参数为可调用的则返回True，否则返回False。
如果返回True，调用仍然可能失败，但如果为False，则调用对象将永远不会成功。
类是可调用的（调用类会返回一个实例）; 如果实例的类有_call_()方法，则实例是可调用的。

>>> callable(7)
False
>>> callable("h")
False
>>> callable(abs)
True
>>> class text():
...     print("text")
...
>>> callable(text)
True
>>> a = text()
>>> callable(a)
False
>>> class text2():
...     def __call__(self):
...         print("text2")
...
>>> callable(text2)
True
>>> b = text2()
>>> callable(b)
True

---

chr( i )

返回表示 Unicode码 为整数 i 的字符的字符串。
参数的有效范围是 0 <= i <= 1,114,111（16进制：0 <= i <= 0x10FFFF）。

与 ord() 的作用是相反的。

>>> chr(0)
'\x00'
>>> chr(1114111)
'\U0010ffff'
>>> chr(0x10ffff)
'\U0010ffff'
>>> chr(97)
'a'
>>> chr(48)
'0'
>>> chr(65)
'A'

---

classmethod( function )

将 方法 转换为 类方法。
类方法 接收 类 作为隐藏的第一个参数。

@classmethod 形式是一个函数装饰器。

要声明一个 类方法，使用格式：

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

---

compile（source，filename，mode，flags = 0，dont_inherit = False，optimize = -1 ）

将源 source 编译为可由 exec() 或 eval() 执行的代码对象。
source 可以是普通字符串，字节字符串；可以是Python模块，语句或表达式。
filename 为代码文件名称，如果不是从文件读取代码则传递一些可辨认的值（通常使用 ‘< string >’）。
mode 参数指定编译代码的种类;如果 source 包含一系列语句，则可以是 ‘exec’，如果 source 由单个表达式组成，则为 ‘eval’，如果 source 由单个交互式语句组成，则为 ‘single’。
optimize 指定编译器的优化级别;默认值-1，选择 -O 选项给出的解释器的优化级别。显式级别为0（无优化; __debug__为真），1（断言被删除，__ debug__为假）或2（文档字符串也被删除）。

一般用法 compile(‘source’，’ ‘，’mode’)。

>>> c1 = compile("for i in range(10): print(i)","","exec")
>>> exec(c1)
0
1
2
3
4
5
6
7
8
9
>>> c2 = compile("1+4+7+8+5+2","","eval")
>>> eval(c2)
27
>>> c3 = compile('name = input("please input your name:")',"","single")
>>> name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
NameError: name 'name' is not defined
>>> exec(c3)
please input your name:star
>>> name
'star'

---

complex（[real[, imag]] ）

返回值为复数;或将字符串或数字转换为复数。
如果 real 参数是一个字符串，将被解释为一个复数，必须在没有 imag 参数的情况下调用该函数。
imag 参数永远不能是字符串。
参数可以是任何数字类型（包括复数）。如果省略 imag，则默认为零。
如果省略两个参数，则返回0j。

注意：从字符串转换时，字符串内运算符周围不能有空格。

>>> complex('1+2j')
(1+2j)
>>> complex(1+2j,5j)
(-4+2j)
>>> complex(1,5j)
(-4+0j)
>>> complex(1,5)
(1+5j)
>>> complex(1+2j,5)
(1+7j)
>>> complex(1+2j,5.5)
(1+7.5j)
>>> complex(1.5,5.5)
(1.5+5.5j)
>>> complex()
0j
>>> complex('1 + 2j')    # 有空格
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
ValueError: complex() arg is a malformed string

---

delattr（obj，name ）

从给定对象 obj 中删除属性 name。

>>> class text(object):
...     def __init__(self):
...         self.name = 'name'
...         self.age = 18
...
>>> t = text()
>>> print(t.name)
name
>>> print(t.age)
18
>>> delattr(t, 'name')
>>> print(t.name)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: 'text' object has no attribute 'name'
>>> print(t.age)
18

---

dict（ ）

dict（）创建一个新的空字典。

dict（ mapping ）从映射对象初始化新字典, （键 , 值）。

dict（ iterable ）从可迭代对象初始化新字典。

dict（ ** kwargs ）从命名参数初始化新字典, （键 = 值）。

>>> dict()
{}
>>> dict(zip(['one', 'two', 'three'], [1, 2, 3]))
{'one': 1, 'two': 2, 'three': 3}
>>> dict([('two', 2), ('one', 1), ('three', 3)])
{'two': 2, 'one': 1, 'three': 3}
>>> dict(one=1, two=2, three=3)
{'one': 1, 'two': 2, 'three': 3}

---

dir（ [object] ）

返回 object 对象的有效属性的字符串列表。
在没有参数的情况下调用，则返回当前环境范围中的名称。
使用参数，则返回 object 对象的有效属性列表。
如果 object 对象有 __dir__（）方法，则调用 object 对象的此方法，并且返回属性列表。

这允许实现自定义 __getattr__（） 或 __getattribute__（）函数方法,实现自定义dir（）属性列表。

如果对象是模块对象，则包含模块属性的名称。
如果对象是类型或类对象，则包含其属性的名称，并递归地包含其父类的属性。

当参数是类时，元类属性不在结果列表中。

>>> dir()
['__annotations__', '__builtins__', '__doc__', '__loader__', '__name__', '__package__', '__spec__']
>>> dir(dir)
['__call__', '__class__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__name__', '__ne__', '__new__', '__qualname__', '__reduce__', '__reduce_ex__', '__repr__', '__self__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__text_signature__']

---

divmod（ x, y ）

返回一个元组。
将两个（非复数）数值作为参数，并在使用整数除法时返回由 商 和 余数 组成的一对数。

>>> divmod(9,2)
(4, 1)
>>> divmod(9.7,2)
(4.0, 1.6999999999999993)
>>> divmod(9.7,2.2)
(4.0, 0.8999999999999986)
>>> divmod(9,2.2)
(4.0, 0.1999999999999993)
>>> divmod(9+7,2+3)
(3, 1)

---

enumerate（ iterable, start=0 ）

返回一个枚举对象。
iterable 必须是可迭代的对象。返回一个包含计数（从start开始，默认为0）和迭代得到的值的元组。

>>> text = ['Spring', 'Summer', 'Fall', 'Winter']
>>> list(enumerate(text))
[(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
>>> list(enumerate(text,3))
[(3, 'Spring'), (4, 'Summer'), (5, 'Fall'), (6, 'Winter')]

---

eval（ expression, globals=None, locals=None ）

返回值是参数 expression 的结果。
参数 expression 是一个表达式或任意由 compile（）创建的代码对象。如果提供， globals 必须是字典。 locals 可以是任何映射对象。

>>> eval("1+5+8+4+5")
23
>>> c1 = compile("for i in range(10): print(i,end='\t')","","exec")
>>> eval(c1)
0       1       2       3       4       5       6       7       8       9
>>> c2 = compile("1+4+7+8+5+2","","eval")
>>> eval(c2)
27

---

exec（ object[, globals[, locals]] ）

返回值是参数 expression 的结果。
参数 object 是一个表达式或任意由 compile（）创建的代码对象。如果提供， globals 必须是字典。 locals 可以是任何映射对象。

>>> exec("for i in range(10): print(i,end='\t')")
0       1       2       3       4       5       6       7       8       9       >>> c1 = compile("for i in range(10): print(i,end='\t')","","exec")
>>> exec(c1)
0       1       2       3       4       5       6       7       8       9

---

filter（ function or None, iterable ）

返回一个迭代器，如果函数不是None，则filter（function，iterable）等效于生成器表达式， 如果function为None，则返回true的项。
filter() 函数用于过滤序列，过滤掉不符合条件的元素，返回由符合条件元素组成的新列表。
接收两个参数，第一个为函数，第二个为可迭代序列（不是迭代器），序列的每个元素作为参数传递给函数进行判，然后返回 True 或 False，最后将返回 True 的元素放到新列表中。

>>> def text(x):
...     return x % 2 == 1
...
>>> list1 = [i for i in range(19)]
>>> new = filter(text, list1)
>>> [i for i in new]
[1, 3, 5, 7, 9, 11, 13, 15, 17]
>>> list1
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
>>> list2 = (i for i in range(19))
>>> [i for i in list2]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18]
>>> list2
<generator object <genexpr> at 0x00000272BCDC3990>
>>> new2 = filter(text, list2)
>>> [i for i in new2]
[]

---

float（ x ）

返回一个由数字或字符串 x 构造的浮点数。
如果没有给出参数，则返回0.0。

>>> float(9)
9.0
>>> float(-9)
-9.0
>>> float('+2E-33')
2e-33
>>> float('-3e-33')
-3e-33
>>> float('infinity')
inf
>>> float('-infinity')
-inf
>>> float()
0.0

---

format（ value, format_spec=”“ ）

将 value 转换为“格式化”表示，由 format_spec 控制格式。

>>> "{} {}".format("hello","world")
'hello world'
>>> "{1} {1}".format("hello","world")
'world world'
>>> "{0} {0}".format("hello","world")
'hello hello'
>>> "{name}:{gender}".format(name = "star", gender = "man")
'star:man'
>>> "{:+.3f}".format(684.485348)
'+684.485'
>>> "{:b}".format(4348)
'1000011111100'
>>> "{:d}".format(4348)
'4348'
>>> "{:o}".format(4348)
'10374'
>>> "{:x}".format(4348)
'10fc'
>>> "{:#x}".format(4348)
'0x10fc'
>>> "{:#X}".format(4348)
'0X10FC'

---

frozenset（ object ）

返回一个冻结的集合，冻结后集合不能再添加或删除任何元素。
iterable 是可迭代的对象。不传参数返回一个空的冻结的集合。

>>> a = frozenset()
>>> a
frozenset()
>>> b = frozenset(range(10))
>>> b
frozenset({0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
>>> dir(a)      # 没有更改的方法
['__and__', '__class__', '__contains__', '__delattr__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__iter__', '__le__', '__len__', '__lt__', '__ne__', '__new__', '__or__', '__rand__', '__reduce__', '__reduce_ex__', '__repr__', '__ror__', '__rsub__', '__rxor__', '__setattr__', '__sizeof__', '__str__', '__sub__', '__subclasshook__', '__xor__', 'copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']

---

getattr（ object, name[, default] ）

返回 object 对象的 name 属性的值。
name必须是一个字符串，如果是对象属性之一的名称，则结果是该属性的值。
如果给出了 default 参数，则在属性不返回时返回它，在这种情况下会引发例外。
如果没有 default 参数，在属性不返回时，则引发AttributeError。

>>> class text(object):
...     name = 'star'
...     age = 18
...
>>> getattr(text,'name')
'star'
>>> getattr(text,'age',16)
18
>>> getattr(text,'gender','man')
'man'
>>> getattr(text,'gender')
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'text' has no attribute 'gender'

---

globals（ ）

返回包含当前环境的全局变量的字典。

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

---

hasattr（ object, name ）

返回布尔值。
如果 name 是 object 对象的属性，则结果为True，否则返回False。 （这是通过调用getattr（object，name）并查看它是否引发AttributeError来实现的。）

>>> class text(object):
...     name = 'star'
...     age = 18
...
>>> hasattr(text,'name')
True
>>> hasattr(text,'gender')
False

---

hash（ object ）

返回 object 对象的哈希值。

>>> hash(0)
0
>>> hash(1)
1
>>> hash(1.0)
1
>>> hash('a')
-4081453637750261806
>>> hash('A')
-4002580005845345212
>>> hash(123456789876543216484548646)
2114213238349232149
>>> hash(-1.0)
-2
>>> hash(-1)
-2
>>> hash(-2)
-2

---

help（ [object] ）

调用 object 对象内置的帮助文档。
如果未给出参数，则交互式帮助系统将在解释器控制台上启动。
如果参数是字符串，则查找字符串作为模块，函数，类，方法，关键字或文档主题的名称，并在控制台上打印帮助页面。
如果参数是任何其他类型的对象，则会生成对象的帮助页面。

>>> help(hash)
Help on built-in function hash in module builtins:
hash(obj, /)
    Return the hash value for the given object.
>>> help()
Welcome to Python 3.6's help utility!
help> q
>>>

---

hex（ number ）

返回整数的带有前缀“0x”十六进制表示。
如果要将整数转换为 带有前缀 或 不带前缀 的 大写 或 小写 十六进制字符串，可以使用格式化方法。

>>> hex(1236987)
'0x12dffb'
>>> '%#x'%1236987,'%#X'%1236987,'%x'%1236987,'%X'%1236987
('0x12dffb','0x12dffb','12dffb','12DFFB')
>>> format(1236987,'#x'),format(1236987,'#X'),format(1236987,'x'),format(1236987,'X')
('0x12dffb','0x12DFFB','12dffb','12DFFB')
>>> f'{1236987:#X}',f'{1236987:#x}',f'{1236987:x}',f'{1236987:X}'
（'0X12DFFB'，'0x12dffb'，'12dffb'，'12DFFB'）

---

id（ obj ）

返回对象的标识。对象的内存地址。
这保证在同时存在的对象中是唯一的。

>>> id(1)
1780510176
>>> id('a')
2060288327104
>>> id('1')
2060288415536

---

input（ prompt=None ）

从输入中读取一行，将其转换为字符串（剥离尾部换行符），然后返回该行。
如果给出了 prompt 提示字符串参数，则将其写入标准输出而不带尾随换行符，
在读取输入之前跟踪换行符。

>>> a = input("提示字符串,请输入：")
提示字符串,请输入：输入我的内容。
>>> a
'输入我的内容。'

---

int（ x = 0，base = 10 ）

返回由数字或字符串 x 构造的整数对象，如果没有给出参数，则返回0。
对于浮点数，这将截断为零。
如果 x 不是数字或者给出了 base，那么x必须是一个字符串、bytes或bytearray实例。
base 表示给定的基数。基数默认为10，有效基数为0和2-36。
base-2，base-8和base-16 可以选择前缀为0b / 0B，0o / 0O或0x / 0X 表示。

>>> int()
0
>>> int('101010',2)
42
>>> int('101010',3)
273
>>> int('101010',4)
1092
>>> int('101010',8)
33288
>>> int('101010',10)
101010
>>> int('101010',12)
250572
>>> int('abcdef',16)
11259375
>>> int('abcdef',36)
623714775

---

isnistance（ obj, class_or_tuple ）

返回 obj 对象是 类 的实例还是其子类的实例。
class_or_tuple 参数可以是一个 类 或 类组成的元组。
如果 obj 是 class_or_tuple 参数的实例，或子类的实例，则返回true。否则返回false。

>>> text
<class '__main__.text'>
>>> c = text()
>>> c
<__main__.text object at 0x000001DFB4E72C88>
>>> class text2(text):
...     pass
...
>>> text2
<class '__main__.text2'>
>>> isinstance(c,text)
True
>>> isinstance(c,text2)
False
>>> isinstance(c,(text,text2))
True

---

issubclass（ cls, class_or_tuple ）

返回 cls 类是不是 class_or_tuple 类的子类。
class_or_tuple 参数可以是一个 类 或 类组成的元组。
如果 cls 是 class_or_tuple 参数的子类，则返回true。否则返回false。

类被认为是其自身的子类。

>>> class text():
...     pass
...
>>> class text1(text):
...     pass
...
>>> class text2():
...     pass
...
>>> issubclass(text1,text)
True
>>> issubclass(text,text)
True
>>> issubclass(text2,text)
False
>>> issubclass(text2,(text,text2))
True
>>> issubclass(text2,(text,text1))
False

---

iter（ object[, sentinel] ）

返回一个迭代器对象。
如果没有第二个参数 sentinel， object 必须是可迭代的集合对象，否则引发TypeError。
如果给出第二个参数 sentinel，则 object 必须是可调用的对象，如果返回的值等于 sentinel，则会引发StopIteration，否则返回该值。

>>> t = iter([i for i in range(10)])
>>> t
<list_iterator object at 0x0000018FB62BBB00>
>>> [i for i in t]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> class text(object):
...     def __init__(self):
...         self.li = [1,2,3,4,5,6,7,8,9]
...         self.it = iter(self.li)
...     def __call__(self):
...         item = next(self.it)
...         return item
...     def __iter__(self):
...         return iter(self.li)
...
>>> it = text()
>>> callable(it)
True
>>> new = iter(it,7)
>>> [i for i in new]
[1, 2, 3, 4, 5, 6]
>>> new2 = iter(it,4)
>>> [i for i in new2]
[8, 9]
>>> it = text()
>>> new3 = iter(it,4)
>>> [i for i in new3]
[1, 2, 3]

---

len（ object ）

返回对象的长度（项数）。
参数可以是序列（字符串，字节，元组，列表或范围）或集合（字典，集合或冻结集合）等。

>>> len('jksdhflakshofs')
14
>>> len((65,564,54,341,33,1,))
6
>>> len([65,564,54,341,33,1,6])
7
>>> a = "ksdhfoshdfjsdkfkjsdh"
>>> len(a[2:])
18
>>> len({'a':564,'v':341,'j':1,'k':6})
4

---

list（ [iterable] ）

返回从 iterable 对象初始化的列表。
如果没有参数，返回一个空列表。

list的常用方法
list.append(object)	list.insert(index，object)
list.pop([index])	list.remove(value)
list.sort()	list.count(value)
list.index(value，[start，[stop]])	list.reverse()
list.clear()

>>> list()
[]
>>> a = "abc123"
>>> t = list(a)
>>> t
['a', 'b', 'c', '1', '2', '3']
>>> t.append(['d',4])
>>> t
['a', 'b', 'c', '1', '2', '3', ['d', 4]]
>>> t.insert(5,9)
>>> t
['a', 'b', 'c', '1', '2', 9, '3', ['d', 4]]
>>> t.pop()
['d', 4]
>>> t
['a', 'b', 'c', '1', '2', 9, '3']
>>> t.pop(0)
'a'
>>> t
['b', 'c', '1', '2', 9, '3']
>>> t.remove(9)
>>> t
['b', 'c', '1', '2', '3']
>>> t.sort()
>>> t
['1', '2', '3', 'b', 'c']
>>> t.count('3')
1
>>> t.append('3')
>>> t
['1', '2', '3', 'b', 'c', '3']
>>> t.count('3')
2
>>> t.index('3',1,-1)
2
>>> t.clear()
>>> t
[]

---

locals（ ）

返回包含当前环境的局部变量的字典。

请注意，locals字典仅对读取有用，因为忽略了对locals字典的更新。

>>> def text():
...     a = 7
...     b = 5
...     print(locals())
...     return a + b
...
>>> text()
{'b': 5, 'a': 7}
12

---

map（ function, iterable, … ）

返回一个迭代器，它将 function 函数应用于每个 iterable 项，从而产生结果。
如果传递了多个可迭代参数，则函数并行地应用于所有迭代的项。迭代器会在最短的 iterable 耗尽时停止。

>>> def text(x):
...     return x + x
...
>>> m = map(text,[1,2,3,4,5,6,7])
>>> m
<map object at 0x0000018FB62FE438>
>>> [i for i in m]
[2, 4, 6, 8, 10, 12, 14]
>>> def text2(x,y):
...     return x + y
...
>>> m1 = map(text2,[1,2,3,4,5,6,7],[9,8,5,4,5])
>>> [i for i in m1]
[10, 10, 8, 8, 10]

---

max（ ）

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

返回可迭代中的最大项或两个或多个参数中的最大项。
如果提供了一个位置参数，则它应该是可迭代的。返回iterable中的最大项。
如果提供了两个或多个位置参数，则返回最大的位置参数。

>>> max(5,69,46,65,4,65,4)
69
>>> max([1,2,3,4],[1,2,4,3])
[1, 2, 4, 3]

---

memoryview（ obj ）

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

obj 参数必须是字节对象

>>> memoryview(b'a')
<memory at 0x0000018FB62D1708>

---

min（ ）

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

返回可迭代中的最小项或两个或多个参数中的最小项。
如果提供了一个位置参数，则它应该是可迭代的。返回iterable中的最小项。
如果提供了两个或多个位置参数，则返回最小的位置参数。

>>> min(5,69,46,65,4,65,6)
4
>>> min([1,2,3,4],[1,2,4,3])
[1, 2, 3, 4]

---

next（ iterator[, default] ）

通过调用 __next __（）方法从迭代器中检索下一个项。
如果给定default，则在迭代器耗尽时返回，否则引发StopIteration。

>>> it = iter(range(3))
>>> next(it)
0
>>> next(it)
1
>>> next(it)
2
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>> it = iter(range(3))
>>> next(it,'over')
0
>>> next(it,'over')
1
>>> next(it,'over')
2
>>> next(it,'over')
'over'

---

object( )

返回一个新的无特征对象。

object 是所有类的基础。 它具有所有Python类实例共有的方法。 此函数不接受任何参数。

---

oct（ number ）

返回将整数 number 转换为前缀为“0o”的八进制字符串。
如果要将整数转换为 带有前缀 或 不带前缀 的八进制字符串，可以使用格式化方法。

>>> oct(1236987)
'0o4557773'
>>> '%#o'%1236987,'%o'%1236987
('0o4557773','4557773')
>>> format(1236987,'#o'),format(1236987,'o')
('0x4557773','4557773')
>>> f'{1236987:#o}',f'{1236987:x}'
（'0o4557773'，'4557773'）

---

open（ file, mode=’r’, buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None ）

打开文件并返回文件对象。如果无法打开文件，则会引发OSError。

file 是要打开的文件的路径名（绝对路径或相对于当前工作目录的路径）
mode 是一个可选字符串，用于指定打开文件的模式。默认为“r”，表示只读模式。
buffering 是一个可选的整数，用于设置缓冲策略。传递 0 以切换缓冲关闭（仅允许在二进制模式下），1 选择行缓冲（仅在文本模式下可用），大于 1 以指示固定大小的块缓冲区的大小（以字节为单位）。如果没有给出缓冲参数，则默认缓冲策略的工作方式。
encoding 是用于解码或编码文件的编码的名称。这应该只在文本模式下使用。
errors 是一个可选字符串，用于指定如何处理编码和解码错误。这不能在二进制模式下使用。
newline 控制通用换行模式的工作方式（仅适用于文本模式）。 它可以是None，”，’\ n’，’\ r’和’\ r \ n’。
如果 closefd 为 False 并且给出了文件描述符而不是文件名，则在关闭文件时，底层文件描述符将保持打开状态。 如果给出文件名，则 closefd 必须为 True（默认值）否则将引发错误。
opener 来获取文件对象的基础文件描述符。

模式	描述
r	以只读方式打开文件。文件的指针将会放在文件的开头。这是默认模式。
rb	以二进制格式打开一个文件用于只读。文件指针将会放在文件的开头。这是默认模式。
r+	打开一个文件用于读写。文件指针将会放在文件的开头。
rb+	以二进制格式打开一个文件用于读写。文件指针将会放在文件的开头。
w	打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb	以二进制格式打开一个文件只用于写入。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
w+	打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
wb+	以二进制格式打开一个文件用于读写。如果该文件已存在则打开文件，并从开头开始编辑，即原有内容会被删除。如果该文件不存在，创建新文件。
a	打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
ab	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。也就是说，新的内容将会被写入到已有内容之后。如果该文件不存在，创建新文件进行写入。
a+	打开一个文件用于读写。如果该文件已存在，文件指针将会放在文件的结尾。文件打开时会是追加模式。如果该文件不存在，创建新文件用于读写。
ab+	以二进制格式打开一个文件用于追加。如果该文件已存在，文件指针将会放在文件的结尾。如果该文件不存在，创建新文件用于读写。

---

ord（ char ）

返回字符的Unicode码的整数。

>>> ord('a')
97
>>> ord('A')
65
>>> ord('1')
49
>>> ord(' ')
32
>>> ord('*')
42

---

pow（ x, y[, z] ）

返回 x 的 y 次幂的值。
如果有 z 则返回 x 的 y 次幂的 值 与 z 的 模。
参数必须是数字类型。
如果第二个参数为负数，则必须省略第三个参数。
如果存在 z，则 x 和 y 必须是整数类型，y 必须是非负的。

>>> pow(2,8)
256
>>> pow(2,8,30)
16
>>> pow(2,-8)
0.00390625

---

print（ *objects, sep=’ ‘, end=’\n’, file=sys.stdout, flush=False ）

将对象 objects 打印到文本流文件，以 sep 分隔，以 end 结束。 sep，end，file，flush（如果存在）必须作为关键字参数给出。
file 参数必须是带有write（string）方法的对象;如果它不存在或None，将使用sys.stdout。
如果flush关键字参数为true，则强制刷新流。

>>> for i in range(5):
...     print(i+1,i)
...
1 0
2 1
3 2
4 3
5 4
>>> for i in range(5):
...     print(i+1,i,sep=':')
...
1:0
2:1
3:2
4:3
5:4
>>> for i in range(5):
...     print(i+1,i,sep=':',end='|')
...
1:0|2:1|3:2|4:3|5:4|

---

property（ fget=None, fset=None, fdel=None, doc=None ）

返回属性值。
fget 是获取属性值的函数。
fset 是用于设置属性值的函数。
fdel 是用于删除属性值的函数。
doc 为该属性创建了一个描述信息。

class C(object):
    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 的实例, c.x 将触发 getter,c.x = value 将触发 setter ， del c.x 触发 deleter。
如果给定 doc 参数，其将成为这个属性值的描述。
将 property 函数用作装饰器可以很方便的创建只读属性：

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

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

上面的代码将 voltage() 方法转化成同名只读属性的 getter 方法。

---

range（ start, stop[, step] ）

返回的是一个可迭代对象。
计数从 start 开始。默认是从 0 开始。可省略。
计数到 stop 结束，但不包括 stop。
step 为步长，默认为1。

>>> [i for i in range(10)]
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> [i for i in range(3,10)]
[3, 4, 5, 6, 7, 8, 9]
>>> [i for i in range(3,20,2)]
[3, 5, 7, 9, 11, 13, 15, 17, 19]

---

repr（ object ）

将对象转化为供解释器读取的形式。

>>> obj = 'print("text")'
>>> obj
'print("text")'
>>> repr(obj)
'\'print("text")\''
>>> eval(obj)
text

---

reversed（ seq ）

返回反向迭代器。

>>> t = reversed([1,2,3,4,5,6,7,8,9])
>>> t
<list_reverseiterator object at 0x0000018FB6376390>
>>> [i for i in t]
[9, 8, 7, 6, 5, 4, 3, 2, 1]

---

round（ number[, ndigits] ）

小数点后舍入到ndigits精度的返回数。如果省略ndigits或者为None，则返回其输入的最接近的整数。

四舍五入

>>> round(7)
7
>>> round(7.49999999)
7
>>> round(7.500000)
8
>>> round(7.49999999,3)
7.5
>>> round(-7.49999999)
-7
>>> round(-7.49999999,3)
-7.5

---

set（ [iterable] ）

从 iterable 返回一个集合，如果没有 iterable 则返回一个空集合。

>>> set()
set()
>>> s = set([1,2,3,4,5,6,7,8,9,6,5,4,1,2,3])
>>> s
{1, 2, 3, 4, 5, 6, 7, 8, 9}
>>> s.add(10)
>>> s
{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
>>> s.discard(5)
>>> s
{1, 2, 3, 4, 6, 7, 8, 9, 10}
>>> s.pop()
1
>>> s
{2, 3, 4, 6, 7, 8, 9, 10}
>>> s.remove(7)
>>> s
{2, 3, 4, 6, 8, 9, 10}
>>>s.clear()
>>> s
set()

---

setattr（ object, name, value ）

设置 object 对象的 name 属性的值 value。
name必须是一个字符串，如果是对象属性之一的名称，则修改该属性的值。如果不是对象属性之一的名称，则增加该属性和属性值。

>>> class text(object):
...     name = 'star'
...     age = 18
...
>>> text.name
'star'
>>> setattr(text,'name','newstar')
>>> text.name
'newstar'
>>> text.gender
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'text' has no attribute 'gender'
>>> setattr(text,'gender','man')
>>> text.gender
'man'

---

slice（ start, stop[, step] ）

返回一个切片对象，表示由range（start，stop，step）指定的索引集。
start 和 step 参数默认为None。

>>> a = [1,2,3,4,5,6,7,8,9,10]
>>> s = slice(5)
>>> s
slice(None, 5, None)
>>> a[s]
[1, 2, 3, 4, 5]
>>> s1 = slice(1,5)
>>> a[s1]
[2, 3, 4, 5]
>>> s2 = slice(1,9,2)
>>> a[s2]
[2, 4, 6, 8]

---

sorted（ iterable, key=None, reverse=False ）

从 iterable 可迭代对象返回一个新的排序列表。
key 主要是用来指定可迭代对象中的一个元素来进行排序。默认值为None（直接比较元素）。
key 如果指定一个参数的函数，该函数用于，具体的函数的参数就是取自于可迭代对象，元素来进行排序。
reverse 是一个布尔值。reverse = True 降序 ， reverse = False 升序（默认）。

>>> sorted([9,5,4,6,87,3,4,9])
[3, 4, 4, 5, 6, 9, 9, 87]
>>> sorted([9,5,4,6,87,3,4,9],reverse=True)
[87, 9, 9, 6, 5, 4, 4, 3]
>>> sorted([9,5,4,6,87,3,4,9],key=lambda i : i*-1)
[87, 9, 9, 6, 5, 4, 4, 3]
>>> sorted([9,5,4,6,87,3,4,9],key=lambda i : i*2)
[3, 4, 4, 5, 6, 9, 9, 87]

---

staticmethod( function )

将 方法 转换为 静态方法。
静态方法 接收 类 作为隐藏的第一个参数。

@staticmethod 形式是一个函数装饰器。

要声明一个 静态方法，使用格式：

class C():
    @staticmethod
    def f(cls, arg, ...):
        ...

---

str（ object = [b]”[,encoding =’utf-8’，errors =’strict’] ）

返回 从给定对象创建的一个新的字符串对象。

常用方法
[‘capitalize’, ‘center’, ‘count’, ‘encode’, ‘find’, ‘format’, ‘index’, ‘join’, ‘lstrip’, ‘partition’, ‘replace’, ‘rfind’, ‘rindex’, ‘rsplit’, ‘rstrip’, ‘split’,]

>>> a = 123456789
>>> b = str(a)
>>> b
'123456789'
>>> a
123456789
>>> a == b
False

---

sum( iterable[, start] )

返回从左到右开始迭代的总和。 start默认为0. iterable的项通常是数字，起始值不允许是字符串。

>>> sum([1,2,3,4,5,6,7,8,9])
45
>>> sum([1,2,3,4,5,6,7,8,9],7)
52
>>> sum([1,2,3,-4,5,6,-7-4j,8+2j,9],7)
(30-2j)

---

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

返回将方法调用委托给父类或兄弟类类型的代理对象。这对于访问已在类中重写的继承方法很有用。该属性是动态的，只要更新继承层次结构，就可以更改该属性。

super有两个典型的用例。在具有单继承的类层次结构中，super可用于引用父类而不显式命名它们，从而使代码更易于维护。这种用法与其他编程语言中super的使用密切相关。第二个用例是在动态执行环境中支持协作多重继承。此用例是Python独有的，

---

tuple（ [iterable] ）

返回从 iterable 对象初始化的元组。
如果没有参数，返回一个空元组。
如果参数是元组，则返回值是同一个对象。

>>> tuple()
()
>>> tuple([i for i in range(1,20,3)])
(1, 4, 7, 10, 13, 16, 19)
>>> a = (1,1,2,3,5,8,1,3,2,1)
>>> b = tuple(a)
>>> a
(1, 1, 2, 3, 5, 8, 1, 3, 2, 1)
>>> b
(1, 1, 2, 3, 5, 8, 1, 3, 2, 1)
>>> a is b
True

---

type（ ）

type(object)

使用一个参数，返回对象的类型。
type(name, bases, dict)

使用三个参数，返回一个新类型对象。 (元类)

type是元类

>>> type(type)
<class 'type'>
>>> type(1)
<class 'int'>
>>> type('a')
<class 'str'>
>>> type(())
<class 'tuple'>
>>> type([])
<class 'list'>
>>> type({})
<class 'dict'>

---

vars（ [object] ）

返回对象object的属性和属性值的字典对象。
没有参数，vars（）就像locals（）一样。

>>> vars()
{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>}
>>> class text(object):
...     name = 'star'
...     age = 18
...
>>> vars(text)
mappingproxy({'__module__': '__main__', 'name': 'star', 'age': 18, '__dict__': <attribute '__dict__' of 'text' objects>, '__weakref__': <attribute '__weakref__' of 'text' objects>, '__doc__': None})

---

zip（ *iterables ）

返回一个zip对象。没有参数则返回一个空的zip对象。

将可迭代的对象 iterables 作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。
如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

>>> a
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b
['a', 'b', 'c', 'd', 'e', 'f']
>>> c
['A', 'B', 'C', 'D', 'E']
>>> z = zip(a,b,c)
>>> list(z)
[(1, 'a', 'A'), (2, 'b', 'B'), (3, 'c', 'C'), (4, 'd', 'D'), (5, 'e', 'E')]
>>>

---

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

导入模块。 import 语句调用此函数。
该函数可以使用给定的 globals 和 locals 导入模块名称，以确定如何解释 包 上下文中的名称。
fromlist 给出了应该从 name 给出的模块导入的对象或子模块的名称。
标准实现根本不使用其 locals 参数，并仅使用其全局变量来确定 import 语句的 包 上下文。
level 指定是使用绝对导入还是相对导入。 0（默认值）表示仅执行绝对导入。level的正值表示要搜索的父目录相对于调用 import （）的模块的目录的数量。
当 name 变量的形式为 package.module 时，通常会返回顶级包（直到第一个点的名称），而不是按名称命名的模块。但是，当给出非空的 fromlist 参数时，将返回按名称命名的模块。

注意这是一个高级函数，