第1章 快速构造：基础知识

　　1.2交互式构造器

不强制分号，一行就是一行。可以加上分号

　　1.4数字和表达式

加、减、乘、除、整除、求余、指数、取反（-例如-2**2，**的优先级比-大）

from __future__ import division   之后，除法将会是正常的除法，不会有取舍。

　　　　1.4.1长整数

　　　整数默认为4字节，大小为-21亿-21亿

　　　长整数后面加L，为8字节存储

　　　1.4.2十六进制和八进制

0X  十六进制

　　　　　 　 0  八进制

　  1.7获取用户输入

　　　　　　input(''please input),得到的是个整数或者浮点数，如果输入字符串则报错

　　1.8函数

　　　　pow(n,m),abs(n),round(n)

　　1.9模块

　　　　　1、如果要使用srqt，因为sqrt不是标准函数，而sqrt在math或者cmath模块，所以需要先导入特定的模块

　　方式1：

from math
from cmath

　　math.sqrt(10)
　　cmath.sqrt(-1)

　　　 　　　方式2：

from math impot sqrt
from cmath

    sqrt(10)
　　 cmath.sqrt(-1)

　　2、int()、long()、float()

　　　　3、math.floor()向下取整，math.ceil()向上取整

　　　　1.9.1 cmath和复数

　　　　　　python内置支持虚数，虚数一般定义为1+3j的形式

　　　　1.9.2回到__future__

　　　　　　__future__里面是未来python标准的一些特性

　　1.10保存并执行程序

　　　　print ('hello world');

　　　　input和raw_input()[原生的意思，也就是字符串]

　　　　1.10.3注释

　　　　　　#

　　1.11 字符串

　　字符串可以使用单引号也可以使用双引号，单引号括起来的里面的单引号需要转义，但是双引号不需要转义。双引号括起来的里面的双引号需要转义，但是单引号不用转义。

两个字符串紧接出现，代表字符串连接

　　　　1.11.3 字符串表示 str、repr、反引号

　　　　　　　　print ('hello world')输出的是 hello world，如果想输出'hello world',可以这样 print str/repr/反引号 ('hello world')

　　　　　　　　str和int、long一样都是一种类型。repr是函数，该函数会返回一个str。反引号等价于repr。这三种方式都是将值转为字符串。

　　　　　　　　python字符串相加操作，操作符两边必须都是字符串。所以，编程时经常需要利用上面的三个将值转为字符串的三种方式。

　　　　1.11.4 input 和raw_input的比较

　　　　　　input会认为用户会输入正确的类型，如果输入字符串需要带引号。

　　　　　　raw_input则返回的是个字符串

　　　　1.11.5 长字符串、原始字符串和unicode

　　　　　　1、长字符串　

　　　　　    　　三个单引号或者三个双引号，可以使得字符串跨越多行，同时单引号和双引号都不用转义。但是反斜杠还是需要转义

　　　　　　　　一行的最后一个字符如果是反斜线，说明下面一行和本行实际是同一行，只不过物理隔开了。所以字符串的多行可以通过该形式实现。该方式不仅可以实现字符串多行，其他的也适用。

　　　　　2、原始字符串　

　　　　　　　　　反斜线不再需要转义，但是如果有其他字符需要转义时，此时通过反斜线转义，则输出的字符串最后还是有反斜线。原始字符串只能保证对反斜杠不用转义。

　　　　　　　　　原始字符串的最后一个字符不能是反斜线

　　　　　　3、unicode字符串

　　　　　　　　　　u'hello world'

　　　　　　　　　　python 3.0中，所有字符串都是unicode字符串

第二章   元组和序列

　　2.1序列概览

　　　　python包含了6种序列，元组合列表是其中的两种。元组是不可变的，列表是可变的。其他的内建序列类型有字符串、Unicode字符串、buffer对象和xrange对象。

　　　　python容器是包含其他对象的任意对象。容器类型有字典、序列、集合。

　　2.2通用序列操作（序列是可变的，由中括号定义）（list类型，支持传入一个序列，返回一个列表）

　　　　2.2.1索引

　　　　　　下表可以是正也可以是负。-1代表最后一个元素，0指向第一个元素

