《PYTHON学习手册》(《Learing Python》--Mark Lutz)书摘

1. Python是为了让脚本的质量等级再提升几个级别。

2. 《learning Python》和《programming Python》反映了作者培训内容的两部分：核心语言和应用程序程序设计。

3. 动态定型和其引用值：这是掌握Python的关键。

4. 输入的代码会在Python中创建和处理对象。

5. 函数是为重用而打包代码并避免代码冗余的简单方式。

6. Python的OOP多数就是在链接的对象中查找对象名。

7. 原则：最新的Python就是最好的Python。

8. 选择Python的主要因素：软件质量，开发效率，可移植，标准库，组件集成，享受乐趣。

9. Python代码可以调用C和C++的库，可以被C和C++的程序调用，可以与Java组件集成，可以与COM和.NET等框架进行通信，并且可以通过SOAP、XML-RPC和CORBA 等接口与网络进行交互。

10. Python的特性是以统一并有限的方式进行交互，可以在一套紧凑的核心思想基础上进行自由发挥。

11. “脚本”往往倾向于描述简单的顶层代码文件。

12. Python的缺点：性能。

13. 使用Python可以：

　　1）系统编程：Python的标准库绑定了POSIX以及其他OS工具：环境变量、文件、套接字、管道、进程、多线程、正则表达式模式匹配、命令行参数、标准流接口、Shell命令启动器、文件名扩展等。

　　2）用户图形接口：内置TKinter可生成可移植的本地观感的GUI。PMW为Tkinter增加高级部件。基于C++平台的工具包wxPython。PythonCard和Dabo等一些高级工具包是构建在wxPython和tkinker的基础API之上的。通过适当的库，可以在Python中使用其他的GUI工具包。例如，通过PyQt使用Qt，通过PyGTK使用GTK，通过PyWin32使用MFC、通过IronPython使用.NET，以及通过Jython使用Swing等。

　　3）Internet脚本：可以通过套接字进行通信；从发给服务器端的CGI脚本的表单中提取信息；通过FTP传输文件；解析、生成和分析XML文件；发送、接受、编写和解析Email；通过URL获取网页；从获取的网页中解析HTML和XML文件；通过XML-RPC、SOAP和Telnet通信等。第三方工具：HTMLGen可以从Python类的描述中生成HTML文件，mod_python包可以使在Apache服务器上运行的Python程序更具效率并支持Python Server Page这样的服务器端模板，Jython系统提供了无缝的Python/Java集成而且支持在客户端运行的服务器端Applet。Web开发工具包：Django、web2py、Pylons、Zope和WebWere，它们包含了诸如对象关系映射器、MVC架构、服务器端脚本和模板，以及支持AJAX等功能，从而提供了完整的、企业级的Web开发解决方案。

　　4）组件集成：在Python连接编译好组件时，SWIG和SIP这样的代码生成工具可以让这部分工作自动完成。 CPython允许混合。

　　5）数据库编程： Python定义了一种通过Python脚本存取SQL数据库系统的可移植的数据库API，这个API对于各种底层应用的数据库系统都是统一的。

　　6）快速原型：不需重写

　　7）数值计算和科学计算编程

　　8）游戏、图像、AI、XML、机器人等

14. Python在技术上的优点：

　　1）面向对象

　　2）免费

　　3）可移植：Linux\UNIX, Windows\DOS, Mac OS , BeOS\OS/2\VMS\QNX, VxWorks, Cray和IBM大型机，Palm OS, PocketPC, PDA(Linux),游戏终端等

　　4）功能强大：动态类型（Python在运行过程中随时跟踪对象的种类），自动内存管理（Python自动进行对象分配，当对象不再使用时将自动撤销对象），大型程序支持（模块、类、异常），内置对象类型，内置工具(合并concatenation、分片slice，排序sort，映射mapping)，库工具，第三方工具

　　5）可混合

　　6）简单易用

　　7）简单易学

15.Python的创立者所受的是数学家的训练，因此，他创造出来的语言具有高度的统一性，其语法与工具集都相当一致。Perl语言的创立者是语言学家，相同的任务有很多方式可以完成，并且语言材料的交互对背景环境敏感，有时还有相当微妙的方式，就像自然语言那样（Perl有一格言：完成的方法不止一种。）。在工程世界中，我们需要最小化功能集和可预测性。

------------

第2章

1. 从技术上讲，以.py结尾的命名方式在被“导入”时才是必须的。

2. Python执行文件：从头至尾按照顺序一个接一个地运行文件中的语句。

3. 下一次运行程序时，如果你在上次保存字节码之后没有修改过源代码的话，Python将会加载.pyc文件并跳过编译这个步骤。当Python重编译时，它会自动检查源文件和字节码文件的时间戳：如果你又保存了源代码、下次程序运行时，字节码将自动重新创建。

4. 无法写入字节码时，放在内存中。Python可以运行.pyc而没有源代码。

5. 从严格意义上讲，只有文件导入的情况下字节码才保存，并不是对顶层文件。

6. PVM就是运行字节码指令的一个大循环，一个接一个地完成操作。

7. 在运行时，Python程序去构建并执行另一个Python程序是有可能的。例如：eval和exec内置模块。

8. 在Python中，所有的事情都是在程序运行时发生的。

9. Jython：包含了Java类，这些类编译Python源代码，形成Java字节码，并将得到的字节码映射到JVM上。Jython的目标是让Python代码能够脚本化Java应用程序，就好像CPython允许Python脚本化C和C++组件一样。

10. Psyco实时编译器： Psyco系统是一个扩展字节码执行模块的组件，可以让程序运行得更快。这个工具收集并使用信息，在程序运行时，可以将部分程序的字节码转换成底层的真正的二进制机器代码，从而实现更快的执行速度。它生成机器代码将数据类型精简至你程序实际上所使用的类型。可以生成不同版本的机器码用来支持每一个不同的类型组合。PyPy是其代替品。

11. 冻结二进制文件能够将程序的字节码、PVM以及任何程序所需要的Python支持文件捆绑在一起形成一个单独的文件包。主要工具有：py2exe, PyInstaller, freeze。

------------

第三章

1.  给一个变量赋值之前就使用它，这总是一个错误。

2. >>>和...在内置模块sys中定义，并可以改变。

