余弦:我没看过python的书，但我通读过python文档。文档不过一遍，视野会局限。 近日读sqlmap源码，发现自己对于标准库所知甚少，想到knownsec技能表中余弦的一番话，加之最近有意提升English能力，遂意通读python2.7.13官方文档，去粗取精，译成中文，国内虽有一译站点已有翻译，但为参考。然本钱平平，词不达意，技止于此，望看客海涵。

Python标准库-内建函数

python有很多始终可用的内建函数。

• abs(x)
  • 返回x的绝对值，x可以是整型、长整型或浮点数。如果x是复数，则返回模。
• all(iterable)
  • 如果iterable中所有元素都为真或iterable为空，则返回True。
• any(iterable)
  • 如果iterable中任一元素为真，则返回True。如果iterable为空，返回False。
• basestring()
  • str和unicode类型的虚基类。不可以被直接调用或实例化，但是可以用来测试一个对象是否是str或unicode的实例。
  • isinstance(obj, basestring)
  • 等价写法：isinstance(obj, (str, unicode))
• bin(x)
  • 将整数转为二进制串，结果是有效的python表达式。如果x不是python int对象，那么x需要定义一个__index__()方法来返回一个整数。
• class bool([x])
  • 返回一个Boolean值，只能是True或False。x会通过标准的真值测试过程处理。如果x为假或者被忽略，则返回False，否则返回True。bool也是一个class，且是int的子类。bool类不能被继承，它仅有的两个实例是False和True。
• class bytearray([source[, encoding[, errors]]])
  • 返回一个字节数组。bytearray类是一个0到256的不定整数序列。它拥有不定序列（Mutable Sequence）类型和str类型的大多数常用方法。
  • 可选参数source可以有几种不同方法来初始化array。
    • unicode 需要给定encoding，bytearray利用unicode.encode()将unicode转成bytes
    • integer 定义数组尺寸并用null填充
    • 遵循buffer接口的对象 对象的只读buffer会用来初始化bytearray
    • iterable 必须是0-256整数的迭代器，用于初始化array
  • 如果没有参数，则bytearray尺寸为0。
• callable(object)
  • 如果object表现为可调用，则返回True，否则返回False。若返回True，则call依然可能会失败。但如果返回False，那么call永远不会成功。class是可调用的（返回一个新实例）。如果类实例拥有__call__方法，则也是可调用的。
• chr(i)
  • 返回一个单字符string，其ASCII码为i。与ord()相反。i范围必须是0-255，越界则抛ValueError。
• classmethod(function)
  • 返回function的类方法
  • 类方法将类作为第一个隐式参数，和实例方法接收实例类似。定义一个类方法，按如下写：

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

• • @classmethod格式是一个函数装饰器。
  • 类方法既可以被class调用（如C.f()），也可以被类实例调用（如C().f()）。如果继承类调用了父类方法，第一个隐式参数将选择继承类。
  • Python的类方法和C++、Java的静态成员函数不太一样。Python额外提供类似的staticmethod()。
• cmp(x,y) -比较两个对象x和y，根据结果返回一个integer。如果x<y则返回负数，x==y则返回0，x>y则返回正数。
• compile(source, filename, mode[, flags[, dont_inherit]])
  • 编译源码制成code或AST对象。可以通过exec和eval()来执行code对象。source可以是Unicode字符串，Latin-1编码字符串或AST对象。AST对象可参考ast模块。
  • filename用于指定从哪个文件读code。
  • mode表明需要编译哪种code。如果source包含一序列语句的话可设为exec，单语句可设为eval，单交互式语句可设为single。
  • 可选参数flags和dont_inherit控制哪些future语句影响编译。如果都不设定（或都为0）的话，使用调用compile的代码当前有效的future语句来编译。如果只出了flags参数，则除了本该使用的future语句之外，由flags指明的future语句也会影响编译。如果dont_inherit是非0整数，flags被忽略。
  • future语句由bit位指明，这些bit可以做或运算来指明多个语句。可以在__future__模块中，_Feature实例的compiler_flag属性找到指明功能的bit位。
  • 如果source不合法，则抛SyntaxError异常。如果source包含null，则抛TypeError异常。
  • 如果想把python code保存为AST格式，看看ast.parse()。

    当以single或eval mode来编译多行source时，输入必须以一个空行结尾，用于更好的区别是否未竟。

