Python 参考手册

#函数                                  #描述  
-------------------------------------------------------------------------------------------------  
abs(numbers)                           #返回一个数的绝对值  
apply(func[,arg[,kwargs]])             #调用给定的函数，可选择提供参数  
all(iterable)                          #如果所有iterable的元素均为真则返回True,否则返回False  
any(iterable)                          #如果有任一iterable的元素为真则返回True,否则返回False  
basestring()                           #str和unicode抽象超类，取决于obj的布尔值  
callable(obj)                          #检查对象是否可调用  
char(number)                           #返回ASCII为给定的字符  
classmethod(func)                      #通过一个实例方法创建类的方法  
cmp(x,y)                               #比较x,y。x<y:返回负数;x>y:返回正数;x==y,返回0  
complex(real[,imag])                   #返回给定实部的复数  
delattr([mapping-or-sequence])         #从给定的对象中删除给定的属性  
dict([mapping-or-sequence])            #构造字典，可选择从键值对组成的列表构造。也可以用关键字参数调用  
dir(object)                            #列出给定对象的大多数特性  
divmod(a,b)                            #返回(a//b,a%b)  
enumerate(iterable)                    #对iterable所有项进行迭代  
eval(string[,globals[,locals]])        #对包含表达式的字符串进行计算。可选择给定的全局或局部作用域中进行  
execfile(file[,globals[,locals]])      #执行一个Python文件，可选在给定全局或者局部作用域中进行  
file(filename[,mode[,bufsize]])        #创建给定文件名的文件，可选择使用给定的模式和缓存区大小  
float(object)                          #将字符串或者数值转换为浮点型  
frozenset([iterable])                  #创建一个不可变集合，这意味着不能将它添加到其他集合中  
getattr(object,name[,default])         #返回给定对象中指定的特性的值，可选择给定默认值  
globals()                              #返回表示当前作用域的字典  
hasattr(object,name)                   #检查给定的对象是否有指定的属性  
help([object])                         #调用内置的帮助系统，或打印给定对象的帮助信息  
hex(number)                            #将数字转换为十六进制表示的字符串  
id(object)                             #返回给定对象的唯一ID  
input([prompt])                        #等同于eval(raw_input(prompt))  
int(object[,radix])                    #将字符串或者数字转换为整数  
isinstance(object,classinfo)           #检查给定的对象是否是给定的classinfo值的实例,classinfo可以是类对象、类型对象  
issubclass(class1,class2)              #检查class1是否是class2的子类  
iter(object[,sentinel])                #返回一个迭代对象，可以用于迭代序列的object_iter()迭代器  
len(object)                            #返回给定对象的长度  
list([object])                         #构造一个列表  
locals()                               #返回表示当前局部作用域的字典  
long(object[,radix])                   #将字符串或者数字转换为长整形  
map(function,seq1,...)                 #创建给定函数func应用到列表seq中每一项时返回的值组成的列表  
max(obj1[,obj2]...)                    #如果obj1为非空序列，则返回最大的元素;否则返回所提供参数的最大值    
mix(obj1[,obj2]...)                    #如果obj1为非空序列，则返回最小的元素;否则返回所提供参数的最小值         
object()                               #返回所有新式类的基数Object的实例  
oct(number)                            #将整型转换为八进制表示的字符串  
open(filename[,mode[,bufsize]])        #file的别名，在打开文件的时候使用open而不是file  
pow(x,y[,z])                           #返回x的y次方，可选择模除z  
ord(char)                              #返回给定单字符的ASCII值  
range([start,]stop[,step])             #使用给定的起始值和结束值来创建数值范围  
property(fget[,fset[,fdel[,doc]]])     #通过一组访问器创建属性  
raw_input([prompt])                    #将用户输入的数据作为字符串返回，可选择使用给定的提示符prompt  
reduce(func,seq[,initializer])         #将序列的所有渐增应用给定的函数，使用累积的结果作为第一个参数,所有的项作为第二个参数，可选择给定起始值  
reload(module)                         #重载入一个已经载入的模块并且将其返回  
repr(object)                           #返回表示对象的字符串，一般作为eval的参数使用  
reversed(object)                       #返回序列的反向迭代器  
round(float[,n])                       #将给定的浮点四舍五入，小数点后保留n位  
set([iterable])                        #返回从iterable生成的元素集合  
setattr(object,name,value)             #设定给定对象的指定属性的值为给定值  
sorted(iterable[,cmp][,key][,reverse]) #从iterable中返回一个新排序后的列表，可选的参数和列表方法sort中的参数相同  
staticmethod(func)                     #从一个实例方法创建静态类方法  
str(object)                            #返回表示给定对象object的格式化好的字符串  
sum(seq[,start])                       #返回添加到可选参数start中的一系列数字的和  
super(type[,obj/type])                 #返回给定类型的超类  
tuple([sequence])                      #构造一个元祖,可选择使用sequence一样的项  
type(object)                           #返回给定对象的类型  
type(name,bases,dict)                  #使用给定的名称，基类和作用域返回一个新的类型对象  
unichr(number)                         #chr的Unicode版本  
unicode(object[,encoding[,errors]])    #返回给定对象的Unicode编码版本，可以给定编码方式和错误处理模式  
vars([object])                         #返回表示局部作用于的字典，或者对应给定对象特性的字典  
xrange([start,]stop[,step])            #类似于range，但是返回的对象使用较少的内存，而且只用于迭代  
zip(seq1,...)                          #返回元祖的列表，每个元祖包括一个给定序列中的项。返回长度以最小为准.