3. 操作系统使用#!找到解释器来运行文件其他部分的程序代码。例：#!/usr/bin/env python ：当这样写时，env程序可以通过系统的搜索路径的设置定位Python解释器，以使代码更具有可移植性。

4. 在Windows下，注册表使通过点击图标打开文件变得容易。非Windows系统中图标、文件管理器、浏览的原理以及很多方面都有少许不同。在一些UNIX系统上，也许需要在文件管理器的GUI中注册.py的扩展名，或者使用应用程序关联文件的MIME类型或通过编辑文件、安装程序等命令。

5. 导入文件是另一种运行文件的方法。但是导入是一个开销很大的操作，以至于每个文件、每个程序运行不能够重复多于一次。调用imp标准库模块中的reload函数，可以载入并运行文件最新版本的代码。但它是不可传递的，重载一个模块不能够重载该模块所导入的任何模块。reload函数希望获得的参数是一个已经加载了的模块对象的名称，因此要确保在重载之前已经成功地导入了这个模块。reload的返回值是一个Python模块对象。

6. reload是一个被调用的函数，import是一个语句。

7. 模块就是变量名的封装，变量名是其属性。导入得到模块中顶层定义的所有变量名。这些变量名通常被赋值给通过模块函数、类、变量以及其他被导出的工具。

8. 当文件导入时，它的代码运行并生成了模块的属性。导入模块的组件在顶层文件中得到了变量名的读取权。

9. 例：exec(open('module.py').read())

10. pdb还包含了一个postmortem函数，可以在异常发生后执行它，从而获取发生错误时的信息。

11. winpdb系统是一个独立的调试器，具有高级的调试支持、跨平台的GUI和控制台界面。

------------

第四章

1. 在Python程序中处理的每样东西都是一种对象。

2. 函数、模块和类这样的编程单元由def,class,import和lambda这样的语句和表达式创建，并且可以在脚本间自由地传递，存储在其他对象中等。

3. 运行的表达式的语法决定了创建和使用的对象的类型。

4. Python是动态类型的（它自动地跟踪你的类型而不是要求声明代码），但它也是强类型语言（你只能对一个对象进行适合该类型的有效的操作）。

5. 对象的代码形式repr，对象的用户友好形式str。

6. Python还包括一些少见的数字对象：复数、固定精度十进制数、有理数、集合和布尔值。第三方甚至包括矩阵和向量。

--以下字符串--

7. 作为序列，字符串支持假设其中各个元素包含位置顺序的操作。

8. 我们能在方括号中使用任意表达式。

9. 使用[:]有效地拷贝整个字符串。

10. 一个操作的意义取决于被操作的对象。

11. 在Python中的每个对象都可以分为不可变性和可变性。

12. 对象的函数，将会通过一个调用表达式触发。

13. 字符串的操作不会改变原始的字符串。

14. 格式化可以以一个表达式的形式（%）和一个字符串方法调用（.format）形式使用。

15. 可作用于多种类型的通用型操作都是以内置函数或表达式的形式出现的，但是类型特定的操作是以方法调用的形式出现的。

16. 反斜线转义序列表示特殊的字符。

17. 三引号内，在每一行的末尾会增加换行符。

18. raw字符串常量 会去掉反斜线转义机制。

19. 模式匹配中，与模式中括号包含的部分匹配的子字符串的对应部分保存为组。

---以下列表--

20. 列表是可变的，大多数列表的方法都会就地改变列表对象，而不是创建一个新的列表。

21. 列表解析源自集合的概念。它是一种通过对序列中的每一项运行一个表达式来创建一个新列表的方法，每次一个，从左至右。

22. 迭代协议：表示在内存中物理存储的序列，或一个在迭代操作情况下每次产生一个元素的对象。如果一个对象在响应next之前先用一个对象对iter内置函数做出响应，那么它属于后一种情况。

23. 列表解析和相关的函数编程工具，如map和filter，通常运行得比for循环快。也许版本和版本之间差别很大。

24. Python中的一个主要原则 ：首先为了简单和可读性去编写代码，在程序可以工作，并证明了确实有必要考虑性能后，再考虑该问题。

25. 元组提供了一种完整性约束。

--以下文件--

26. 要创建一个文件对象，需调用内置的open函数以字符串的形式传递给它一个外部的文件名以及一个处理模式的字符串。

27. 文件提供了一个迭代器。

28. Python3.0的文件在文本和二进制数据之间划出了一条清晰的界限。文本文件把内容显示为字符串，并且自动执行Unicode编码和解码；而二进制文件把内容显示为一个特定的字节字符串类型，并且允许你不修改地访问文件内容。

29. 额外的类文件工具：管道、FIFO、套接字、通过键访问文件、对象持久、基于描述符的文件、关系数据库和面向对象数据库接口等。其中，描述符文件支持文件锁定和其他的底层工具，而套接字提供网络和进程间通信的接口。

30. 核心概念：在代码中检验了特定的类型，实际上破坏了它的灵活性，即限制它只能使用一种类型工作。

31. 在Python中，我们编写对象接口（所支持的操作）而不是类型。

---------------

本章习题：

1. 列举4个Python核心数据类型的名称。

2. 为什么我们把它们称作是“核心”数据类型？

3. “不可变性”代表了什么，哪三种Python的核心类型被认为是具有不可变性的？

4. “序列”是什么意思，哪三种Python的核心类型被认为是这个分类中的？

5. “映射”是什么意思，哪种Python的核心类型是映射？

6. 什么是“多态”，为什么我们要关心多态？

---------------

第五章 数字

1. 内置函数hex(I),oct(I),bin(I)把一个整数转换为3种进制表示的字符串，并且int(str, base)根据给定的进制把一个运行时字符串转换为一个整数。

2. 可以通过手动调用内置函数来强制转换类型，然而，通常没有必要这么做。因为Python在表达式中自动升级为更复杂的类型。

3. 要留心所有的Python操作符可以通过Python的类或C扩展类型被重载。

4. 从技术上来说，默认的交互模式回显和打印的区别就相当于内置repr和str函数的区别。

5. Python允许我们把多个比较连续起来执行范围测试。例： >>>1 == 2 < 3   值：False

6. eval函数，将会把字符串作为Python代码。

--小数--