• class complex([real[, imag]])
  • 返回一个值为real+imag*1j的复数。也可以将string或number转为复数。如果first参数为string，那么其将被解释成复数且与此同时不可有第二个参数。第二个参数永远不会是string。每个参数都可以是数值类型（包含complex本身）。如果imag被忽略，则默认取0，此时complex表现类似int()、long()、float()。如果两个参数都缺省，则返回0j。

    如果参数为string，则+/-号旁不允许有空白字符。

• delattr(object, name)
  • name为object的某个属性。该函数会删除该属性。与setattr()相反。
• class dict(**kwarg)
• class dict(mapping, **kwarg)
• class dict(iterable, **kwarg)
  • 创建一个字典。
• dir([object])
  • 如果没有参数，则返回当前局部范围内所有name。如果有参数，则返回object的所有有效的属性list。
  • 如果object有一个方法叫__dir__()，则会调用该方法。这允许对象实现一个自定义的__getattr__()或__getattribute__()方法来定制dir()返回的属性。
  • 如果object不支持__dir__(),该函数则尽可能从object的__dict__属性(如果有定义的话)和type object收集。此时结果是不完整的，如果对象有一个自定义的__getattr__()，则甚至可能是错的。
  • 对于不同类型object来说，默认的dir()原理大相径庭。它试图产生最相关而不是最完整的信息。
    • 如果object是module object，list包括modules所有属性的名。
    • 如果object是一个type或class object，list包含它的所有属性名，递归到它的祖先类。
    • 其他情况，list包含object的属性名，object所属class的属性名，也递归到祖先类。
