Python03-函数与过程编程

定义: 函数是指将一组语句的集合通过一个名字(函数名)封装起来，要想执行这个函数，只需调用其函数名即可特性:
1. 减少重复代码
2. 使程序变的可扩展
3. 使程序变得易维护

语法定义：

def sayhi(x,y):#函数名，定义过程和函数都是与def开始，然后是函数名(),函数可以带形参      
'''文档注释，对方法进行说明'''    
	print("Hello, I'm nobody!")   
	return Xxx  #带返回值得称为函数，不带返回值得称为过程。函数可以返回多个object，多个object之间用逗号,隔开；最终会用一个元组封装，返回一个元组

sayhi(1,2) #调用函数

形参变量只有在被调用时才分配内存单元，在调用结束时，即刻释放所分配的内存单元。因此，形参只在函数内部有效。函数调用结束返回主调用函数后则不能再使用该形参变量实参可以是常量、变量、表达式、函数等，无论实参是何种类型的量，在进行函数调用时，它们都必须有确定的值，以便把这些值传送给形参。因此应预先用赋值，输入等办法使参数获得确定值

过程或函数调用的参数传递方式：
1, 位置参数传递
sayhi(1,2)
根据参数的相对位置将1， 2分别传递给x, y

2, 关键参数传递
sayhi(x=1,y=2) 或者 sayhi(y=2,x=1) 关键参数传参时，参数的前后顺序调换是没关系的。

3, 上述两者传参混合使用
sayhi(1,y=2) 不可以出现 sayhi(y=2,1)
混合传参的原则是：关键参数不能写在位置参数前面。因此在定义函数或是过程时，要将默认参数置于形参的最后默认参数：

使用: 在定义函数或是过程时，给形参默认赋一个值，这个函数或过程便有了默认参数，这个默认参数可传也可不传，不传便使用默认值

def sayhi(x,y=1):      
'''文档注释，对方法进行说明'''   
	print("Hello, I'm nobody!")    
 	return Xxx   

sayhi(1) #调用函数，默认参数y=1

sayhi(1,2) 或 sayhi(1,y=2) 这两种方式是一样的

非固定参数个数的传参

若函数在定义时不确定用户想传入多少个参数，就可以使用非固定参数
方式一，使用*args，其中args是参数名，可以任意取名字。python会将可变的参数当做一个元组序列来处理。*args接收的是位置参数

 def stu_register(name,age,*args): # *args 会把多传入的参数变成一个元组形式             
 	print(name,age,args)
 	        
 stu_register("Alex",22)   #输出Alex 22 ()，后面这个()就是args,只是因为没传值,所以为空        
 stu_register("Jack",32,"CN","Python")  #输出 Jack 32 ('CN', 'Python')  

  传参时可以将可变长参数封装成一个列表或是元组传入，都是可以的，例如stu_register("Jack",32,*["CN","Python"])     或者 stu_register("Jack",32,*("CN","Python"))         

方式二：还可以有一个kwargs，其中kwargs是参数名，可以任意取名字。python会将可变的参数当做一个字典来处理序列来处理，传入的实参一定要使用关键参数，或者传入一个字典

def stu_register(name,age,*args,**kwargs): # *kwargs 会把多传入的参数变成一个dict形式              
	print(name,age,args,kwargs)        
stu_register("Alex",22)  #输出Alex 22 () {}#后面这个{}就是kwargs,只是因为没传值,所以为空        
stu_register("Jack",32,"CN","Python",sex="Male",province="ShanDong")  #输出 Jack 32 ('CN', 'Python') {'province': 'ShanDong', 'sex': 'Male'}    

传入可变字典参数时必须使用关键传参，不可以使用位置参数。另外传入字典也可以，例如stu_register(“Jack”,32,“CN”,“Python”,**{sex=“Male”,province=“ShanDong”}) 当存在确定参数和非固定参数时，非固定参数一定要放在形参列表最后，即使有默认参数，可变参数也要放到最后。

匿名函数

匿名函数定义 calc = lambda x:x*3
匿名函数调用 calc(3)

作用域，局部变量与全局变量

函数内部不能改变全局变量的值，除非在函数内部，先使用global声明，声明方式如下：
global 变量名 #声明为全局变量，在函数内部都可以声明全局变量，然后修改全局变量，但是不要这么做
函数内部不要定义全局变量，也不要修改全局变量（对于数值类型和字符串类型）；
列表，集合，字典类型，类的变量是可以在函数内部修改的，元组本身不可更改。

全局与局部变量
在子程序中定义的变量称为局部变量，在程序的一开始定义的变量称为全局变量。

全局变量作用域是整个程序，局部变量作用域是定义该变量的子程序。
当全局变量与局部变量同名时: 在定义局部变量的子程序内，局部变量起作用；在其它地方全局变量起作用。

3，返回值要想获取函数的执行结果，就可以用return语句把结果返回
注意:
1. 函数在执行过程中只要遇到return语句，就会停止执行并返回结果，so 也可以理解为 return 语句代表着函数的结束
2. 如果未在函数中指定return,那这个函数的返回值为None

4,递归在函数内部，可以调用其他函数。如果一个函数在内部调用自身本身，这个函数就是递归函数。python的递归最大次数是999层。
递归特性:
1. 必须有一个明确的结束条件
2. 每次进入更深一层递归时，问题规模相比上次递归都应有所减少
3. 递归效率不高，递归层次过多会导致栈溢出（在计算机中，函数调用是通过栈（stack）这种数据结构实现的，每当进入一个函数调用，栈就会加一层栈帧，每当函数返回，栈就会减一层栈帧。由于栈的大小不是无限的，所以，递归调用的次数过多，会导致栈溢出）

eval(str) :可以将字符串转换为python内建的数据格式

5, 高阶函数

定义，满足以下任一条件的即为高阶函数
1，把一个函数名当做实参传递给另外一个函数的形参(在不修改被装饰函数的源代码的情况下为其添加新功能)
2，返回值中包含函数名（不修改被装饰函数的调用方式）
注意：python中可以将函数作为实参，也可将函数的返回值作为实参，两者的区别是：函数作为实参调用方式是test(calc), 函数作为返回值调用的方式是test(calc())，
函数调用时后带()就意味着立马调用执行
高阶函数有装饰其他函数的作用

6, 嵌套函数

定义，在一个函数体内定义另一个函数;即在使用def定义一个函数A时在它的函数体内部再使用def定义一个函数B。内嵌的函数只能在A内调用，函数即“变量”，那么B的作用域就只限于在A内使用(调用)
1，把一个函
2，返回值
注意：python中函数调用时后带()就意味着立马调用执行

7, 内置函数

具体参考: https://docs.python.org/3/library/functions.html?highlight=built#ascii

字符串是不可更改的，每次操作会重新生成一个新的字符串。
abs(x)
返回数字x的绝对值。参数可以是整数或浮点数。如果参数为复数，则返回其模(大小)。如果x定义__abs__()，则 abs(x)返回x.abs()。

all(iterable)
返回True如果的所有迭代元素是真（或者如果可迭代为空）。相当于：def all(iterable): for element in iterable: if not element: return False return True