7. 小数是通过一个导入的模块调用函数后创建的，而不是通过运行常量表达式创建的。从功能上来说，小数对象就像浮点数，只不过它们有固定的位数和小数点，因此小数是有固定的精度的浮点值。from decimal import Decimal

8. decimal模块中的其他工具可以用来设置所有的小数数值的精度、设置错误处理等。模块中的一个上下文对象允许指定精度（小数位数）和舍入模式（舍去、进位等）。decimal.getcontext().prec = 4

9. 小数实际上是手动舍入和字符串格式化的一种替代方式。

10. 可用上下文管理器语句来重新设置临时精度。 with decimal.localcontext() as ctx: ctx.prec = 2

--分数--

11. 分数，实现了有理数对象。它明确地保留一个分子和一个分母，从而避免了浮点数学的某些不精确性和局限性。可能通过固定小数位数和指定舍入或截断策略来控制数值精度。from fractions import Fraction

12. 分数对象也可以从浮点数字符串来创建。 Fraction('.25')

13. 分数保持精确性，并且自动简化结果。

14. 分数转换：分数有一个from_float方法，float接受一个Fraction作为参数。 (2.5).as_integer_ratio()

15. 可以通过限制最大分母值来简化结果。 a.limit_denominator(10)

--集合--

16. 集合：可迭代(len, for, 列表解析)，不是序列也不是映射类型。 intersection, update, add, remove, union, issubset

17. 字典键列表在Python 3.0 中是视图对象，它支持像交集和并集这样的类似集合的行为。

18. 在Python中{}仍然是一个字典。空的集合必须通过内置函数set来创建。

19. 集合只能包含不可变的（即可散列的）对象类型。因此，列表和字典不能嵌入到集合中。

20. 集合本身也是不可改变（？？？）的，因此，不能直接嵌入到其他集合中。？？？如果需要在另一个集合中存储一个集合，可以像调用set一们调用frozenset，它创建一个不可变的集合，该集合不可修改并且可以嵌套到其他集合中。

21. Python 3.0 支持多种解析（列表、集合、字典和生成器）。

--布尔型--

22. 实际上仅仅是内置的整数类型int的子类（从面向对象的观点来看）。从技术上讲，bool为它的两个对象重新定义了str和repr的字符串格式。

---------------

本章习题

1. Python中表达式 2 * (3 + 4)的值是多少？

2. Python中表达式 2 * 3 + 4的值是多少？

3. Python中表达式 2 + 3 * 4的值是多少？

4. 通过什么工具你可以找到一个数字的平方根以及它的平方？

5. 表达式 1 + 2.0 + 3的结果是什么类型？

6. 怎样能够截断或舍去浮点数的小数部分？

7. 怎样将一个整数转换成浮点数？

8. 如何将一个整数显示成八进制、十六进制或二进制的形式？

9. 如何将一个八进制、十六进制或二进制的字符串转换成平常的整数？

---------------

 第六章 动态类型简介

1. 类型的概念是存在于对象中而不是变量名中。变量原本是通用的，它只是在一个特定的时间点，简单地引用了一个特定的对象而已。

2. 所有的变量必须在其使用前明确地赋值。

3. 在内部，变量事实上是至对象内存空间（通过运行常量表达式3而创建）的一个指针。

4. 引用是一种关系，以内存中的指针的形式实现。

5. 术语：

　　变量是一个系统表的元素，拥有指向对象的连接的空间。

　　对象是分配的一块内存，有足够的空间去表示它们所代表的值。

　　引用是自动形成的从变量到对象的指针。

6. 从概念上讲，在脚本中，每一次通过运行一个表达式生成一个新的值，Python都创建了一个新的对象去表示这个值。从内部来看，作为一种优化，Python缓存了不变的对象并对其进行复用。

7. 从技术上讲，对象有更复杂的结构而不仅仅是有足够的空间表示它的值那么简单。每个对象有两个标准的头部信息：一个类型标志符去标识这个对象的类型，一个引用的计数器用来决定是不是可以回收这个对象。

8. Python的变量就是在特定的时间引用了一个特定的对象。

9. 对象支持在原处修改的对象，共享引用时需要加倍小心，因为对一个变量名的修改会影响其他的变量。如果不想这样，需要Python拷贝对象，而不是创建引用。

10. 复制一个字典或集合应该使用X.copy()方法调用。注意： copy.copy(Y)  copy.deepcopy(Y)

11. “==操作符” 测试两个被引用的对象是否有相同的值。

12. “is操作符” 检查对象的同一性。 实际上，is只是比较实现引用的指针。

13. sys模块中的getrefcount函数会返回对象的引用次数。

14. Python中，任何东西看起来都是通过赋值和引用操作的。

---------------

本章习题

思考各题的三条语句。它们会改变A的值吗？

1.

A = "spam"

B = A

B = "shrubbery"

2.

A = ["spam"]

B = A

B[0] = "shrubbery"

3.

A = ["spam"]

B = A[:]

B[0] = "shrubbery"

---------------

第七章

1. s = r'\temp\spam', s = b'spam',  s = u'spam'

2. s.lower(), s.encode('latin-1')

3. 单双字符串是一样的。

4. Python自动在任意的表达式中合并相邻的字符串常量。

5. 转义序列让我们能够在字符串中嵌入不容易通过键盘输入的字节。注意原始的反斜杠字符并不真正和字符串一起存储在内存中；它们告诉Python字符串中保存的特殊字节值。字符串反斜杠字符：\newline, \\, \', \'', \a, \b, \f, \n, \r, \t, \v, \N{id}, \uhhhh, \Uhhhhhhhh, \xhh, \ooo, \0 (表示NULL，而不是字符串结尾), \other。

6. Python以十六进制显示非打印字符，不管是如何指定它们的。

7. 如果Python没有作为一个合法的转义编码识别出在"\"后的字符，它就直接在最终的字符串中保留反斜杠。

8. 如果字母r(大写或小写)出现在字符串的第一个引号前面，它将关闭转义机制。但是，一个raw字符串不能以单个的反斜杠结尾，也就是说，r"...\"不是一个有效的字符串常量，一个raw字符串不能以奇数个反斜杠结束。如果需要用单个反斜杠结束，可以：1）使用两个反斜杠并分片掉第二个反斜杠[:-1]；2）手动添加一个反斜杠；3）忽略raw字符串语法并在常规字符串中把反斜杠改为双反斜杠。

