Python参考手册(第4版) 学习笔记1

第一章


在Shell模式下，可以使用 _ 表示上次的计算结果，用来参与下一次运算。
如： 2+3 输出 5， 然后 _ + 1 输出 6。（注：只可以在Shell中这么用）




py程序退出：
1、输入EOF（End of File,文件结束）
2、使用菜单退出。Unix是Ctrl+D, Windows是Ctrl+Z
3、程序抛出退出异常：raise SystemExit




py接受用户输入：
row_input("Enter you name:") #py3中是 input()
等同于
sys.stdout.write("Enter your name:")
name = sys.stdin.readline()


切片：
a=“hello world”
b=a[0:5] // a从第0个到第4个字符，不包含第五个


在py中，程序肯定不会讲字符串和数字进行默认转换。所以字符串"+"运算是连接字符串。
字符串和数字转换方式：ia = int(str); str = str(ix);str = repr(ix);
str得到的字符串和print相同，repr的到的字符串用于表示程序对象的精确值。


列表list
lst = ["jack","ann","Prel"],索引从0开始。
读取，修改数据：a=lst[2];lst[3]="Tom";也可以使用切片的办法读取和修改。
append()添加到结尾，insert()插入
“+”运算表示连接两个list列表。


元组
ps = ("ok",1,23.1,'aa')
a = () # 0 元组，即空元组
a = ('ob',) # 1 元组，注意逗号
元组无法替换，删除，插入。
读取和list一样，三种方式：索引、切片、连接。更一般的使用解包方式，即(x,y) = (0,1)


集合Set
集合包含的是一组无序的对象,元素不重复。无法通过索引读取。
s = set([1,4,10]) # 数组集合
t = set("hello") # == set( ['H','e','l','o'] )
添加：add(“xx”)#添加一项。update([])#添加多项
remove('xx')#删除一项


字典dict
dct = { "jack":12, 'Tom':"good", 'Ann':12.6 }
访问和修改：age = dct["jack"];dct["Tom"]=23;
测试是否是dct中的一员：if "Ann" in dct:.... 或者 p = dct.get("Jim",0)
获取所有关键字列表：list(dct) #[xx,xx,xx]
del dct["jack"]


迭代遍历
for i in range(0,100):....
for i in [0,1,4,6]:....
在Py2中当range()范围特别大时，内存会消耗很厉害，所以有xrange()替代。在Py3中都被range()替代了。


函数：
def f1(a,b=3):
c = a+b
d = a-b
return (c,d)


(x,y) = f1(1,2) # x = 3,y = -1




生成器：
yield 可以产生一个结果序列，任何使用yield的函数都成为生成器，调用生成器都会创建一个对象，该对象有next()方法(py3中是__next__())产生序列。


生成器是处理管道、流和数据流程序的强大方式。


生成器是这样一个函数，它记住上一次返回时在函数体中的位置。对生成器函数的第二次（或第 n 次）调用跳转至该函数中间，而上次调用的所有局部变量都保持不变。
生成器不仅“记住”了它数据状态；生成器还“记住”了它在流控制构造（在命令式编程中，这种构造不只是数据值）中的位置。


生成器的特点：
1、生成器是一个函数，而且函数的参数都会保留。
2、迭代到下一次的调用时，所使用的参数都是第一次所保留下的，即是说，在整个所有函数调用的参数都是第一次所调用时保留的，而不是新创建的


程序运行到yield这行时，就不会继续往下执行。而是返回一个包含当前函数所有参数的状态的iterator对象。目的就是为了第二次被调用时，能够访问到函数所有的参数值都是第一次访问时的值，而不是重新赋值。


class Fib:
    def __init__(self, max):
        self.max = max
    def __iter__(self):
        self.a = 0
        self.b = 1
        return self
    def next(self):
        fib = self.a
        if fib > self.max:
            raise StopIteration
        self.a, self.b = self.b, self.a + self.b
        return fib


协程：
是yield的接收者。使用表达式(yield)创建协程。


def print_matches(matchnext):
print “look for”,matchnext
while True:
line = (yield) #获取一行文本
if matchnext in line:
print line


使用时，首先调用它，向前执行到第一条(yield)语句，然后向他send数据。


matcher = print_matches("python")
matcher.next() #执行到第一条(yield)语句，函数暂停
>> look for python
matcher.send("python is good") #激活函数，然后到(yeild)继续暂停
>>> python is good
matcher.send("it is good") #无输出
matcher.close() #结束函数匹配器调用


