《Dive into Python》学习笔记

Download: Python-2.3.2.tgz or Python-2.3.2.tar.bz2,
tar -zxvf Python-2.3.2.tgz or bzcat Python-2.3.2.tar.bz2 | tar -xf -
./configure
make
make install
1. def(params)                                                      
- there is only def, if with return then return a value, or return None
– do not need to declare the data type of params
2. doc_string
- ”’ doc_string”’ — to explain the functionality of the def or class
- must be declared after class() or def()
- the doc_string can be an object as well
3. everything is an object in python
- everything has its own property and method
4、缩排代码
there are no begin and end, just using : for def():, if:, for loop:, etc
5、if __name__
在 if 表达式周围不需要小括号
象C语言一样，Python使用 == 进行比较，使用 = 进行赋值。
模块是对象，并且所有的模块都有一个内置属性 __name__。如果 import 模块，那么 __name__ 的值通常为模块的文件名，不带路径或者文件扩展名。如果直接运行模块， __name__ 的值将是一个特别的缺省值， __main__。
for testing: if __name__ == “__main__”:
6 Dictionary: like Java’s Map ，VBScipt’s Scripting. eg：>>> d = {”server”:”mpilgrim”, “database”:”master”}
1)using {} to set the value to d
2)server is a key to link mpilgrim，and writing like this d["server"] for calling
3)this eg only can get the value, but not the key e.g. >>> d["database"] = “pubs”
4)its to change the value of the key database e.g. >>> d["database"] = “pubs”
5)there is no dupilcated key in a dictionary, if there is one, its for change the value of the key e.g. >>> d["database"] = “pubs”
6)can add a key any time, e.g. >>> d["new_key"] = “new_value”
7)there is no sequence in dictionary
8)the values could be any data type: string, ini, object, even other dictionary
9)字典的关键字要严格一些，但是它们可以是字符串，整数和几种其它的类型 >>> del d['server']
10)delete all >>> d.clear()
7、list
1)using [] for list e.g. >>> li = ["a", "b", "mpilgrim", "z", "example"]
3)一个列表可以象一个以0开始的数组一样使用。任何一个非空列表的第一个元素总是 xxx[0]。
4)negative index is started from the end of list e.g.>>>li[n] == li[n – len(li)], e.g.>>> li[-3] the result is “mpilgrim”.
5)to get the last index: li[-1]。
6)you can make a slice by using to index, start from the first index, but no include the second index
7)list is still working with two negative index, but is the second is bigger than the first, then return an None value
8)if index is 0 then ignore it, li[:3] and li[0:3] is the same
9)li[:n] return the first n elements，and li[n:] will return the rest
10)li[:] means a new slice which is excectely same as the original li list, but it is just an copy
11)append add an element to the end of list： >>> li.append(”new”)
12)insert 在列表中插入单个元素。数值参数是使得列表增加的第一个元素的索引(注意，不是序号).>>> li.insert(2, “new”)
13)elements in list are not unique
14)用extend 连接列表。注意不要用多个参数调用 extend ，要使用一个列表参数调用。>>> li.extend(["two", "elements"])
15)index returns the index number of the required first element in the list, >>> li.index(”example”)
16)if python did not find the value seposed to be found, it will return an error(or something?)
17)test if an element by using in if there is then returns 1, otherwise returns 0, there is no bool in python, also (”")，([]),({})are 0, others are 1, e.g.>>> “new” in li
18)remove: for delete the required first element in the list>>> li.remove(”new”)
19)用pop除掉列表的最后一个元素，然后返回除掉的值。注意这一点同 li[-1]不同，后者返回一个值但不改变列表，也不同于 li.remove(value)，后者改变列表但不返回值。如：>>> li.pop()
21)列表也可以用 + 操作符连接起来。list = list + otherlist 相当于 list.extend(otherlist)。但是 + 操作符将连接后的列表作为一个值返回，而 extend 仅修改存在的列表。如：>>> li = li + ['example', 'new']
22)Python支持 += 操作符。li += ['two'] 相当于 li = li + ['two']。+= 操作符可用于列表，字符串，和整数，并且它也可以在用户定义类中被重载。
23)* 操作符作为一个重复符可用在列表上。li = [1, 2] * 3 相当于 li = [1, 2] + [1, 2] + [1, 2]， 将三个列表连成一个。
8、序列
1)序列是不可变列表。一旦创建了一个序列就不能以任何方式改变它。
2)序列的定义同列表的定义方式相同，除了整个元素集是用小括号包围的而不是方括号
3)当分割一个列表时，会得到一个新的列表；当分割一个序列时，会得到一个新的序列。
4)序列没有方法,所以不能查找、删除和增加元素，但可以用in来检查元素是否在序列里。
5)序列比列表操作速度快。
6)序列可以在字典中被用作关键字，但是列表不行。
7)内置的 tuple 函数接收一个列表，返回一个有着相同元素的序列。而 list 函数接收一个序列，返回一个列表。从效果上看，tuple 冻结一个列表，而 list解冻一个序列。
8)序列用在字符串格式化.
9、变量
1)Python象大多数其它语言一样有局部和全局变量，但是它没有明显的变量声明。变量通过赋值产生，当超出作用范围时自动消灭。
2)当一条命令用续行符(“\”)分割成多行时，后续的行可以以任何方式缩排，Python通常的严格的缩排规则不需遵守。
3)严格地讲，在小括号，方括号或大括号中的表达式(如定义字典)可以用或者不用续行符(“\”)分割成多行。
4)Python不允许你引用一个未被赋值的变量，试图这样做会引发一个异常。
10、字符串格式化
1)基本语法如：”带占位符的字符串” % (参数序列)
2)试图将一个字符串同一个非字符串连接会引发一个异常。字符串连接只能在每个都是字符串时起作用。此时选择格式化串会是个不错的主意。
11、映射
1)基本语法如：[ 函数或表达式 for 循环变量 in 列表/序列 ]
2)映射是通过循环遍历一个列表/序列，并对每个元素应用一个函数，然后返回一个包含为计算后的值的新列表。
3)注意列表映射不改变被映射的列表。
4)新列表拥有与原有列表/序列拥有相同数量的元素数。
12、列表与字符串
1)用一个字符串对象的join 方法将列表元素连接成单个字符串，此字符串充当分隔符。
2)join 只用用于字符串列表；它不进行任何的类型强制转换。连接一个存在一个或多个非字符串元素的列表将引发一个异常。
3)用一个字符串对象的split 方法将列表元素连接成单个字符串，此字符串充当分隔符。
4)split 接受一个可选的第二个参数，它是要分割的次数。
5)split 无参数调用时，默认为以空白为分隔符(空格/换行/制表符),多个连续空白初见为一个。
13、导入模块
1)Python用两种方法导入模块，一是import module,一种是from module import,
2)第一种方法导入整个模块，对其属性或方法的引用要加限制名，如：
/>>> import types
/>>> types.FunctionType
3)第二种方法将模块的方法和属性直接导入名字空间中，可以直接引用这些方法和属性，如：
/>>> from types import FunctionType
/>>> FunctionType
4)两种方法各有利弊，前者可明确指定要导入的方法和属性，并直接引用，比较方便；对于属性或方法重名的情况，则后者非常有用。
14、函数的参数
1)函数的参数可以拥有缺省值，某个参数有什么缺省值在定义函数时指明，
2)拥有缺省值的参数为可选参数，否则为必备参数，即调用函数时必须为必备参数提供参数，如果没有对可选参数提供参数值，则其使用缺省值。
3)调用函数时，可以通过指定参数名而以任意次序来传递参数，称为定名参数。如：
定义：
def help(object, spacing=10, collapse=1):
合法调用：
help(odbchelper)
help(odbchelper, 12)
help(odbchelper, collapse=0)
help(spacing=15, object=odbchelper)
4)参数是个“字典¡±，缺省可以不指定名字而用顺序将参数名与值匹配起来。
15、内置函数
1)所有Python内置函数被组合进一个名叫 __builtins__ (前后有两个下划线)的特别模块中。
2)内置函数dir 返回任意一个对象的属性和方法的列表。
3)内置函数str 强制将任一种类型的数据转化为字符串，对python的空值None，则str(None)返回字符串”None”.
4)内置函数type 返回任意对象的数据类型。
5)使用函数 getattr 得到对象的各种引用，这个过程中方法没有被调用。
6)使用getattr得到引用后，其返回值为方法，可以调用相应的函数。如：>>>getattr(li, “append”)(”Moe”)
16、列表映射过滤语法
[mapping-expression for element in source-list if filter-expression]
4.1:apihelper.py:
methodList = [method for method in dir(object) if callable(getattr(object, method))]
17、and-or技巧,对bool and a or b来说，
1)逻辑运行采用了快捷方式，即如果or前值为真，是不再计算后面的值，并返回前面的结果
2)用 (bool and [a] or )[0]的方法，可以实现与c中bool?a:b的功能
18、lambda函数?
1)可以使用lambda定义单行的最小函数，格式如：funcVar = lambda x : x…
没有名字，返回是默认的。上式中可以没有funcVar，有funcVar时可与正常函数一样调用，没有funcVar时可如下调用：
(lambda x:x…)(a)
2)lambda函数可以接受一到多个参数(包括可选参数),返回单个表达式的值，函数中不能包含命令，表达式不能超过一个。
19、一些小技巧
1)python几乎总是在操作列表
2)字符串的ljust(spacing)可以在右边加空格以达到spacing值所示的长度，当spacing的值小于字符串的长度时，不会截断。
20、Class: (normal method, special method, advanced special method)
以FileInfo类的定义为例
from UserDict import UserDict
class FileInfo(UserDict): — 1)
“store file metadata” — 2)
def __init__(self, filename=None): — 3)
UserDict.__init__(self) — 4)
self["name"] = filename
1)ancestor class name is in the ()
2)class may have doc_string
3)__init__函数在对象被创建后被自动调用的第一个函数，可以指定任何个数的参数。
4)__init__应为类中第一个定义的方法，其第一个参数指向类的当前实例的第一个引用，且应命之为self。__init__中要显式地调用父类的__init__方法。
5)__init__ method never returns a value.
6)__init__的定义是可选的，一旦定义必须显式调用父类的__init__方法。
7)normal method:
def clear(self): self.data.clear()
def copy(self): –returns a new dictionary that is an exact duplicate of the original (all the same key−value pairs)
if self.__class__ is UserDict:
return UserDict(self.data)
import copy
return copy.copy(self)
def keys(self): return self.data.keys()
def items(self): return self.data.items()
def values(self): return self.data.values()
8)special method:
def __getitem__(self, key): return self.data[key] –get value
def __setitem__(self, key, item): self.data[key] = item –set value
/>f = fileinfo.FileInfo(”/music/_singles/kairo.mp3″)
/>f[“name”]
/>f[“anothername”]=…
9)advanced special method:
__repr__:返回一个对象的字符串表示。Python用内置函数repr来显示变量的值，如果repr的参数是某个对象时，那用它的类的__repr__返回对象的字符
串表示。
__cmp__专用函数，在比较类实例时被调用。即当作==比较时，被调用。
__len__专用函数，当调用内置函数len(instance)时被调用，对字符串返回字符的个数，对字典返回关键字的个数，对序列或列表返回元素个数。对自由定义的类，可自由定义返回的len的值的含义
__delitem__专用函数， 在调用 del instance[key]被调用。
__setitem__,__getitem__,__cmp__,__len__,等方法加入到类的定义中后，可以使任何类看起来象“字典¡±。还有其它的一些专用方法，可以使类看起来象数值一样可以对它进行运行。
21、class attributes (instance and clear):
1)象调用函数一样调用类，就可以实例化一个类，传入的参数是__init__定义的参数(参数是以从右向左的顺序传递给__init__的，python会自动添加self)，返回一个实例对象。
2)python采用引用计数的技术进行垃圾回收，因而维护着对第一个创建的实例的引用的列表，当计数为0时，实例自动被破坏。
3)不用显式的释放一个实例，因为当变量超出作用域时自动失效，而至其所对应的实例的引用数减一。
4)在Python中，你不能子类化象字符串、列表和字典的内置数据类型。作为补偿，Python附带了封装类，可以模拟这些内置的数据类型的行为： UserString，UserList，和 UserDict。
5)子类中定义的方法覆盖父类的方法，python不支持函数重载。由此，子类的__init__与父类的__init__的参数序列可以有较大的不同。
6)python支持数据属性，即C++中所谓的“数据成员¡±，对其值的引用需要以”实例名.属性名”的方式。注意，数据属性是类实例拥有的属性，还有一种属性是叫属性，是类所拥有的
7)类属性是一个类的属性，在创建任何类实例之前就有效了。类属性既可以通过直接对类的引用，也可以通过对类的任意实例的引用来使用。
8)类属性可以作为类级别的常量来使用，但是它们不是真正的常量，可以修改它们。
9)__class__ 是每个类实例的一个内置属性(也是每个类的),它是一个类的引用，而 self 是一个类的实例
22、private:
/>>> import fileinfo
/>>> m = fileinfo.MP3FileInfo()
/>>> m.__parse(”/music/_singles/kairo.mp3″)
Traceback (innermost last):
File “”, line 1, in ?
AttributeError: ‘MP3FileInfo’ instance has no attribute ‘__parse’
1)there are private founction, method, attributes in python, they can not be called from outside class
3)Python没有类方法保护的概念(只能用于它们自已的类和子父中)。类方法要不私有(只能在它们自已的类中使用)要不公有(任何地方都可使用)。
23、Error:
try:
import termios, TERMIOS
except ImportError:
try:
import msvcrt
except ImportError:
try:
from EasyDialogs import AskPassword
except ImportError:
getpass = default_getpass
else:
getpass = AskPassword
else:
getpass = win_getpass
else:
getpass = unix_getpass
1)try…except ,after try is been tested，if no error in try, then the else is excuted.
2)一个try … finally，finally always be excuted
24、File object:
1)Python有一个内置函数open，用来打开在磁盘上的文件。open 返回一个文件对象，它拥有一些方法和属性，可以得到打开文件的信息，和对打开文件进行操作。
2)open 方法可以接收三个参数：文件名，模式，和缓冲区参数。只有第一个参数，文件名，是必须的；其它两个是可选的。如果没有指定，文件以文本方式打开。
3)文件对象的mode属性，标明文件属性以何种方式被打开
4)文件对象的 name 属性标明文件对象所打开的文件名。
5)文件对象的 tell 方法指明在打开文件中的当前位置
6)文件对象的 seek 方法在打开文件中移动到另一个位置。第二个参数指出第一个参数是什么意思：0 表示移动到一个绝对位置(从文件开始算起)，1 表示移到一个相对位置(从当前位置算起)，还有 2 表示对于文件尾的一个相对位置。
7)read 方法从打开文件中读取指定个数的字节，并且返回含有读取数据的字符串。可选参数指定了读取的最大字节数。如果没有指定参数，read 将读到文件末尾。
8)文件对象的 closed 属性表示对象是否打开或关闭了文件
9)调用文件对象的 close 方法来关闭一个文件，以释放掉你加在文件上的锁(如果有的话)，刷新被缓冲的系统确实还未写入的输出(如果有的话)，并且翻放系统资源。closed 属性证实了文件被关闭了。
10)当文件被关闭后，文件对象所对应的变量仍然存在，直到超出作用域，或被删除，此时所有的对文件的操作（close除外）都会抛出异常，close只是静静地失败。
25、python: for loop
26、set value
1)using list to set many values for one varible
/>>> v = (’a', ‘b’, ‘e’)
/>>> (x, y, z) = v
/>>> (x, y, z) = range(3) –return a list from value 0
2)如果一个函数返回一个序列或列表，则可将它组赋值给一组变量，就象函数一次返回一组值一样。如：
/>>> (filepath, filename) = os.path.split(”/music/ap/mahadeva.mp3″)
/>>> (shortname, extension) = os.path.splitext(filename)
27: xml
1. import:
/>>>from xml.dom import minidom –import an package xml with its dom (also:from xml import dom)
/>>>minidom / xml, dom
2. xml file:
/>>>xmldoc = minidom.parse(’/home/bwar/python/diveintopythonzh-cn-5.4b/py/kgp/binary.xml’) –import an xml file
/>>>print xmldoc.toxml() –print all
3. childNodes:
/>>>xmldoc.childNode — to display all the nodes
/>>>xmldoc.childNode[-1][0][1][2] / xmldoc.firstChild –display nodes one by one
/>>>grammarNode = xmldoc.firstChild
/>>>print grammarNode.toxml()
3. keyword:
/>>>reflist = xmldoc.getElementsByTagName(’preface’)
4. print:
/>>>print reflist.toxml() ##also:print reflist[1].toxml()##
5. print inside:
5.1:
/>>>plist = reflist.getElementsByTagName(’preface’)
5.2:
/>>>plist = xmldoc.getElementsByTagName(’preface’)
6. visite the elements:
/>>>bitref = reflist[0]
/>>>print bitref.toxml()
/>>>bitref.attributes
/>>>bitref.attributes.keys()
/>>>bitref.attributes.values()
/>>>bitref.attributes["id"]
/>>>a = bitref.attributes["id"]
/>>>a
/>>>a.name
/>>>a.value
To get os path
/>>>import os
/>>> for k, v in os.environ.items():
… print “%s=%s” % (k, v)
or
/>>>import os
/>>> print “\n”.join(["%s=%s" % (k, v)
... for k, v in os.environ.items()])
28. HTTP web:
1) old method:
/>>>import urllib
/>>>data = urllib.urlopen(’http://diveintomark.org/xml/atom.xml’).read()
/>>>print data
2) new method with urllib2:
/>>>import urllib2
/>>>httplib.HTTPConnection.debuglevel = 1
/>>>import urllib2
/>>>request = urllib2.Request(’http://diveintomark.org/xml/atom.xml’)
/>>>opener = urllib2.build_opener()
/>>>feeddata = opener.open(request).read()
/>>>request.get_full_url()
/>>>request.add_header(’User-Agent’, ‘OpenAnything/1.0 +http://diveintopython.org/’) ####add more info
/>>>firstdatastream = opener.open(request)
/>>>firstdatastream.headers.dict
/>>>request.headers