9. Python脚本会自动在Windows和UNIX的路径中使用斜杠表示字符串路径，因为Python试图以可移植的方法解释路径。

10. 在Python中，实用胜过美观。

11. 字符串可以通过+操作符进行合并并可以通过*操作符进行重复。

12. 内置的len函数返回了一个字符串（或任意有长度的对象）的长度。

13. Python支持使用负偏移从序列中获取元素。

14. 扩展分片--第三个限制值--X[I:J:K]。步进K默认为1。可以使用负数作为步进。 S = 'abcdefg', S[5:1:-1]为'fdec'。

15. 分片等同于用一个分片对象进行索引。

16. Python的座右铭之一是：拒绝猜的诱惑。例如：Python中不能让数字和字符串相加，即使字符串看起来像数字也不可以。这是有意设计的，因为+即能够进行加法运行也能进行合并运算。在Python中，如果让操作变得更复杂，通常就要避免这样的语法。

17. int和str是通过的指定转换工具。

18. 内置的eval函数会运行一个包含了Python表达式代码的字符串，并能够将一个字符串转换为任意类型的对象。

19. 内置的ord函数转换单个字符为其对应的ASCII码，这个函数实际上返回的是这个字符在内存中对应的字符的二进制值。chr函数则相反。

20. 每修改一次字符串就生成一个新对象并不像听起来效率那么低下。

21. 函数也就是代码包，方法调用同时进行了两次操作（一次获取属性和一次函数调用）。

22. 内置的字符串方法实现了分隔和连接、大小写转换、内容测试、子字符串查找和替换这些操作。

23. 如果你不得不对一个超长字符串进行许多的修改，为了优化脚本的性能，可能需要将字符串转换为一个支持原处修改的对象。

24. join将列表字符串连在一起，并用分隔符隔开。

25. split的默认分隔符为空格。

26. 没有字符串方法支持模式。字符串方法有时与re模块工具相比是具有运行速度方面的优势的。

27. 如今的Python字符串格式化可以以两种形式实现：字符串格式化表达式，字符串格式化方法调用。

28. 方法和表达式。表达式是通用的，可用于多种类型（同一类）；同样分类的类型共享其操作集合。方法是类型特定的，只能用于单一数据类型上。在Python3.0中，有一些对方法分组的尝试，但方法仍然比其他的操作集更特定于类型。

---------------

本章习题

1. 字符串find方法能用于搜索列表吗？

2. 字符串切片表达式能用于列表吗？

3. 如何将字符转换为ASCII码？如何反向转换？

4. 在Python中，怎么修改字符串？

5. 已知字符串S的值为"s,pa,m"，提出两种从中间抽取两个字符的方式。

6. 字符串"a\nb\x1f\000d"中有多少字符？

7. 为什么 要使用string模块，而不使用字符串方法调用？

---------------

第八章

1. 列表和字典：可以在原处进行修改；可以按需求增长和缩短；可以包含任何种类的对象或者被嵌套。

--列表--

2. 从技术上讲，Python列表包含了零个或多个其他对象的引用。从Python的列表中读取一个项的速度与索引一个C语言数组差不多。实际上，在标准Python解释器内部，列表就是C数组而不是链接结构。当把一个对象赋给一个数据结构元素或变量名时，Python总是会存储对象的引用，而不是对象的一个拷贝。

3. Python中多数数据结构的建立都是在运行时执行程序代码的。

4. 不能用+将一个列表和一个字符串合并到一起，除非先把列表转换成字符串（使用诸如反引号、str或者%格式这样的工具），或者把字符串转换为列表（列表内置函数）。

5. 列表解析对序列中的每一项应用一个表达式来构建一个新的列表。与for循环密切相关。

6. 内置函数map对序列中的每一项应用一个函数，把结果收集到一个新的列表。

7. 分片赋值能够用来替换（覆盖）、增长（插入）、缩短（删除）主列表，不过Python程序员更喜欢用合并、insert、pop以及remove列表方法来实现。

8. L.append(X)与 L+[X]的结果类似，不过，前者会原地修改L，而后者会生成新的列表。分片模拟append:L[len(L):]=[X]；前端插入：L[:0]=[X]。

9. sort使用Python标准的比较检验作为默认值，而且以递增的顺序进行排序。(key=xx,reverse=False)。在Python3.0中，不同类型的比较不再依赖于固定的跨类型之间的排序，而是引发一个异常。Python3.0也不支持传入一个任意的比较函数来进行排序。

10. 类似 L=L.append(X)不会得到L修改后的值。L会被赋append函数的返回值None，同时会失去整个列表的引用。当使用append和sort之类的属性时，对象的修改有点像副作用，所以没有理由再重新赋值。

11. extend和pop方法分别能够在末端插入多个元素、删除一个元素。

12. 因为分片赋值是删除外加插入操作，可以通过将空列表赋值给分片来删除列表片段：L[i:j]=[]。

13. 可变性是每个对象类型的固有属性。

--字典--

14. 字典可以取代许多搜索算法和数据结构。有时也能执行其他语言中的记录、符号表的功能；可以表示稀疏数据结构等。

15. Python采用最优化的散列算法来寻找键，因此搜索是很快速的。

16. 字典是无序集合。keys方法能够返回字典中所有的键，将它们一个列表中（Python3.0不是列表，而是字典视图）。后者对于按顺序处理字典是非常有用的，但是不应该依赖keys列表的次序。

17. in用来做键存在测试，如同has_key方法。从技术上讲，in能起作用是因为字典定义了单步遍历keys列表的迭代器。

18. 每当对新字典键进行赋值，就会在字典内生成一个新的元素。

19. 字典的values和items方法分别返回字典的值列表和(key,value)对。

20. 当键不存在时会报missing-key错误。为避免此，1）可以在if语句中预先对键进行测试；2）可以合适try明确地捕获并修复这一异常；3）可通过get方法返回默认值（None或者用户定义的默认值）。

21. 字典的update方法类似于合并，它把一个字典的键和值合并到另一个字典中，盲目地覆盖相同键的值。

22. 字典提供copy方法，可避免相同字典共享引用潜在的副作用。

