open(name[,mode[,buffering]]):打开文件，返回一个file类型的对象。如果文件不能打开，抛出IOError。打开文件，相比较直接使用file构造器来说，使用open()方法更被推荐。

前两个参数和stdio的fopen()方法相同：name是文件的名字，mode表面如何打开文件。

最常用的mode值包括：'r'，表明读文件，'w'，表明写文件（如果文件存在，则截断文件），'a'，表明追加（在一些unix系统中，所有的写都是追加在文件的末尾，而无论文件的当前位置）。如果没有传进mode参数，则默认为'r'。默认使用文本格式，会将'\n'字符转换为平台特定的表示形式。因此，当打开一个二进制文件，mode的值应该加上'b'以提高兼容性。

可选的buffering参数指定文件使用的缓冲区的大小：0表示不是用缓冲，1表示使用1行缓冲。其它的正数表明使用的缓冲的（近似）字节数，负数表示系统默认缓冲区，一般来说，tty设备时一行缓冲区，而其他设备时全文缓冲。如果这个参数忽略，则使用系统默认缓冲。

模式'r+','w+','b+'打开文件以更新（注意到，'w+'会截断文件，），加上'b'，用来打开二进制文件。但在在一些不区分二进制文件和文本文件的系统里，加上'b'不起效果。

在标准的fopen()方法里，mode的值可能还包括'U'和'rU'，python更多是如下方式构建：通用新的一行支持，提供'U'来作为开打一个文本文件，但是一些行为会结束一行：Unix通过'\n'作为结束一行的转换；Mactonsh通过'\r'转换，Windows通过'\r\n'结束一行。这些外在的表示，在python里都是为'\n'。如果python不是通用的支持新行，那么mode为'U'的表现和一般的文本模式表现一样。值得注意的是，被打开的对象同样有一个 newline的属性，（在还没有新的一行的时候）且它的值是None。

python提供一些文件处理模块，包括：fileinput，os，os.path，tempfile以及shutil。

ord(c):给定一个长度为1的字符串参数，当参数是一个unicode对象时，返回字符的整型表示的unicode码，当参数是一个8位字符时，返回位值

>>> ord('a')
97
>>> ord(u'\u2020')
8224

对于8位字符来说，这个方法是chr()方法的逆方法，对于unicode方法来来说，此方法是unichr()方法的逆方法。

pow(x,y[,z]):返回x的y次幂。如果出现z，返回x的y次幂的结果模z，此犯法的效率高于pow(x,y)%z。当只有两个参数，即pow(x,y)等价于幂操作符 x**y.

参数必须是数值类型，且必须是二元操作数（正或者负操作数）类型。对于整型和长整型来说，结果的类型与他相同，除非第二个操作时为负数，此时，这两个操作数都会转化为float型，结果也将返回一个float型。如果第二个参数是负数的话，那么不能传入第三个参数。

print(*objects,sep='',end='\n',file=sys.stdout):打印对象到流式文件。文件由sep分割，以end结束。如果出现end和file参数，那么必须向关键参数那样提供。

所有的非关键参数都会同str()方法转化为字符串，并被写到流文件中。sep和end必须为字符串，当然，它们也可以为None，如果为None，那么就采用默认值，如果没有给到对象，那么将直接将end写入文件。

file参数必须是一个有write(string)方法的对象，如果不提供或者为None，那么会使用sys.out。输出缓存由file决定。使用file.flush()保证立即打印在屏幕上。

要注意的是，自从print被视为print语句之后，print()就不再是一个内置方法，如果想使得print语句失效，并且使用print()方法，在模块顶部使用future语句，

from __future__ import print_function

property([fget[,fset[,fdel[,doc]]]]):返回一个新型类的property属性。

fget是获取属性值的方法。类似的，fset是设置属性值的方法，fdel是删除属性值的方法。以属性X为例，一般使用如下：

class C(object):def __init__(self):self._x = Nonedef getx(self):return self._xdef setx(self, value):self._x = valuedef delx(self):del self._xx = property(getx, setx, delx, "I'm the 'x' property.")

如果c是类C的一个实例，那么c.x会调用getter方法，c.x=value会调用setter方法，del c.x会调用deleter方法。

