Python核心编程-细节

直接从六张开始看看书里有什么。

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)

不同平台用来表示行结束的符号是不同的, 例如 \n, \r, 或者 \r\n这就是 UNS 的关键所在, 作为 PEP 278 的结果, Python 2.3 引入了 UNS. 当你使用 'U' 标志打开文件的时候, 所有的行分割符(或行结束符, 无论它原来是什么)通过 Python 的输入方法(例如 read*() )返回时都会被替换为换行符 NEWLINE(\n). ('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:  ', arg1print 'arg2:  ', arg2  for i in tuple_args:print 'tuple_args:   ', ifor 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_strg_str = 'badboy'print g_str

报错：UnboundLocalError: local variable 'g_str' referenced before assignment。

g_str = 'fzk'
def test1():print g_strg_str = 'badboy'print g_strglobal g_strprint 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 = 1passb2 = B()print B.fooprint b2.foob2.foo = 3print b2.fooprint B.foob3 = B()print b3.fooB.foo = 4print B.fooprint b2.fooprint b3.foo
结果：

　　　　1
　　　　1
　　　　3
　　　　1
　　　　1
　　　　4
　　　　3
　　　　4

classmethod和staticmethod：

class C(object):def foo():passfoo = 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_codeexec_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 = 0print 'x is currently:', xwhile x < 5:x += 1print 'incrementing x to:', x"""

input()：是 eval()和 raw_input()的组合,等价于 eval(raw_input())。如：aList = input('Enter a list: ')