23. for key in D: 和 for key in D.keys(): 效果是一样的。

24. 字典使用注意事项：1）序列运算无效；2）对新索引赋值会添加项；3）键不一定总是字符串，任何不可变对象都可以，只要有合适的协议方法，类实例对象也可用作键。

25. Python3.0中的字典变化：1）字典解析；2）字典视图；3）字典视图和几何；4）排序字典键；5）字典大小比较不再有效；6）has_key方法已死，in永生。

26. 视图对象是可迭代的，这就意味着对象每次产生一个结果项，而不是在内存中立即产生结果列表。

27. Python中的循环结构会自动迫使可迭代的对象在每次迭代上产生一个结果。

28. 和Python 2.X的列表结果不同，Python3.0中的字典视图并非创建后不能改变--它们可以动态地反映在视图对象创建之后对字典做出的修改。

---------------

本章习题

1. 举出两种方式来创建内含五个整数零的列表。

2. 举出两种方式来创建一个字典，有两个键'a' 和'b'，而每个键相关联的值都是零。

3. 举出四种在原处修改列表对象的运算。

4. 举出四种在原处修改字典对象的运算。

---------------

 第九章

--元组--

1. 作为特殊情况，在不会引起语法冲突的情况下，Python允许忽略元组的圆括号。

2. 元组的不可变性只适用于元组本身顶层而并非其内容。

--文件--

3. 内置open函数，处理模式加上+意味着同时为输入和输出打开文件。第三个是可选参数，它能够用来控制输出缓存：传入0意味着输出无缓存（写入方法调用时立即传给外部文件）。

4. 在任何情况下，Python程序中的文本文件都采用字符串的形式。

5. 文件迭代器是最好的读取行工具。

6. 与print语句不同的是，当你把数据写入文件时，Python不会自动把对象转换为字符串--你必须传递一个已经格式化的字符串。

7. pickle模块可用来处理一般对象的存储，struct模块可处理文件中打包的二进制数据。

8. 调用文件close方法将会终止对外部文件的连接。手动进行文件close方法调用是我们需要养成的好习惯，也可用with/as替换。

9. 返回空字符串是Python文件方法告诉我们已经到达文件底部（文件的空行是含有新行符的字符串，而不是空字符串）。

10. 写入方法不会为我们添加行终止符，所以程序必须包含它来严格地终止行。

11. 文件迭代器对于内存使用很好，并且比其他选项更快。

12. Python3.0中的文本和二进制文件：1）文本文件把内容表示为常规的str字符串，自动执行Unicode编码和解码，并且默认执行末行转换。2）二进制文件把内容表示为一个特殊的bytes字符串类型，并且允许程序不修改地访问文件内容。二进制文件不会对数据执行任何末行转换。

13. 我们不一定非要运行rstrip来删除最后部分的"\n"，int和一些其他转换方法会忽略数字旁边的空白。

14. eval是一个功能强大的工具。它有时过于强大。eval会完全执行Python的任何表达式，甚至是可能会删除计算机上的所有文件的表达式，只要给予必要的权限。

15. pickle像是超级通用的数据格式化和解析工具。Python2.6有一个cPickle模块，是pickle的一个优化版本，可以直接导入以提高速度。Python3.0把这模块改名为_pickle，并在pickle中自动使用它。

16. shelve用pickle把Python对象存放到按键访问的文件系统中。

17. struct模块能够构造并解析打包的二进制数据。从某种意义上说，它是另一个数据转换工具，它能够把文件中的字符串解读为二进制数据。big-endian。例：struct.pack('>i4sh', 7, 'spam', 8)

18. 类型分类：1）对象根据分类来共享操作；2）只有可变对象（列表、字典和集合）可以原处修改；3）文件导出是唯一的方法，因此可变性并不适合--当处理文件时，它们的状态可能会修改，但这与Python的核心类型可变性限制不完全相同。4）下表的”数字“包含了所有数字类型；5）下表的”字符串“包括str，以及Python3.0中的bytes和Python2.6中的unicode;Python 3.0中的bytearray字符串类型是可变的。

对象类型　　分类　　是否可变

数字　　　　数值　　　　否

字符串　　　序列　　　　否

列表　　　　序列　　　　是

字典　　　　对应　　　　是

元组　　　　序列　　　　否

文件　　　　扩展　　　　N/A

Sets　　　　集合　　　　是

frozenset　集合　　　　否

bytearray　序列　　　　是

 

20. 自己实现的类的对象可以在这些分类中任意选择。例如，如果你想提供一种新的特殊序列对象，它与内置序列一致，那么就写一个类，重载索引和合并等类似的操作。

--引用vs拷贝--

21. 赋值操作总是储存对象的引用，而不是这些对象的拷贝。

22. 因为赋值操作会产生相同对象的多个引用，需要意识到在原处修改对象时可能会影响程序中其他地方对相同对象的其他引用，这一点很重要。如果不想这样做，需要明确地告诉Python复制该对象。

23. 引用令你可以在程序范围内任何地方传递大型对象而不必在途中产生拷贝。

24. 复制对象的方法： 1）分片表达式L[:]能够复制序列。2）字典的copy方法能够复制字典。3）有些内置函数能够生成拷贝（例如 list(L)）。4）copy标准库模块能够生成完整拷贝。

--比较、相等性和真值--

25. 所有的Python对象可以支持比较操作--测试相等性、相对大小等。Python的比较总是检查复合对象的所有部分，直到可以得出结果为止。事实上，当嵌套对象存在时，Python能够自动遍历数据结构，并从左到右递归地应用比较，首次发现的差值将决定比较的结果。

26. == 操作符测试值的相等性。 is 表达式测试对象的一致性。

27. 长短字符串。

28. Python 3.0删除了字典的大小比较。替代方法：1）编写循环来根据键比较值；2）手动比较排序的键/值列表。

29. 真假概念是Python中每个对象的固有属性。整数0代表假，整数1代表真。任意的空数据结构视为假，任何非空数据结构视为真。数字非零为真。对象非空为真。

30. 可以测试对象自身，而不是将它们和一个空的对象比较。

31. None是Python中一种特殊数据类型的唯一值，一般起到空的点位作用。与C的NULL类似。None不是”未定义“。它是一个真正的对象，有内存，由Python给定一个内置的名称。

