《Dive into Python》Chapter 2 and Chapter 3 笔记

Example 2.1. odbchelper.py

def buildConnectionString(params):
    """Build a connection string from a dictionary

    Returns string."""
    return ";".join(["%s=%s" % (k, v) for k, v in params.items()])

if __name__ == "__main__":
    myParams = {"server":"mpilgrim", \
	    "database":"master", \
	    "uid":"sa", \
	    "pwd":"secret"
	    }
    print buildConnectionString(myParams)

odbchelper.py的输出结果：

pwd=secret;database=master;uid=sa;server=mpilgrim

1、函数声明

Python里的函数不需要指定返回值的数据类型，甚至不需要指定是否有返回值。实际上，每个Python函数都会返回一个值：如果函数执行过return语句，它将返回指定的值，否则将返回None（Python的空值）。

2、文档化函数

可以通过给出一个doc string(文档字符串)来文档化一个Python函数。

def buildConnectionString(params):
    """Build a connection string from a dictionary

    Returns string."""

三重引号表示一个多行字符串。在开始与结束引号之间的所有东西都被视为单个字符串的一部分，包括硬回车和其它的引号字符。在三重引号中的任何东西都是这个函数的doc string，它们用来说明函数可以做什么。如果存在doc string，它必须是一个函数要定义的第一个内容（也就是说，在冒号后面的第一个内容）。

3、万物皆对象

在Python中一切都是对象，并且几乎一切都有属性（看上去是什么样）和方法（会做什么）。万物皆对象可以感性地解释为：一切都可以赋值给变量或者作为参数传递给函数。

4、测试模块

所有的Python模块都是对象，并且都有一个内置属性__name__。一个模块的__name__的值取决于你如何应用模块：

如果import模块，那么__name__的值通常为模块的文件名，不带路径和文件扩展名。

>>>import odbchelper
>>>odbchelper.__name__
'odbchelper'

而如果直接运行模块，__name__的值将是一个特别的缺省值(即默认值)，__main__。

可以利用这一特性在模块内部设计一个测试套件：

if __name__=="__main__":

当直接运行模块时，__name__的值是__main__,所以测试套件执行。而导入模块时，__name__的值就是别的东西了，所以测试套件被忽略。这样使得在将新的模块集成到一个大程序之前开发和调试容易多了。

5、字典（Dictionary）

>>>d = {"server":"mpilgrim","database":"master"}       (1)
>>>d
 {'server':'mpilgrim','database':'master'}
>>>d["server"]                                         (2)
'mpilgrim'
>>>d["database"]
'master'
>>>d{"mpilgrim"}                                       (3)
Traceback (innermost last):
  File"<interractive input>",line 1, in ?
KeyError: mpilgrim
>>>d["datebase"] = "pubs"                              (4)
>>>d
{'server':'mpilgrim','database':'pubs'}
>>>d["uid"] = "sa"                                     (5)
>>>d
{'server':'mpilgrim','uid':'sa','database':'pubs'}

（1）创建一个新的字典，它有两个元素，将其赋给变量d。每一个元素都是一个key—value对；整个元素集合用大括号括起来。

（2）’server’是一个key，它所关联的value是通过d[“server”]来引用的，为‘mpilgrim’。

（3）可以通过key来引用其值，但不能通过值获取key。

（4）在一个dictionary中不能有重复的key。给一个存在的key赋值会覆盖原有的值。

（5）1、在任何时候都可以加入新的key—value对。2、dictionary是无序的。

dictionary的key是大小写敏感的（即区分大小写）。

dictionary不止是用于存储字符串。它的值可以是任意数据类型，包括字符串、整数、对象，甚至其他的dictionary。在单个dictionary里，它的值不需要全都是同一数据类型，可以根据需要混用和匹配。dictionary的key则要严格的多。

del dictionary[key] 使用key从一个dictionary中删除独立的元素。

dictionary.clear（）清除dictionary中的所有元素。

6、列表（List）

list中的元素是有序的，并且不必唯一。

append（追加）接受一个参数（这个参数可以是任何数据类型），并且简单地追加到list尾部。而extend（扩展）接受一个参数，这个参数总是一个list，并且把这个list中的每个元素添加到原list中。

insert将单个元素插入到list中。数值参数是插入点的索引。

index在list中查找一个值的首次出现并返回索引值。如果在list中没有找到值，python会引发一个异常。

要测试一个值是否在list中，使用in。如果值存在，它返回True，否则返回False。True和False的首字母必须大写。

remove从list中删除一个值的首次出现。如果没有找到该值，python同样会返回一个异常。

pop会删除list的最后一个元素，然后返回删除元素的值。

list可以用 + 运算符连接起来。list = list + otherlist相当于list。extend（otherlist）。

li += [‘two’]等同于li.extend([‘two’]).

* 运算符可以作为重复器作用于list。li = li * 3即把三个list连接成一个。

7、元组（Tuple）

Tuple是不可改变的list。一旦创建了一个tuple，就不能以任何方式改变它。

定义tuple与定义list的方式相同，但整个元素集是用小括号包围的，而不是方括号。

tuple的元素与list一样按定义的次序进行排序。

tuple没有方法，但可以使用in来查看一个元素是否存在于tuple中。

使用tuple的好处：