any(iterable)
True如果iterable的任何一个或多个元素为true ，则返回。如果iterable为空，则返回False。相当于：def any(iterable): for element in iterable: if element: return True return False

ascii(object)
如repr()一样,返回一个对象的可打印字符串， 但是repr()返回的字符串中非 ASCII 编码的字符，会使用 \x、\u 和 \U 来转义。生成类似于Python 2中repr()返回的字符串类似。

bin(x)
将整数转换为以“ 0b”为前缀的二进制字符串。结果是有效的Python表达式。如果x不是Python int对象，则必须定义一个__index__()返回整数。一些例子：

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

如果不需要前缀“ 0b”，则可以使用以下两种方式之一。

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

另请参阅format()以获取更多信息。

class bool([x])
返回一个布尔值，即True或False之一。 x是使用标准真值测试程序转换的。如果x为false或省略，则返回False；否则返回True。 bool类是int（参见数值类型-整数，浮点，复合）的子类。它不能进一步细分，它唯一的实例是False和 True（请参阅布尔值）。
在版本3.7中更改：x现在是仅位置参数。

breakpoint( args，* kws )**
此功能使您进入呼叫站点的调试器。具体来说，它调用sys.breakpointhook()，传递args和kws直接传递。默认情况下，sys.breakpointhook()调用 pdb.set_trace()不包含任何参数的.在这种情况下，它纯粹是一种便利功能，因此您不必显式导入 pdb或键入尽可能多的代码即可进入调试器。但是， sys.breakpointhook()可以将其设置为其他功能， breakpoint()并将自动调用该功能，从而使您可以进入所选的调试器。

使用参数引发审核事件 。builtins.breakpointbreakpointhook
3.7版中的新功能。

class bytearray([source[, encoding[, errors]]]])
返回一个新的字节数组。bytearray类是整数一个可变的序列,范围为0<= X <256，它有大部分的可变序列的常规方法，描述可变序列类型，以及大多数方法，该bytes类型有，见字节和ByteArray操作。可选的source参数可以通过几种不同的方式用于初始化数组：
* 如果它是字符串，则还必须提供encoding（和可选的 errors）参数；bytearray()然后使用将字符串转换为字节str.encode()。
* 如果它是整数，则数组将具有该大小，并将使用空字节初始化。
* 如果它是符合缓冲区接口的对象，则该对象的只读缓冲区将用于初始化bytes数组。
* 如果它是可迭代的，则它必须是范围内的整数的可迭代对象，这些整数 用作数组的初始内容。0 <= x < 256

没有参数，将创建大小为0的数组。
另请参见二进制序列类型-字节，字节数组，内存视图和字节数组对象。

class bytes([source[, encoding[, errors]]]])
返回一个新的“字节”对象，该对象是range中整数的不可变序列。 是的不变版本 –它具有相同的非变异方法以及相同的索引和切片行为。0 <= x < 256bytesbytearray因此，将构造函数参数解释为bytearray()。字节对象也可以使用文字创建，请参见String和Bytes文字。另请参见二进制序列类型—字节，字节数组，内存视图，字节对象以及字节和字节数组操作。

callable(object)
True如果object参数看起来可调用， False则返回，否则返回。如果返回True，则调用仍然有可能失败，但是如果返回，则False调用对象将永远不会成功。注意，类是可调用的（调用一个类将返回一个新实例）。如果实例的类具有__call__()方法，则它们是可调用的。
3.2版中的新功能：此功能首先在Python 3.0中删除，然后在Python 3.2中重新使用。

chr(i)
返回表示一个字符的字符串，该字符的Unicode代码点为整数i。例如，chr(97)返回字符串’a’，而 chr(8364)返回字符串’€’。这是的反函数ord()。参数的有效范围是从0到1,114,111（以16为底的0x10FFFF）。 ValueError如果我不在该范围内，将被提升。

@classmethod
将方法转换为类方法。类方法将类作为隐式第一个参数接收，就像实例方法接收实例一样。要声明类方法，请使用以下惯用法：

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

该@classmethod表单是一个函数装饰器 – 有关详细信息，请参见 函数定义。
可以在类（例如C.f()）或实例（例如C().f()）上调用类方法。该实例除其类外均被忽略。如果为派生类调用类方法，则派生类对象作为隐式第一个参数传递。
类方法不同于C ++或Java静态方法。如果需要这些，请参见staticmethod()。
有关类方法的更多信息，请参见标准类型层次结构。

compile（source，filename，mode，flags = 0，dont_inherit = False，optimize = -1 ）
将源代码编译为代码或AST对象。代码对象可以通过exec()或来执行eval()。 source可以是普通字符串，字节字符串或AST对象。ast有关如何使用AST对象的信息，请参阅模块文档。
该文件名参数应该给从代码读取的文件; 如果未从文件中读取（’'通常使用），则传递一些可识别的值。
该模式参数指定必须编译什么样的代码; 它可以是 ‘exec’，如果源包含的语句序列的，'eval’如果它由一个单一的表达的，或者’single’如果它由单个交互式声明的（在后一种情况下，计算结果为比其他东西表达式语句None将被打印）。
可选参数标志和dont_inherit控制哪些将来的语句会影响source的编译。如果两者都不存在（或两者都不为零），则使用正在调用的代码中有效的将来的语句来编译代码compile()。如果 给定flags参数且dont_inherit不（或为零），则除了将始终使用的那些语句外，还将使用flags参数指定的将来语句。如果dont_inherit是非零整数，则使用flags参数–忽略编译调用周围有效的将来语句。
将来的语句由位指定，这些位可以按位进行“或”运算以指定多个语句。可以在模块中compiler_flag的_Feature实例上找到指定给定功能所需的位域作为属性__future__。可选参数标志也控制编译源是否允许含有顶层await，和。设置该位后，返回代码对象已设置为，并且可以通过交互执行。async forasync withast.PyCF_ALLOW_TOP_LEVEL_AWAITCO_COROUTINEco_codeawait eval(code_object)
参数optimize指定编译器的优化级别；default值-1选择由-Ooptions 给出的解释器的优化级别。显式级别为0（无优化； __debug__为true），1（断言__debug__为false ，为false）或2（也删除了文档字符串）。
SyntaxError如果编译的源无效，并且ValueError源包含空字节，则此函数引发。
如果要将Python代码解析为AST表示形式，请参见 ast.parse()。
使用参数 和引发审核事件 。隐式编译也可能引发此事件。compilesourcefilename
注意 在’single’或 'eval’模式下用多行代码编译字符串时，输入必须以至少一个换行符终止。这是为了便于检测code模块中不完整和完整的语句。
警告 由于Python AST编译器中的堆栈深度限制，在编译为AST对象时，使用足够大/复杂的字符串可能会使Python解释器崩溃。

在版本3.2中更改：允许使用Windows和Mac换行符。同样，在’exec’模式下输入不必再以换行符结尾。添加了optimize参数。
在版本3.5中进行了更改：以前TypeError是在source中遇到空字节时引发的。

