程序流程图设计：
先给出开始和结束框图，在中间按照顺序设计加入大致的程序流程框图，然后再进行完善和补充（增删和修改）。

It may seem like a lot of work to sketch out a flow chart about the program first. After all, people want to play games, not look at flowcharts! But it is much easier to make changes and notice problems by thinking about how the program works before writing the code for it.

If you jump in to write the code first, you may discover problems that require you to change the code you’ve already written. Every time you change your code, you are taking a chance you create new bugs by changing too little or too much. It is much better to know what you want to build before you build it.

Import sys
Sys.path
Sys.path是一个目录名称的列表，它构成当前的搜索路径。Sys内置模块无法取得源代码，它们是用C语言写的。
可以通过sys.path.insert(0, new_path)插入一个新的目录到sys.path列表的第一项。

这个很重要,因此刚开始我会重复几次以防你忘记了:在 Python 里面所有东西都是对象。字符串是对象,列表是对象,函数是对象,类是对象,类的实例是对象,甚至模块也是对象。

Python使用try...except块处理异常，使用raise语句来抛出异常。

Os模块提供了两个函数处理当前目录

import os
print(os.getcwd())
使用os.chdir()函数改变当前工作目录
Os.path.join()函数从一个或者多个路径片段中构造一个路径名
Os.path.expanduser()用来将包含～符号的路径扩展为完整的路径。
Os.path.split()可以用于分割完整路径名，目录名和文件名
(shortname, extension) = os.path.splitext(filename) 可以对文件名和拓展名进行分割

glob 模块是 Python 标准库中的另一个工具,它可以通过编程的方法获得一个目录的内容,并且它使用熟悉的命令行下的通配符。 glob 模块使用 shell 风格的通配符。

获取文件元信息
每一个现代文件系统都对文件存储了元信息: 创建时间,最后修改时间,文件大小等等。Python 单独提供了一个的 API 用于访问这些元信息。 你不需要打开文件。知道文件名就足够了。

当前工作目录是 examples 文件夹。
feed.xml 是 examples 文件夹中的一个文件。 调用 os.stat() 函数返回一个包含多种文件元信息的对象。
st_mtime 是最后修改时间,它的格式不是很有用。(技术上讲,它是从纪元,也就是 1970 年 1 月 1 号的第一秒钟,到现在的秒数)
time 模块是 Python 标准库的一部分。 它包含用于在不同时间格式中转换,将时间格式化成字符串以及处理时区的函数。
time.localtime() 函数将从纪元到现在的秒数这个格式表示的时间(os.stat()函数返回值的 st_mtime 属性)转换成更有用的包含年、月、日、小时、分钟、秒的结构体。这个文件的最后修改时间是 2009 年 7 月 13 日下午 5:25。

操作实例（使用之前的humansize.py进行查看）：

os.getcwd()
'/home/wsx/python_learn/Dive_into_python'
metadata = os.stat('humansize.py')
metadata.st_mtime
1484925139.3738046
import time
time.localtime(metadata.st_mtime)
time.struct_time(tm_year=2017, tm_mon=1, tm_mday=20, tm_hour=23, tm_min=12, tm_sec=19, tm_wday=4, tm_yday=20, tm_isdst=0)
metadata.st_size
702
import humansize
humansize.approximate_size(metadata.st_size)
'0.7 KiB'

构造绝对路径
在前一节中,glob.glob() 函数返回一个相对路径的列表。第一个例子的路径类似'examples\feed.xml',而第二个例子的路径'romantest1.py'更短。只要你保持在当前工作目录中,你就可以使用这些相对路径来打开文件或者获得文件的元信息。但是当你希望构造一个从根目录开始或者是包含盘符的绝对路径时,你就需要用到os.path.realpath()函数了。

列表解析创造一个新的列表而不改变原列表。
可以安全的将列表解析的结果赋值给被映射的变量。Python会在内存中构造新的列表,在列表解析完成后将结果赋值给原来的变量。
你可以在列表解析中使用任何的 Python 表达式, 包括 os 模块中用于操作文件和目录的函数。
你可以在列表解析的最后加入 if 子句来过滤列表。对于列表中每一个元素 if 关键字后面的表达式都会被计算。如果表达式的计算结果为 True,那么这个元素将会被包含在输出中。这个列表解析在当前目录查找所有.py 文件,而 if 表达式通过测试文件大小是否大于 6000 字节对列表进行过滤。有 6 个符合条件的文件,所以这个列表解析返回包含六个文件名的列表。
到目前为止的例子中的列表解析都只是用了一些简单的表达式, 乘以一个常数、调用一个函数或者是在过滤后返回原始元素。 然而列表解析并不限制表达式的复杂程度。

交换字典的键和值
这里是一个可能有用的通过字典解析实现的小技巧:键和值。

