Python学习手冊笔记

之前为了编写一个svm分词的程序而简单学了下Python。认为Python非常好用。想深入并系统学习一下，了解一些机制，因此開始阅读《Python学习手冊(第三版)》。

假设仅仅是想高速入门。我在这里推荐了几篇文章，有其它语言编程经验的人简单看一看就能够非常快地開始编写Python程序了。

　　黑体表示章节。 下划线表示能够直接在原文相应位置查到的专有技术名词。

　　原书配套答案请到http://www.hzbook.com/Books/4572.html下载，简单注冊就可以。

第三章 怎样执行程序

　　import进行模块导入仅仅能执行一次。多次执行需使用reload。

　　模块往往是变量名的封装，被觉得是命名空间。比如：

                #
                myfile.py
title = "test"

>>>import myfile
>>>print myfile.title
test 

　　替代方案是from，以下有相同的效果：

>>>from myfile import title
>>>print tittle
test

            from myfile import
             * 则能够把myfile所有变量所有导入（第19章内容）。
        

第四章 介绍Python对象类型

　　尽管字符串支持多种操作。可是它具有不可变性，即原字符串不能改变，仅仅能用新字符串作为结果赋予一个变量。

以下是一个试图改变原字符串的操作及报错信息：

>>> s="spam"
>>> s[0] = ‘z‘
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: ‘str‘ object does not support item assignment

 第五章 数字

 　　str和repr显示格式

>>>num = 1/3.0
>>>num
0.33333333333333331
>>>print num
333333333333

>>>repr(num)
‘0.33333333333333331‘#交互模式回显
>>>str(num)
‘333333333333‘#打印语句

　　浮点数运算在精确方面有缺陷。

这和硬件有关，打印结果也不能全然解决。

>>> 0.1+0.1+0.1-0.3
5.551115123125783e-17
>>> print 0.1+0.1+0.1-0.3
5.55111512313e-17 

　　使用小数对象能够进行修正

>>> from decimal import Decimal
>>> Decimal(‘0.1‘) + Decimal(‘0.1‘) + Decimal(‘0.1‘) - Decimal(‘0.3‘)
Decimal(‘0.0‘) 

 第六章 动态类型简单介绍

　　a = 3这个语句实际上运行了三个步骤：创建一个对象代表值3。假设还未创建，创建一个变量a；将变量与新的对象3连接。这时，变量a成为了对象3的一个引用。也能够看做是指针。

　　类型属于对象，而不是变量，这就非常好理解为什么Python中同一个变量名能够作为不同类型的对象的引用了。

　　在这样的机制下。每一个对象都有一个引用计数器。当计数器为0时就被系统回收。这便是Python中对象的垃圾收集的方法了。

　　不同变量引用同一个数字或字符串时，对变量操作（eg.a=3 a=a+2）仅仅是创建了一个新的对象并使它引用新对象，这也是上一章提到的字符串不能修改的原因。而对于一些类型来说，有的操作确实能改变对象，例如以下所看到的：

                #
                situation 1
>>>L1=[2,3,4]
>>>L2=L1
>>>L1=24
>>>L2
[2,3,4]

#situation 2
>>L1=[2,3,4]
>>>L2=L1
>>>L2[0]=24
>>>L1
[24,3,4]

　　为了让两个变量使用不同的对象。能够拷贝对象，使用L2=L1[:]来取代L2=L1就可以。对于字典则使用D.copy()方法。标准库的copy模块提供了一个对随意对象的调用方法。以下两种方式的差别暂不讨论：

                import
                 copy
X = copy.copy(Y) #表层拷贝
X = copy.deepcopy(Y) #深拷贝

　　这里就出现了个问题。两个引用是否是同一对象？能够用以下的方式推断：

>>>L=[1,2,3]
>>>M=L
>>>L== M
True
>>>L is M
True

　　负值索引相当于从末尾倒数。-1就是最后一个元素的索引。

对于s="spam"，-5是个非法的索引值。分号:前的空值表示从第一个開始，后的空值表示直到最后一个。

 第七章 字符串

　　单双引號是一样的。这样同意用户不使用转移字符来实现带有单或双引號的字符串。个人觉得避免了按shift才干使用双引號“的麻烦。