　　　　2.2.2分片（得到一个新的列表）

　　　　　　[].[a,b,c]     a是起始，b是终止（不包含），c是步长（可正可负，默认为1，如果是负数代表从后向前取数据）。a,b,c都是可以省略的，如果a省略则a默认指向第一个元素，如果b省略则b默认指向最后一个元素之后。如果a指向的元素在b之后出现则返回

的是一个空的列表。

　　　　2.3.3 序列相加

　　　　　　　同类型的序列才能一起相加：如[1,2]+['a','b']可以相加，因为[1,2]和['a','b']都是列表，是同一种序列，但是['a','b']+'hello'则不行，因为这是列表类型的序列和字符串类型的序列相加。

　　　　2.2.4乘法

　　　　　　　2*[1,2]=[1,2,1,2]

　　　　　　　None代表空值

　　　　　　　初始化一个列表为10个元素，而且元素都为空。x=10*[None]　　

　　　　2.2.5成员资格

　　　　　　　　in 返回布尔值   ，如[1,2]  in [1,2,[1,2]]返回true

　　　　　　　　对于字符串序列，一个元素就是一个字符，也就是'a' in'abc'是合法的。但是现在对in进行了扩展，'abc'   in 'helloabc'也是可以的。

　　　　2.2.6 长度、最小值和最大值

　　　　　　　　　len函数、max函数和min函数。

　　　　　　　　　　max([1,2,'abc'])也是可以比较大小的。

　　　　2.3.2基本的列表操作（基本都是原地操作）

　　　　　　1、改变列表：元素赋值

　　　　　　2、删除元素

　　　　　　　　del [1.2].[2]

　　　　　　3、分片赋值（同时可以达到insert和del的效果）

　　　　　　4、list('hello')   返回一个新的列表

　　　　2.3.3 列表方法

　　　　　　1、append

　　　　　　　　x=[1]

　　　　　　　　x[2]=2   报错

　　　　　　　　x.append(2)  正确

　　　　　　2、count

　　　　　　3、extend（比序列的加法效率高，因为这个是原地操作）

　　　　　　4、index   返回第一个匹配项的位置，如果没有找到会报异常

　　　　　　5、insert（可以通过分片赋值实现）

　　　　　　6、pop 移除元素，默认是最后一个，同时返回删除的元素，可以实现栈。

　　　　　　7、remove删除匹配的第一个，不返回删除的什么。如果没有找到则报异常

　　　　　　8、reverse  原地反转

　　　　　　　　　reversed函数返回列表的反转迭代器

　　　　　　9、sort原地排序

　　  　　　　　sorted()函数可以传入列表、字符串等，返回的是一个新建的列表

　　　　　　10、高级排序

　　　　　　　　sort方法支持传入cmp函数、key、reverse。同时这三个参数也可以传入sorted函数。

　　2.4元组（不可变，由小括号定义，或者x=1,或者x=1,2,3,或者x=（1，））（tuple类型，支持传入一个序列，返回一个元组）

　　　　基本操作和列表类似，但是元组是不可变的

第三章 使用字符串

　　3.1基本字符串操作

　　　　字符串是序列的一种，所以序列的基本操作，对于字符串都是可行的。但是字符串是不可变的。

　　3.2字符串序列化：精简版

%，如果格式化字符串里面有%，则要使用%%产生一个%

　　　模板字符串

　　3.3字符串格式化：完整版

　　3.4字符串方法

　　　　3.4.1find  返回子串的最左端索引，如果没有找到则返回-1

　　　　3.4.2 join

　　　　　　join方法是split方法的逆方法，用来连接序列中的元素并返回字符串。所连接的序列元素必须都是字符串，否则报错

　　　　3.4.3 lower　

　　　　3.4.4 replace 查找所有并被替换

　　　　3.4.5 split

　　　　3.4.6 strip 去除字符串两端的一些特定元素，比java里面的trim强大

　　　　     strip方法的参数可以指定去除哪些

　　　　3.4.7 translate

　　　　　　　替换单个字符。

第4章 字典：当索引不好用时

　　字典是python里面的唯一映射类型

　　4.1字典的使用

　　4.2创建和使用字典

　　　　x={'a':1,'b':c}