#方法                                  #描述  
-------------------------------------------------------------------------------------------------  
L.append(obj)                          #等同于L[len(L):len(L)] = [obj]  
L.count(obj)                           #返回L[i] == obj中索引为i的值  
L.extend(obj)                          #等同于L[len(L):len(L)] = seq  
L.index(obj)                           #返回L[i] == obj中最小的i,不存在会触发ValueError异常  
L.insert(index,obj)                    #index>0,等同于L[index:index]=[obj],index<0,插入列表最前面  
L.pop([index])                         #移除并且返回给定索引的项(默认为:-1即最后一项)    
L.remove(obj)                          #等同于L[L.index(obj)]      
L.sort([cmp][,key][,reverse])          #对L中的项进行原地排序。可以提供比较函数cmp,创建用于排序的键的key函数和reverse标志进行自定义

#方法                                  #描述  
-------------------------------------------------------------------------------------------------  
D.clear()                              #移除D中的所有项  
D.copy()                               #返回D的副本  
D.fromkeys(seq[,val])                  #返回从seq中获得的键和被设置为val的值的字典。可做类方法调用  
D.get(key[,default])                   #如果D[key]存在，将其返回；否则返回给定的默认值None  
D.has_key(key)                         #检查D是否有给定键key  
D.items()                              #返回表示D项的(键，值)对列表  
D.iteritems()                          #从D.items()返回的(键，值)对中返回一个可迭代的对象  
D.iterkeys()                           #从D的键中返回一个可迭代对象  
D.itervalues()                         #从D的值中返回一个可迭代对象  
D.keys()                               #返回D键的列表  
D.pop(key[,d])                         #移除并且返回对应给定键key或给定的默认值D的值  
D.popitem()                            #从D中移除任意一项，并将其作为(键，值)对返回  
D.setdefault(key[,default])            #如果D[key]存在则将其返回；否则返回默认值None  
D.update(other)                        #将other中的每一项加入到D中。  
D.values()                             #返回D中值的列表