需要并发协程时，可以使用一组：


#创建一组匹配器
matchers = {
print_matches("one"),
print_matches("two"),
print_matches("three")
}
#启动所有的协程
for m in matchers:
m.next()
#当需要时，send
.... # when need
for m  in matchers:
m.send("xxx")


对象和类：
Python中所有的值都是对象。
dir()可列出对象的所有可用方法。


class Stack(object): #声明一个对象，继承于object
# 每个方法的第一个参数总是指向对象自身，约定为self
def __init__(self): #初始化栈
self.stack = []
def push(self,object):
self.stack.append(object)
# 使用装饰器产生一个静态方法
@staticmethod
def staticf1():
pass


异常：
异常通常会导致程序终止，但是我们可以通过try...except...方法接受并处理异常。
try:
f = open("a.txt")
except IOError as e:
print e


也可以通过手工产生异常：
raise RuntimeError("xxxx")


with...可以简单地由系统接管对象，如果发生异常，则控制会离开block代码，继续下面的处理。


模块：
import xxx 可以直接导入其他模块，每个文件就是一个模块。
import导入会按照原来的名称产生一个命名空间，我们可以使用import xx as newxx从而使用自定义命名空间。
from xx import * 会将模块内容导入自身模块，并且不产生命名空间。




第二章


使用 \ 可以将单行程序延展到下一行。
() [] {} 等有明确范围的可以多行编写。


内置数据类型：
布尔型： True， False
整数：int，位数可以是任意的，可以用来表示特别大的数。
浮点数：12.41, 1.23e+02
复数：12+2j, -3.2J
字符串：
\000 八进制（\000-\377）
\uxxxx Unicode（\u0000-\uffff）
\Uxxxxxxxx Unicode(\u00000000-\uffffffff)
\N{字符名称} Unicode字符名称
\xhh 十六进制值(0x00-0xff)
注：Py3中所有字符都是Unicode，不必使用u前缀。


字符串前面加上r/R则引号内部会当做自然字符串处理，不产生转义。


文档字符串：
def fn1():
'''这里是文档字符串内容，可以通过__doc__访问'''
pass


装饰器：
使用@作为前缀，位于单独的行并且位于方法或者类的前面。第6和7章有详细介绍。


源代码编译：
# -*- coding: UTF-8 -*-
这样似乎也行
# encoding:utf8




第三章  类型和对象


对象身份判别：
if a is b:.... #a和b是同一个对象
if a == b:... #a和b的值相同
if type(a) is type(b):... #a和b有相同的类型


检查类型更好的方式：
if isinstance(a,list):.... #检查a类型是否是list


引用计数与垃圾回收：
所有对象都有引用计数，del或者超出作用域都会减少引用计数。
sys.getrefcount()可以获取对象的引用计数。
当引用计数为0时，对象会被垃圾收集器处理掉。


对象默认是浅复制，即数据共享。使用xx.deepcopy()则使用深层复制，数据不共享。


字符串常用函数：
s.isslnum(),s.isupper()
s.find(),s.rfind() # 失败返回-1
s.index(),s.rindex() # 失败产生ValueError异常
s.replace() # 建议使用re
s.split(),s.rsplit() # 分割字符串，返回列表
s.partition(),s.rpatition() # 将文本按分隔符分为三个部分
s.translate() # 按照一个映射将字符进行替换
s.encode(),s.decode() # 编码解码，py3中encode用于字符串，decode用于字节数据
s.format() # 格式化字符串
s.join(t) # 用s作为分隔符连接序列t中的字符串


映射类型常用函数：
m.clear()
m.copy()
m.fromkeys(s[,value]) # 将s序列中的项作为key创建字典
m.has_key(k)
m.items() # 返回(key,value)序列
m.keys() # 返回key组成的序列
m.values() # 返回value组成的序列


函数：
__doc__ # 文档字符串
__name__ # 函数名称
__dict__ # 包含函数属性的字典
__code__ # 字节编译的代码
__defaults__ # 默认参数的元组
__globals__  # 自定义全局命名空间的字典
__closure__  # 包含与嵌套作用域相关数据的元组


with: __enter__(self); __exit__(self,type,value,tb);




第四章