　　　　字典中的键是唯一的

　　　　4.2.1 dict函数--创建字典

　　　　　　1、items=[('1','2'),(1,2)]

　　　　　　　　dict(items)

　　　　　　2、通过关键字参数创建

　　　　　　　　dict(name='1',age=1)

　　　　4.2.2 基本字典操作

　　　　　　len(d)返回d中键值对的数量

　　　　　　d[k]

　　　　　　d[k]=v

　　　　　　del d[k]

　　　　　　k in d 键值k是否在d里

　　　　　　键可以是任意的不可变对象：字符串、基本数据类型、元组

　　　　4.2.3 字典的格式化字符串

　　　　4.2.4字典的方法

　　　　　　1、clear  原地操作，无返回值

　　　　　　2、copy   浅复制

　　　　　　3、fromkeys   新建一个字典，该字典包含原字典的所有键，但是值都是None

　　　　　　4、get  如果使用x['aa']访问时如果没有找到则报错，但是get如果没有找到则返回None。get函数的重载版本可以传入一个参数指定如果没有找到返回什么。

　　　　　　5、has_key

　　　　　　6、items返回字典的一个列表，但是顺序是不能保证的。iteritems返回的是个列表的迭代器

　　　　　　7、keys和iterkeys

　　　　　　　　分别返回key的列表和迭代器

　　　　　　8、删除给定的key，并返回值

　　　　　　9、popitem随机删除一个，返回元组

　　　　　　10、setdefault    返回给定key的值，如果给定的key不存在则设置相应的值（默认为None）

　　　　　　11、update 用一个字典更新另一个字典   a.update(b)  a里面如果不存在b里面的key，则添加，如果存在则使用b的value覆盖

　　　　　　12、values和itervalues

　　　　　　　　分别返回值的列表和迭代器

第5章 条件、循环和其他语句

　　5.1 print和 import更多信息

　　　　5.1.1使用逗号输出

　　　　　　如：print '1',2,3,'aa'   输出以空格隔开。

print 'a',

　　　　　　print 'b'    这两行输出会在一起并以空格隔开

　　　　5.1.2 把某一事件作为另一事件导入

　　　　from/import module as alias

　　　　　 from module import  function as alias

　　　　　 from module import funcationa,functionb...

　　　　　 from module import *

　　5.2赋值魔法

　　　　　5.2.1序列解包

　　　　　　　　左边的变量个数需要和右边的序列的大小一致

　　　　　5.2.2 链式赋值

　　　　   5.2.3  增量赋值

　　5.3语句块：缩排的乐趣

　　　　:代表一个语句块开始

　　5.4条件和条件语句

　　　　5.4.1 这就是布尔变量的作用

　　　False None 0 "" () [] {}都认为是false

　　　　　　true==1  正确

　　　　　　false==0 正确

　　　　　　true和false还能当成1和0进行算术计算

　　　　　　bool函数可以判断表达式是true还是false，返回的是true和false

　　　　5.4.2 条件执行和if语句

　　　　　　 if  elif else

　　　　5.4.6更复杂的条件

　　　　　　is  、is not、in、not in 、not（相当于!）

　　　　　  is  相当于比较指针

　　　　　　==相当于equals

　　　　　　5、字符串和序列比较

　　　　　　　　序列比较：[1,[2,3]]<[2,[3,4]]

　　　　　　6、布尔运算符

　　　　　　　　1<number<10  相当于and

　　　　　　　　and、or

　　　　　　　　条件表达式：a if b else c

　　　　5.4.7断言

　　　　　　相当于java里面junit里面的assert，如果assert检查不是true则会报错。可以指定assert报错的信息。

　　5.5 循环

　　　　while、for

　　　　range(a,b)：一次返回一个[a,b)之间的列表

　　　　xrange(a,b)：不是一次全部返回，一次只创建一个数

　　　　5.5.3循环遍历字典元素

　　　     遍历字典   for  key in d :

　　　                    for  key,value in d.items()

　　　　5.5.4一些迭代工具

　　　　　　1、并行迭代

　　　　　　　　zip能把两个序列压缩成每个元素是个元组的列表，而且当其中一个序列的元素用完时就结束了