如果给出了，那么doc将返回property属性的docstring（说明文档）。否则，属性会拷贝fget的docstring（如果存在的话），这样的话，使用property()作为装饰器，会得到一个只读的属性。

class Parrot(object):def __init__(self):self._voltage = 100000@propertydef voltage(self):"""Get the current voltage."""return self._voltage

property()使得voltage()方法成为一个getter，并且其docstring为相同命名的只读属性。

一个有将getter，setter，deleter方法用作装饰器的属性对象，会产生 由设置的装饰器的对应访问函数的属性的拷贝，示例如下：

class C(object):def __init__(self):self._x = None@propertydef x(self):"""I'm the 'x' property."""return self._x@x.setterdef x(self, value):self._x = value@x.deleterdef x(self):del self._x

以上的例子与第一个实例效果相同。

返回的属性同样有getter，setter，deleter，来对应方法的参数。

range(stop)

range(start,stop[,step]):这是一个包含算术级数的产生列表的方法。经常用于for循环中，参数必须是简单的整型。如果step参数忽略掉，那么默认是1，如果start参数被忽略掉，那么默认是0。返回的列表的完整形式是[start, start+step, start+2*step, ...]。step不能为0，否则会抛出valueerror。

>>> range(10)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> range(1, 11)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>> range(0, 30, 5)
[0, 5, 10, 15, 20, 25]
>>> range(0, 10, 3)
[0, 3, 6, 9]
>>> range(0, -10, -1)
[0, -1, -2, -3, -4, -5, -6, -7, -8, -9]
>>> range(0)
[]
>>> range(1, 0)
[]

raw_input([prompt]):如果提供了prompt参数，那么它将不会折行的写到标准输出上。方法会从输入中读取一行，转化为不折行的字符串，并返回这个字符串，当读到EOF，抛出EOFError，示例如下：

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

如果载入了readline模块，那么raw_input会使用它来提供行编辑以及历史记录等特色功能。

reduce(function,iteralbe[,initilizar]):运用两个参数的方法，对迭代对象的各个元素从左至右的累计，从而最终返回一个值。如：

>>> reduce(lambda x, y: x+y, [1, 2, 3, 4, 5])
15

reduce方法会做如下计算(((1+2)+3)+4)+5。左边的参数x是累计的值，参数y是从可迭代对象中拿到的最新的值。如果提供可选参数initilizar，它将会置于可迭代对象之前，并且是可迭代对象为空时的默认值。如果initilizar为空，且可迭代对象只有1个元素，那么reduce()方法返回这个元素。它等价于：

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 = initializerfor x in it:accum_value = function(accum_value, x)return accum_value

reload(module):重新载入之前引入的模块。参数必须是一个模块对象，且之前已经成功引入。当你通过外部编辑器编辑了模块的源文件，且想不离开python解释器而重新使用新版的模块，此方法就正好派上用场。

当reload(module)语句被执行：

• python模块的代码被重新编译，模块级别的代码会被重新执行，并且会定于模块字典的变量名字绑定的对象的集合。init()方法和其扩展模块不会立即执行。
• 所有其他的旧的对象只有在其引用数为0时才会被重新声明。
• 此模块命名空间的变量会更新到任意新的或以改变的对象的状态。
• 其它旧的对象的引用不会指向新的对象。如果需要，必须在每个命名空间都更新。

还有几个要注意的地方：

repr(object):返回包含对象的可打印表达式的字符串，它与（通过双引号）转换之后的值相等。可以通过访问这个操作作为一个一般的方法。对于很多类型来说，这个方法试着返回一个字符串，并且值与eval()方法的结果相同。否则，表达式是包含在尖括号内的字符串，它包含不同的对象的名称，连同附加信息通常包括的对象的名称和地址。一个类可以通过定义repr()方法控制其实例的repr()方法的返回值。

reversed(seq):返回一个逆转的可迭代对象，seq必须是一个有__reversed__方法的对象，并且支持序列协议。

round(number[,ndigit]):返回浮点数值且四舍五入到ndigit位，如果ndigit缺失，默认为0。结果是一个浮点数，四舍五入之后的值接近10的倍数的负的ndigiht次幂。如果有两个数同样接近，返回远离0的那个值，如