32. Python提供一个内置函数bool，它可以用来测试一个对象的布尔值。

--类型层次--

33. 类型本身在Python中也是对象类型。

34. Python 2.x的核心对象有内置名来支持面向对象子类的类型定制：dict, list, str, tuple, int, float, complex, byte, type, set, file。调用这些名称事实上是对这些构造函数的调用，而不仅仅是转换函数。

35. 类型测试建议使用isinstance。

36. 附带工具和内置类型之间的主要区别在于，内置类型有针对它们的对象的特殊语言生成语法。其他工具必须先导入才能使用。

37. 序列重复就好像是多次将一个序列加到自己身上。但当可变序列嵌套时，效果就不见得如你所想。记住：重复、合并以及分片只是在复制操作数对象的顶层。

38. 无论何时Python在对象中检测到循环，都会打印成[...]。

---------------

本章习题

1. 你怎么确定元组有多大？

2. 写个表达式，修改元组中第一个元素。在此过程中，(4,5,6)应该变成(1,5,6)。

3. open文件调用中，默认的处理模式自变量是什么？

4. 你可能使用什么模块把Python对象储存在文件中，而不需要亲自将它们转换成字符串？

5. 你怎么一次复制嵌套结构的所有组成部分？

6. Python在什么时候会认为一个对象为真》

 第二部分练习题请自做

---------------

第三部分

第10章 Python语句简介

1. Python是面对过程的、基于语句的语言。

2. 程序由模块构成。模块包含语句。语句包含表达式。表达式建立并处理对象。

3. 说明：print在3.0中不是语句而是内置的函数调用。 yield实际上是一个表达式而不是语句。

4. 作为脚本语言，Python的目标之一就是让程序员少打些字让生活轻松点。

5. 所有Python的复合语句都是首行以:结尾。

6. 括号是可选的。终止行就是终止语句。缩进的结束就是代码块的结束。

7. 两个嵌套代码块的缩进可以完全不同。不应该在同一段Python代码中混合使用制表符和空格。

8. 可以让一个语句的范围跨多行，只需要一对括号。语句将一直运行，直到Python遇到包含闭合括号的那一行。不提倡使用反斜线跨行。

9. Python中，做Python程序员该做的事，不要做C程序员做的事。

10. 只有简单语句可以跟在冒号后面。有一个例外。

11. 字符串对象的isdigit方法可以检查字符串的内容。

12. 在Python中，else可出现在if语句中，也可以出现在try以及循环中（包括while和for）--其缩进会告诉你它属于哪个语句。

13. 如果想要支持输入浮点数而不只是整数，使用try将比手动的错误检测容易得多--可直接运行一个float调用并捕获其异常，而不是试图分析所有可能的浮点语法。

---------------

本章习题

1. 类C语言中需要哪三项在Python中省略了的语法成分？

2. Python中的语句一般是怎样终止的？

3. 在Python中，嵌套代码块内的语句一般是如何关联在一起的？

4. 你怎么让一条语句跨过多行？

5. 你怎么在单个行上编写复合语句？

6. 有什么理由要在Python语句末尾输入分号呢？

7. try语句是用来做什么的？

8. Python初学者最常犯的编写代码的错误是什么？

---------------

第11章 赋值、表达式和打印

1. Python变量更像是指针，而不是数据存储区域。

2. 一旦赋值了，每当这个变量名出现在表达式时，就会被其所引用的值取代。

3. 模块导入、函数和类的定义、for循环变量以及函数参数全都是隐式赋值运算。因为赋值语句在任何出现的地方的工作原理都相同，所有这些环境都是在运行时把变量名和对象的引用值绑定起来而已。

4. 语句执行时，Python会建立临时的元组，来存储右侧变量原始的值。

5. 从技术的角度来讲，序列赋值语句实际上支持右侧任何可迭代的对象，而不仅局限于任何序列。

6. 通常，并且在Python 2.X中总是如此：赋值目标中的项数和主体的数目必须一致。

7. 可以赋值嵌套序列。

8. 可以利用已经形状取出数据结构的组成成分。在for循环中也有效。

9. Python 3.0 的扩展序列解包：1）在目标中使用单个星号来通用匹配；2）左边的目标中的项数不需要与主体序列的长度匹配；3）当带星号的名称出现在中间，它收集其他列出的名称之间的所有内容；4）不管带星号的名称出现在哪里，包含该位置的每个未赋值名称的一个列表都将赋给它；5）总会赋一个列表，可以为空。

10. 增加赋值语句（+=）的优点：1）输入减少；2）通常执行更快；3）优化技术会自动选择，对于支持原处修改的对象而言，增强形式会自动执行原处的修改运算，而不是相对更慢的复制。例如：Python会自动调用较快的extend方法，而不是使用较慢的 + 合并运算。

11. 变量命名：区分大小写。禁止使用保留字。注意不同版本的差异：

Python 3.0 的保留字：False class finally is return None continue for lambda try True def from nonlocal while and del global not with as elif if or yield assert else import pass break except in raise

Python 2.6 与之相比：print exec 都是， nonlocal 不是

Python 2.6 之前：with as 都不是，直到上下文管理器（异常处理的新形式）出现。

Python 2.3 之前：yield不是

12. 无法对保留字做赋值运算。

13. 命名惯例。解释器惯例：1）以单一下划线开头的变量名（_X）不会被 from module import *  语句导入；2）前后有下划线的变量名（__X__）是系统定义的变量名，对解释器有特殊意义；3）以两下划线开头、但结尾没有两个下划线的变量名（__X）是类的本地变量；4）通过交互模式运行时，只有单个下划线的变量名（_）会保存最后表达式的结果。 程序员惯例：1）类变量名通常以一个大写字母开头；2）模块变量名以小写字母开头；3）self虽非保留字，但在类中角色特殊。

14. 变量名没有类型，但对象有。        （变量只是对象的引用值。没有不可变的观念，也没有相关联的类型信息，除了它们在特定时刻碰巧所引用的对象的类型。）

15. 变量名也会存在于所谓的作用域内，作用域定义了变量名在哪里可以使用；对一个名字赋值的地点，决定了它在哪里可见。

16. PEP 8 只适合做指南，而不是真理。