　　　　　　　  x=[(1,2),(3,4)]

　　　　　　　　for y,z in x

　　　　　　2、按索引迭代

　　　　　　　　enumerate，返回一个每个元素是个二元元组的列表

　　　　　　3、反转和排序迭代

　　　　　　　　sorted()非原地排序，返回liebioa　　

　　　　　　　　reversed()得到一个列表迭代器。

　　　　5.5.5 跳出循环

　　　　　　break，continue

　　　　5.5.6 循环中的else子句

　　　　　　for:

　　　　　　else:

　　　　　　其中的else只在for里面没有调用break时执行

　　　　5.6列表推导式

　　　　　　[x*x for x in range(10)]

　　　　　　[x*x for x in range(10) if x%3==0]

　　　　　　[(x,y) for x in range(3) for y in range(3)]

　　5.7 三人行

　　　　5.7.1什么都没发生

　　　　　　pass

　　　　5.7.2使用del删除

　　　　　　python是自动垃圾收集的

　　　　　　del x   只会删除变量，不会删除变量对应的值（x指向的内存或者对象），x指向的内存或者对象是由垃圾收集器进行的。

　　　　5.7.3 使用exec和eval执行和求值字符串

　　　　　　exec " print 'hello world'"

　　　　　  eval('2+2')

　　　　　　exec和eval都可以使用命名空间。

　　　　　　scope={}//其实相当于字典

　　　　　　scope['x']=2

　　　　　　scope['y']=3

　　　　　　eval('x*y',scope)

　　　　　　exec 'print x+y'　

　　　　　　scope实际上相当于字典，一般的字典操作scope也可以。

第6章 抽象

　　6.2抽象和结构

　　6.3创建函数

　　　　callable函数可以判断一个东西是否可以调用

　　　　python3.0之后callable函数就废弃了，只能使用hasattr(func,_call_)代替

　　　　6.3.1文档化函数

　　　　　　def function:

　　　　　　　　''

　　　　　　　　return 　　

　　　　　通过squre._doc_可以获得文档，其中_doc_是属性

　　　　　help(function)也能获得文档字符串

　　　　6.3.2并非真正函数的函数

　　　　　　return可以只用于程序返回。

　　　　　　一个函数可以没有返回值，但是x=function()也是可以执行的，只是x的值为none。　　　　

　　6.4参数魔法

　　　　6.4.3关键字参数和默认值

　　　　　　调用方法时可以使用关键字参数

　　　　　　定义方法时可以定义默认值

　　　　6.4.4搜集参数

　　　　　　*params实际上在函数内部是个元组（不能使用关键字参数，搜集的是剩余的参数）

　　　　　　**params是个字典（调用时传入的必须是关键字参数,定义时不能使用关键字参数）

　　例子:  def func(name='aa',*param,**tt): pass

　　　　6.4.5 搜集参数的逆过程

　　　　　　函数调用时可以使用此特性

　　　　　　　　x=[1,2]

　　　　　　　　func(*x)

　　　　　　或者

　　　　　　　　x={'name':2,'address':4}

　　　　　　　　func(**x)

　　6.5作用域

　　　　vars()返回该代码所在的作用域，返回的是一个不可修改的字典，即使修改产生的结果也是未知的。

　　　　默认有全局作用域，每次函数调用进入一个函数就产生一个新的作用域

　　　　当在一个新的作用域内进行了一次赋值，则认为在该作用域内产生了一个新的变量。所以就产生了在函数内怎么访问外部变量（或者全局变量）的问题。

　　　　globals()返回全局作用域的map

　　　　locals()返回本地作用域的map

　　　　在作用域内指定变量为全局的变量：global   x

　　　　嵌套作用域：相当于java的内部函数

第7章 更加抽象

　　　　多态、封装、继承

　　　　isinstance(object,tuple)函数可以进行类型检查

　　　　module为random的choice方法：x=choice([1,2,'abc']);

　　　　多态的多种形式

　　　　　　　+

　　　　　　  repr函数、len函数等

　　7.2类和类型

　　　　7.2.1 类到底是什么

　　　　7.2.2 创建自己的类

　　　　　　怎么定义类