• tuple比list操作速度快，如果定义了一个值的常量集，并且唯一要用它做的是不断遍历它，应该使用tuple代替list。
• 如果对不需要修改的数据进行“写保护”，可以使代码更安全。
• tuple可以在dictionary中被用做key，但list不行。Dictionary key必须是不可变的。
• tuple可以用在字符串格式化中。

8、变量声明

当一条命令用续行符（“\”）分割成多行时，后续的行可以以任意方式缩进。

一次赋多值

>>> v = ('a','b','e')
>>> (x,y,z) = V
>>> x
'a'
>>>y
'b
>>>z
'e'

v是一个三元素的tuple，并且（x,y,z）是一个三变量的tuple。将一个tuple赋值给另一个tuple，会按顺序将v的每个值赋给每个变量。

连续值赋值

>>>range(7)
[0,1,2,3,4,5,6]
>>>(MONDAY,TUESDAY,WEDNESDAY,THURSDAY,FRIDAY,SATURDAY,SUNDAY) = range(7)
>>>MONDAY
0
>>>TUESDAY
1
>>>SUNDAY
6

内置的range函数返回一个元素为整数的list。

9、格式化字符串

字符串的格式化

>>> uid = "sa"
>>> pwd = "se cret"
>>> print pwd + " isnot agood passwor d for " + uid       (1)
secret is not agoodpasswo rd for sa
>>> print "%s is nota good passw ord for %s" % (pw d,uid) (2)
secretis not agood passwo rd for sa
>>> userCou nt = 6
>>> print "Users con nected: %d" %(use rCoun t, )         (3) (4)
Users connected:6
>>> print "Users con nected: " + userCoun t               (5)
Traceback (innermost last) :
File "<i nteract ive input>", line 1, in ?
TypeError: cannot concatenate 'str'and 'int' objects

（1）通过连接操作符“+”连接

（2）通过字符串格式化实现连接

（3）（userCount，）是一个只包含一个元素的tuple。当定义一个list，tuple，dictionary时，可以总是在最后一个元素后面跟上一个逗号，但是当定义一个只包含一个元素的tuple时逗号是必须的。如果省略逗号，python不会知道（userCount）究竟是一个只包含一个元素的tuple还是变量userCount的值。

（4）字符串格式化通过将%s替换成%d即可处理整数。

（5）试图将一个字符串同一个非字符串连接会引发一个异常。字符串连接只能在被连接的每一个都是字符串时起作用。

数值的格式化

>>> print "Today's stock price: %f" %50.4625   (1)
50.462500
>>> print "Today's stock price: %.2f" %50.4625 (2)
50.46
>>> print "Change since yesterday: %+.2f" %1.5 (3)
+1.50

（1）%f格式符选项对应一个十进制浮点数，不指定精度时打印6位小数。

（2）使用包含“.2”精度修正符的%f格式符选项将只打印2位小数。

（3）添加+修正符用于在数值之前显示一个正号或负号。

10、映射list

通过对list中的每个元素应用一个函数，从而将一个list映射为另一个list

>>> li = [1, 9,8, 4]
>>> [elem*2 for elem in li]        (1)
[2, 18, 16, 8]
>>> li                             (2)
[1, 9, 8, 4]
>>> li = [ elem*2 for elem in li]  (3)
>>> li
[2, 18, 16, 8]

（1）li是一个将要映射的list。Python循环遍历li中的每个元素。对每个元素均执行如下操作：首先临时将其值赋给变量elem，然后Python应用函数elem*2进行计算，最后将结果追加到要返回的list中。

（2）对list的解析并不改变原始的list。

（3）将一个list的解析结果赋值给对其映射的变量是安全的。

keys、values和items函数

>>> params = {"server":"mpilgrim", "database":"master", "uid":"sa",  "pwd":"secret"}
>>> params .keys()   (1)
['server', 'uid', 'database' , 'pwd']
>>> params .values() (2)
['mpilgrim', 'sa', 'master', 'secret']
>>> params .items()  (3)
[('server', 'mpilgrim'), ('uid', 'sa'), ('database' , 'master'), ('pwd' , 'secret')]

（1）dictionary的keys方法返回一个包含所有键的list。这个list没按dictionary定义的顺序输出（因为dictionary中的元素是无序的）。

（2）values方法返回一个包含所有值的list。它同keys返回的list输出顺序相同。

（3）items函数返回一个形如（key，value）组成的tuple的list，这个list包括dictionary中所有的数据。

11、连接list与分割字符串

连接list

return ";".join(["%s=%s" % (k, v) f or k, v i nparams. items()])

字符串”;”本身就是一个对象，而调用join方法是将list中的元素连接成单个字符串，每个元素用一个分号隔开。分隔符不必是一个分号，它甚至不必是单个字符，它可以是任何字符串。

join只能用于元素是字符串的list，它不进行任何的强制类型转换。连接一个存在一个或多个非字符串元素的list将引发一个异常。

分割字符串

>>> li = ['se rver=mpilgrim', 'uid=sa', 'database=master', 'pwd=secret']
>>> s = ";".join(li)
>>> s
'server=mpilgrim;uid=sa;database=master;pwd=secret'
>>> s.split(";")     (1)
['server=mpilgrim', 'uid=sa', 'datab ase=master', 'pwd=secret']
>>> s.split(";", 1)  (2)
['server=mpilgrim', 'uid=sa;datab ase=master;pwd=secret']

（1）与join相反，split将一个字符串分割成多元素list。其中，分隔符被完全去掉了。

（2）split接受一个可选的第二参数，它是要分割的次数。