a_dict = {'a': 1, 'b': 2, 'c': 3}
{value:key for key, value in a_dict.items()}
{1: 'a', 2: 'b', 3: 'c'}

UNICODE
有一种 Unicode 编码方式每 1 个字符使用 4 个字节。它叫做UTF‐82,因为 32 位 = 4 字节。UTF‐32 是一种直观的编码方式;它收录每一个 Unicode 字符(4 字节数字)然后就以那个数字代表该字符。这种方法有其优点,最重要的一点就是可以在常数时间内定位字符串里的第 N 个字符,因为第 N 个字符从第4×Nth 个字节开始。另外,它也有其缺点,最明显的就是它使用 4 个“诡异”的字节来存储每个“诡异”的字符...

尽管有Unicode字符非常多,但是实际上大多数人不会用到超过前 65535 个以外的字符。因此,就有了另外一种Unicode编码方式,叫做UTF‐16(因为 16 位 = 2 字节)。UTF‐16 将 0–65535 范围内的字符编码成 2 个字节,如果真的需要表达那些很少使用的“星芒层(astral plane)”内超过这 65535 范围的Unicode字符,则需要使用一些诡异的技巧来实现。UTF‐16 编码最明显的优点是它在空间效率上比UTF‐32 高两倍,因为每个字符只需要 2 个字节来存储(除去 65535 范围以外的),而不是UTF‐32 中的 4 个字节。并且,如果我们假设某个字符串不包含任何星芒层中的字符,那么我们依然可以在常数时间内找到其中的第N个字符,直到它不成立为止这总是一个不错的推断...

但是对于 UTF‐32 和 UTF‐16 编码方式还有一些其他不明显的缺点。不同的计算机系统会以不同的顺序保存字节。这意味着字符 U+4E2D 在 UTF‐16 编码方式下可能被保存为 4E 2D 或者 2D 4E,这取决于该系统使用的是大尾端(big‐endian)还是小尾端(little‐endian)。(对于 UTF‐32 编码方式,则有更多种可能的字节排列。)只要文档没有离开你的计算机,它还是安全的 — 同一台电脑上的不同程序使用相同的字节顺序(byte order)。但是当我们需要在系统之间传输这个文档的时候,也许在万维网中,我们就需要一种方法来指示当前我们的字节是怎样存储的。不然的话,接收文档的计算机就无法知道这两个字节 4E 2D 表达的到底是 U+4E2D 还是 U+2D4E。

为了解决这个问题,多字节的Unicode编码方式定义了一个“字节顺序标记(Byte Order Mark)”,它是一个特殊的非打印字符,你可以把它包含在文档的开头来指示你所使用的字节顺序。对于UTF‐16,字节顺序标记是U+FEFF。如果收到一个以字节FF FE开头的UTF‐16 编码的文档,你就能确定它的字节顺序是单向的(one way)的了;如果它以FE FF开头,则可以确定字节顺序反向了。

不过,UTF‐16 还不够完美,特别是要处理许多 ASCII 字符时。如果仔细想想的话,甚至一个中文网页也会包含许多的 ASCII字符 — 所有包围在可打印中文字符周围的元素(element)和属性(attribute)。能够在常数时间内找到第 Nth 个字符当然非常好,但是依然存在着纠缠不休的星芒层字符的问题,这意味着你不能保证每个字符都是 2 个字节长,所以,除非你维护着另外一个索引,不然就不能真正意义上的在常数时间内定位第 N 个字符。另外,朋友,世界上肯定还存在很多的 ASCII 文本... 另外一些人琢磨着这些问题,他们找到了一种解决方法: UTF-8

格式说明符
但是,还有一些问题我们没有讲到!再来看一看 humansize.py中那一行奇怪的代码:
if size < multiple:
return '{0:.1f} {1}'.format(size, suffix)
{1}会被传递给 format()方法的第二个参数替换,即 suffix。但是{0:.1f}是什么意思呢?它其实包含了两方面的内容:{0}你已经能理解,:.1f 则不一定了。第二部分(包括冒号及其后边的部分)即格式说明符(format specifier),它进一步定义了被替换的变量应该如何被格式化。
☞格式说明符的允许你使用各种各种实用的方法来修饰被替换的文本,就像 C 语言中的 printf()函数一样。我们可以添加使用零填充(zero‐padding),衬距(space‐padding),对齐字符串(align strings),控制 10 进制数输出精度,甚至将数字转换成 16 进制数输出。 在替换域中,冒号(:)标示格式说明符的开始。“.1”的意思是四舍五入到保留一们小数点。“f”的意思是定点数(与指数标记法或者其他 10 进制数表示方法相对应)。因此,如果给定size 为 698.24,suffix 为'GB',那么格式化后的字符串将是'698.2 GB',因为 698.24 被四舍五入到一位小数表示,然后后缀'GB'再被追加到这个串最后。