　　　　　　类的方法第一个参数都是self

　　　　　　除了person.setName('aa')之外还可以这样调用：Person.setName(person,'aa')

　　　　7.2.3 特性、函数和方法

　　　　　　1、函数和方法的差异区别只是方法绑定了一个对象

　　　　　　2、再论私有化

　　　　　　　　python的所有东西都是可以做到public访问的

　　　　　　　　方法或者特性前面加上两个下划线可以达到java里private的效果，但是可以绕过这个限制（实际上python内部实际上生成了一个_className_methodName的方法）

　　　　　　　　带有下划线的名字不能被import *导入

　　　　7.2.4 类的命名空间的导入

　　　　　　　　所有class语句中的代码块都在特殊的命名空间中执行-类命名空间。这个命名空间可以由类内的所有成员访问。类的定义其实就是执行戴拿块

　　　　　　　　对比java的理解：类全局变量，类static代码执行块（现在认为python是顺序执行，待确认）。

　　　　　　　　　　　　　　　　类作用域、对象作用域

　　　　7.2.5 指定超类

　　　   7.2.6检查继承

　　　　　　issubclass

　　　　　　_bases_

　　　　　　isinstance

　　　　　　_class_

　　　　7.2.7多个超类

　　　　　　　python支持多继承，但是不建议

　　　　　　　先继承的类的方法会覆盖后继承类的方法

　　　　7.2.8接口和内省

　　　　　　hasattr()

　　　　　　getattr()

　　　　　　setattr()

　　　　　　如果要查看对象内所有存储的值，那么可以使用_dict_特性

第8章 异常

　　8.1什么是异常

　　8.2 按自己的方式出错

　　　　8.2.1 raise语句

raise #捕获到异常之后再次抛出异常

raise Exception

　　　　　　内建的异常都在exceptions模块里

　　　　8.2.2自定义异常类

　　　　　　继承Exception

　　　　8.3捕捉异常

　事例1：　　　

try:

     ...

except exceptiona:

    ...

except exception b:

    ...

else:

    ...

finally:

    ...

事例2：

try:

    ...

except (exceptiona,exceptionb),e

    ...

else:

    ...

finally

    ...

事例3：全捕捉

try:

    ...

except:  #也能捕获ctrl+c和sys。exit

    ...    

或者

try:

    ...

except Exception:    #建议采取这种形式

    ...

第9章 魔法方法、属性和迭代器

　　9.1 准备工作

　　　　为了保证类是新型的类（能使用super和属性），应该把赋值语句__metaclass__=type放在你的模块的最开始或者类的开始，或者子类化内建类object。python3.0没有旧式的类，也不需要显式的子类化object或者将元类设置为type。所有的类都会隐式的成

　　　　为object的子

　　　　类。

　　9.2构造方法

　　　　__init__(self)

　　　　__del__(self)会在垃圾回收之前调用

　　　　9.2.1重写一般方法和特殊的构造方法

　　　　　　对于构造方法可以不调用父类的构造方法，但是这可能会引起问题，也不规范。所以一般构造方法的重写需要先调用父类的构造方法。共两种方法能达到这个目的：分别是9.2.2和9.2.3

　　　　9.2.2调用未绑定的超类构造方法

class hello:

  def __init__():

        print 'hello'

class world(hello):

    def __init__():

      hello.__init__(this)

      print 'world'

　　　　9.2.3使用super函数

　　　　使用super方法能调用超类的方法，不仅仅是构造函数

　　9.3成员访问

　　　　python中的多态性是基于对象行为的。在其他的语言中队形可能被要求属于某一个类，或者被要求实现某个接口，但python中只是简单的要求它遵循几个规则。

　　　　9.3.1基本的序列和映射规则

　　　　　　。。。

　　　　　　如果键是一个不合适的类型，会引起一个TypeError异常

　　　　　　如果序列的死因是正确的类型，但是超出了范围，应该引发一个IndexError异常

　　　　　　isinstance，这个函数应当尽量避免使用，因为类或者类型的检查和python中多态的目标背道而驰。因为python的语言规范上明确指出索引类必须是整数（包括长整数），所以上面的代码才会如此使用。遵守标准是使用类型检查的（很少的）正当理由之