>>>‘knight"s ‘,"knight‘s"
(‘knight"s ‘,"knight‘s")

　　此外，合并相邻的字符串常量。如‘knight"s ‘ "knight‘s"（中间有空格）会显示为‘knight"s knight\‘s‘。可见。最外层是单引號，为了保持原内容。Python把单引號里的单引號改写成了转义字符，这个样例和书上的不同，更有助于理解。转义字符和C非常类似，多了几种。可是Python里没有空字符串，Python为每一个字符串保存了内容和长度。

同一时候，假设一个字符串中没有合法的转义编码出如今"\"后，那么它将在字符串中保留反斜线。抑制转义的方法是在字符串前加r，如r"C:\new\text.dat"。此时的\n和\t就不会被当做是转义字符，同一时候。这样做也不必把\改写成\\。

三重引號适用于多行的字符串的直接输入而不使用转义字符。利用三重引號也能够实现类似C中/* */凝视掉代码的目的。

　　Unicode字符串通过在前面加u获得。

扩展分片是第三个索引。用作步进。

这时完整的分片形式为X[I:J:K]。当中步进为K。

当步进取-1时，能够把字符串反转，非常奇妙的方法。

　　利用分片，能够对字符串进行改动。即把新字符串加到原字符串上，再把原字符串切掉。

字符串格式化的使用方法与C的printf非常像。不同之处在于全部參数外须要加一个()，形成%(arg1,arg2,arg3)的形式。

格式化代码请參考原书表格，通用结构：%[(name)][flags][width][.precision]code。当中name能够是字典名。这时在參数表里提供这个字典的键就可以。

　　既然字符串是对象，那么它就有相应的方法。书上介绍了改动字符串的replace()、查找find()、把每一个元素取出创建列表的list()、把列表合并成字符串的join()（能够作为list()的反操作）、提取组件的split()。

第八章 列表

　　用中括号表示列表，列表的组成对象是有序的。组成列表的各个对象同意不同。

　　用大括号表示字典，字典的组成对象是无序的，字典键的搜索方式是哈希搜索，速度非常快。

　　能够用字典来模拟列表：使用序数作为字典的索引就可以。

类似地，字典能够用来表示一些稀疏矩阵。

　　字典的get方法用于避免不存在的键，假设键不存在。返回值是0。

字典接口是使用方式类似字典而且实际工作都和字典一样的一些Python扩展程序的接口。

第9章 元组、文件及其它 

　　用小括号表示元组，元组不能原处改动。

　　为了避免仅仅含一个元素的元组被当做表达式。使用一个逗号，写为(40,)。逗号能够帮助识别元组，以下的也是元组的表示方式：

t = 0,‘Ni‘,1.2,3

　　从文件里读取的是字符串，须要作为其它类型来操作时必须转换。

　　eval()用来把字符串作为对象。因此也能够达到运行Python的不论什么表达式。

　　pickle模块能够直接在文件里存储差点儿不论什么Python对象。

　　struct模块提供了二进制数据的打包。打包+存入文件。读取文件+解包。

　　在“赋值VS引用”这一节，对于复合方式的赋值，改动其成员会导致全部使用该成员的对象的改变。直观来看就是以下：

>>>X = [1,2,3]
>>>L = [‘a‘, X, ‘b‘]
>>>D = {‘x‘:X, ‘y‘:2}
>>>X[1] = ‘surprise‘
>>>L
[‘a‘, [1,‘surprise‘,3], ‘b‘]
>>>D
{‘x‘:[1,‘surprise‘,3], ‘y‘:2}

　　这是一个陷阱，为了避免这样的情况。依据详细类型使用拷贝（比方分片、copy方法）而不是引用。

　　Python内部临时存储并反复使用短字符串。因此对相同内容的字符串，is判定可能依据其长度为True（字符串较短时）或False（字符串较长时）。

不同类型的比較（用==进行）的判定方式不一样。

　　还有其它内置类型陷阱，如反复能添加层次深度。循环数据结构L=L.append(L)

第二部分练习题

　　2.（摘自附录B）分片运算超出边界（比如，L[-1000:100]）可工作，由于Python会缩放超出边界的分片（必要时，限制值可设为零和序列长度）。以翻转的方式提取序列是行不通的（较低边界值比較高边界值更大，比如，L[3:1]）。你会得到空分片（[ ]），由于Python会缩放分片限制值，以确定较低边界永远比較高边界小或相等（比如，L[3:1]会缩放成L[3:3]，空的插入点是在偏移值3处）。

Python分片一定是从左至右抽取。即使你用负号索引值也是这样（会先加上序列长度转换成正值）。

注意到，Python 2.3的第三限制值分片会略微改动此行为：L[3:1:-1]的确是从右至左抽取。

　　3.索引运算、分片运算以及del：对于L=[1,2,3,4], L[2] = []仅仅能把3变为[]，而L[2:3] = []却能删掉第三项。

　　4.X,Y = Y,X，左边视为两个对象，右边视为一个元组，这个表达式交换了两个引用。

第10章 Python语句简单介绍 

　　绝大多数的Python程序每行一个语句，不须要分号。Python的风格就是全然不要分号，尽管在语句末加上分号也能通过。

唯一须要分号的情况是一行中多个语句的分隔符。

相反地，括号能够使一个语句分隔成非常多行。比方用列表直观地定义一个矩阵时。反斜线\也能够达到这个目的。

　　嵌套代码仅仅须要保持缩进一致就可以。Python是WYSIWYG语言（what you see is what you get，所见即所得）

第11章 赋值、表达式和打印

　　形如X+=Y的赋值语句称为增强赋值语句，它有三个长处：程序猿输入降低，左側仅仅须要计算一次（X=X+Y中X计算两次），优化技术会自己主动选择（支持原处改动的类型能够直接原处改动）。

　　单一下划线开头的变量名不会被from module import *这种语句导入。前后都有双下划线的变量名是系统定义的变量名，对解释器有特殊意义。双下划线开头但结尾没有双下划线的变量是类的本地变量（參考第19章）。

　　表达式语句通经常使用于运行可原处改动列表的列表方法。即对于列表L，L.append(3)是正确的，而L=L.append(4)是错误的，第二个式子右边返回的是None。

　　标准输出的重定向方法：

                import
                 sys
sys.stdout = open(‘log.txt‘,‘a‘)
...
print x,y,x #写入log.txt

　为了避免忘记恢复sys.stdout，写入log.txt也能够用：

log = open(‘log.txt‘,‘a‘)
print >>log, x, y, x

第12章 if測试

 　　类似于C。Python的布尔运算or是短路运算，而它返回第一个为真的操作对象。或者是第二个为假的对象。[ ] or { } 将返回{ }。

　　if选择分支有下面几种等价形式：

                #
                最常见的分支形式
                if
                 X:
    A = Y
else:
    A = Z

#Python2.5以后引入
A = Y if X else Z

#Python2.5曾经（以后也兼容）
#须要理解and和or的运算和返回值规则
A = ((X and Y) or Z)

#列表形式
A = [Z,Y][bool(X)]

第13章  while和for循环

　　pass语句是无运算的占位符，为了表示语法须要语句而且还没有不论什么有用的语句可写时就能够使用它。

　　while和for循环都有一个可选的else语句，在循环条件不满足时且没实用break结束循环时使用。

　　C语言形式的 while((x = next()) != NULL) { ...process x...}在Python里行不通：C语言赋值语句会返回赋值后的值，而Python赋值语句仅仅是语句，不是表达式。

　　Python的迭代协议：有next方法的对象会前进到下一个结果。而在末尾时引发StopIteration。

全部的迭代工具内部工作都调用next，并捕捉StopIteration异常来确定何时离开。

　　用for改动列表时，for x in L:x+=1是无法改动的，由于它改动的是循环变量x而不是列表L。应该使用L[i]  +=1的索引来控制改动。

　　zip()能够用于for并行改动多个对象时的情况（按最短的截断）。

它也能够用来再循环中建立列表：for (k,v) in zip(keys, vals):D[k]=v。

　　enumerate()用于产生偏移和元素：for (offset,item) in enumerate(S): print offset,item

　　主要的列表解析：L=[x+10 for x in L]

　　扩展的列表解析。删除文件里的换行符：

lines = [line.rstrip() for line in open(‘script1.py‘) if line[0] ==‘p‘]

　　从文件里逐行读取文本行的最佳方法是不要刻意去读：

                for line in open(‘script1.py‘):
    print line.upper()

第十四章 文档

　　__doc__属性封装了对象上的文档，通过它能够查看（比方函数的）凝视。

　　文档字符串被觉得最是用于较大、功能性的文档，而#最好仅仅限于关于费解的表达式或语句的微型文档。

PyDoc系统可以将前者取出并显示。

第十五章 函数基础

　　def是可执行代码，直到执行了def时其定义的函数才開始存在。

　　因为函数的參数没有类型规定。因此能够非常方便地实现多态：

>>>def times(x,y):
...        return x*y
...

>>>times(2,4)
8
>>>times(‘Ni‘,4)
‘NiNiNiNi‘

第十六章 作用域与參数

　　变量名解析的LEGB原则：变量名引用分为三个作用域进行查找。本地作用域（L。每次调用函数时创建）、上一级调用的本地作用域（E）、全局作用域（G。模块作用域）、内置作用域（B，提前定义的变量名如open）。

仅对简单变量生效，对于特定对象的变量如object.spam，查找规则规则全然不同。

　　内置作用域是一个名为__builtin__的内置模块，import后才干够使用，这时能够用dir(__buildin__)查看提前定义的变量名。依据LEGB原则，在本地作用域定义一个新的open = ‘spam‘会导致open()函数不能被调用。

　　global用于全局变量声明。

　　作者觉得在模块导入时，导入其它模块的模块拥有了对其它模块变量的改动权，这使得被导入模块的维护变得复杂：维护者不知道第二个模块什么情况下会改动变量。因此最好的解决的方法是不这样做，在文件间进行通信的最好办法就是通过调用函数。传递參数。然后获得返回值（用函数提供改动变量的接口，而且告诉维护者这个变量能够被其它模块改变）。

工厂函数（又称闭合），是能记住嵌套作用域的变量值的函数。

演示样例：

>>> def maker(N):
...     def action(X):
...             return X ** N
...     return action
... 
>>> f = maker(2)
>>> f #显示f的引用
<function action at 0xb7738294>
>>> f(3)
9
>>> f(4)
16
>>> g = maker(3)
>>> g(3)
27
>>> f(3)
9

　　对于函数參数，不可变參数是通过传值来传递，可变对象（列表、字典等）是通过传引用进行传递的。

　　多个返回值的经常使用return方式是使用元组。

　　函数參数的四种匹配方式：位置匹配、keyword參数、全部对象、全部keyword/值：

>>>def f(a,b,c):print a,b,c #常规匹配
>>>f(1,2,3)
1 2 3

>>>f(c=3,b=2,a=1) #keyword匹配
1 2 3

>>>f(1,c=3,b=2) #位置+keyword匹配
1 2 3

>>>def f(a,b=2,c=3):print a,b,c #默认參数
>>>f(1)
1 2 3
>>>f(a=1)
1 2 3

>>>def f(*args):print args # 随意參数*
>>>f()
()
>>>f(1)
(1,)
>>>f(1,2,3,4)

>>>def f(**args):print args # 随意參数**，把參数组装成为字典
>>>f()
{}
>>>f(a=1,b=2)
{‘a‘=1,‘b‘=2}

相反地，调用函数在參数变量前面加*能够分解參数。

　　參数匹配顺序：调用和定义中先是非keyword參数（name）、然后是keyword參数(name=value)、*name最后是**name。

第17章 函数的高级话题

def f(x,y,z):return x+y+z和f= lambda x,y,z:x+y+z会达到相同的效果。 lambda是一个表达式，而不是语句，同意出如今def不能出现的地方。正是由于这个特点，lambda比def的使用更加灵活，比方编写跳转表（也即行为的列表或字典）：L=[(lambda x:x**2),[(lambda x:x**3),[(lambda x:x**4)]。出于代码易读性的考虑，应尽量避免嵌套的lambda。

　　apply的介绍略过。它能够用*和**型參数取代。

（似乎在Python3.0以上版本号已废弃，待确认）