Dive Into Python 学习记录1-函数/模块导入/字典/列表/元组/字符串分割、连接、格式化/映射list/

######     Dive Into Python 学习记录 主要记录该书中的重点内容，部分以前学过的内容就只作简单的回顾记忆，没有实际去操作

1.1 概览

#filename:
#coding=utf-8
def buildConnectionString(params):
    """Build a connection string from a dictionary
    
    Returns string.
    """
    return "   ".join(["%s=%s" % (k, v) for k, v in params.items()]) #return 后两个分号间的空格，表现在输出时各字典内容间的空格，可换成分号，则输出变分号；

                                                                                                                # 输出调用字典的for循环方法，但输出无序；Dictionary 没有元素顺序的概念。说元素 “顺序乱了” 是不正确                                                                                                                       #的，它们只是序偶的简单排列。这是一个重要的特性，它会在您想要以一种特定的，可重现的顺序 如以key

                                                                                                               #的字母表顺序) 存取 dictionary 元素的时候骚扰您。有一些实现这些要求的方法，它们只是没有加到 dictionary

if __name__ == "__main__":
    myParams = {"server":"mpilgrim", \                      #一条被分成了多行的命令，用反斜线 (“\”) 作为续行符。当一条命令用续行符 (“\”) 分割成多行时，后续的行

                                                                                         #可以以任何方式缩进，此时Python 通常的严格的缩进规则无需遵守
                "database":"master", \
                "uid":"sa", \
                "pwd":"secret"
                }
    print buildConnectionString(myParams)

输出：

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

1.2 定义 buildConnectionString 函数的 doc string
def buildConnectionString(params):
    """Build a connection string from a dictionary of parameters.

    Returns string."""

三重引号表示一个多行字符串。在开始与结束引号间的所有东西都被视为单个字符串的一部分，包括硬回车和其它的引号字符。您可以在任何地方使用它们，但是您可能会发现，它们经常被用于定义 doc string。

在三重引号中的任何东西都是这个函数的 doc string，它们用来说明函数可以做什么。如果存在 doc string，它必须是一个函数要定义的第一个内容 (也就是说，在冒号后面的第一个内容)。在技术上不要求给出函数的 doc string，但是您应该这样做。

>>> print buildConnectionString.__doc__ 
Build a connection string from a dictionary

Returns string.  #输出三重引号的内容

当使用在被导入模块中定义的函数时，必须包含模块的名字。所以不能只使用 buildConnectionString，而应该使用 odbchelper.buildConnectionString。

当导入一个模块时，Python 在几个地方进行搜索。明确地，它会对定义在 sys.path 中的目录逐个进行搜索。它只是一个list (列表)，您可以容易地查看它或通过标准的list方法来修改它。

1.3 模块导入搜索路径

import sys

print sys.path                      #'C:\\mywork\\workspace\\game_guess\\src', 'C:\\mywork\\workspace\\game_guess\\src', 'C:\\Python27', 'C:\\Python27\\DLLs', 'C:\\Python27\\lib', 'C:\\Python27\\lib\\lib-tk', 'C:\\Python27\\lib\\plat-win', 'C:\\Python27\\lib\\site-packages', 'C:\\Python27\\lib\\site-packages\\wx-2.8-msw-unicode', 'C:\\Windows\\system32\\python27.zip', 'C:\\mywork\\eclipse\\plugins\\org.python.pydev_1.4.8.2881\\PySrc']

sys.path.append('mynewpath')           #可增加搜索路径

1.4 关于 if __name__ == "__main__":

模块是对象，并且所有的模块都有一个内置属性 __name__。一个模块的 __name__ 的值取决于您如何应用模块。如果 import 模块，那么 __name__ 的值通常为模块的文件名，不带路径或者文件扩展名。但是您也可以像一个标准的程序一样直接运行模块，在这种情况下__name__ 的值将是一个特别的缺省值，__main__。

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

只要了解到这一点，您就可以在模块内部为您的模块设计一个测试套件，在其中加入这个 if 语句。当您直接运行模块，__name__ 的值是__main__，所以测试套件执行。当您导入模块，__name__ 的值就是别的东西了，所以测试套件被忽略。这样使得在将新的模块集成到一个大程序之前开发和调试容易多了。

1.5 dictionary 常识

>>> d
{'server': 'mpilgrim', 'database': 'master'}
>>> d["database"] = "pubs" 
>>> d
{'server': 'mpilgrim', 'database': 'pubs'}
>>> d["uid"] = "sa"        
>>> d
{'server': 'mpilgrim', 'uid': 'sa', 'database': 'pubs'}

	在一个 dictionary 中不能有重复的 key。给一个存在的 key 赋值会覆盖原有的值。
	在任何时候都可以加入新的 key-value 对。这种语法同修改存在的值是一样的。(是的，它可能某天会给您带来麻烦。假设你一次次地修改一个 dictionary，但其间您使用的 key 并未按照您的想法进行改变。您可能以为加入了新值，但实际上只是一次又一次地修改了同一个值。)

Dictionary 的 key对大小写敏感的