　　　　　　一。

　　　　9.3.2子类化列表、字典和字符串

　　　　　　使用继承得到自己的列表、字典和字符串

　　　　　　list、dict、str

　　　　　　UserList、UserDict、UserString

　　9.4更多的魔力

　　9.5属性

　　　　9.5.1 property函数

　　　　　　property函数可以使用0、1、3和4个参数来调用。如果没有参数，产生的属性既不可读也不可写。如果只使用一个参数调用（一个取值方法），产生的属性是只读的，第三个参数（可选）是一个用于删除属性的方法（这个方法不需要参数）。第4个参数

　　　　　　（可选）是一个文档字符串。property的4个参数分别被叫做fget、fset、fdel和doc

　　　　9.5.2静态方法和类成员方法

　　　　　　方法1：静态方法和类成员方法分别在创建的时候被装入staticmethod类型和classmethod类型的对象中。

　　　　　　方法2：@staticmethod和@classmethod

　　　　9.5.3__getattr__、__setattr__和它的朋友们

　　　　　　　通过这些魔法方法能设置读写属性时进行的额外操作

　　　　　　　类的__dict__属性返回的是该类的属性的字典

　　9.6迭代器

　　　　9.6.1迭代器规则

　　　　　__iter__返回一个迭代器对象，所谓的迭代器对象就是实现了next方法（python3.0里面应该是__next__）的对象。如果next被调用时，但迭代器没有值可以返回，则引发一个StopIteration异常。　　　

　　　　　iter()函数可以从可迭代对象中获得迭代器

　　　　　list、tuple类型函数也能从迭代器对象获得对应的列表和元组

　　9.7生成器

第十章 自带电池

　　10.1模块

　　　　10.1.1模块是程序

　　　　　　pyc为扩展名的文件是（平台无关的）经过处理（编译的），已经穿换成python能够更有效的处理的文件。

　　　　　　模块导入多次和导入一次是一样的

　　　　　　reload()函数能使得模块被重复的导入，python3.0里面已经去掉了reload函数。exec一样能实现这样的功能。

　　　　10.1.2 模块用于定义

　　　　　　1、模块和类一样有自己的作用域

　　　　　　2、在模块里面增加测试代码

　　　　　　　　模块里面的__name__属性

　　　　　　　　如果再主程序中，变量__name__的值是__main__,而在导入的模块中，这个值就被设定为模块的名字。

　　　　10.1.3让你的模块可用

　　　　　　1、将模块放置在正确的位置

　　　　　　　　1、sys.path    　　site-packages目录是最佳的选择，因为它本来就是用来做这些事情的

　　　　　　　   2、告诉编译器到哪去找

　　　　　　　　　　PYTHONPATH这个操作系统的环境变量

　　　　　　　　3、命名模块

　　　　　　　　　　模块的名字和文件的名字相同

　　　　10.1.4包

　　　　　　包就是文件夹的名字

　　　　　　包的模块就是对应文件夹下__init_.py

　　10.2探究模块

　　　　10.2.1模块中有什么

　　　　　　1、使用dir

　　　　　　　　可以将模块、对象的所有函数、类、变量等列出。

　　　　　　2、__all__变量

　　　　　　　　定义了模块的公共接口

　　　　10.2.2 用help获取帮助

　　　　　　help()函数

　　　　10.2.3文档

　　　　　　__doc__属性

　　　　10.2.4使用源代码

　　　　　　__file__属性（显示源码的位置）

　　　　　　一些模块并不包含任何可以阅读的python源代码。它们可能已经融入到解释器内了（比如sys模块），或者可能是使用C等语言写成的。

　　10.3标准库：一些最爱

第14章 网络编程

　　14.1少数几个网络设计模块

　　　　　14.1.1 socket模块

　　　　　14.1.2 urllib和urllib2模块

　　　　　　　　通过它们在网络*问文件，就好像访问本地电脑上的文件一样。

　　　　　　　　urllib2比urllib强大

　　　　　　　　urlopen()访问类文件对象

　　　　　　　　urletrive()下载存储

　　　　　　14.2.3其他模块

　　14.2 socketserver和它的朋友们