#方法                                   #描述  
-------------------------------------------------------------------------------------------------  
S.capitalize()                          #返回首字母大写的字符串的副本  
S.center(width[,fillchar])              #返回一个长度为max(len(S),width),S居中，两侧fillchar填充  
S.count(sub[,start[,end]])              #计算子字符串sub的出现次数，可将搜索范围限制为S[start:end]  
S.decode([encoding[,error]])            #返回使用给定编码方式的字符串的解码版本，由error指定错误处理方式  
S.endswith(suffix[start[,end]])         #检查S是否以suffix结尾，可给定[start:end]来选择匹配的范围  
S.expandtabs([tabsize])                 #返回字符串的副本，其中tab字符会使用空格进行扩展，可选择tabsize  
S.find(sun[,start[,end]])               #返回子字符串sub的第一个索引，不存在则为-1,可选择搜索范围  
S.index(sub[,start[,end]])              #返回子字符串sub的第一个索引，不存在则引发ValueError异常.  
S.isalnum()                             #检查字符串是否由字母或数字字符组成  
S.isalpha()                             #检查字符串是否由字母字符组成  
S.isdigit()                             #检查字符串是否由数字字符组成  
S.islower()                             #检查字符串是否由小写字母组成  
S.isspace()                             #检查字符串是否由空格组成  
S.istitle()                             #检查字符串时候首字母大写  
S.isupper()                             #检查字符串是否由大写字母组成  
S.join(sequence)                        #返回其中sequence的字符串元素由S连接的字符串  
S.ljust(width[,fillchar])               #返回S副本左对齐的字符串,长度max(len(S),W),右侧fillchar填充  
S.lower()                               #返回所有字符串都为小写的副本  
S.lstrip([char])                        #向左移除所有char，默认移除(空格,tab,\n)  
S.partition(seq)                        #在字符串中搜索seq并返回  
S.replace(old,new[,max])                #将new替换olad,最多可替换max次  
S.rfind(sub[,start[,end]])              #返回sub所在的最后一个索引，不存在则为-1,可定搜索范围S[start:end]  
S.rindex(sub[,start[,end]])             #返回sub所在的最后一个索引，不存在则会引发ValueError异常。  
S.rjust(width[,fillchar])               #返回S副本右对齐的字符串,长度max(len(S),W),左侧fillchar填充  
S.rpartition(seq)                       #同Partition,但从右侧开始查找  
S.rstip([char])                         #向右移除所有char，默认移除(空格,tab,\n)  
S.rsplit(sep[,maxsplit])                #同split,但是使用maxsplit时是从右往左进行计数  
S.split(sep[,maxsplit])                 #使用sep做为分割符,可使用maxsplit指定最大切分数  
S.zfill(width)                          #在S的左侧以0填充width个字符  
S.upper()                               #返回S的副本，所有字符大写  
S.splitlines([keepends])                #返回S中所有行的列表，可选择是否包括换行符  
S.startswith(prefix[,start[,end]])      #检查S是否以prefix开始，可用[start,end]来定义范围  
S.strip([chars])                        #移除所有字符串中含chars的字符，默认移除(空格，tab,\n)  
S.swapcase()                            #返回S的副本，所有大小写交换  
S.title()                               #返回S的副本，所有单词以大写字母开头  
S.translate(table[,deletechars])        #返回S的副本，所有字符都使用table进行的转换，可选择删除出现在deletechars中的所有字符

#类型             #描述                   示例  
--------------------------------------------------------  
Integer           #无小数部分的数         42  
Long Integer      #大整数                 42L  
Float             #有小数部分的数         42.5, 42.5e-2  
Complex           #实数和虚数的和         4 + 3j,42j  
String            #不可变的字符序列       'foo',"bar","""abc""",r'\n'    
Unicode           #不可变的Unicode序列    u'foo',u"bar",u"""abc"""

#为真:  
>>> age = 20  
>>> assert age >= 12, 'The age under 12 is not allowed!'  
#为假:  
>>> assert age >= 40, 'The age must over 40!'  
Traceback (most recent call last):  
  File "<stdin>", line 1, in <module>  
AssertionError: The age must over 40!

>>> name, age = 'Jerry', 38   # 序列解包  
>>> x = y = z = 42            # 链式赋值  
>>> x = 42                    # 简单赋值

>>> x *= 2                    # x = x * 2  
>>> x += 5                    # x = x + 5

try:  
    x.name  
except AttributeError:  
    pass  
else:  
    print 'Hello', x.name

del x                        # 解除变量绑定  
del seq[4]                   # 删除序列元素  
del seq[4:]                  # 删除序列切片  
del map['foo']               # 删除字典中的映射项

>>> print 'Hello,World!'      # 将'Hello,World!\n'写入到sys.stdout中  
>>> print 1, 2, 3             # 将'1 2 3\n'写入到sys.stdout中  
>>> print >> somefile, 'xyz'  # 将'xyz'写入到somefile中  
>>> print 42,                 # 将'42'写入到sys.stdout中

>>>return                     # 从当前函数中返回None  
>>>return 42                  # 从当前函数中返回42  
>>>return 1, 2, 3             # 从当前函数中返回(1,2,3)

yielda 42                     # 从当前函数中返回42

raise                         # 只能用于except子句中  
raise IndexError  
raise IndexError, 'index out of bounds'  
raise IndexError('index out of bounds')

while True:  
    line = file.readline()  
    if not line:  
        break  
    print line

while True:  
    line = file.readline()  
    if not line: break  
    if line.isspace(): continue  
    print line

import math  
from math import sqrt  
from math import sqrt as squareroot  
from math import *

count = 1  
def inc():  
    global count  
    count += 1

exec 'print "Hello,World!"'  
exec 'x = 2' in myglobals, mylocals   # mygolobals和mylocals都是字典

lambda x,y: x ** 2 + y, (1,2)         # 冒号分割，前面变量，后面return值

if x < 10:  
    print 'Less than 10'  
elif 10 <= x <= 20:  
    print 'Less than 20'  
else:  
    print 'More than 20'