在新版本3.8：ast.PyCF_ALLOW_TOP_LEVEL_AWAIT现在可以在标志传递给启用顶级的支持await 和async forasync with

class complex([real [,imag ]])
返回值为real + imag * 1j的复数，或将字符串或数字转换为复数。如果第一个参数是字符串，它将被解释为复数，并且必须在没有第二个参数的情况下调用该函数。第二个参数不能是字符串。每个参数可以是任何数字类型（包括复数）。如果IMAG被省略，默认为零，并且构造用作数字转换等 int和float。如果两个参数都省略，则返回 0j。
对于一般的Python对象x，请complex(x)委托 x.complex()。如果__complex__()未定义，则返回到__float__()。如果__float__()未定义，则返回到__index__()。
注意 从字符串转换时，字符串不得在中心+或-运算符周围包含空格。例如， complex(‘1+2j’)很好，但是提高了 。complex(‘1 + 2j’)ValueError复杂类型在数字类型中进行了描述-int，float，complex。在版本3.6中进行了更改：允许按代码文字中的下划线对数字进行分组。在3.8版中进行了更改：退回到__index__()if complex()和 float()undefined。

delattr（对象，名称）
这是的亲戚setattr()。参数是一个对象和一个字符串。该字符串必须是对象属性之一的名称。如果对象允许，该函数将删除命名属性。例如，等效于。delattr(x, ‘foobar’)del x.foobar

class dict（ kwarg ）
class dict（映射，** kwarg ）
class dict（可迭代，** kwarg ）
创建一个新的字典。该dict对象是字典类。请参见dict和映射类型-字典以获取有关此类的文档。
对于其他容器看到内置 -in list，set以及 tuple类，还有collections模块。

dir([object])
不带参数的情况下，返回当前本地范围内的名称列表。使用一个参数尝试返回该对象的有效属性列表。如果对象具有名为的__dir__()方法，则将调用此方法，并且该方法必须返回属性列表。这允许实现自定义__getattr__()或__getattribute__()功能的对象自 定义dir()报告其属性的方式 。如果对象未提供__dir__()，则该函数将尽最大努力从该对象的__dict__属性（如果已定义）及其类型对象中收集信息。结果列表不一定是完整的，并且当对象具有custom时可能是不准确的__getattr__()。默认dir()机制对不同类型的对象的行为有所不同，因为它试图产生最相关的信息，而不是完整的信息：
* 如果对象是模块对象，则列表包含模块属性的名称。
* 如果对象是类型或类对象，则列表包含其属性的名称以及递归其基础属性的名称。
* 否则，该列表包含对象的属性名称，其类的属性名称以及递归其类的基类的属性。

结果列表按字母顺序排序。例如：

>>>>>> import struct
>>>> dir() # show the names in the module namespace ['__builtins__', '__name__', 'struct']
>>>> dir(struct) # show the names in the struct module ['Struct', '__all__', '__builtins__', '__cached__', '__doc__', '__file__', '__initializing__', '__loader__', '__name__', '__package__', '_clearcache', 'calcsize', 'error', 'pack', 'pack_into', 'unpack', 'unpack_from']
>>>> class Shape:... def __dir__(self):... return ['area', 'perimeter', 'location']
>>>> s = Shape()
>>>> dir(s)['area', 'location', 'perimeter']

注意 因为dir()主要是为了方便在交互提示符下使用而提供，所以它尝试提供一组有趣的名称，而不是尝试提供一组严格或一致定义的名称，并且其详细行为可能会因版本而异。例如，当参数是类时，元类属性不在结果列表中。