　　　　socketserver包含了4个基本的类：TCPServer、UFPServer、UnixStreamServer、UnixDatagramServer

　　14.3 多个连接

　　　　有2种主要的方法能实现并行处理：分叉（fork）、线程和异步IO

　　　　14.3.1使用socketserver进行分叉和线程处理

　　　　　　代码真简单。。。

　　　　14.3.2带有select和poll的异步IO

　　14.4 Twisted

　　　　事件驱动的Python网络框架

　　　　支持SSH2、SMTP、POP3、IMAP4、AIM、ICQ、IRC、MSN、Jabber、NNTP和DNS等

第15章  python和web

　　15.1屏幕抓取（正则表达式、HTMLParser、Beautiful soup）

　　　　正则表达式

　　　　　　　缺点：1、正则表达式并不是完全可读的

　　　　　　　　　　2、程序对于CDATA部分和字符实体比如（&amp;）子类的html特性是无法处理的。

　　　　　　　　　　3、正则表达式被html源代码约束，而不是取决于更抽象的结构

　　　　15.5.1Tidy和XHTML解析

　　　　　　1、Tidy是什么？

　　　　　　　　Tidy是用来修复不规范且有些随意的Html文档的工具。它能以相当智能的方法修复一般的错误，做那些你不愿意做的事情。

　　　　　　　　当然Tidy并不能修复HTML文件的所有问题，但是它会确保文件的格式是正确的也就是所有元素都是正确嵌套。

　　　　　　4、为什么使用XHTML

　　　　　　　　XHTML相对于HTML来说，XHTML的标签必须严格满足XML格式（比如显示的关闭元素）。

　　　　　　5、使用HTMLParser

　　　　　　　　　　基于事件的，下面是HTMLParser的事件

HTMLParser.reset()

Reset the instance. Loses all unprocessed data. This is called implicitly at instantiation time.

重置该实例。失去所有未处理的数据。这个在实例化对象时被隐含地调用。

HTMLParser.feed(data)

Feed some text to the parser. It is processed insofar as it consists of complete elements; incomplete data is buffered until more data is fed or close() is called.

提供一些文本给解析器。在由完整元素组成的限度内进行处理，不完整的数据被缓冲直到更多的数据提供或者close()被调用。

HTMLParser.close()

Force processing of all buffered data as if it were followed by an end-of-file mark. This method may be redefined by a derived class to define additional processing at the end of the input, but the redefined version should always call theHTMLParser base class method close().

强制将所有的缓冲数据按跟在结束标记的数据一样进行处理。该方法可以通过派生类定义对输入结尾的额外处理来进行重定义，但是重定义的版本应该总是调用HTMLParser基类方法close()

HTMLParser.getpos()

Return current line number and offset.

返回当前行数和位移值。

HTMLParser.get_starttag_text()

Return the text of the most recently opened start tag. This should not normally be needed for structured processing, but may be useful in dealing with HTML “as deployed” or for re-generating input with minimal changes (whitespace between attributes can be preserved, etc.).

返回文本最近的开放标签。

HTMLParser.handle_starttag(tag, attrs)

This method is called to handle the start of a tag. It is intended to be overridden by a derived class; the base class implementation does nothing.

The tag argument is the name of the tag converted to lower case. The attrs argument is a list of (name, value) pairs containing the attributes found inside the tag’s <> brackets. The name will be translated to lower case, and quotes in the value have been removed, and character and entity references have been replaced. For instance, for the tag <A HREF="http://www.cwi.nl/">, this method would be called as handle_starttag('a', [('href', 'http://www.cwi.nl/')]).

该方法用来处理开始标签。其目的是被派生类重写；基类什么也不实现。tag参数是转换成小写的标签名称。attrs参数是一个(name，value)对包含了在标签<>中得属性。name将会转换成小写，并且value中得引号会被引出，并且字符串和实体引用将会被替代。

例如，对于标签<A HREF="http://www.cwi.nl/">，该方法将会调用为handle_starttag('a', [('href', 'http://www.cwi.nl/')])

Changed in version 2.6: All entity references from htmlentitydefs are now replaced in the attribute values.

2.6的版本变动：所有来自htmlentitydefs的实体引用现在在属性值中被替代了。