17. 虽然表达式在Python中可作为语句出现，但语句不能用作表达式。

18. 对列表调用append, sort, reverse这类在原处的修改的运算，一定是对列表做原处的修改，但在修改后不会把列表返回。事实上，它们返回的是None对象。

--打印操作--

19. 从技术角度讲，print打印是把一个或多个对象转换为其文本表达形式，然后发送给标准输出或另一个类似文件的流。因此，和文件方法不同，在打印操作时，不需要把对象转换为字符串。

20. 标准输出流通常映射到启动Python程序的窗口，除非它已经在操作系统的shell中重定向到一个文件或管道。

21. Python 3.0中print函数的语法：  print([object,...][, sep=' '][, end='\n'][, file=sys.stdout])。 sep是在每个对象的文本之间插入的；带有一个类似文件的write(string)方法的任何对象都可以传递给file，但真正的文件应该已经为了输出而打开；要打开的每个对象的文本表示，通过把该对象传递给str内置函数调用而获得。

22. 有可能把sys.stdout重新赋值给标准输出流以外的东西。甚至可以将其重设为非文件的对象，只要该对象有预期的协议。当该对象是类时，打印的文字可以定位并通过任意方式进行处理。这种重设输出列表的技巧主要用于程序原本是用print语句编写的情况。

22. sys模块中的 __stdout__ 属性，指的是程序启动时sys.stdout的原始值。重设使用完成后，应该把sys.stdout恢复成sys.__stdout__从而回到原始的值。

23. 在Python 2.6中，当print语句以 >> 开始，后面再跟着输出的文件对象（或其他的兼容对象）时，会有同样的效果。

---------------

本章习题

1. 举出三种可以把三个变量赋值成相同值的方式。

2. 将三个变量赋值给可变对象时，你可能需要注意什么？

3. L = L.sort() 有什么错误？

4. 怎么使用print语句来向外部文件发送文本？

---------------

第12章 if测试和语法规则

1. 字典也可以包含函数，从而代表更为复杂的分支动作，并实现一般的跳跃表格。这类函数作为字典的值，通常写成函数名或lambda，通过增加括号调用来触发其动作。

2. 编写代码时的原则：有疑虑的时候，就遵循简易性原则和可读性原则。

3. 混合使用制表符和空格时，Python 3.0会产生错误。Python 2.6 有一个-t命令行标志会警告制表符用法不一致，-tt标志会产生错误。

4. 相邻的字符串常量是隐式地连接起来的，当它与前面提到的开放对规则一起使用时，把这个结果包含到圆括号中就可以允许它跨越多行。

5. 比较和相等测试会递归地应用在数据结构中。比较和相等测试会返回True和False。布尔and 和 or运算符会返回真或假的操作对象，而不是True或False。

6. 常见Python编码手法之一：从一个固定大小的集合中选择非空的对象（只要将其串在一个or表达式中即可）。

7. 可以用 __bool__或 __len__ 方法指定其布尔特性（在Python 2.6中 __bool__叫做 __nonzero__）。如果前者通过返回一个长度为0而成为空缺的并指定为假的对象的话（一个空的对象看做是假），将测试后者。

---------------

本章习题

1. 在Python中怎样编写多路分支？

2. 在Python中怎样把if/else语句写成表达式？

3. 怎样使单个语句横跨多行？

4. True和False这两个字代表了什么意义？

---------------

第13章 while 和 for循环

1. 循环的else块：只有当循环正常离开时才会执行（没有碰到break语句）。

2. Python 3.0允许在可以使用表达式的任何地方使用...来省略代码。省略号可以和语句头出现在同一行，并且，如果不需要具体类型的话，可以用来初始化变量名。

3. 和循环else语句结合时，break语句通常可以忽略其他语言中所需的搜索状态标志位。

4. for在Python中是一个序列迭代器：可以遍历任何有序的序列对象内的元素。

5. for首行中用作赋值目标的变量名可以在循环主体中修改，但是，当控制权再次回到循环顶端时，就会自动被设成序列中的下一个元素。

6. for循环中的元组赋值通常和zip调用一起使用，以实现并行遍历。

7. 在Python中，元组赋值通常和SQL数据库一起使用，查询结果--外围的列表就是数据库表，嵌套的元组是表中的行，元组赋值和列对应。

8. 序列赋值例： for ((a,b),c) in [([1,2],3),['xy',6]]: print (a,b,c)

9. Python 2.x的分片与Python 3.0的星号提取嵌套部分的差别：分片返回一个特定类型的结果，星号名称总是赋值一个列表。

10. 文件结尾， char = file.read(1) , if not char: break

11. 两个定制迭代的内置函数：内置range函数返回一系列连续增加的整数，可作为for中的索引；内置zip函数返回并行元素的元组的列表，可用于在for中遍历数个序列。

12. 如果想要明确掌控索引逻辑，可以用while代替for循环。

13. 除非有特殊的索引需求，不然在可能的情况下，最好使用Python中的简单的for循环，不要用while，并且不要在for循环中使用range调用，只将其视为最后的手段。更简单的办法总是更好的。 例： for i in range(0, len(S), 2):   -> for c in S[::2]:。使用range唯一的真正优点是--它没有复制字符串中，并且不会在3.0中创建一个列表，对于大字符串来讲，会节省内存。

14. 可以使用range 和for 组合的常见场合就是在循环中遍历列表时并对其进行修改。

15. zip可以接受任何类型的序列（其实就是任何可迭代的对象，包括文件），并且可以有两个以上的参数。当参数长度不同时，zip会以最短序列的长度为准来截断所得到的元组。例：list(zip(T1,T2,T3))， dict(zip(keys,vals))。

16. enumerate函数返回一个生成器对象。这个对象有一个 __next__ 方法，由下一个内置函数调用它。

---------------

本章习题

1. while 和 for之间的主要功能区别是什么？

2. break和continue之间有何区别？

3. 一个循环的else分句何时执行？

4. 在Python中怎样编写一个基于计数器的循环？

5. 怎样使range 用于 for循环中？

---------------

 第14章 迭代器和解析 第一部分

1. 可迭代对象包括实际序列和按照需求而计算的虚拟序列。

2. 文件迭代器的__next__与 readline()效果相同，区别在于，到达文件末尾时，__next__会引发内置的 StopIteration异常，而不是返回空字符串。