为一个已经存在的 dictionary key 赋值，将简单覆盖原有的值。

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

Dictionary 的 key 要严格多了，但是它们可以是字符串、整数或几种其它的类型

>>> d
{'server': 'mpilgrim', 'uid': 'sa', 'database': 'master',
42: 'douglas', 'retrycount': 3}
>>> del d[42] 
>>> d
{'server': 'mpilgrim', 'uid': 'sa', 'database': 'master', 'retrycount': 3}
>>> d.clear() 
>>> d
{}

	del 允许您使用 key 从一个 dictionary 中删除独立的元素。
	clear 从一个 dictionary 中清除所有元素。注意空的大括号集合表示一个没有元素的 dictionary。

1.6 list 简述

>>> li = ["a", "b", "mpilgrim", "z", "example"] 
>>> li
['a', 'b', 'mpilgrim', 'z', 'example']
>>> li[0]                                       
'a'
>>> li[4]                                       
'example'

	首先我们定义了一个有 5 个元素的 list。注意它们保持着初始的顺序。这不是偶然。List 是一个用方括号包括起来的有序元素的集合。
	List 可以作为以 0 下标开始的数组。任何一个非空 list 的第一个元素总是li[0]。
	这个包含 5 个元素 list 的最后一个元素是 li[4]，因为列表总是从 0 开始。

负数索引从 list 的尾部开始向前计数来存取元素。 任何一个非空的 list 最后一个元素总是 li[-1]。

List 从 0 开始，所以 li[0:3] 返回 list 的前 3 个元素，从 li[0] 开始，直到但不包括 li[3]  所以list可以进行切片操作

append 向 list 的末尾追加单个元素。

insert 将单个元素插入到 list 中。数值参数是插入点的索引。请注意，list 中的元素不必唯一

extend 用来连接 list。请注意不要使用多个参数来调用 extend，要使用一个 list 参数进行调用

>>> li = ['a', 'b', 'c']
>>> li.extend(['d', 'e', 'f']) 
>>> li
['a', 'b', 'c', 'd', 'e', 'f']
>>> len(li)                    
6
>>> li[-1]
'f'
>>> li = ['a', 'b', 'c']
>>> li.append(['d', 'e', 'f']) 
>>> li
['a', 'b', 'c', ['d', 'e', 'f']]
>>> len(li)                    
4
>>> li[-1]
['d', 'e', 'f']

	Lists 的两个方法 extend 和 append 看起来类似，但实际上完全不同。extend 接受一个参数，这个参数总是一个 list，并且把这个 list 中的每个元素添加到原 list 中。
	在这里 list 中有 3 个元素 ('a'、'b' 和'c')，并且使用另一个有 3 个元素 ('d'、'e' 和'f') 的 list 扩展之，因此新的 list 中有 6 个元素。
	另一方面，append 接受一个参数，这个参数可以是任何数据类型，并且简单地追加到 list 的尾部。在这里使用一个含有 3 个元素的 list 参数调用append 方法。
	原来包含 3 个元素的 list 现在包含 4 个元素。为什么是 4 个元素呢？因为刚刚追加的最后一个元素本身是个 list。List 可以包含任何类型的数据，也包括其他的 list。这或许是您所要的结果，或许不是。如果您的意图是extend，请不要使用 append。

index 在 list 中查找一个值的首次出现并返回索引值。

>>> li
['a', 'b', 'new', 'mpilgrim', 'z', 'example', 'new', 'two', 'elements']
>>> li.index("example") 
5

若一个list中含有重复的元素，而index 只返回第一个索引

list 删除元素

 remove 从 list 中删除一个值的首次出现。remove仅仅 删除一个值的首次出现，后面的第二个值保留；

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

>>> list = [23, 'qw', 45, 'li', 'dc', 45]
]
>>> list
[23, 'qw', 45, 'li', 'dc', 45]
>>> list.remove(45)
>>> list
[23, 'qw', 'li', 'dc', 45]
>>> list.pop()
45
>>> list
[23, 'qw', 'li', 'dc']

Lists 也可以用 + 运算符连接起来。list =list + otherlist 相当于list.extend(otherlist)。

Python 支持 += 运算符。li += ['two'] 等同于li.extend(['two'])。+= 运算符可用于 list、字符串和整数

* 运算符可以作为一个重复器作用于 list。li = [1, 2] * 3 等同于li = [1, 2] + [1, 2] + [1, 2]

1.7 tuple 简述

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

>>> t = ("a", "b", "mpilgrim", "z", "example") 
>>> t
('a', 'b', 'mpilgrim', 'z', 'example')
>>> t[0]                                       
'a'
>>> t[-1]                                      
'example'
>>> t[1:3]                                     
('b', 'mpilgrim')

	定义 tuple 与定义 list 的方式相同，但整个元素集是用小括号包围的，而不是方括号。
	Tuple 的元素与 list 一样按定义的次序进行排序。Tuples 的索引与 list 一样从 0 开始，所以一个非空 tuple 的第一个元素总是t[0]。
	负数索引与 list 一样从 tuple 的尾部开始计数。
	与 list 一样分片 (slice) 也可以使用。注意当分割一个 list 时，会得到一个新的 list ；当分割一个 tuple 时，会得到一个新的 tuple。