HTMLParser.handle_startendtag(tag, attrs)

Similar to handle_starttag(), but called when the parser encounters an XHTML-style empty tag (<a .../>). This method may be overridden by subclasses which require this particular lexical information; the default implementation simple calls handle_starttag() and handle_endtag().

类似于handle_starttag()，不过用来处理遇到XHTML风格的空标签(<a .../>)。

HTMLParser.handle_endtag(tag)

This method is called to handle the end tag of an element. It is intended to be overridden by a derived class; the base class implementation does nothing. The tag argument is the name of the tag converted to lower case.

该方法用来处理元素的结束标签。

HTMLParser.handle_data(data)

This method is called to process arbitrary data. It is intended to be overridden by a derived class; the base class implementation does nothing.

该方法用来处理任意的数据。

HTMLParser.handle_charref(name)

This method is called to process a character reference of the form &#ref;. It is intended to be overridden by a derived class; the base class implementation does nothing.

该方法用来处理&#ref;形式的字符引用。

HTMLParser.handle_entityref(name)

This method is called to process a general entity reference of the form &name; where name is an general entity reference. It is intended to be overridden by a derived class; the base class implementation does nothing.

该方法用来处理形式&name;的一般实体引用，参数name是一般的实体引用。

HTMLParser.handle_comment(data)

This method is called when a comment is encountered. The comment argument is a string containing the text between the --and -- delimiters, but not the delimiters themselves. For example, the comment <!--text--> will cause this method to be called with the argument 'text'. It is intended to be overridden by a derived class; the base class implementation does nothing.

该方法用来处理遇到的评论。

HTMLParser.handle_decl(decl)

Method called when an SGML doctype declaration is read by the parser. The decl parameter will be the entire contents of the declaration inside the <!...> markup. It is intended to be overridden by a derived class; the base class implementation does nothing.

当解析器读到一个SGML的doctype声明该方法被调用。

HTMLParser.unknown_decl(data)

Method called when an unrecognized SGML declaration is read by the parser. The data parameter will be the entire contents of the declaration inside the <!...> markup. It is sometimes useful to be overridden by a derived class; the base class implementation throws an HTMLParseError.

 当解析器读到一个未被识别SGML声明时将调用该方法。

HTMLParser.handle_pi(data)

Method called when a processing instruction is encountered. The data parameter will contain the entire processing instruction. For example, for the processing instruction <?proc color='red'>, this method would be called as handle_pi("proccolor='red'"). It is intended to be overridden by a derived class; the base class implementation does nothing.

当遇到一个处理指令时将调用该方法

The HTMLParser class uses the SGML syntactic rules for processing instructions. An XHTML processing instruction using the trailing '?' will cause the '?' to be included in data.

15.1.2 Beautiful Soup

　　　　经常用来解析和检查在网上看到的那类乱七八糟而且不规范的HTML　　

第16章  测试

　　16.1先测试、后编码

　　　　测试一点，写一点代码

　　　　16.1.1 精确的需求说明

　　　　　　测试驱动编程的理念是从编写测试程序开始，然后编写可以通过测试的程序。测试程序就是程序的需求说明，它帮助程序员在开发程序时候不偏离需求。

　　　　16.1.2 为改变而改变

　　　　16.1.3 测试的4个步骤

　　　　　　（1）指出新的特性。为其编写测试代码

　　　　　　（2）编写特性的骨干代码

　　　　　　（3）为特性的编写哑代码，能满足测试需求就行。

　　　　　　（4）重构和完成代码

　　16.2 测试工具

　　　　unitest

　　　　doctest

　　16.3 单元测试以外的内容

　　　　16.3.1 使用PyChecker和PyLint检查源代码

　　　　　　代码静态检查工具

第17章　　扩展python

　　　　c、c++、java等语言比python快几个数量级

　　　　当性能受到影响时，需要用c、c++、java等作为扩展重写出现瓶颈的代码。

第19章 好玩的编程

　　19.3原型设计

　　　　python的强大之处就在于编写一个模型只需要很少的投入，而不用大动干戈。

　　19.4配置

　　　　19.4.1提取常量

　　　　19.4.2配置文件

　　19.5日志记录