字符串
format(x[,format_spec]) # 格式化为字符串
eval(str) # 对字符串求值并返回对象,类似脚本
chr(x) # 整数转换为字符
unichar(x) # 整数转换为Unicode字符，只存在于Py2
ord(cstr) # 字符转化为整数值
hex(x);bin(x);oct(x); # 将整数转换为2、8、16进制字符串


整数
x&y # 按位与
x|y # 按位或
x^y # 按位异或
not x # 逻辑非
x and y # 逻辑与
x or y # 逻辑或
lambda args: expr # 匿名函数




第五章


for (x,y) in zip(list1,list2):
pass
则x,y每次分别从list1和list2中获取一个元素.


try:
pass
except error as e:
pass
else: # 必须在except之后，没有异常就会被执行
pass
finally: # 无论是否有异常，都会被执行
pass


定义新的异常：
class MyError(Exception):
def __init__(self,errno,msg):
self.args = (errno,msg)  # 打印异常跟踪消息使用
self.errno = errno
self.errmsg = msg
# 引发一个异常
raise MyError(1,"Not respense")


sys.exc_info() # 获取最近一次引发的异常


上下文管理器与with语句：
with obj语句在控制流程进入和离开相关代码块时，允许对象管理所发生的事情。执行with obj语句时，它执行obj.__enter__()来只是正进入新的上下文。当控制流程结束时，就会执行obj.__exit__(type,value,traceback)。如果没有异常，则__exit__三个参数都为None，否则则为异常类型、值和信息，最后返回True或False。当为False时，异常将被传递出上下文。


断言与__debug__
assert test [,msg] # 如果test==False,则抛出AssertionError异常，打印msg
__debug__ 默认为True,在最优模式为False
__debug__和assert只有在最优模式中被省略，其他情况是都会被执行。




第六章


函数拥有默认参数时需要特别注意:
def f1(a,b=[]):
b.append(a)
print b

f1(1) # [1]
f1(2) # [1,2]
f1(3) # [1,2,3]
所以，为了防止这种情况发生，最好使用None值，并且加上参数检验:
def f1(a,b=None):
if b is None:
b = []
b.append(a)
print b


函数参数中最后一个如果加上*则可以接收任意数量参数，从当前参数之后的参数被组合成一个元组作为最后一个参数。


*args 用来接收位置参数的元组
**kargs用来接收含有关键字参数的字典


在函数中使用全局变量，必须使用global进行修饰，否则会作为局部变量处理。


Python中递归有深度限制 sys.getrecursionlimit()，所以一般使用生成器。


functools的wraps函数可以辅助进行属性的复制。


exec() # 执行一组语句
eval() # 执行一个表达式
compile() # 编译




第七章


# encoding:utf8
class NewClass(object):
    num_count = 0 # 所有的实例都共享此变量，即不单独为每个实例分配
    __priValue = 0 # 会自动变形为"_类名__priValue"的成员变量
    def __init__(self,name):
        self.name = name
        self.__class__.num_count += 1
        print name,NewClass.num_count
    def __del__(self):
        self.__class__.num_count -= 1
        print "Del",self.name,self.__class__.num_count
    def test():
        print "aa"


注意 self.__class__.num_count，用来访问修改全局共享变量，更多细节参看
http://blog.csdn.net/bbdxf/article/details/25774763


类继承时，需要主动调用父类__init__()方法，为方便，一般使用super().xxxx;


类的实例返回的是所谓的“绑定方法”，它是一个对象，在对象上调用()时指向方法的调用。绑定方法类似已经部分计算的函数，其部分参数需要在()调用时提供。


@staticmethod  # 设置为静态方法，按照函数原样进行返回
@classmethod # 类方法，包装之后的返回


@property # 设置方法可以被像属性一样访问，无需加()
@xxx.setter # 赋值时被调用
@xxx.deleter # 删除时被调用


__new__()是唯一在实例创建之前执行的方法，一般用在定义元类时使用。


del xxx 不会主动调用__del__方法，只有引用计数==0时，__del__()才会被执行，并且定义了__del_()的实例无法被Python的循环垃圾收集器收集，所以尽量不要自定义__del__()。推荐方法是使用弱引用(weakref)


__slots__ = ('') # 在实例上分配属性名称将被限定为指定的名称，否则属性异常，它可以优化内存和执行速度。


抽象基类，使用ABCMeta进行辅助，暂不讨论。
元类




第八章


import ... # 引入命名空间
from ... # 导入，无命名空间


from os import (a,b,c)
from os import *