• divmod(a,b)
  • 返回非复数a、b的商和余数。对integer来说，相当于(a // b, a % b)。
• enumerate(sequence, start=0)
  • 返回一个枚举对象。sequence必须是序列类型、iterator或其他支持迭代的对象。enumerate()返回的iterator的next()方法返回一个元组，它包含一个从start开始计数和从sequence中迭代得到的值。
• eval(expression[, globals[, locals]])
  • 参数是Unicode或Latin-1编码的字符串。可选参数globals如果提供，则必须是一个字典，locals提供则必须是一个任何映射的对象。
  • expression被当做python表达式来解析并演算，globals和locals字典作为全局和局部命名空间。如果globals存在，且缺少__builtins__，在expression被解析之前，当前的全局变量被拷贝进globals。这意味着一般来说expression能完全访问标准__builtin__模块，且受限的环境会传播。如果locals字典被忽略，则取globals作为默认字典。如果两个字典都被忽略，则在eval被调用的环境执行。
• execfile(filename[, globals[, locals]])
  • 和exec类似，但是传递的是一个文件名而不是string。它和import不同以至于它不使用模块管理——它无条件的读取文件，并不产生新的module。
  • 参数为文件名和两个可选字典。文件内容如同python顺序语句解析一样，使用globals和locals字典作为命名空间。locals可以是任意映射对象。记住在模块层面，globals和locals是相同的字典。如果两个独立的对象作为globals和locals，代码会像把二者嵌入在同一class定义中那样执行。
  • 如果locals缺省，则默认采用globals字典。如果二者都缺省，则表达式在execfile()调用的环境中执行。返回的值是None。
• file(name[,mode[,buffering]])
  • file类型的构造函数。构造函数的参数和下述的open()一致。
  • 要打开一个文件，建议用open而不是直接调用该构造函数，file更适合用于类型测试（比如，isinstance(f,file)）。
• filter(function, iterable)
  • 用那些使得function返回True的iterable子集构造一个list。iterable可以是个支持迭代的序列，或者是一个迭代器。如果iterable是string或元组，则结果也是string或元组。否则结果总是列表。如果function是None，那么所有值为False的iterable元素被移除。
  • 注意，在function不是None的情况下，filter(function, iterable)等同于[item for item in iterable if function(item)]；否则等同于[item for item in iterable if item]。 -class float([x])

  • 将字符串或数字转为浮点数。如果参数是字符串，它必须包含小数或浮点数（可以有符号），周围可以有空白字符。参数也可以是[+

    -]nan或者[+

    -]inf。其他情况下，参数可以是整型/长整型或浮点数，此时返回等值的浮点数。如果没有参数，则返回0.0。

  • 注意，传递字符串时，依赖于底层C库，可以返回NaN和Infinity这样的值。该函数接受字符串nan，inf和-inf。对于NaN，不区分大小写和正负，总是用nan。
• format(value[, format_spec])
  • 将value转为“格式化”的表现形式，格式由format_spec控制。对format_spec的解释依赖于value的参数类型。
• frozenset([iterable])
  • 返回一个新的frozenset对象，如果iterable存在，则frozenset的元素由iterable决定。frozeset是个内置类。
• getattr(object,name[,default])
  • 返回object的属性名为name的值。name必须是一个字符串。如果name属性不存在，且有default参数，则返回default，否则抛AttributeError。
• globals()
  • 返回表示当前全局符号表的字典。它总是当前模块的字典（在函数或方法中，指定义的模块而非调用的模块）。
• hasattr(object, name)
  • 如果object拥有名为name的属性，则返回True，否则返回False（实际上是通过调用getattr(object, name)，看是否会抛异常来实现的）。
• hash(object)
  • 返回object的哈希值（如果有的话）。哈希值是一串整数。在字典查询时，用来快速比对字典键。相等的数值拥有相同的哈希值（尽管是不同类型，比如1和1.0）。
• help([object])
  • 调用内置的help系统。（该函数一般用于交互使用。）如果没有指定参数，则交互帮助系统在解释器终端启动。如果参数为string，则string作为module、function、class、method的名字，关键字或者是未文档化的主题，终端会打印一个帮助页面。如果参数是其他类型的对象， 则生成一个该对象的帮助页面。
  • 该函数被site模块加进了内置的命名空间。
• hex(x)
  • 将integer转为小写的十六进制数值串，具有0x前缀。
  • 如果x不是python的int或long类型，则x需要自定义一个__index__()方法，且其返回一个integer。
• id(object)
  • 返回一个object的id。id是个integer，用于保证在object生命周期中是独一无二且恒定的。两个生命周期不产生交集的object，可能会有同样值的id。
  • 实现细节：id是object在内存的地址。
• input([prompt])
  • 等价于eval(raw_input(prompt))。
  • 该函数并不catch用户的错误。如果输入语法无效，会抛一个SyntaxError。如果在求值时遇到其他错误也会抛出该异常。
  • 如果readline模块被加载了，那么input()会提供更精巧的行编辑以及历史特性。
  • 也会的常规输入，请考虑用raw_input()。
• class int(x=0)
• class int(x, base=10)
  • 返回一个由数值或string转成的integer对象。如果不给参数，则返回0。如果x是一个number，那么它可以是一个int或long或float。如果x是float，转换向0截断。如果参数超出了integer的范围，则返回一个long对象代替。
  • 如果x非number，则x必须是一个string或Unicode对象，且要是按某种进制的逐字integer。可以以+或-开头（和number间不能有空白）。默认进制为10。允许的范围是0和2-36。二进制、八进制和十六进制可以以0b/0B，0o/00/0，0x/0X开头。0意味着单纯的将string串当成integer，无需进制转换。
• isinstance(object, classinfo)
  • 如果object是个classinfo实例，则返回True（子类也可以，直接+间接+虚）。如果classinfo是一个类型对象，object是该类型的对象，也返回True。否则返回False。如果classinfo是一个元组，元组里有多个class或type对象，那么只要object是其中之一的实例，则返回True。如果classinfo既不是class，也不是type，又不是装class和type的元组，则抛TypeError。
• issubclass(class, classinfo)
  • 如果class是classinfo的子类（直接，间接，虚），则返回True。class也是自己的子类。classinfo可以是一个元组，元组里存放多个class对象，此时将会检查元组内所有class。其他情况下，抛TypeError。
• iter(o[, sentinel])
  • 返回一个iterator对象。首参的意义取决于第二个参数。如果没有第二个参数，则o必须是一个支持迭代（拥有__iter__()方法）或顺序协议（拥有__getitem__()方法）的集合对象。如果两种协议都不支持，则抛TypeError。如果sentinel给定，那么o必须是一个callable object。iterator会以无参数形式call o的next()方法，如果value和sentinel相等，则抛StopIteration。否则该值会返回。
  • 对第二个参数来说，一个有用的应用是用iter()来按行读文件，直到一个确切的想要停止的行。下面的例子展示了如何按行读文件直到遇到一个空行。

with open('mydata.txt') as fp:
	for line in iter(fp.readline, ''):
		process_line(line)

• len(s)
  • 返回对象的尺寸（拥有几个元素）。参数可以是一个序列（string,bytes,tuple,list或range）或者一个容器(dictionary,set,frozen set)。
• class list([iterable])
  • 根据iterable迭代的元素返回一个相同的列表。iterable可以是序列，支持迭代的容器，或一个支持迭代的对象。如果iterable已经是一个list，则简单的copy并返回（类似iterable[:]）。list(‘abc’)返回[‘a’,’b’,’c’]；list((1,2,3))返回[1,2,3]。如果没有参数，则返回空列表,[]。
  • list是一个可变的序列类型。
• locals()
  • 更新并返回一个表示当前局部符号表的字典。如果在function代码块而非class块中调用locals()，则返回游离的变量。
  • 注意：字典的内容不应该被修改；对其值得修改不会影响解释器对local和free变量的使用。
• class long(x=0)
• class long(x, base=10)
  • 返回一个由数值或字符串x转成的long对象。如果x是string，则必须包含一个数字，任意大小，可以有符号，周围可以有空白字符。base参数和int()的等同，且只有x是string时才能给定。其他情况下，参数可以是原始或长整型或浮点数，此时会返回一个等值的long。浮点数会向0截断。如果没有参数，则返回0L。
• map(function, iterable, …)
  • 对迭代器的每个元素执行function，并返回一个结果list。如果有额外的iterable参数，则并行的从这些参数中取元素，执行function。如果参数参差不齐，则以None扩展参数元素。如果有多个参数，map()返回一元组列表，元组包含从各个参数中取得的对应的元素。iterable可以是任意序列或任意可迭代对象，结果总是列表。
• max(iterable[, key])
• max(arg1,arg2,*args[,key])
  • 返回iterable元素中最大的元素，或者返回2个或多个参数中最大的参数。
  • 如果有一个位置参数，iterable必须是个非空可迭代对象（如非空字符串，元组或列表）。此时返回可迭代对象中最大的一个。如果有两个或更多的位置参数，则返回最大位置参数。
  • key指明了有一个参数的排序函数，如list.sort()中使用的排序函数。如果有key参数，它必须写成key=的形式（例如max(a,b,c,key=func)）。
• memoryview(obj)
  • 根据obj参数，返回一个“内存视图”对象。
• min(iterable[, key])
• min(arg1, arg2, *args[, key])
  • 返回迭代器或多个参数中最小的元素。
  • 如果有一个位置参数，则iterable必须是非空可迭代的（如非空字符串，元组或列表）。最小的元素会返回。如果有两个以上的位置参数，则返回最小的那个位置参数。
  • key指明了有一个参数的排序函数。如list.sort()中使用的排序函数。如果有key参数，必须写成key=的形式，同max。
• next(iterator[, default])
  • 通过调用iterator的next()方法，得到它的下一个元素。如果有default参数，在迭代器迭代完所有元素后返回该参数，否则抛StopIterator。
• object()
  • 返回一个新的无特征的对象。object是所有类的基类。它具有对所有子类实例通用的方法。
• oct(x)
  • 将一个任意大小整数转成一个八进制字符串。结果是一个合法的python表达式。
• open(name[, mode[, buffering]])
  • 打开一个文件，返回一个file类型的对象。如果文件打不开，则抛IOError。打开文件请优先使用open()，而不是直接调用file构造函数。
  • 前两个参数和C的stdio库的fopen()函数想死。name是名字，mode是打开姿势。
  • mode常用值包括：’r’读文件,’w’写文件（如果文件存在则截断）,’a’附加。如果没有mode，默认是’r’，默认使用文本模式，会在写文件时将’\n’转换成平台特定字符，在读文件时转回来。因此打开二进制文件时，要指定’b’来增强移植性。
  • buffering指明了文件需要的缓冲大小，0意味着无缓冲，1意味着行缓冲；其他正数表示缓冲区大小。负数则表示使用系统默认值。一般对于tty，是行缓冲，对其他文件，是全缓冲。如果没有参数，则用默认值。
  • 模式’r+’、’w+’和’a+’打开文件以便更新（同时读写）。’w+’会截断文件。区分文本文件和二进制文件的系统上，mode附加’b’会以二进制打开。不区分的系统上，’b’无效。
  • 除了标准的fopen() mode值外，还可以是’U’或’rU’。构建python时一般会添加universal newline支持。’U’以文本文件方式打开，但是行可以以’\n’,’\r’或’\r\n’结束。python通常认为他们都是’\n’。如果构建python时没添加对universal newline的支持，则mode的’U’和普通文本一样。
• ord(c)
  • 给定一个长度为1的字符串，如果参数是Unicode对象，则返回表示整型的Unicode code point。如果是八位字符串，则返回字节值。比如ord(‘a’)返回97，ord(u’\u2020’)返回8224。chr()或unichr()的相反操作。如果参数是Unicode且构建Python时添加了UCS2 Unicode支持，那么字符的码点必须在[0..65535]的闭区间；如果字符串的长度为2，则抛出TypeError。
• pow(x,y[,z])
  • 返回x的y次幂，如果z提供了，则返回x的y次幂，再对z取模。
  • 参数必须是数字类型。由于操作数是混合类型的，二进制计算时需要一些强制规定。对int和long，计算结果与本身一致。如果第二个参数是负数，则所有参数都被转成float，返回float。如果第二个参数是负数，则第三个参数必须省略。
• print(*objects,sep=’‘,end=’\n’,file=sys.stdout)
  • 以sep分割，end结尾，将对象打印到文件流中。如果sep,end和file提供了，则必须以键值形式书写。
  • 所有非键值形式提供的参数，都被转成字符串，相当于被str()。然后写到文件流中，以sep分割，end结尾。sep和end都必须是字符串，也可以留成None，这时用默认值。如果没有打印对象，print()只打印一个结束符号end。
  • file一定要是含有write(string)方法的对象；如果该参数为空，或为None，默认使用sys.stdout输出。输出缓冲方式由file本身决定。例如以file.flush()确保立即显示。
• property([fget[, fset[, fdel[, doc]]]])
  • 返回新类（继承object）的一个属性。
  • fget是用于获取属性值的函数，fset时设置属性值的函数，fdel用于删除属性。如果给出doc，则作为该属性的文档字符串。否则该属性拷贝fget的文档字符串。
  • 典型的用法：

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将调用获取函数，c.x = value调用设置函数，del c.x调用删除函数。 - range(stop) - range(start, stop[, step])
- 用于产生包含数列list的多功能函数。最常用于for循环。参数必须是整型。如果step缺省，则默认为1。如果start函数缺省，默认为0。完整的list构成像是[start, start+step, start+2*step, ...]的一个整数列表。如果step是正数，则最后一个元素是最大满足start+i*step < stop的数。如果step为负，则最后一个元素是start+i*step > stop中最小的那个数，step不能是0，否则会抛ValueError。 - raw_input([prompt])
- 如果prompt参数存在，则会将其输出到标准输出，且不带换行。该函数此后接收一行输入，转成string（会去掉换行符），并返回。如果读到了EOF，则抛EOFError。
- 如果加载了readline模块，则raw_input()会使用它来提供精确的行编辑以及历史特性。 - reduce(function, iterable[, initializer])
- 将带有两个参数的function累计的应用到iterable的元素上。从左到右，将可迭代的序列归纳为一个值。例如，reduce(lambda x, y: x+y, [1,2,3,4,5])相当于计算((((1+2)+3)+4)+5)。左边的参数x是累计后的值，右边的参数y是来自iterable中的修改值。如果提供initializer，则计算时以此为基值，在可迭代序列为空时也作为默认值。如果没给出，且iterable只包含一个元素，那么就返回第一个元素。
- 大致相当于：

def reduce(function, iterable, initializer=None):
	it = iter(iterable)
	if initializer is None:
		try:
			initializer = next(it)
		except StopIteration:
			raise TypeError('reduce() of empty sequence with no initial value')
	accum_value = initializer
	for x in it:
		accum_value = function(accum_value, x)
	return accum_value

• reload(module)
  • 重载一个已经引入过的模块。参数必须是模块对象，且之前必须是曾经import过。如果你在编辑一个模块源文件时，想要用当前的python解释器来试试新的版本，reload是很有用的。返回值是一个module对象（和module参数相同）。
  • 当reload(moduyle)执行时：
    • python模块代码被重编译，且模块级别的代码会重新执行，定义一系列被绑定到模块字典相应名称的对象。改进后的模块init函数不会第二次加载。
    • 和python其他对象相同，旧对象只在引用计数降为0时，才会被系统回收。
    • 模块命名空间中名字自动升级指向新的对象。
    • 对旧对象的其他引用不会连接到新对象。每个命名空间在被请求时，都必须要更新。
  • 注意：如果模块重载，它的字典（包含模块全局变量）被保留。重新定义这些名字会覆盖旧定义，因此这一般不是一个问题。如果新对象没有定义和旧对象同样名字，旧的定义就被保留。这可用于模块的一大优势，如果他保留一个全局表或对象缓存——可以用try模块来测试table是否存在，且如果需要的话可跳过它的初始化。

    try:
      cache
    except NameError:
      cache = {}
    

• • 通常重载内置的动态加载模块是没什么用的。不推荐重载sys，__main__，内置和其他关键模块。多数情况下，扩展模块并不是被设计用于初始化多次，如果重载可能会导致失败。
  • 如果模块import了其他模块的对象，比如from ... import ...，那么调用reload()不会重定义这些对象的来源模块——一种方法是重新执行from语句，另一种方法是利用import和限制名称（module.name）取而代之。
  • 如果一个模块实例化了类的实例，那么重载模块对该class的定义并不影响实例定义的方法——它们继续用旧的class定义。对继承类来说也是一样。
• repr(object)
  • 返回某个对象其可打印的字符串。它与字符串转换（反引号）产生的值相同。有时把该操作用作普通函数访问非常有用。对多种类型来说，函数尝试去返回一个字符串，该字符串会yield一个值视图传递给eval()的对象。类可以通过定义__repr__()方法控制该函数的返回。
• reversed(seq)
  • 返回一个反向迭代器。seq必须是一个具有__reversed__()方法或支持序列规则的对象。
• round(number[, ndigits])
  • 返回一个float近似值，保留小数点后ndigits位。如果ndigits缺省，则默认为0。
• set([iterable])
  • 返回一个新的set对象，其元素是从可选的iterable获取。set是内建类。
• setattr(object, name, value)
  • getattr()的反操作。参数是一个对象，一个字符串和值。字符串可以是一个已存在的名字。函数将该值赋给该属性。
• slice(stop)
• slice(start, stop[, step])
  • 返回一个slice对象，表示由索引range(start, stop, step)指出的集合。start和step参数默认为None。切片对象具有只读属性start,stop和step，它们仅仅返回参数的值（或默认值）。使用扩展的索引语法时也会产生切片对象。比如a[start:stop:step]或a[start:stop,i]。
• sorted(iterable[,cmp[,key[,reverse]]])
  • 根据iterable的元素返回一个新的排序列表。
  • cmp,key,reverse和list.sort()方法参数含义相同。
  • cmp指定一个自定义带有两个参数的比较函数（可迭代的元素），它应该根据第一个参数是小于等于还是大于第二个参数返回负数，0或正数：cmp=lambda x,y: cmp(x.lower(), y.lower())。默认值是None。
  • key指定一个带有一个参数的函数，用于从每个列表元素选择一个比较的关键字：key=str.lower。默认为None（直接比较元素）。
  • reverse是一个bool值，如果设置为True，那么列表元素用于反向比较排序。
  • 通常情况，key和reverse转换处理比指定一个等同的cmp函数要快得多。因为cmp为每个元素调用多次，但是key和reverse只调用一次。
• staticmethod(function)
  • 返回function的一个静态方法。
  • 静态方法不接受隐式的第一个参数（self）。要声明静态方法，按如下写：

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

• • @staticmethod形式是一个函数装饰器。
  • 既可以在类对象调用（C.f()），也可以在类实例上调用（C().f()）。
  • python静态方法类似于java或C++。
• str(object=’’)
  • 返回一个字符串，包含对象的友好打印形式字符串。字符串object则返回其自身。于repr的区别在于，str不会试图返回一个eval()可接受的字符串。str的目标仅仅是一个可打印的字符串，没有参数则返回空串。
• sum(iterable[, start])
  • 将start以及iterable的元素从左向右相加并返回总和。start默认为0。iterable元素通常是数字，start值不允许是一个字符串。
  • 某些场景，有比sum()更好的选择。连接字符串序列的首选和快速的方式是调用’‘.join(sequence)。浮点数可用math.fsum()。迭代对象可用itertools.chain()。
• super(type[, object-or-type])
  • 返回一个代理对象，这个对象指派方法给一个父类或同类。这对类中被覆盖的继承方法非常有用。搜索顺序和getattr()一样。自己的类型被忽略。
  • type的__mro__属性罗列了用getattr()和super()来搜索排序的静态方法。可以随着继承关系的变化而动态更新。
  • 如果第二个参数缺省，则返回未绑定的super对象，如果第二个参数是个object，则isinstance(obj,type)必须为true，如果是type，则issubclass(type2,type)必须是true。
• tuple([iterable])
  • 返回一个元组，元素及顺序与iterable元素相同。iterable可以是一个序列，或支持迭代的容器或对象。如果iterable是一个元组，则原样返回。如果没有参数，则返回空元组()。
• type(object)
• type(name,bases,dict)
  • 只有一个参数时，返回object类型。返回值是一个类型对象。建议用isinstance()测试一个对象的类型。
  • 带有3个参数时，返回一个新的类型对象。本质上是class语句的动态形式。name是类的名字，作为__name__属性。bases元组逐条列举基类并成为__bases__属性；dict字典是包含类体定义的命名空间并作为__dict__属性。
• unichr(i)
  • 返回Unicode码为整数i的Unicode串。unichr(97)返回字符串u’a’。ord()的反操作。参数合法范围取决于python配置-可以是UCS2[0..0xFFFF]或UCS4[0..0x10FFFF]。否则抛ValueError。对ASCII和8比特字符串，参考chr()。
• unicode(object=’’)
• unicode(object[,encoding[,errors]])
  • 使用下列模式返回一个Unicode串。
  • 如果encoding和errors给定，unicode()会解码对象，对象可以是8位字符串或使用encoding编码的字符缓冲区。encoding参数是一个表示编码名称的字符串；如果编码未知，抛LookupError。根据errors完成错误处理。如果errors是’strict’（默认），则抛ValueError错误，如果是’ignoret’，错误会安静忽略，如果是’replace’，则用官方的Unicode替代字符U+FFFD来替换不能被解码的输入字符串。
  • 如果没有给出可选参数，unicode()和str()基本一致，只是返回Unicode串而不是8位字符串。
  • 对于提供__uincode__()方法的对象，将不带参数调用此方法来创建一个Unicode字符串。对于所有其他对象，要求提供8位字符串版本或表示，然后在’strict’模式下使用默认编码的编解码器将其转为Unicode字符串。
• vars([object])
  • 返回模块、类、实例或其他任何具有__dict__属性的对象的__dict__属性。
  • 如果不带参数，则vars()类似locals()。
• xrange(stop)
• xrange(start,stop[,step])
  • 和range()类似，只是返回的是个xrange对象，而非list。这是个惰性序列类型，它生成和range()生成列表同样的值但不会真正的存储。
• zip([iterable,…])
  • 返回一个以元组为元素的列表，第i个元组包含每个参数序列的第i个元素。返回列表长度被截断成最短的参数序列长度。多个参数长度相同时，zip()类似于带有初始参数为None的map()。只有一个序列参数时，返回一个1元组列表，没参数时则简单的返回一个空列表。
  • zip()和*操作符可以用来unzip一个列表：

>>> x = [1,2,3]
>>> y = [4,5,6]
>>> zipped = zip(x, y)
>>> zipped
[(1,4),(2,5),(3,6)]
>>> x2, y2 = zip(*zipped)
>>> x == list(x2) and y == list(y2)
True

• import(name[, globals[, locals[, fromlist[, level]]]])
  • 对python编程来说，这是个非必须的高级函数，这与importlib.import_module()不同。
  • 该函数被import语句所调用。可以替换这个函数用于改变import语句的行为（对内置模块的导入前指派新的__builtint__.__import__）。当下它更为单纯的用于import的hook操作。直接使用__import__()是罕见的，除了某些情况比如当你想要导入一个模块，且该模块的名字只在运行时才能得知。
  • 该函数导入模块名称，在包的上下文环境可能还会根据给定的globals和locals来决定如何解析该名字。fromlist给定了对象或子模块的名称，指明需要再name中导入的模块。标准的实现一般不用locals参数，仅用globals来决定import语句的包上下文。
  • level指定是适用绝对还是相对导入。默认是-1，表示两种均可，此时import会做尝试。0表示用绝对导入，正数表示调用__import__()导入模块时，其根目录的相对层级。
  • 如果name是package.module的格式，通常情况下，顶级包（第一个.字符前的名字）会被返回，而不是name指定的全部名称。然而，当一个非空fromlist给定时，全部名称的name会被返回。
  • 例如，import spam返回结果像下面的字节码：
  • spam = __import__('spam',globals(),locals(),[],-1)
  • 语句import spam.ham像这样调用：
  • spam = __import__('spam.ham',globals(),locals(),[],-1)
  • 注意这里的__import__()返回了顶级模块回来，因为对象被绑定到了顶级名称spam。
  • 另一方面，语句from spam.ham import eggs, sausage as saus像这样表现：

_temp = __import__('spam.ham', globals(), locals(), ['eggs', 'sausage'], -1)
eggs = _temp.eggs
saus = _temp.sausage	

• • 在这里，spam.ham会被返回。对象中待导出的名字被分别返回并指配成返回对象中同样的名字属性。
  • 如果你只是想简单的通过名称导入一个模块，使用importlib.import_module()。

非必要内建函数

还有一些当前python编程不必要的内置函数。为了兼容旧版python的程序，它们被保留了下来。 python程序员可以轻松的跳过这些函数，不必担心漏掉了重要的内容。

• apply(function, args[, keywords])
  • function必须是一个可调用的对象（用户自定义或内置的函数或方法，或class对象），args必须是一个序列。function的调用会用args作为参数，参数个数就是其长度。如果可选的option给定了，它必须是一个字典，且键全为string。它用于指定需要加入参数列表的那些关键字参数。调用apply()和直接调用function(args)是有区别的，尽管都是一个参数。调用apply()等价于function(*args,**keywords)。
• buffer(object[, offset[, size]])
  • object参数必须是一个支持缓存调用接口的对象（比如string，array，buffer）。一个新的buffer对象会由引用的object参数创建。buffer对象回事object从头开始的一个切片（或者从指定的offset处开始切片）。切片会延展到object的尾部（或者到一个给定的size参数长度结束）。
• coerce(x,y)
  • 返回一个由x，y这两个数字型参数转换成其普通类型的元组，对算数操作来说使用同样的法则。如果转换不可用，抛TypeError。
• intern(string)
  • 把string加入interned字符串表，返回这个interned字符串——string自己或一个copy。intern字符串对于优化字典的查找操作有一定增益效果——如果key是interned，查找的key也是interned，那么key的比较可以简单的比较指针的值而不是string的值。通常，python编程中所用的名字都是自动intern的，用于存模块，类或实例属性的字典也具有interned键。
  • interned string并非是不朽的，你必须始终保持一个指向intern()返回值的引用，以保证长期受益。