直接从六张开始看看书里有什么。
cmp() len() max() and min() sorted() and reversed() enumerate() and zip() sum() list() and tuple() dir()方法来得到它所有的方法和属性
extend() and append() extend()接受一个列表的内容，然后把所有元素追加到另一个列表中 append()把整个元素追加列表中，如：[].extend('abc') 最后输出的结果就是 ['a', 'b', 'c'] [].append('abc')输出结果是['abc']
pop() 把数组中的元素去掉，接受的参数是一个integer，把传入的index去掉，如果不传默认是最后一个
range(start, end, step =1)
filter(func, seq) map(func, seq1[,seq2...]) reduce(func, seq[, init])
issubclass() isinstance() hasattr(), getattr(),setattr(), delattr() dir() super() vars()
list.append(obj)
list.count(obj)
list.extend(seq) a
list.index(obj, i=0,
j=len(list))
list.insert(index, obj)
list.pop(index=-1)
list.remove(obj)
list.reverse()
list.sort(func=None,key=None,reverse=False)
字典
d = {'name':'allen','name2':'allen','age':'40'}
d = dict((['x', 1],['y', 2], ['z',3])) # 注意：两个()，dict只接受一个参数，可以是元祖，可以是列表，每个组合的数据个数两个
d = dict([['x', 1],['y', 2], ['z',3]])
d = {}.fromkeys(('x', 'y'), 1)
d = dict(zip(('x', 'y'), (1, 2)))
d = dict([('xy'[i-1], i) for i in range(1,3)]) #{'y':2, 'x':1}
d= dict(x=1, y=2)
cmp():字典的比较，先比较两个字典的元素个数，通过keys()方法获取返回键的顺序，在比较第一组的键，在比较第一组的值，在比较第二组的键。。。。。。。。
dict.clear ()
dict.copy ()
dict.fromkeys (seq,
val=None) c
dict.get(key,default=None)
dict.has_key(key)
dict.items()
dict.keys()
dict.iter() 对字典 dict 中的键 key,返回它对应的值 value,如果字典中不存在此键,则返回 default 的值(注意,参数 default 的默认值为 None)
dict.pop (key[, default])
dict.setdefault(key,default=None)
dict.update(dict2) 将字典 dict2 的键-值对添加到字典 dict
dict.values()
set() frozenset()
集合等价/不等价
obj in s
obj not in s
s == t
s != t
s < t (严格意义上)子集测试; s != t 而且s中所有的元素都是 t 的成员
s.issubset(t) s <= t
s > t
s.issubset(t) s <= t
s > t
s.issuperset(t) s >= t
s.union(t) s | t 合并操作:s 或 t 中的元素
s.intersection(t) s & t 交集操作:s 和 t 中的元素
s.difference(t) s - t 差分操作: s 中的元素,而不是 t 中的元素
s.symmetric_difference(t) s ^ t 对称差分操作:s 或 t 中的元素,但不是 s 和 t 共有的元素
s.update(t) s |= t (Union) 修改操作: 将 t 中的成员添加 s
s.intersection_update(t) s &= t 交集修改操作: s 中仅包括 s 和 t 中共有的成员
s.difference_update(t) s -= t 差修改操作: s 中包括仅属于 s 但不属于 t 的成员
s.symmetric_difference_update(t) s ^= t 对称差分修改操作: s 中包括仅属于 s 或仅属于 t 的成员
s.add(obj)
s.remove(obj)
s.discard(obj)
s.pop()
s.clear()
条件和循环
if condition:
pass
elif condition:
pass
else:
pass
while expression:
pass
for iter_var in iterable:
pass
pass什么也不做
文件和输入输出
open() file()
file_object = open(file_name, access_mode='r', buffering=-1)
access_mode是一个字符串代表一个文件打开的模式，r读 w写 a追加 U通用换行符。r 和U 打开的文件必须是存在的，w打开的文件首先会清空，a打开的文件是为了追加做准备的，所有写入的文件追加到末尾。+ 代表可读可写，b 代表二进制模式访问
buffering用于指示访问文件采用的缓冲方式，0 表示不缓冲，1 表示只缓冲一行数据。
r 以读方式打开
rU 或 Ua 以读方式打开, 同时提供通用换行符支持 (PEP 278)
w 以写方式打开 (必要时清空)
a 以追加模式打开 (从 EOF 开始, 必要时创建新文件)
r+ 以读写模式打开
w+ 以读写模式打开 (参见 w )
a+ 以读写模式打开 (参见 a )
rb 以二进制读模式打开
wb 以二进制写模式打开 (参见 w )
ab 以二进制追加模式打开 (参见 a )
rb+ 以二进制读写模式打开 (参见 r+ )
wb+ 以二进制读写模式打开 (参见 w+ )
ab+ 以二进制读写模式打开 (参见 a+ )
例子：fp = open(r'c:io.sys', 'rb') # 以二进制读模式打开 这里需要说一下的是file_name参数中的r 的意思是名字就是字符串的所显示的名，也就是遇见 ’‘ 不转义
open()
open() 和 file() 函数具有相同的功能, 可以任意替换.您所看到任何使用 open() 的地方, 都可以使用 file() 替换它.一般说来, 我们建议使用 open() 来读写文件, 在您想说明您在处理文件对象时使用 file() , 例如 ifinstance(f, file)
9.2.2 通用换行符支持(UNS)
不同平台用来表示行结束的符号是不同的, 例如 , , 或者 这就是 UNS 的关键所在, 作为 PEP 278 的结果, Python 2.3 引入了 UNS. 当你使用 'U' 标志打开文件的时候, 所有的行分割符(或行结束符, 无论它原来是什么)通过 Python 的输入方法(例如 read*() )返回时都会被替换为换行符 NEWLINE( ). ('rU' 模式也支持 'rb' 选项) . 这个特性还支持包含不同类型行结束符的文件. 文件对象的 newlines 属性会记录它曾“看到的”文件的行结束符.
如果文件刚被打开, 程序还没有遇到行结束符, 那么文件的 newlines 为 None .在第一行被读取后, 它被设置为第一行的结束符. 如果遇到其它类型的行结束符, 文件的 newlines 会成为一个包含每种格式的元组. 注意 UNS 只用于读取文本文件. 没有对应的处理文件输出的方法.在编译 Python 的时候,UNS 默认是打开的. 如果你不需要这个特性, 在运行 configure 脚本时,你可以使用 --without-universal-newlines 开关关闭它. 如果你非要自己处理行结束符, 请查阅核心笔记,使用 os 模块的相关属性.
当使用输入方法如 read() 或者 readlines() 从文件中读取行时, Python 并不会删除行结束符. 这个操作被留给了程序员. 例如这样的代码在 Python 程序中很常见:
f = open('myFile', 'r')
data = [line.strip() for line in f.readlines()]
f.close()
类似地, 输出方法 write() 或 ritelines() 也不会自动加入行结束符. 你应该在向文件写入数据前自己完成。
文件内移动：seek()
seek() 方法(类似 C 中的 fseek() 函数)可以在文件中移动文件指针到不同的位置. offset字节代表相对于某个位置偏移量. 位置的默认值为 0 , 代表从文件开头算起(即绝对偏移量), 1 代表从当前位置算起, 2 代表从文件末尾算起. 如果你是一个 C 程序员,并且使用过了 fseek() , 那么,0, 1, 2 分别对应着常量 SEEK_SET, SEEK_CUR, 以及 SEEK_END. 当人们打开文件进行读写操作的时候就会接触到 seek()方法。
text() 方法是对 seek() 的补充; 它告诉你当前文件指针在文件中的位置 - 从文件起始算起,单位为字节.
seek()方法在文件内移动，tell()告诉我们当前的位置。
函数：
一个方法理解可变长度的函数：只有是 * = * 格式的才会进入**dict_args中，否则就算本身是dict也算入*tuple_args中
def bar1(arg1, arg2='default', *tuple_args, **dict_args): print 'arg1: ', arg1 print 'arg2: ', arg2 for i in tuple_args: print 'tuple_args: ', i for j in dict_args.keys(): print 'dict_args : %s = %s' % (j, dict_args[j]) d = dict(x=1, y=2) bar1(1, 2, 3, 4, 'd', d, x=1, y=1)
结果：
arg1: 1 arg2: 2 tuple_args: 3 tuple_args: 4 tuple_args: d tuple_args: {'y': 2, 'x': 1} dict_args : y = 1 dict_args : x = 1
匿名函数lambda
a = lambda x, y = 2: x + y
filter函数用法： 就是过滤用的，经过帅选，选出符合方法返回值的数。传入的方法有且只接受一个参数
def odd(n): return n % 2 allNums = range(10) print filter(odd, allNums)
结果：[1, 3, 5, 7, 9]
map函数用法：
print map(lambda x, y: (x+y, x-y), [1,3,5], [2,4,6]) 结果：[(3, -1), (7, -1), (11, -1)]
reduce函数用法：就是算出前两个参数的值作为一个值和第三个参数一起算出一个值，依次进行。
def add(x, y): return x + y print reduce(add, [1,2,3])
结果：6
partial函数的用法：
int函数的用法:int(10)省略了base=10，默认就是一个十进制的数，所以用int('10')也可已得到十进制数。int('11', base = 2)会得到一个基于二进制的十位数，这里的不痛是指定了base参数，那么前面的参数就必须是一个string类型的参数，int(11, base=2)会报 : int() can't convert non-string with explicit base
baseTwo = partial(int, base=2) baseTwo('10010')
结果：18
下面这种写法：
baseTwoBAD = partial(int, 2)
baseTwoBAD('10010') TypeError: an integer is required
baseTwoBAD(10) TypeError: int() can't convert non-string with explicit base
上面baseTwo(x) = int(x, base=2)。baseTwoBAD(x) = int(2, x)
关键字参数总是出现在形参之后，也就是说，a = * 这种关键字参数一定要出现在单独一个参数 x 后面，这里没有指定base，2默认为形参，当在传入x后，x会放在第二个位置上也就是base的位置，所以上面两种情况分别报了不同错误。
作用域：
变量是有作用域的，在方法中声明的变量虽然和全局变量名一样，也有可能直接访问全局变量，但是出了方法后，全局变量的值就变回来了。直接代码解释：
g_str = 'fzk' def test1(): print g_str
没有问题，结果：fzk
g_str = 'fzk' def test1(): print g_str g_str = 'badboy' print g_str
报错：UnboundLocalError: local variable 'g_str' referenced before assignment。
g_str = 'fzk' def test1(): print g_str g_str = 'badboy' print g_str global g_str print g_str
结果：
fzk
badboy
badboy
第三种情况没报错，说明全部变量global在哪里声明都无所谓，只要在方法里声明了。
闭包的问题，是一个问题，和装饰器弄一篇。
在导入模块的时候，注意循环导入的问题。
python中，一个模块也就是一个已.py结尾的文件， 一个packge中可以有很多个模块，一般新建一个packge后会自动生成一个__init__.py文件。
类中的__init__(), __new()__, __del__()：
__init__() ：就是一个构造器，一般自己重写。
__new__()：这个方法更像是一个构造器，因为__new()__必须返回一个合法的实例，这样解释器在调用__init__()时就可以把他作为self传给他。调用__new()__会先调用父类的__new()__。
__del__() ：结构器，只有在所有的引用全部del后，才会调用__del__()方法。调用__del__()方法前先调用父类的__del__()方法。并不是调用删除一个属性(del a)就会调用这个方法，这是删除了一个引用，只有全部引用全部删除后才会调用这个方法。
类中有属性，修改实例中的类属性时需要谨慎。
实例中可以访问类中的属性，类中的属性修改实例也会感知到。但是如果在实例中修改类的属性就要注意了，如果实例中修改类的属性，相当于在实例中创建了原类中相同名的一个属性(只是名一样，并不是类中的属性)，实例在访问自己的属性时先会查找自己的属性，没有则会从类中查找，如果修改了实例中属性，相当于给实例属性赋值，这时就不会从类中查找，除非删除实例中属性。
class B(object): foo = 1 pass b2 = B() print B.foo print b2.foo b2.foo = 3 print b2.foo print B.foo b3 = B() print b3.foo B.foo = 4 print B.foo print b2.foo print b3.foo
结果：
1
1
3
1
1
4
3
4
classmethod和staticmethod：
class C(object): def foo(): pass foo = staticmethod(foo)
@staticmethod
def bar():
pass
class D(object): def foo(cls): pass
@classmethod
def bar():
pass
foo = classmethod(foo)
对应的内建函数被转换成它们相应的类型,并且重新赋值给了相同的变量名。如果没有调用这两个函数,二者都会在 Python 编译器中产生错误,显示需要带 self 的常规方法声明。现在, 我们可以通过类或者实例调用这些函数。没个类中两个的方法的生命是等价的。
老式类和新式类集成的问题：
老实类采用深度优先，比如
class P1: #(object): def foo(self): print 'called P1-foo()' class P2: #(object) def foo(self): print 'called P2-foo()' def bar(self): print 'called P2-bar()' class C1(P1, P2): pass class C2(P1, P2): def bar(self): print 'called C2-bar()' class GC(C1, C2): pass
gc = GC() gc.foo() # GC ==> C1 ==> P1 called P1-foo() gc.bar() # GC ==> C1 ==> P1 ==> P2 called P2-bar()
新式类采用广度优先：
上面的代码中，把p1和p2的(object)注解打开。重新调用上面的两个方法
gc = GC() gc.foo()# GC ==> C1 ==> C2 ==> P1 called P1-foo() gc.bar() # GC ==> C1 ==> C2 called C2-bar()
在继承类的括号中（如C1(P1, P2)左边p1，右边p2）从左侧开始查找，查找完一个类后在找同胞顺序是从左到右，依次向深处查找。直到找到为止。下面还有一个例子：
class G(object): def __init__(self): print 'G init' class H(object): def __init__(self): print 'H init' class I( H, G): pass i = I()
结果：H init
如果改成下面这样：
class I(G, H): pass
结果：G init
定制类：
基本定制型
C.__init__(self[, arg1, ...]) 构造器(带一些可选的参数)
C.__new__(self[, arg1, ...]) 构造器(带一些可选的参数);通常用在设置不变数据类型的子类。
C.__del__(self) 解构器
C.__str__(self) 可打印的字符输出;内建 str()及 print 语句
C.__repr__(self) 运行时的字符串输出;内建 repr() 和‘‘ 操作符
C.__unicode__(self) Unicode 字符串输出;内建 unicode()
C.__call__(self, *args) 表示可调用的实例
C.__nonzero__(self) 为 object 定义 False 值;内建 bool() (从 2.2 版开始)
C.__len__(self) “长度”(可用于类);内建 len()
特殊方法
C.__cmp__(self, obj) 对象(值)比较对象比较;内建 cmp()
C.__lt__(self, obj) and 小于/小于或等于;对应<及<=操作符
C.__gt__(self, obj) and 大于/大于或等于;对应>及>=操作符
C.__eq__(self, obj) and 等于/不等于;对应==,!=及<>操作符
属性
C.__getattr__(self, attr) 获取属性;内建 getattr();仅当属性没有找到时调用
C.__setattr__(self, attr, val) 设置属性
C.__delattr__(self, attr) 删除属性
C.__getattribute__(self, attr) 获取属性;内建 getattr();总是被调用
C.__get__(self, attr) (描述符)获取属性
C.__set__(self, attr, val) (描述符)设置属性
C.__delete__(self, attr) (描述符)删除属性
数值类型:二进制操作符
C.__*add__(self, obj) 加;+操作符
C.__*sub__(self, obj) 减;-操作符
C.__*mul__(self, obj) 乘;*操作符
C.__*div__(self, obj) 除;/操作符
C.__*truediv__(self, obj) True 除;/操作符
C.__*floordiv__(self, obj) Floor 除;//操作符
C.__*mod__(self, obj) 取模/取余;%操作符
C.__*divmod__(self, obj) 除和取模;内建 divmod()
C.__*pow__(self, obj[, mod]) 乘幂;内建 pow();**操作符
C.__*lshift__(self, obj) 左移位;<<操作符
定制类/模拟类型
数值类型:二进制操作符
C.__*rshift__(self, obj) 右移;>>操作符
C.__*and__(self, obj) 按位与;&操作符
C.__*or__(self, obj) 按位或;|操作符
C.__*xor__(self, obj) 按位与或;^操作符
数值类型:一元操作符
C.__neg__(self) 一元负
C.__pos__(self) 一元正
C.__abs__(self) 绝对值;内建 abs()
C.__invert__(self) 按位求反;~操作符
数值类型:数值转换
C.__complex__(self, com) 转为 complex(复数);内建 complex()
C.__int__(self) 转为 int;内建 int()
C.__long__(self) 转为 long;内建 long()
C.__float__(self) 转为 float;内建 float()
数值类型:基本表示法(String)
C.__oct__(self) 八进制表示;内建 oct()
C.__hex__(self) 十六进制表示;内建 hex()
数值类型:数值压缩
C.__coerce__(self, num) 压缩成同样的数值类型;内建 coerce()
C.__index__(self) 在有必要时,压缩可选的数值类型为整型(比如:用于切片索引等等)
序列类型
C.__len__(self) 序列中项的数目
C.__getitem__(self, ind) 得到单个序列元素
C.__setitem__(self, ind,val) 设置单个序列元素
C.__delitem__(self, ind) 删除单个序列元素
特殊方法
序列类型
C.__getslice__(self, ind1,ind2) 得到序列片断
C.__setslice__(self, i1, i2,val) 设置序列片断
C.__delslice__(self, ind1,ind2) 删除序列片断
C.__contains__(self, val) 测试序列成员;内建 in 关键字
C.__*add__(self,obj) 串连;+操作符
C.__*mul__(self,obj) 重复;*操作符
C.__iter__(self) 创建迭代类;内建 iter()
映射类型
C.__len__(self) mapping 中的项的数目
C.__hash__(self) 散列(hash)函数值
C.__getitem__(self,key) 得到给定键(key)的值
C.__setitem__(self,key,val) 设置给定键(key)的值
C.__delitem__(self,key) 删除给定键(key)的值
C.__missing__(self,key) 给定键如果不存在字典中,则提供一个默认值
"*" 代表''(selp OP obj), 'r'(obj OP self),或'i'(原位(in-place)操作),例如__add__, __radd__, or __iadd__.
双下划线(__)和单下划线(_)
双下划线是Python 为类元素(属性和方法)的私有性提供的形式。
单下划线是模块级私有化。可以防止模块的属性用“from module import *”来加载。
__slots__属性：
__dict__属性跟踪所有实例属性。举例来说,你有一个实例 inst.它有一个属性 foo,那使用 inst.foo 来访问它与使用 inst.__dict__['foo']来访问是一致的。字典会占据大量内存,如果你有一个属性数量很少的类,但有很多实例,那么正好是这种情况。为内存上的考虑,用户现在可以使用__slots__属性来替代__dict__。
如果__slots__属性中没有要获取的属性户会报异常，如果在__slots__外面又定义了一个属性a，那么a是read-only的。
class SlottedClass(object): __slots__ = ('foo', 'bar') c = SlottedClass() c.xxx = "don't think so"
结果：AttributeError: 'SlottedClass' object has no attribute 'xxx'
要知道的是他继承的是object，如果继承了其他的类，但是这个类中并没有用__slots__属性，那么也不会报错，他会认为那个属性是父类的。但是如果父类（非object）也用了__slots__，那么和集成object效果一样。
描述符真的是一个很恶心的东西。在弄一篇。
callable()：一个布尔函数，确定一个对象是否可以通过函数操作符(())来调用。如果函数可调用便返回 True,否则便是 False
compile()：函数允许程序员在运行时刻迅速生成代码对象，函数中有三个参数，都是必须的，第一个参数是python代码。第二个是一个字符串，存放代码生成文件的名字，通常置为空(‘’)。第三个参数有三个选择
'eval' 可求值的表达式[和 eval()一起使用]
'single' 单一可执行语句[和 exec 一起使用]
'exec' 可执行语句组[和 exec 一起使用]
eval_code = compile('100 + 200', '', 'eval') eval(eval_code) single_code = compile('print "Hello world!"', '', 'single') single_code exec_code = compile(""" ... req = input('Count how many numbers? ') ... for eachNum in range(req): ... print eachNum ... """, '', 'exec') exec exec_code
eval()：对表达式求值。如：eval('100 + 200')
exec：
exec """ x = 0 print 'x is currently:', x while x < 5: x += 1 print 'incrementing x to:', x """
input()：是 eval()和 raw_input()的组合,等价于 eval(raw_input())。如：aList = input('Enter a list: ')