'{0:.1f} {1}'.format(698.24, 'GB')
'698.2 GB'

其他字符串常用方法

我们可以在 Python 的交互式 shell 里输入多行(multiline)字符串。一旦我们以三个引号标记多行字符串的开始,按 ENTER 键,Python shell 会提示你继续这个字符串
的输入。连续输入三个结束引号以终止该字符串的输入,再敲ENTER 键则会执行该条命令(在当前例子中,把这个字符串赋给变量 s)。

splitlines()方法以多行字符串作为输入,返回一个由字符串组成的列表,列表的元素即原来的单行字符串。请注意,每行行末的回车符没有被包括进去。

lower()方法把整个字符串转换成小写的。(类似地,upper()方法执行大写化转换操作。)

count()方法对串中的指定的子串进行计数。是的,在那一句中确实出现了 6 个字母“f”。

Byte

使用“byte 字面值”语法 b''来定义 bytes 对象。byte 字面值里的每个字节可以是 ASCII 字符或者是从\x00 到\xff 编码了的 16 进制数。

bytes 对象的类型是 bytes。

跟列表和字符串一样,我们可以通过内置函数 len()来获得bytes 对象的长度。

使用+操作符可以连接 bytes 对象。操作的结果是一个新的bytes 对象。

连接 5 个字节的和 1 个字节的 bytes 对象会返回一个 6 字节的 bytes 对象。

一如列表和字符串,可以使用下标记号来获取 bytes 对象中的单个字节。对字符串做这种操作获得的元素仍为字符串,而对 bytes 对象做这种操作的返回值则为整数。确切地说,是 0–255 之间的整数。

bytes对象是不可变的;我们不可以给单个字节赋上新值。如果需要改变某个字节,可以组合使用字符串的切片和连接操作(效果跟字符串是一样的),或者我们也可以将bytes对象转换为bytearray对象。

Python源码的编码方式
Python 3 会假定我们的源码 — 即.py 文件 — 使用的是 UTF‐8 编码方式。
☞Python 2 里,.py文件默认的编码方式为ASCII。Python 3 的源码的默认编码方式为UTF‐8 如果想使用一种不同的编码方式来保存 Python 代码,我们可
以在每个文件的第一行放置编码声明(encoding declaration)。以下声明定义.py 文件使用 windows‐1252 编码方式:

‐‐ coding: windows‐1252 ‐‐

从技术上说,字符编码的重载声明也可以放在第二行,如果第一行被类UNIX系统中的hash‐bang命令占用了。

!/usr/bin/python3

‐‐ coding: windows‐1252 ‐‐

为什么要用正则表达式
所有的现代编程语言都有内建字符串处理函数。在 python 里查找,替换字符串的方法是:index()、 find()、split()、 count()、 replace()等。但这些方法都只是最简单的字符串处理。比如:用index()方法查找单个子字符串,而且查找总是区分大小写的。为了使用不区分大小写的查找,可以使用 s.lower()或者s.upper(),但要确认你查找的字符串的大小写是匹配的。replace() 和 split() 方法有相同的限制。

如果使用 string 的方法就可以达到你的目的,那么你就使用它们。它们速度快又简单,并且很容易阅读。但是如果你发现自己要使用大量的 if 语句,以及很多字符串函数来处理一些特
例,或者说你需要组合调用 split() 和 join() 来切片、合并你的字符串,你就应该使用正则表达式。

正则表达式有强大并且标准化的方法来处理字符串查找、替换以及用复杂模式来解析文本。正则表达式的语法比我们的程序代码更紧凑,格式更严格,比用组合调用字符串处理函数的方法更具有可读性。甚至你可以在正则表达式中嵌入注释信息,这样就可以使它有自文档化的功能。
☞如果你在其他语言中使用过正则表达式(比如perl,javascript 或者 php),python 的正则表达式语法和它们的很像。阅读 re 模块的摘要信息可以了解到一些处理函数以及它们参数的一些概况。 ⁂

^ 匹配字符串开始. $ 匹配字符串结尾
为了在正则表达式中表达这个独立的词,你可以使用‘\b’。它的意思是“在右边必须有一个分隔符”。在 python 中,比较复杂的是‘\’字符必须被转义,这有的时候会导致‘\’字符传染(想想可能还要对\字符做转义的情况)。这也是为什么 perl 中的正则表达式比 python 的简单的原因之一。另一方面,perl 会在正则表达式中混合其他非正则表达式的语法,如果出现了 bug,那么很难区分这个bug 是在正则表达式中,还是在其他的语法部分。