divmod(a,b)
使用两个（非复数）数字作为参数，并在使用整数除法时返回一对包含其商和余数的数字。对于混合操作数类型，适用于二进制算术运算符的规则。对于整数，结果与相同。对于浮点数，结果为，其中q通常为但可能小于1。在任何情况下都非常接近a，如果非零，则与b和b具有相同的符号。(a // b, a % b)(q, a % b)math.floor(a / b)q * b + a % ba % b0 <= abs(a % b) < abs(b)

enumerate(iterable，start = 0)
返回一个枚举对象。iterable必须是序列， 迭代器或其他支持迭代的对象。next()由enumerate()返回的迭代器的方法 返回一个元组，该元组包含一个计数（从start开始，默认为0），以及通过对iterable进行迭代而获得的值。

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

相当于：

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

eval（expression [，globals [，locals ] ] ）
参数是一个字符串以及可选的全局变量和局部变量。如果提供，则 全局变量必须是字典。如果提供的话，本地变量可以是任何映射对象。
使用globals和locals 字典作为global和local名称空间将expression参数解析并评估为Python表达式（从技术上来说是条件列表）。如果存在globals字典并且不包含key的值，则在解析表达式之前，将在该key下插入对内置模块字典的引用。这意味着 表达式通常可以完全访问标准 模块，并且可以传播受限环境。如果 省略了locals字典，则默认为globals__builtins__builtinsbuiltins字典。如果省略两个字典，则在调用环境中使用全局变量和 局部变量执行表达式eval()。请注意，eval（）在封闭环境中 无权访问嵌套作用域（非本地作用域）。
返回值是求值表达式的结果。语法错误被报告为异常。例：

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

此函数还可用于执行任意代码对象（例如由创建的代码对象compile()）。在这种情况下，传递代码对象而不是字符串。如果代码对象已’exec’作为模式参数编译，则其 eval()返回值为None。
提示：exec() 函数支持动态执行语句。的globals()和locals()功能返回当前全球和本地词典，分别，其可以是通过以绕过使用有用eval()或exec()。请参阅参考资料ast.literal_eval()，该函数可以安全地对仅包含文字的表达式求值的字符串。使用代码对象作为参数引发审核事件 exec。代码编译事件也可能引发。

exec（object [，globals [，locals ] ] ）
此功能支持动态执行Python代码。对象必须是字符串或代码对象。如果是字符串，则将字符串解析为一组Python语句，然后执行该语句（除非发生语法错误）。1如果它是代码对象，则只需执行即可。在所有情况下，执行的代码都可以作为文件输入有效（请参见《参考手册》中的“文件输入”一节）。请注意， 即使在传递给函数的代码的上下文中，也不能在函数定义之外使用returnand yield语句 exec()。返回值为None。
在所有情况下，如果省略了可选部分，则代码将在当前范围内执行。如果仅提供全局变量，则它必须是字典（而不是字典的子类），该字典将用于全局变量和局部变量。如果全局和 当地人给出，它们分别用于全局和局部变量。如果提供的话，本地变量可以是任何映射对象。请记住，在模块级别，全局变量和局部变量是相同的字典。如果exec获得两个单独的对象作为globals和locals，则代码将像嵌入在类定义中一样执行。
如果globals词典不包含该键的值， 则在该键下插入对内置模块 的词典的引用。这样，您可以在将自己的字典传递给之前，将自己的字典插入到globals中，从而控制执行的代码 可以使用哪些内置函数 。__builtins__builtins__builtins__exec()使用代码对象作为参数引发审核事件 exec。代码编译事件也可能引发。
注意 在建 -in功能globals()和locals()返回当前的全局和局部字典，分别，这可能是通过围绕用作第二个和第三个参数有用exec()。
注意 默认本地变量的功能locals()如下所述：不应尝试对默认本地变量字典进行修改。如果需要在函数返回后查看代码对本地人的影响，请传递一个明确的本地人字典。exec()

filter(function，iterable）
从这些iterable的元素构造一个迭代器，为其功能 返回true。 iterable可以是序列，支持迭代的容器或迭代器。如果function为None，则假定为身份函数，即，将所有false 的iterable元素都删除。
请注意，如果function不是，并且function是 ，则等效于生成器表达式。filter(function, iterable)(item for item in iterable if function(item))None(item for item in iterable if item)None
请参阅itertools.filterfalse()补充函数，该函数返回iterable的元素，该函数为其返回false。

class float（[ x ] ）
返回由数字或字符串x构造的浮点数。如果参数是字符串，则应包含一个十进制数字，可以选择在其后加上一个符号，并可以选择将其嵌入空格中。可选符号可以是’+‘或’-’；一个’+'符号具有上产生的值没有影响。参数也可以是表示NaN（非数字）或正无穷大的字符串。更准确地说，删除前导和尾随空白字符后，输入必须符合以下语法：

符号 :: =“ +” | “-”
infinity :: =“ Infinity” | “ inf”
nan :: =“ nan”
数字值 :: = floatnumber| infinity| numeric_string :: = [ ]nansignnumeric_value

这floatnumber是Python浮点文字的形式，在浮点文字中进行了描述。大小写无关紧要，因此，例如，“ inf”，“ Inf”，“ INFINITY”和“ iNfINity”都是可接受的表示正无穷大的拼写。否则，如果参数是整数或浮点数，则返回具有相同值（在Python的浮点精度内）的浮点数。如果参数超出Python浮点数的范围，OverflowError则会引发an 。对于一般的Python对象x，请float(x)委托 x.float()。如果__float__()未定义，则返回到__index__()。如果没有给出参数，0.0则返回。例子：

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

浮点类型在数值类型中进行了描述-int，float，complex。
在版本3.6中进行了更改：允许按代码文字中的下划线对数字进行分组。
在版本3.7中更改：x现在是仅位置参数。
在3.8版中进行了更改：index()如果__float__()未定义，则返回到。

format（值[，format_spec ] ）
按照format_spec的控制，将值转换为“格式化”表示形式 。format_spec的解释将取决于value参数的类型，但是大多数内置类型都使用一种标准格式语法：Format Specification Mini-Language。默认的format_spec是一个空字符串，通常会产生与call相同的效果str(value)。搜索值的方法时，对的调用会转换为 绕过实例字典的调用。一 ，如果该方法搜索到达引发异常 和format_spec非空，或者这两个 format_spec或返回值是不是字符串。format(value, format_spec)type(value).format(value, format_spec)format()TypeErrorobject在版本3.4中更改： 如果format_spec不是空字符串，则object().format(format_spec)引发。TypeError

class frozenset（[ 迭代] ）
返回一个新frozenset对象，可以选择从iterable获取元素 。 frozenset是内置类。请参阅frozenset并 设置类型-set，frozenset，以获取有关此类的文档。对于其他容器看到内置 -in set，list， tuple，和dict类，还有collections 模块。

getattr（object，name [，默认] ）
返回object的命名属性的值。 名称必须是字符串。如果字符串是对象属性之一的名称，则结果是该属性的值。例如，等效于 。如果named属性不存在，则返回default（如果提供），否则引发。getattr(x, ‘foobar’)x.foobarAttributeError

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

hasattr（对象，名称）
参数是一个对象和一个字符串。结果是True，字符串是否是对象属性之一的名称，False如果不是。（这是通过调用并查看它是否引发来实现的。）
getattr(object, name)AttributeError

hash（对象）**
返回对象的哈希值（如果有）。哈希值是整数。它们用于在字典查找期间快速比较字典关键字。比较相等的数值具有相同的哈希值（即使它们的类型不同，例如1和1.0）。
注意 对于具有自定义__hash__()方法的对象，请注意，它会hash() 根据主机的位宽截断返回值。有关__hash__()详细信息，请参见。

help（[ 对象] ）
调用内置的帮助系统。（此功能旨在用于交互式使用。）如果未提供任何参数，则交互式帮助系统将在解释器控制台上启动。如果参数是字符串，则将字符串作为模块，函数，类，方法，关键字或文档主题的名称进行查找，并在控制台上打印帮助页面。如果参数是任何其他类型的对象，则会在该对象上生成帮助页面。请注意，如果在函数的参数列表中出现斜杠（/），则在调用时help()，表示斜杠之前的参数仅是位置信息。有关更多信息，请参阅 仅位置参数上的FAQ条目。该功能由模块添加到内置的命名空间中site。
在版本3.4中进行了更改：更改pydoc并inspect意味着所报告的可调用签名现在更加全面和一致。

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

>>>>>> hex(255)'0xff'
>>>> hex(-42)'-0x2a'

如果要将整数转换为带前缀或不带前缀的大写或小写十六进制字符串，可以使用以下两种方法之一：>>>>>> ‘%#x’ % 255, ‘%x’ % 255, ‘%X’ % 255(‘0xff’, ‘ff’, ‘FF’)>>> format(255, ‘#x’), format(255, ‘x’), format(255, ‘X’)(‘0xff’, ‘ff’, ‘FF’)>>> f’{255:#x}’, f’{255:x}’, f’{255:X}’(‘0xff’, ‘ff’, ‘FF’)
另请参阅format()以获取更多信息。
另请参见int()使用16的底数将十六进制字符串转换为整数。
注意 若要获取浮点数的十六进制字符串表示形式，请使用 float.hex()方法。

id（对象）
返回对象的“身份”。这是一个整数，可以保证在此对象的生存期内唯一且恒定。具有不重叠生命周期的两个对象可能具有相同的id() 值。CPython实现细节：这是对象在内存中的地址。

input（[ 提示] ）
如果存在提示参数，则将其写入到标准输出中，而无需尾随换行符。然后，该函数从输入中读取一行，将其转换为字符串（将尾随换行符分隔），然后将其返回。读取EOF时，EOFError将引发。例：

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

如果readline模块已加载，input()则将使用它来提供详细的行编辑和历史记录功能。
在读取输入之前使用参数引发审核事件 builtins.inputprompt
成功读取输入后，使用结果引发审核事件。builtins.input/result

类 int（[ x ] ）
类别 int（x，base = 10 ）
返回由数字或字符串x构造的整数对象，或者0如果未提供任何参数，则返回 。如果x定义__int__()，则 int(x)返回x.int()。如果x定义__index__()，则返回x.index()。如果x定义__trunc__()，则返回x.trunc()。对于浮点数，它会截断为零。
如果x不是数字或给定base，则x必须是一个字符串 bytes，或者是bytearray表示基数base中的整数文字的实例。可选地，文字可以以或开头（之间没有空格），并用空格包围。以n为底的原义文字由0到n-1的数字组成， to （或to ）的数值为10到35。默认的底数是10。允许的值为0和2–36。Base-2，-8和-16字面量可以选择加/ ， / 或/ 前缀±azAZ0b0B0o0O0x0X，与代码中的整数文字一样。底数0表示要完全解释为代码文字，因此实际的底数是2、8、10或16，因此不合法，而 is和。int(‘010’, 0)int(‘010’)int(‘010’, 8)
整数类型在数字类型中描述-int，float，complex。
在版本3.4中进行了更改：如果base不是的实例，int并且基础对象具有 base.__index__方法，则调用该方法以获取base的整数。以前的版本 base.int__代替base.index。
在版本3.6中进行了更改：允许按代码文字中的下划线对数字进行分组。
在版本3.7中更改：x现在是仅位置参数。
在3.8版中进行了更改：index()如果__int()未定义，则返回到。

isinstance（object，classinfo ）
返回True，如果对象参数是的一个实例CLASSINFO 参数，或其中的（直接，间接或虚拟）的子类物。如果object不是给定类型的对象，则该函数始终返回False。如果classinfo是类型为对象的元组（或递归地为其他此类元组），True则如果object是任何类型的实例，则返回。如果classinfo不是类型或此类的元组，TypeError则会引发异常。

issubclass（class，classinfo ）
返回True如果类是子类（直接，间接或虚拟）的CLASSINFO。类被认为是其自身的子类。classinfo可以是类对象的元组，在这种情况下，将检查classinfo中的每个条目。在任何其他情况下，TypeError都会引发异常。

iter（object [，sentinel ] ）
返回一个迭代器对象。根据第二个参数的存在，第一个参数的解释非常不同。如果没有第二个参数，则object必须是支持迭代协议（该__iter__()方法）的集合对象，或者它必须支持序列协议（getitem()以int开头的整数参数的方法0）。如果它不支持这些协议中的任何一个， TypeError则引发。如果给定第二个参数sentinel，则object必须是可调用对象。在这种情况下创建的迭代器将在每次对其方法的调用时调用不带参数的 对象__next__()。如果返回的值等于 哨兵，StopIteration 将被提高，否则将返回该值。另请参见迭代器类型。
第二种形式的一个有用的应用iter()是构建一个块读取器。例如，从二进制数据库文件中读取固定宽度的块，直到到达文件末尾：

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

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

类list（[ 迭代] ）
实际上不是list可变的函数，而是可变的序列类型，如Lists和Sequence Types（列表，元组，范围）中所述。

locals（）
更新并返回代表当前本地符号表的字典。locals()在函数块中调用自由变量时会返回自由变量，而在类块中则不会。请注意，在模块级别，locals() 并且globals()是相同的字典。
注意 该字典的内容不应修改；更改可能不会影响解释器使用的局部变量和自由变量的值。

map(function，iterable，…)
返回一个迭代器，该迭代器将函数应用于iterable的每个项目，并产生结果。如果传递了其他可迭代的参数，则 函数必须采用那么多参数，并且并行地将其应用于所有可迭代的项目。对于多个可迭代对象，当最短可迭代对象耗尽时，迭代器将停止。对于函数输入已经安排在参数元组中的情况，请参见itertools.starmap()。

max（迭代， [，键，默认] ）
max（arg1，arg2， args [，键] ）**
返回可迭代的最大项目或两个或多个参数中的最大一个。
如果提供了一个位置参数，则它应该是可迭代的。返回迭代器中最大的项。如果提供了两个或多个位置参数，则返回最大的位置参数。
有两个可选的仅关键字参数。该关键参数指定一个参数的排序功能，类似于用于list.sort()。该 默认参数指定的对象返回如果提供的迭代是空的。如果iterable为空且未提供默认值， ValueError则引发a。
如果有多个最大项，则该函数返回遇到的第一个项。这与其他排序稳定性保存工具（例如和）一致 。
sorted(iterable, key=keyfunc, reverse=True)[0]heapq.nlargest(1, iterable, key=keyfunc)
在新版本3.4：在默认情况下只有关键字的说法。
在3.8版本中更改：该键可以None。

类memoryview（obj ）
返回从给定参数创建的“内存视图”对象。有关更多信息，请参见 内存视图。

min（迭代，* [，键，默认] ）
min（arg1，arg2，* args [，键] ）
返回可迭代的最小项或两个或多个参数中的最小项。如果提供了一个位置参数，则它应该是可迭代的。返回iterable中的最小项。如果提供了两个或多个位置参数，则返回最小的位置参数。有两个可选的仅关键字参数。该关键参数指定一个参数的排序功能，类似于用于list.sort()。该 默认参数指定的对象返回如果提供的迭代是空的。如果iterable为空且未提供默认值， ValueError则引发a。
如果最少有多个项目，则该函数返回遇到的第一个项目。这与其他排序稳定性保存工具（例如和）一致。sorted(iterable, key=keyfunc)[0]heapq.nsmallest(1, iterable, key=keyfunc)
在新版本3.4：在默认情况下只有关键字的说法。
在3.8版本中更改：该键可以None。

next（迭代器[，默认] ）
通过调用其 方法从迭代器中检索下一项__next__()。如果给定default，则迭代器已用尽，否则返回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')
另请参阅format()以获取更多信息。

open（文件，模式= ‘R’ ，缓冲= -1，编码=无，误差=无，换行符=无，closefd =真，开启器=无）
打开文件并返回相应的文件对象。如果无法打开文件，OSError则引发。
file是一个类似路径的对象，提供了要打开的文件的路径名（相对于当前工作目录的绝对路径或相对于当前工作目录的路径）或要包装的文件的整数文件描述符。（如果给定了文件描述符，则除非将closefd 设置为，否则当关闭返回的I / O对象时，它将关闭False。）
mode是一个可选字符串，用于指定打开文件的模式。默认为默认状态’r’，表示可以在文本模式下阅读。其他通用值’w’用于写入（如果文件已经存在，则将其截断），‘x’用于独占创建和’a’附加（在某些 Unix系统上，这意味着所有写入都将附加到文件末尾，而不管当前查找位置如何）。在文本模式下，如果 编码未指定使用的编码是与平台相关的： locale.getpreferredencoding(False)被称为获取当前的本地编码。（要读取和写入原始字节，请使用二进制模式， 而未指定编码。）可用模式为：
字符 含义
‘r’ 打开阅读（默认）
‘w’ 打开进行写入，先截断文件
‘x’ 打开以进行独占创建，如果文件已经存在则失败
‘a’ 打开进行写入，如果存在则追加到文件末尾
‘b’ 二进制模式’t’文字模式（默认）
‘+’ 开放进行更新（读写）默认模式为
‘r’ （打开以阅读文本，为的同义词’rt’）。

模式，‘w+’ 然后’w+b’打开并截断该文件。模式’r+’ 并’r+b’打开文件而不会被截断。
如概述所述，Python区分二进制I / O和文本I / O。以二进制模式（包括’b’在mode 参数中）打开的文件将内容作为bytes对象返回，而不会进行任何解码。在文本方式下（默认方式，或’t’在mode参数中包括时），文件内容返回为str，首先使用依赖于平台的编码或使用给定的指定编码对字节进行了解码 。允许使用其他模式字符’U’，该字符不再起作用，被认为已弃用。它以前在文本模式下启用了 通用换行符，这成为了Python 3.0中的默认行为。有关更多详细信息，请参考newline参数的文档 。注意 Python不依赖于底层操作系统的文本文件概念；所有处理都由Python本身完成，因此与平台无关。buffering是用于设置缓冲策略的可选整数。传递0以关闭缓冲（仅在二进制模式下允许），传递1以选择行缓冲（仅在文本模式下可用），并传递大于1的整数来指示固定大小的块缓冲区的字节大小。如果未指定任何缓冲参数，则默认缓冲策略如下：
* 二进制文件以固定大小的块缓冲；使用试探法来确定缓冲区大小，然后尝试确定底层设备的“块大小”，然后回退io.DEFAULT_BUFFER_SIZE。在许多系统上，缓冲区的长度通常为4096或8192字节。
* “交互式”文本文件（isatty() 返回的文件True）使用行缓冲。其他文本文件将上述策略用于二进制文件。

encoding是用于对文件进行解码或编码的编码的名称。仅应在文本模式下使用。默认编码取决于平台（无论locale.getpreferredencoding()返回什么），但是可以使用Python支持的任何 文本编码。请参阅codecs模块以获取受支持的编码列表。errors是一个可选字符串，它指定如何处理编码和解码错误-不能在二进制模式下使用。可以使用多种标准错误处理程序（在错误处理程序之下列出），尽管已向其注册的任何错误处理名称 codecs.register_error()也有效。标准名称包括：
* 'strict’ValueError如果存在编码错误，则引发异常。的默认值None具有相同的效果。
* ‘ignore’忽略错误。请注意，忽略编码错误会导致数据丢失。
* ‘replace’使替换标记（例如’?’）插入到数据格式不正确的地方。
* 'surrogateescape’将表示任何不正确的字节作为Unicode专用区中的代码点，范围从U + DC80到U + DCFF。surrogateescape当在写入数据时使用错误处理程序时，这些专用代码点将被转换回相同的字节。这对于处理未知编码的文件很有用。
* 'xmlcharrefreplace’仅在写入文件时受支持。编码不支持的字符将替换为适当的XML字符引用&#nnn;。
* ‘backslashreplace’ 用Python的反斜杠转义序列替换格式错误的数据。
* ‘namereplace’（仅在写入时受支持）用\N{…}转义序列替换不受支持的字符。

newline控制通用换行模式的工作方式（仅适用于文本模式）。它可以是None，’’，’\n’，’\r’，和 ‘\r\n’。其工作方式如下：
* 从流中读取输入时，如果newline为None，则启用通用换行模式。输入中的行可以以’\n’，’\r’或结束， 在返回给调用方之前’\r\n’，这些行会被翻译成’\n’。如果为’’，则启用通用换行模式，但是行结尾不翻译就返回给呼叫者。如果它具有任何其他合法值，则输入行仅由给定的字符串终止，并且该行的末尾不翻译就返回给调用方。
* 将输出写入流时，如果newline为None，则’\n’ 写入的所有字符都会转换为系统默认的行分隔符 os.linesep。如果换行符是’‘或’\n’，则不会进行翻译。如果换行符是其他任何合法值，’\n’ 则将写入的所有字符转换为给定的字符串。

如果closefd是False并且给出了文件描述符而不是文件名，则在关闭文件时，底层文件描述符将保持打开状态。如果给定文件名，closefd必须为True（默认），否则将引发错误。可以通过传递可调用的打开器来使用自定义打开器。然后，通过使用（file，flags）调用opener来获取文件对象的基础文件描述符。首战必须返回一个打开的文件描述符（通过 作为揭幕战的结果相似，通过功能 ）。os.openNone新创建的文件是不可继承的。以下示例使用函数的dir_fd参数 os.open()打开相对于给定目录的文件：>>>>>> import os>>> dir_fd = os.open(‘somedir’, os.O_RDONLY)>>> def opener(path, flags):… return os.open(path, flags, dir_fd=dir_fd)…>>> with open(‘spamspam.txt’, ‘w’, opener=opener) as f:… print(‘This will be written to somedir/spamspam.txt’, file=f)…>>> os.close(dir_fd) # don’t leak a file descriptor函数返回的文件对象的类型open()取决于模式。当open()使用在文本模式下打开一个文件（‘w’，‘r’，‘wt’，‘rt’，等等），它返回的一个子类 io.TextIOBase（具体而言io.TextIOWrapper）。当用于以带缓冲的二进制模式打开文件时，返回的类是的子类io.BufferedIOBase。确切的类有所不同：在读取二进制模式下，它返回io.BufferedReader；在写二进制和追加二进制模式下，它返回io.BufferedWriter，在读/写模式下，它返回io.BufferedRandom。当缓冲被禁用，原始流，的一个子类io.RawIOBase， io.FileIO，则返回。参见文件处理模块，如，fileinput，io （其中open()被声明）， ，os，os.path，tempfile和shutil。发起一个审计事件 open带有参数file，mode，flags。该mode和flags参数可能已被修改或从原来的呼叫推断。
在版本3.3中更改：
* 在揭幕战中添加参数。
* 该’x’模式已添加。
* IOError曾经被提出，现在是的别名OSError。
* FileExistsError如果以独占创建模式（‘x’）打开的文件已经存在，则现在引发。

在版本3.4中进行了更改：
* 该文件现在不可继承。

自从3.4版本弃用，将在3.9版本中删除：该’U’模式。在版本3.5中进行了更改：
* 如果系统调用被中断并且信号处理程序没有引发异常，则该函数现在重试系统调用而不是引发 InterruptedError异常（请参见PEP 475）。
* 在’namereplace’加入错误处理程序。

在3.6版中进行了更改：
* 添加了支持以接受实现的对象os.PathLike。
* 在Windows中，打开一个控制台缓冲区可能返回的一个子类 io.RawIOBase以外io.FileIO。

ord（c ）
给定一个表示一个Unicode字符的字符串，返回一个整数，表示该字符的Unicode代码点。例如， ord(‘a’)返回整数97，ord(‘€’)（欧元符号）返回8364。这是的反函数chr()。

pow（base，exp [，mod ] ）
将底数返回幂指数 ; 如果MOD存在时，返回基地到功率EXP，模MOD（更有效地比计算 ）。两参数形式等效于使用幂运算符：。pow(base, exp) % modpow(base, exp)baseexp参数必须具有数字类型。对于混合操作数类型，适用于二进制算术运算符的强制规则。对于int 操作数，除非第二个参数为负，否则结果与操作数的类型相同（强制后）；否则，结果与操作数相同。在这种情况下，所有参数都将转换为float并传递float结果。例如，102 return 100，但是10**-2返回0.01。对于base和expint操作数，如果存在mod，则mod也必须是整数类型，并且mod必须非零。如果存在mod且 exp为负，则base必须相对mod而言为素数。在这种情况下， 返回inv_base是基本模mod的倒数 。pow(inv_base, -exp, mod)这是计算38模的逆数的示例97：>>>>>> pow(38, -1, mod=97)23>>> 23 * 38 % 97 == 1True在版本3.8中更改：对于int操作数，pow现在的三参数形式允许第二个参数为负，从而允许计算模逆。在3.8版中更改：允许关键字参数。以前，仅支持位置参数。

print（ objects，sep =’’，end =’\ n’，file = sys.stdout，flush = False ）*
将对象打印到文本流文件中，并用sep分隔，然后用end分隔。 sep，end，file和flush（如果存在）必须作为关键字参数给出。所有非关键字参数都像dos一样转换为字符串str()，并写入流中，以sep分隔，后跟end。无论九月 和年底必须是字符串; 它们也可以是None，表示使用默认值。如果没有给出对象，print()将只写 end。的文件参数必须是与对象write(string)方法; 如果不存在或None，sys.stdout将使用。由于打印的参数将转换为文本字符串，print()因此不能与二进制模式文件对象一起使用。对于这些，请file.write(…)改用。输出是否被缓冲通常由file确定，但如果 flush关键字参数为true，则将强制刷新流。在版本3.3中进行了更改：添加了flush关键字参数。

类property（fget = None，fset = None，fdel = None，doc = None ）
返回属性属性。fget是用于获取属性值的函数。 fset是用于设置属性值的功能。fdel是用于删除属性值的函数。和文档创建的属性的文档字符串。典型的用法是定义一个托管属性x：

class C:
	def __init__(self):
		self._x = Nonedef 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， 将调用setter和Deleter。c.x = valuedel c.x如果给定，doc将是属性属性的文档字符串。否则，该属性将复制fget的文档字符串（如果存在）。这使得有可能创造轻松使用只读属性property()作为装饰：

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

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

该@property装饰变成的voltage()方法变成“吸”与同名的只读属性，并将其设置的文档字符串的 电压为“获取当前的电压。”属性对象具有getter，setter和deleter可用作装饰器的方法，这些方法可创建属性的副本，并将相应的访问器函数设置为装饰的函数。最好用一个例子解释一下：

class C:
	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

此代码与第一个示例完全等效。确保为附加功能赋予与原始属性相同的名称（x在这种情况下）。返回的属性对象也有属性fget，fset以及 fdel相对应的构造函数的参数。在版本3.5中进行了更改：现在可以写入属性对象的文档字符串。

上课range（end）
class range（start，end[，步骤] ）
实际上，range它是一个不变的序列类型，而不是一个函数，如Ranges和Sequence Types（列表，元组，范围）中所述。

repr（对象）
返回包含对象的可打印表示形式的字符串。对于许多类型，此函数会尝试返回一个字符串，该字符串在传递给时将产生具有相同值的对象eval()，否则表示形式是一个用尖括号括起来的字符串，其中包含对象类型的名称以及其他信息通常包括对象的名称和地址。类可以通过定义__repr__()方法来控制此函数为其实例返回的内容。

reversed（seq ）
返回一个反向迭代器。 seq必须是具有__reversed__()方法或支持序列协议的对象（该 len()方法和__getitem__()带有整数参数的方法始于0）。

round（number [，ndigits ] ）
返回数字舍入到小数点后的n位精度。如果ndigits省略或为None，则返回与其输入最接近的整数。
对于内置类型支持round()，将值四舍五入为最接近的10 乘以n的整数。如果两个倍数相等接近，则将舍入为偶数选择（例如，round(0.5)and和round(-0.5)are 0，and round(1.5)is 2）。任何整数值都对n位有效（正数，零或负数）。如果省略ndigits或， 则返回值为整数None。否则，返回值的类型与number相同。
对于一般的Python对象number，请round委托 number.round。
注意 round()for浮点数的行为可能令人惊讶：例如， 给出而不是期望。这不是错误：这是由于大多数十进制小数不能完全表示为浮点数的结果。有关更多信息，请参见浮点算法：问题和限制。round(2.675, 2)2.672.68

class set（[ 迭代] ）
返回一个新set对象，可以选择从iterable获取元素 。 set是内置类。请参阅set并 设置类型-set，frozenset，以获取有关此类的文档。对于其他容器看到内置 -in frozenset，list， tuple，和dict类，还有collections 模块。

setattr（对象，名称，值）
这是的对应项getattr()。参数是对象，字符串和任意值。该字符串可以命名现有属性或新属性。如果对象允许，该函数将值分配给属性。例如，等效于 。setattr(x, ‘foobar’, 123)x.foobar = 123class slice（stop ）

class slice（开始，停止[，步骤] ）
返回表示由所指定的索引集的切片对象 。在启动和步参数默认为 。切片对象具有只读数据属性， 并且仅返回参数值（或其默认值）。它们没有其他显式功能。但是，它们被数值Python和其他第三方扩展使用。使用扩展索引语法时，也会生成切片对象。例如：或。有关返回迭代器的替代版本，请参见 。range(start, stop, step)Nonestartstopstepa[start:stop:step]a[start:stop, i]itertools.islice()sorted（iterable，*，key = None，reverse = False ）从iterable中的项目返回一个新的排序列表。有两个可选参数，必须将其指定为关键字参数。key指定一个自变量的函数，该函数用于从iterable中的每个元素中提取一个比较键（例如key=str.lower）。默认值为None（直接比较元素）。reverse是一个布尔值。如果设置为True，则对列表元素进行排序，就好像每个比较都被反转一样。用functools.cmp_to_key()一个老式的转换CMP功能的 关键功能。在建 -in sorted()功能是保证稳定。如果可以保证不更改比较相等的元素的相对顺序，则排序是稳定的-这有助于多次通过排序（例如，按部门排序，然后按薪级排序）。有关排序示例和简短的排序教程，请参阅《如何排序》。

@staticmethod
将方法转换为静态方法。静态方法不会收到隐式的第一个参数。要声明静态方法，请使用以下惯用法：

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

该@staticmethod表单是一个函数装饰器 – 有关详细信息，请参见 函数定义。可以在类（例如C.f()）或实例（例如C().f()）上调用静态方法。Python中的静态方法类似于Java或C ++中的静态方法。另请参见 classmethod()有关对创建备用类构造函数有用的变体。像所有装饰器一样，也可以将其staticmethod作为常规函数进行调用并对其结果进行处理。在某些情况下，当您需要从类主体中引用函数并且希望避免自动转换为实例方法时，这是必需的。对于这些情况，请使用以下惯用法：class C:builtin_open = staticmethod(open)有关静态方法的更多信息，请参见标准类型层次结构。

class str（object =’’ ）
class str（object = b’’，encoding =‘utf-8’，errors =‘strict’ ）
返回object的str版本。有关详细信息，请参见。

str()str是内置字符串类。有关字符串的一般信息，请参见文本序列类型— str。

sum（迭代，/，start = 0 ）
资金开始和的项目迭代由左到右，并返回总。该迭代的项目通常是数字，起始值不允许是一个字符串。在某些用例中，可以使用替代sum()。连接字符串序列的首选快速方法是调用 ‘’.join(sequence)。要以扩展的精度添加浮点值，请参见math.fsum()。要串联一系列可迭代对象，请考虑使用 itertools.chain()。改变在3.8版本：将启动参数可以被指定为关键字参数。

super（[ type [，object-or-type ] ] ）
返回将方法调用委托给type的父级或同级类的代理对象。这对于访问已在类中重写的继承方法很有用。的对象或类型确定方法的解析顺序 被搜索。从类型之后的类开始搜索 。例如，如果__mro__的对象或类型是 和的值类型是，则搜索。D -> B -> C -> A -> objectBsuper()C -> A -> objectobject-or-type的__mro__属性列出了和使用的方法分辨率搜索顺序。该属性是动态的，并且在继承层次结构更新时可以更改。getattr()super()如果省略第二个参数，则返回的超级对象是未绑定的。如果第二个参数是一个对象，则必须为true。如果第二个参数是类型，则必须为true（这对于类方法很有用）。isinstance(obj, type)issubclass(type2, type)super有两种典型的用例。在具有单一继承的类层次结构中，super可以用于引用父类而无需显式命名它们，从而使代码更具可维护性。这种用法与其他编程语言中super的用法非常相似。第二个用例是在动态执行环境中支持协作式多重继承。该用例是Python独有的，在静态编译语言或仅支持单继承的语言中找不到。这样就可以在多个基类实现相同方法的情况下实现“菱形图”。良好的设计表明该方法在每种情况下都具有相同的调用签名（因为调用的顺序是在运行时确定的，因为该顺序可以适应类层次结构中的更改，并且因为该顺序可以包含在运行时之前未知的兄弟类）。对于这两种用例，典型的超类调用如下所示：class C(B):def method(self, arg):super().method(arg) # This does the same thing as:# super(C, self).method(arg)除方法查找外，super()还适用于属性查找。一种可能的用例是 在父类或同级类中调用描述符。请注意，这super()是在绑定过程中实现的，该绑定过程用于显式的点分属性查找（例如）super().getitem(name)。它通过实现自己的__getattribute__()方法来以支持可协作多重继承的可预测顺序搜索类来实现。因此，super()对于使用语句或运算符（例如）的隐式查找，未定义super()[name]。还应注意，除了零参数形式外，super()它不限于使用内部方法。两个参数形式准确地指定了参数并进行了适当的引用。零参数形式仅在类定义内起作用，因为编译器会填充必要的详细信息以正确检索要定义的类，以及为常规方法访问当前实例。有关如何使用来设计协作类的实用建议 super()，请参见使用super（）的指南。

类tuple（[ 迭代] ）
实际上不是一个函数，而是tuple一个不可变的序列类型，如Tuples和Sequence Types（列表，元组，范围）中所述。

class type（对象）
class type（名称，基础，字典）
使用一个参数返回对象的类型。返回值是一个类型对象，通常与所返回的对象相同 object.class。建议使用内置函数来测试对象的类型，因为它考虑了子类。isinstance()具有三个参数，返回一个新的类型对象。这本质上是class语句的动态形式。该名字符串类名，并成为__name__属性; 所述碱 元组逐条列出的基类和成为__bases__ 属性; 和字典的字典是包含用于类定义体的命名空间和被复制到标准词典成为 __dict__属性。例如，以下两个语句创建相同的type对象：>>>>>> class X:… a = 1…>>> X = type(‘X’, (object,), dict(a=1))另请参见类型对象。在版本3.6中更改：type不覆盖其子类的子类type.__new__可能不再使用单参数形式来获取对象的类型。

vars（[ 对象] ）
返回__dict__模块，类，实例或具有该__dict__属性的任何其他对象的属性。对象（例如模块和实例）具有可更新的__dict__ 属性。但是，其他对象可能对其__dict__属性具有写限制 （例如，类使用 types.MappingProxyType来防止直接字典更新）。不加争论，vars()就像locals()。请注意，本地字典仅对读取有用，因为对本地字典的更新将被忽略。

zip（ iterables ）*
制作一个迭代器，聚合每个可迭代对象中的元素。返回一个元组的迭代器，其中第i个元组包含每个参数序列或可迭代对象中的第i个元素。当最短的可迭代输入耗尽时，迭代器停止。使用单个可迭代参数，它将返回1元组的迭代器。没有参数，它将返回一个空的迭代器。相当于：

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

保证了可迭代对象的从左到右的评估顺序。这使得使用可以将数据系列聚类为n个长度的组成为一个习惯用法zip(*[iter(s)]n)。这将重复相同的迭代器n时间，以便每个输出元组都具有n调用迭代器的结果。这具有将输入分成n个长度的块的效果。zip()仅当您不关心较长的可迭代对象的尾随，不匹配的值时，才应将其与不等长的输入一起使用。如果这些值很重要，请itertools.zip_longest()改用。zip()与运算符一起可用于解压缩列表：

>>>>>> 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))
>>> x == list(x2) and y == list(y2)True