>>> round(0.5)
1.0
>>> round(-0.5)
-1.0

注意到，round()方法的结果有时候并不会向你预期的返回结果，如

>>> round(2.675, 2)
2.67

而不是返回2.68。这并不是bug，而是因为有的十进制的小数不能正确的转换为浮点数。

set([iterable]):返回一个新的集合对象，如果提供可迭代对象iterable，那么集合的元素来自此可迭代对象，集合是一个内置类型。

setattr(object,name,value)：这是对应getter()的方法，参数是一个对象，字符串和任意的值，字符串可以是已经存在的属性，也可以是一个新的属性。此方法分配值给这个属性。

slice(stop)

slice(start,stop[,stop])：返回一个切片对象，表示集合的下标在range(start,stop,step)内的部分。start和stop参数默认为None。切片对象的属性start,stop,step均为只读，且值与此方法的参数值相等（或在参数值缺失的情况下与默认值相等）。尽管可以用来数值计算或第三方扩展，切片对象没有其他显式方法。切片对象可以通过下标语法得到，如a[start:stop:step]或者a[start:stop,i]。iterator.islice()可以返回一个可迭代对象。

sorted(iterable[,cmp[,key[,reverse]]]): 返回一个新的元素来自可迭代对象iterable，且重新排序后的新的列表。

可选参数cmp,key,reverse，且意义通list.sort()方法的同名参数意义相同。

cmp指定两个参数的比较方法。此方法根据第一个参数是否小于，等于，大于第二个参数分别返回负数，0，或者整数，如cmp=lamba x,y :cmp(x.lower(),y.lower())。默认值是None。

key指定一个参数的方法，方法用来从元素中抽取一个用来比较的主键，如key=str.lower。key的默认值为None。

reverse是一个boolean值，如果设为True,那么列表元素的会排序会与每次比较的结果想法。

一般来说，key和reverse参数的转换过程比指定等价的cmp方法快。这是因为cmp方法会针对元素的每个元素调用，而key和reverse只会调用一次，通过functools.cmp_to_key()将一个老式的cmp方法转换成key方法。

staticmethod(function):返回function的静态方法。静态方法第一个参数不能为隐式。声明静态方法，可以这样：

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

@staticmethod的形式称作方法装饰器，这个装饰器，既可以通过类上调用，如c.f()，也可以通过实例调用，如c().f()。除非是类自身，否则实例会被忽略。

python的静态方法跟Java和C++中的类似。

str(object=''):返回一个包含对象的形式美观的表达式的字符串。该方法与repr()方法的区别是：str(object)方法不是总是返回一个对于eval()方法可接受的字符串，它的最终目的只是返回一个打印出的字符串。如果该方法没有给出参数，返回空得字符串''。

sum(iterable[,start]):对可迭代对象从start开始从左至右求和。可迭代对象的元素一般来说是数字；start默认为0，且要求不能是一个字符串。

对于拼接字符串来说，更快的方法是是''.join(sequence)。对于浮点数求和，有精度要求的更好的选择是math.fsum()，对于拼接一系列的可迭代对象，考虑使用itertools.chain()。

super(type[,object-or-type]):返回一个代理对象，代理方法来调用type的父类或者兄弟类。这对于访问类中继承方法被覆盖的情况下非常有用。搜索的顺序同getattr()方法期望的相同。type自身会略过。

type的__mro__属性列出所有按照getattr()和super()搜索顺序的方法。这个属性是动态的，并且在继承层级变化时时可以改变的。

如果第二个参数忽略，返回的超类对象无界。如果第二个参数是一个对象，isinstance(obj,type)必定返回true，如果第二个参数是一个类型，那么isinstance(type2,type)必定返回true。

要注意：super()仅对新式类起作用。

super()方法有两个典型用途：在单继承的类层级结构中，super可以应用其父类，而不用显式的声明。这样使得代码更易于维护，这种情况super是的使用与其它编程语言表现基本雷同。

第二种使用用途是在动态执行环境下，支持多继承。这种用途是python唯一的。这使得菱形编程的实现成为可能，即可以多个基类实现相同的方法。好的设计表明同一个方法可以用相同的签名在任何情况下调用。（因为调用的顺序在运行时决定，同时这个顺序取决于类的层级，并且这个顺序包含兄弟类，这在运行前是未知的）。