为了解决‘\’字符传染的问题,可以使用原始字符串。这只需要在字符串的前面添加一个字符‘r’。它告诉 python,字符串中没有任何字符需要转义。‘\t’是一个制表符,但 r‘\t’只是一个字符‘\’紧跟着一个字符 t。我建议在处理正则表达式的时候总是使用原始字符串。否则,会因为理解正则表达式而消耗大量时间(本身正则表达式就已经够让人困惑的了)。

正则表达式的匹配规则和使用范围，使用时需要找手册多使用熟练。

•
^ 匹配字符串开始位置。
$ 匹配字符串结束位置。
\b 匹配一个单词边界。
\d 匹配一个数字。
\D 匹配一个任意的非数字字符。
x? 匹配可选的 x 字符。换句话说,就是 0 个或者 1 个 x 字
符。
x* 匹配 0 个或更多的 x。
x+ 匹配 1 个或者更多 x。
x{n,m} 匹配 n 到 m 个 x,至少 n 个,不能超过 m 个。
(a|b|c) 匹配单独的任意一个 a 或者 b 或者 c。
(x) 这是一个组,它会记忆它匹配到的字符串。你可以用re.search 返回的匹配对象的 groups()函数来获取到匹配的值。
正则表达式非常强大,但它也并不是解决每一个问题的正确答案。你需要更多的了解来判断哪些情况适合使用正则表达式。
某些时候它可以解决你的问题,某些时候它可能带来更多的问题。

两个松散正则表达式实例

pattern = '''
... ^ # beginning of string
... M{0,3} # thousands - 0 to 3 Ms
... (CM|CD|D?C{0,3}) # hundreds - 900 (CM), 400 (CD), 0-300 (0 to 3 Cs),
... # or 500 - 800 (D, followed by 0 to 3Cs)
... (XC|XL|L?X{0,3}) # tens - 90 (XC), 40(XL), 0-30 (0 to 3 Xs),
... # or 50 - 80 (L, followed by 0 to 3 Xs)
... (IX|IV|V?I{0,3}) # ones - 9 (IX), 4 (IV), 0-3 (0 to 3 Is),
... # or 5-8 (V, followed by 0 to 3 Is)
... $ # end of string
...
... '''
re.search(pattern, 'M', re.VERBOSE)

phonePattern = re.compile(r'''
... # don't match begining of string number can start anywhere
... (\d{3}) # area code is 3 digits (e.g. '800')
... \D* # optional separator is any number of non-digits
... (\d{3}) # trunk is 3 digits
... \D* # optional separator
... (\d{4}) # rest of number is 4 digits
... \D* # optional separator
... (\d*) # extension is optional and can be any number of digits
... $ # end of strinh
... ''', re.VERBOSE)
phonePattern.search('work 1-(800) 555.1212 #1234').groups()
('800', '555', '1212', '1234')

16.Pickling allows us to store and fetch native Python objects as they are and in a single step--the pickle module is remarkably easy to use.

from initdata import db
import pickle
dbfile = open('people-pickle', 'wb')
pickle.dump(db, dbfile)
dbfile.close()

import pickle
dbfile = open('people-pickle', 'rb')
db = pickle.load(dbfile)
for key in db:
print(key, '=>\n', db[key])
print(db['sue']['name'])

17.Pickling objects to files is an optimal scheme in many applications. If we really want keyed access to records, the Python standard library offers an even higher-level tool: shelves.

18.If you’ve already studied Python in any sort of depth, you probably already know that this is where its OPP support begins to become attractive:
Structure-
With OPP, we can naturally associate processing logic with record data-classes provide both a program unit that combines logic and data in a single package and a hierarchy that allows code to be easily factored to avoid redundancy.
Encapsulation-
With OPP, we can also wrap up details such as name processing and pay increases behind method functions-i.e., we are free to change method implementations without breaking their users.
Customization-
And with OPP, we have a natural growth path. Classes can be extended and customized by coding new subclasses, without changing or breaking already working code.

19.If we plan to distribute this GUI widely, we might package it up as a standalone executable program - a frozen binary in Python terminology - using third-party tools such as Py2Exe, PyInstaller, and others (search the Web for pointers).

If you need to do graphics beyond basic windows, the tkinter Canvas widget supports freeform graphics. Third party extensions such as Blender, OpenGL, VPython, VTK, Maya, and PyGame provide even more advanced graphics, visualization, and animation tools for use with Python scripts. Moreover, the PMW, Tix, and ttk widget kits mentioned earlier extend tkinter itself.
For more advanced applications, a wealth of toolkits and frameworks for Python - including Django, TurboGears, Google's App Engine, pylons, web2py, Zope, Plone, Twisted, CherryPy, Webware, mod_python, PSP, and Quixote-can simplify common tasks and provide tools that we might otherwise need to code from scratch in the CGI world. add Flex, Silverlight, and pyjamas

这些记录略显杂乱，以后我会根据自己的学习情况，有序地整理出其中的精要部分。