__main__ == ‘__main__’ # 当当做模块使用时，不相等。当做程序执行时，相等。


搜索路径：
加载模块时，解释器在sys.path中搜索字典列表。sys.path中第一个条目一般是空字符串，表示当前正在使用的字典。sys.path其他条目可能包含字典名称、zip文档、.egg文件等。sys.path中的顺序决定了加载的搜索顺序。


加载zip包文件时，可以指定文件在包中的具体位置，如：
sys.path.append("/tmp/md.zip")
sys.path.append("md.zip/lib/tt.py")


egg文件是由setuptools库创建的包，常用来添加第三方库，实质上也是zip文件。


zip包加载只支持.py、.pyw、.pyc和.pyo文件。


搜索模块foo时，解释器在sys.path中默认搜索顺序：
1、目录foo
2、foo.pyd, foo.so, foomodule.so, foomodule.dll
3、foo.pyo(只适用-O或-OO选项的)
4、foo.pyc
5、foo.py(Windows 系统下还会查找foo.pyw)


对于py文件，首次导入会被编译为字节码并作为pyc文件写回磁盘，后续操作中会加载这段预编译的字节码。
只有import才会在动编译py文件，在命令行或者标准输入中指定的程序不会做这样的处理。当导入的文件在zip文档中或者权限不足时，也不会生成字节码文件。


Python不支持卸载或者重新加载模块，Python2有Reload函数使用，但是它不是安全的，Python3已经完全删除此功能。唯一的办法就是重启解释器进程。


包 略
分发Python程序和库
使用distutils模块，首先应该按照要求组织一个包含README、支持文档、源代码的目录。（具体内容略）
安装方法：Python setup.py install
打包为exe的方法：使用py2exe或者py2app等第三方模块。




第九章


读取命令行选项：
程序启动时，命令行参数放在sys.argv中，第一个是程序的名称，后续的是命令选项。
sys.argv[0]; # 程序名称
sys.argv[1]; # 参数1....
复杂的，使用optparse模块


环境变量：
os.environ["PATH"] # 访问PATH
os.environ["FOO"] = "BAR" # 修改环境变量


文件读写：
open(...) # rwbt+U


145




str = string.Template(xxx,$a $b)
str.substitute({"a":"Hello",'b':"%.2f"%50}) # 使用字典的方法进行替换


 
codecs模块，字节转换
codecs,open("foo.txt","r","urf-8","ignore") # 打开文件
codecs.EncodedFile(f,"utf-8") # 为一个文件对象添加解码包,用二进制打开


unicodedata模块，访问字符特性，如大小写


pickle模块，将对象序列化为字节流，dump()/load()
shelve模块，将对象保存在类似字典的数据库中，db = shelve.open();db['key']=obj;db.close(); xx = db["key"]


第十章
解释器选项：
-3 启动将从Python3中删除或更改的功能警告
-B 阻止在导入时创建pyc或pyo文件
-E 忽略环境变量
-h 打印所有可用命令列表
-i 程序执行后进入交互模式
-n module 以脚本形式运行模块module
-O 优化模式
-OO 优化模式，在创建pyo文件时删除文档字符串
-Qarg 指定Python2中除法运算的行为，默认为Qold
-s 阻止用户将站点目录添加到sys.path
-S 阻止包含site初始化模块
-t 报告不一致的标签警告
-tt 标签不一致时导致tabError异常
-u 未缓冲的二进制stdout和stdin
-U Unicode字面量，所有字符串都是unicode的
-v 详细模式，跟踪导入语句
-V 打印版本号并退出
-x 跳过源程序的第一行
-c cmd 以字符串形式执行cmd




程序终止：
在某些情况下程序终止可能不会调用__del__()函数，所以显示地清除某些对象(已带的文件和网络接口)是不错的做法，编写一个终止函数并注册到atexit模块。
import atexit
conn = open_conn("xx")
def cleanup():
print "Going clear"
close_conn()
atexit.register(clearup)
也可以调用垃圾收集器
import atexit,gc
atexit.register(gc.collect)


第十一章


单元测试unittest
调试器和pdb模块
pdb:基于命令的调试器模块。run/runeval/runcall/set_trace/post_mortem/pm
python.exe -m pdb xxx.py # 基于命令行的调试


time.clock()/time.time() # 获取时间
timeit()/repeat() # 对内部语句进行基准测试，测试运行时间


反汇编：
dis模块可以将python函数方法和类反汇编为低级的解释器指令。