那么使用 tuple 有什么好处呢？

• Tuple 比 list 操作速度快。如果您定义了一个值的常量集，并且唯一要用它做的是不断地遍历它，请使用 tuple 代替 list。
• 如果对不需要修改的数据进行 “写保护”，可以使代码更安全。使用 tuple 而不是 list 如同拥有一个隐含的assert 语句，说明这一数据是常量。如果必须要改变这些值，则需要执行 tuple 到 list 的转换 (需要使用一个特殊的函数)。

1.8 格式化与连接字符串

In [9]: a = 'python'

In [10]: b = 'learn'

In [11]: '%s %s' % (a,b)
Out[11]: 'python learn'                            #格式化输出

In [15]: print a + ' is easy to ' + b          #连接， + 是字符串连接操作符。
python is easy to learn

In [16]: print '%s is easy to %s' % (a, b)
python is easy to learn

In [17]: c = 10

In [18]: print 'Users ID is : %d' % (c,)
Users ID is : 10

In [19]: print 'Users ID is : %d' % (c)
Users ID is : 10

In [20]: print 'Users ID is : %d' % c
Users ID is : 10

In [21]: print 'Users ID is : ' + c                          #类型不同不能连接
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)

/home/lijy/<ipython console> in <module>()

TypeError: cannot concatenate 'str' and 'int' objects

In [22]: c = 18.6754                                              #数值格式化，当然还可以用.format（） 库

In [23]: print 'Users ID is : %f ' % c                    #%f 格式符选项对应一个十进制浮点数，不指定精度时打印 6 位小数。
Users ID is : 18.675400

In [24]: print 'Users ID is : %.2f ' % c                  #使用包含“.2”精度修正符的 %f 格式符选项将只打印 2 位小数。
Users ID is : 18.68

In [25]: print 'Users ID is : %+.2f ' % c             #可以混合使用各种修正符。添加 + 修正符用于在数值之前显示一个正号或负号。
Users ID is : +18.68

1.9 映射 list

In [26]: a = [1, 3, 5, 7, 9]

In [27]: [elem *2 for elem in a]            #list 解析，Python 循环遍历 a 中的每个元素。对每个元素均执行如下操作：首先临时将其值赋给变量 elem，然后 Python

                                                                #应用函数 elem*2 进行计算，最后将计算结果追加到要返回的 list 中
Out[27]: [2, 6, 10, 14, 18]

In [28]: a
Out[28]: [1, 3, 5, 7, 9]                        #对 list 的解析并不改变原始的 list。

In [29]: a = [elem *2 for elem in a]

In [30]: a                                             #将一个 list 的解析结果赋值给对其映射的变量是安全的。不用担心存在竞争情况或任何古怪事情的发生
Out[30]: [2, 6, 10, 14, 18]

In [31]: params = {"server":"mpilgrim", "database":"master", "uid":"sa", "pwd":"secret"}

In [32]: params.keys()                                   #Dictionary 的 keys 方法返回一个包含所有键的 list。这个 list 没按 dictionary 定义的顺序输出

                                                                                   #(记住，元素在 dictionary 中是无序的)，但它是一个 list
Out[32]: ['pwd', 'database', 'uid', 'server']

In [33]: params.values()                               #values 方法返回一个包含所有值的 list。它同 keys 方法返回的 list 输出顺序相同，

                                                                         #所以对于所有的 n，params.values()[n] == params[params.keys()[n]]
Out[33]: ['secret', 'master', 'sa', 'mpilgrim']

In [34]: params.items()                           # items 方法返回一个由形如 (key，value) 组成的 tuple 的 list
Out[34]:
[('pwd', 'secret'),
 ('database', 'master'),
 ('uid', 'sa'),
 ('server', 'mpilgrim')]

In [35]: [k for k, v in params.items()]
Out[35]: ['pwd', 'database', 'uid', 'server']
                                                                             #使用两个变量对 list params.items() 进行遍历。这是多变量赋值的另一种用法。params.items() 的

                                                                            #第一个元素是 ('server', 'mpilgrim')，所以在 list 解析的第一次遍历中，k 将为 'server'，v 将为 'mpilgrim'。
In [36]: [v for k, v in params.items()]
Out[36]: ['secret', 'master', 'sa', 'mpilgrim']

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

	split 与 join 正好相反，它将一个字符串分割成多元素 list。注意，分隔符 (“;”) 被完全去掉了，它没有在返回的 list 中的任意元素中出现。
	split 接受一个可选的第二个参数，它是要分割的次数。(“哦，可选参数……”，您将会在下一章中学会如何在您自己的函数中使用它。)

anystring.split(delimiter, 1) 是一个有用的技术，在您想要搜索一个子串，然后分别处理字符前半部分 (即 list 中第一个元素) 和后半部分 (即 list 中第二个元素) 时，使用这个技术。