x = 1  
while x < 100:  
    x *= 2  
print x

for i in range(10, 0, -1):  
    print i  
print 'Ignition!'

try:  
    1/0  
except ZeroDivisionError:  
    print "Can't divide anything by zero."  
finally:  
    print 'Done trying to calculate 1/0'

with open('NOTE.txt') as myfile:  
    dosomething(myfile)  
#文件在此处关闭

def double(x):  
    return x * 2

class Doubler:  
    def __init__(self,value):  
        self.value = value  
    def double(self):  
        self.value *= 2

#版本           #新特性  
-----------------------------------------------------------------------------------------  
01.Python 3.0:  #print是一个函数  
02.Python 3.0:  #文本文件强制编码  
03.Python 3.0:  #zip、map和filter函数返回迭代器  
04.Python 3.0:  #dict.keys()、dict.values()和dict.items()返回视图而不是列表  
05.Python 3.0:  #cmp参数不再用于sorted和list.sort，使用key代替  
06.Python 3.0:  #除法成了真的除法 1/2 == 0.5  
07.Python 3.0:  #只有一个字符串类型str，等同于Python2.x版本中的unicode类型  
08.Python 3.0:  #basestring类被去除了  
09.Python 3.0:  #新的bytes类型用于表示二进制数据和编码后文本  
10.Python 3.0:  #bytes写成b"abc"  
11.Python 3.0:  #UTF-8为默认的Python源文件编码方式。可以使用非ASCII标识符  
12.Python 3.0:  #StringIO和cStringIO由io.StringIO和io.BytesIO代替  
13.Python 3.0:  #新的内建字符串格式化方法代替了%运算符  
14.Python 3.0:  #函数可以注释它自己的参数和返回值  
15.Python 3.0:  #使用raise Exception(args)代替 raise Exception, args  
16.Python 3.0:  #使用except MyException as identifier代替 except MyException,identifier  
17.Python 3.0:  #经典类和旧式类被去除了  
18.Python 3.0:  #Foo(Base,metaclass=Meta): 用于设置原类  
19.Python 3.0:  #增加抽象类@abstractmethod和@abstractproperty  
20.Python 3.0:  #增加了类修饰符，类似于函数修饰符  
21.Python 3.0:  #不再使用``，而使用repr函数  
22.Python 3.0:  #<>运算符不再使用，一律使用!=  
23.Python 3.0:  #True,False、None、as和with成为关键字，意味着不能用作变量名  
24.Python 3.0:  #long类型被重命名为int，是现在唯一的整形，没有L  
25.Python 3.0:  #sys.maxint被去除,不再有最大值  
26.Python 3.0:  #x<y在x和y属不同类型的情况下会报错  
27.Python 3.0:  #__getslice__和类似的的函数被去除。可以使用分片对象调用__getitem__  
28.Python 3.0:  #参数可以作为专用关键字  
29.Python 3.0:  #使用nonloacl x以后，可以在外部作用域对x进行赋值  
30.Python 3.0:  #raw_input被重命名为input。使用eval(input())获取原先input的功能   
31.Python 3.0:  #xrange重命名为range  
32.Python 3.0:  #元祖参数解包功能被去除。def foo(a,(b,c)):不再可用  
33.Python 3.0:  #迭代器中的next函数被重命名为x.__next__。next(x)会调用x.__next__  
34.Python 3.0:  #增加了八进制字面量。以0o666代替0666  
35.Python 3.0:  #增加了二进制字面量。0b1010 == 10。bin()函数的作用类似于hex()和oct()  
36.Python 3.0:  #增加了星号迭代器解包功能，对于参数a和b来说,使用*rest = seq或*rest.a = seq  
37.Python 3.0:  #super函数可以不用参数调用，行为也会正确  
38.Python 3.0:  #string.letters和相关函数被去除。使用string.ascii_letters代替  
39.Python 3.0:  #apply函数被去除。使用f(*x)代替apply(f.x)  
40.Python 3.0:  #callable被去除。使用hasattr(f,"__call__")代替callable(f)  
41.Python 3.0:  #coerce函数被去除  
42.Python 3.0:  #execfile被去除。使用exec代替  
43.Python 3.0:  #file对象被去除  
44.Python 3.0:  #reduce函数被移动到functools模块中  
45.Python 3.0:  #reload函数被去除。使用exec代替  
46.Python 3.0:  #dict.has_key被去除。使用k in d代替d.has_key(k)  
47.Python 3.0:  #以新的语法创建集合{1,3,2},类似于set([1,3,2])