3. Python的迭代协议：有 __next__方法的对象会前进到下一个结果，而在这一系列结果的末尾时，则会引发 StopIteration。

4. 从技术角度讲，当for 循环开始时，会通过它传给iter 内置函数，以便从可迭代对象中获得一个迭代器，返回的对象含有需要的next方法。例：L = [1,2,3] \n I = iter(L) \n  I.next() 。而对于文件来讲，不需要调用 iter方法，因为文件对象就是自己的迭代器。  例： f = open('xxx') \n iter(f) is f 返回True。

5. 列表以及很多其他的内置对象，不是自身的迭代器，因为它们支持多次打开迭代器。

6. 注意自动和手动迭代之间的对等性。

7. 在最近的Python版本中，字典有一个迭代器，在迭代环境中，会自动一次返回一个键。

8. 列表解析产生一个新的列表对象。要运行列表解析表达式，Python在解释器内部执行一个遍历L的迭代，按照顺序把x赋给每个元素，并且收集对各元素运行左边的表达式的结果。

9. 列表解析比手动的for循环语句运行的更快，因为它们的迭代在解释器内部是以C语言的速度执行的，而不是以手动Python 代码执行的，特别是较大的数据集合，这是使用列表解析的一个主要的性能优点。

10. 当我们开始考虑在一个序列中的每项上执行一个操作时，都可以考虑使用列表解析。

11. map是一个内置函数，它把一个函数调用应用于传入的可迭代对象中的每一项。它比列表解析的局限在于它需要一个函数而不是一个任意的表达式。在Python 3.0中，返回一个可迭代的对象自身。

12. sorted排序可迭代对象中的各项，zip组合可迭代对象中的各项， enumerate根据相对位置来配对可迭代对象中的项， filter选择一个函数为真的项， reduce 针对可迭代对象中的成对的项运行一个函数。 （sorted在3.0返回一个真正的列表而不是一个可迭代对象）

13. sum 计算任何可迭代对象中的总数，如果一个可迭代对象中任何的或所有的项为真的时候，any和 all内置函数分别返回 True， max和 min分别返回一个可迭代对象中最大和最小的项。

14. Python的内置工具集中从左到右地扫描一个对象的每项工具，都定义为在主体对象上使用了迭代协议。

15. Python 3.0中的新的可迭代对象：

1)range迭代器：range内置函数返回一个迭代器，根据需要产生范围中的数字，而不是在内存中构建一个结果列表。range对象只支持迭代、索引以及len函数。

2)map,zip和filter迭代器：对应的3个内置函数都是自己的迭代器，在遍历一次后，它们就用尽了。

3）字典视图迭代器：keys, values, items返回可迭代的视图对象。视图项保持和字典中的那些项相同的物理顺序，并且反映对底层的字典做出的修改。

4)多个迭代器vs单个迭代器：range对象不是自己的迭代器，并且，它支持在其结果上的多个迭代器，这些迭代器会记住它们各自的位置。通过针对iter调用返回一个新对象，可支持多个迭代器；单个迭代器一般意味着一个对象返回自身。 生成器函数和表达式的行为就像map和zip一样支持单个的活跃迭代器，而不是像range一样。

16. 使用yield语句，用户定义的函数可以转换为可迭代的生成器函数。 当编写在圆括号中的时候，列表解析转变为可迭代的生成器表达式。用户定义的类通过 __iter__ 或 __getitem__ 运算符重载变得可迭代。

---------------

本章习题

1. for 循环和迭代器之间有什么关系？

2. for 循环和列表解析之间有什么关系？

3. 举出Python中的4种迭代环境。

4. 如今从一个文本文件逐行读取行的最好方法是什么？

---------------

第15章 文档

1. 内置的dir函数是抓取对象内可用所有属性列表的简单方式。它能够调用任何有属性的对象。

2. 任何内置类型的dir结果都包含了一组属性，这些属性和该类型的实现相关（从技术角度来讲，就是运算符重载的方法）。它们的开头和结尾都是双下划线，从而保证其独特性。

3. str和list作为Python的类型名称，被调用时，会启用其构造函数，从而产生该类型的实例。

4. Python支持可自动附加在对象上的文档，而且在运行时还可保存查看。从语法上来说，这类注释是写成字符串，放在模块文件、函数以及类语句的顶端，就在任何可执行程序代码前。Python会自动封装该字符串，使其成为对应对象的__doc__属性。

5. 这个文档协议的重点在于，注释会保存在__doc__属性中以供查看（文件导入之后）。目前文档字符串的结构没有标准。

6. 标准PyDoc工具是Python程序代码，知道如何提取文档字符串并且自动提取其结构化的信息，并将其格式化成各种类型的排列友好的报表。

7. 两种最主要的PyDoc接口是内置的help函数和PyDoc GUI/HTML接口。

8. help产生的文字报表中的信息，有的是文档字符串，有些（例如，函数调用模式）是PyDoc自动查看对象内部而收集的结构化信息。

9. 使用PyDocr GUI接口。1）启动PythonTools目录下的pydocgui.pyw脚本（或 执行 pydoc.py -g）；2）使用搜索引擎GUI，输入模块名称，或不使用名称，而是按下"open browser" 来查看所有可用的模块（包括Python标准库模块、已安装的第三方扩展模块、位于导入搜索路径上的用户定义模块以及静态或动态连接的C程序模块）；3）和help函数接口一样，GUI接口也能用在用户定义的模块上。     

10. 标准手册集中的两个重要项目：Library Reference（说明内置类型、函数、异常以及标准库模块）和 Language Reference （提供语言层次的结节的官方说明）。                                                                                                                                                  

11. 函数也是对象，只是有特殊的运算--(通过括号触发对它的调用)。

---------------

本章习题

1. 在什么时候应该使用文档字符串而不是#注释？

2. 举出3种查看文档字符串的方式。

3. 如何获得对象中可用属性的列表？

4. 如何获得计算机中所有可用模块的列表？

5. 阅读本书之后，你应该买哪本Python书籍？

---------------

第三部分练习题

...

---------------

第四部分 函数

第16章 函数基础

1. 函数是Python为了代码最大程序的重用和最小化代码冗余而提供的最基本的程序结构。

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

。