import（name，globals = None，locals = None，fromlist =（），level = 0 ）
注意 与相比，这是日常Python编程中不需要的高级功能
importlib.import_module()该函数由import语句调用。可以替换它（通过导入模块并分配给 ）来更改语句的语义 ，但是强烈建议不要这样做，因为使用导入挂钩通常更简单（请参见builtinsbuiltins.import__importPEP 302）以达到相同的目标，并且不会导致假设默认导入实现正在使用的代码出现问题。import()不建议直接使用importlib.import_module()。该函数导入模块名称，可能使用给定的全局变量 和局部变量来确定如何在包上下文中解释该名称。在fromlist里给出了应该从给出的模块导入的对象或子的名字命名。标准实现完全不使用其locals参数，而仅使用其全局参数来确定import语句的包上下文。级别指定使用绝对导入还是相对导入。0（默认）表示仅执行绝对导入。level的正值 表示相对于模块调用目录的要搜索的父目录数__import()（请参见详情请参阅 PEP 328）。
当name变量的形式为时package.module，通常返回顶级包（直到第一个点的名称），而不是返回由name命名的模块。但是，当给出非空的fromlist参数时，将返回以名称命名的模块。
例如，该语句导致字节代码类似于以下代码：import spam
spam = import(‘spam’, globals(), locals(), [], 0)
该语句导致此调用：import spam.ham
spam = import(‘spam.ham’, globals(), locals(), [], 0)
请注意__import__()此处如何返回顶层模块，因为这是通过import语句绑定到名称的对象。
另一方面，该语句导致from spam.ham import eggs, sausage as saus

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], 0)eggs = _temp.eggssaus = _temp.sausage

在此，spam.ham模块从返回__import__()。从该对象中，检索要导入的名称并将其分配给它们各自的名称。
如果您只是想按名称导入模块（可能在包中），请使用importlib.import_module()。
在版本3.3中进行了更改：级别的负值不再受支持（这还将默认值更改为0）。