两种情况下，一个典型的super的使用如下：

class C(B):def method(self, arg):super(C, self).method(arg)

要注意到，super()实现来作为显式属性查找的绑定流程的一部分，比如__super__().getitem(name)。它能着用使用是因为对于支持了多继承的预期顺序的搜索类实现了自己的__getattribute__()。相应的，super()方法不支持隐式的查找语句，或者注入super()[name]的操作符。

同时也要注意到，super()没有局限在使用内在方法两个参数的形式指定了明确的参数和合适的引用。

tuple([iterable]):返回一个元组，元素及其顺序与可迭代对象iterable的元素及其顺序相同。可迭代对象可以是序列，可以是支持迭代的容器，或者可迭代对象。如果iterable就是一个元组，那么就返回改元组。

>>> tuple('abc')
('a', 'b', 'c')
>>> tuple([1, 2, 3])
(1, 2, 3)

如果没有参数，返回一个空元组。元组是一个不可变类型。

type(object)

type(name,bases,dict):如果只有一个参数，则返回对象的类型。推荐使用内置方法isinstance()方法来测试对象的类型。

如果有3个参数，返回一个新型类对象。它本质是是class语句的动态形式。字符串name是类的名字，且是__name__属性；元组bases指定了其基类，且是__bases__属性；字典dict是包含类定义的命名空间，且是__dict__属性。实例如下：

>>> class X(object):
...     a = 1
...
>>> X = type('X', (object,), dict(a=1))

xranges(stop)

xranges(start,stop[,step]):这个方法类似range()，不同的返回的是xrange对象，而不是列表。xrange对象是一个不透明序列类型，它也产生和对应列表相同的值，但是不会立即存储它们。相比较range，xrange的好处忽略不计，因为当调用的适合，还是会产生这些值，但是在对于内存敏感的机器，使用一个很大的range，且这些值不会再次被使用的使用，xrange可能是一个不错的选择。

zip([itarable...]):这个方法返回一个由tuple组成的列表。第i个元组包含从可迭代对象中获取的第i个元素。返回的列表的长度会截断至与长度最小的可迭代对象的长度相同。当有多个长度相同的可迭代对象做参数是，zip()方法与map()方法类似。当只有1个参数时，返回包含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编程中经常使用。为了改变import语句的语义，它可以替换（通过引入__buildin__模块，使用__builtin__.__import__）。但如今这种用法很少被人使用。直接使用__import__很少见，除非是要引入的模块的名字在运行时才知道。

这个方法通过name引入模块，可能会根据globals和locals决定在包环境下如何解释命名。fromlists参数给出了应该引入的对象或子模块的名字。标准的实现完全不需要使用locals参数，而只使用globals来决定import语句的包环境。

level决定是是绝对引用还是相对引用。默认是-1，表明决定引用和相对引用都会尝试，0表明执行决定引用，正数的level值要搜索的父目录是相对于要引入的模块。

一般来说，如果name变量是package.module形式，将返回顶层的包，而不是和name相同的模块。但是，当给出了非空得fromlists，返回的模块是有name决定的。

举例来说，import spam语句的字节码表示形式如下：

spam = __import__('spam', globals(), locals(), [], -1)

import spam.ham会调用

spam = __import__('spam.ham', globals(), locals(), [], -1)

注意到这里返回的是顶层模块，因为它是通过import语句绑定名字的对象。

另一方面，语句 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模块是从__import()__返回，根据这个对象，import的名字取回并分配给各自的命名。

如果只是想简单的通过名字引入模块，使用importlib.import_module()。

unicode(object='') 

unicode(object[, encoding[, errors]])：通过下面的一种形式，返回对象的unicode字符串形式。

• 如果给出 encoding和/或 errors，unicode()方法会对8位字符串或者使用codec加密的字母缓存解码。
• 如果没有可选参数给出，那么unicode()方法与str()方法的结果类似，只是返回一个unicode字符串而不是一个8为字符串。
• 对于提供__unicode__方法的对象，它会不带参数的调用这个方法，返回一个unicode字符串。