笨办法学Python3（Learn Python3 The Hard Way 中文版）

python 编程入门 python入门

译者注： 本书是基于 Zed Shaw 编写的《Learn Python 3 The Hard Way》一书所做的中文译注版。该中文版由“爱学习的ai酱”（微信号：xuexii2018）友情翻译，并在翻译和学习过程中对部分练习添加了批注，以帮助大家在入门 python 的旅途中更好地避坑。该翻译内容在简书/知乎（搜索“爱学习的ai酱”）也有发布，内容仅供学习交流使用，严禁用于商业行为。

目录

前言

这本简单的小书是为了让你开始编程。虽然书名说是“笨办法”，但其实不然。所谓“笨办法”只是本书教授的方法，也就是按照我的要求重复做一系列的练习来构建你的技能。这种方法对于零基础想要掌握基本编程技能的人来说非常有效，它几乎被用于所有的学习，从武术、音乐，到基础数学和阅读技巧。

这本书指导你通过练习和记忆逐渐建立起 Python 的使用技巧，然后用在更复杂的问题上。学完本书，你将会拥有开始学习更复杂编程所需的工具。我很喜欢告诉别人，我的书可以让你拥有“编程黑带”，也就是你已经掌握要开始学习编程的最基本的知识。

如果你肯努力，肯花时间来建立起这些技巧，你将可以正式学习编程。

第四版更新

《笨办法学 Python》第四版用了 Python 3.6。Python 3.6 升级了字符串格式系统，相比于之前的 4 或者 4 更好用，虽然对于初学者来说，学习 Python 3.6 会有很多问题，一个很明显的问题就是它的报错信息非常少，但是我将会帮助你理解从而解决这些问题。

同时，我也根据我过去五年来教授 Python 的经验，更新了视频课程。过去的视频只是简单地让你看着我做练习，而第四版加入了打乱再重新修复的练习，这个技巧叫做“调试”（debuging），它将会叫你如何修复你遇到的问题以及 Python 是如何运行你创建的程序。这个新方法的目标就是建立一种关于 Python 如何运行代码的思维模式，从而能够更容易看出来哪里出了问题。此外，你还会学到很多有用的调试错误程序的有用技巧。

最后，第四版从头到尾完全支持 Windows 10，以前版本更多地专注于基于 Unix 的系统比如 MacOS 和 Linux。而当我开始写第四版的时候微软已经开始认真对待开源工具和开发者，因为作为一个严肃的 Python 开发平台，真的很难忽略他们。视频教程将着重讲解 Windows 系统下 Python 的使用，当然也会展示 MacOS 和 Linux 系统下的操作。我将会告诉你每个平台的安装教程以及其他相关的技巧。

致谢

我想感谢 Angela 在这本书的前两版中对我的帮助，没有她我可能很难完成。她做了第一版的复制编辑工作，并且在我写作的过程中给我提供了极大的支持。

我同样要感谢 Greg Newman 为我设计封面，Brian Shumate 所做的网站设计，以及所有读过这本书并花时间给我反馈和更正意见的读者。

谢谢你们。

笨办法更简单

在这本书的帮助下，你将会做所有程序员学习一门编程语言都会做的非常简单的事情：

1. 做好每一个练习；
2. 准确敲好每一个程序；
3. 让它运行。

就是这样。刚开始可能会比较难，但坚持下去。如果你通读了这本书，每晚花个一两小时做做习题，你将能够为自己读下一本编程书打下良好的基础。这本书不会让你一夜之间变成程序员，但是它将会带你走上学习如何编程的道路。

这本书的目的是教会你作为编程新手所需的三种最重要的技能：读和写、注重细节、发现不同。

一、读和写

如果你连打字都不行，那你学习编程也会成问题。尤其如果你连程序源代码中的那些奇怪字符都打不出来，就别提编程了。没有这些基本技能，你将连最基本的软件工作原理都难以学会。

所以，把代码示例打出来并运行，能够帮助你学习各种符号的名称、更熟练地敲出来、以及读懂编程语言。

二、注意细节

区分好程序员和差程序员的一个重要标准，就是对细节的注重程度，事实上，这也是任何行业区分好坏的标准。如果缺乏对工作中每个微小细节的注意，你的工作成果将缺乏重要的元素。拿编程来讲，主意细节将会让你远离各种bug和难用的系统。

通过这本书的学习，以及准确打出每一个例子，你将能够训练你的大脑，在做练习的时候更多地关注细节。

三、发现不同

程序员长年累月的工作会培养出一个重要技能，那就是对于不同点的区分能力。一个有经验的程序员看到两个仅有细微差别的程序，可以立即指出其中的不同。程序员还造出工具来让这件事更加容易，不过我们不会用到这些工具。你要先用笨办法训练自己，然后再用工具。

在你做这些练习并敲代码的时候，你一定会出错。这是不可避免的，即使有经验的程序员也会偶尔写错。你的任务是把自己写的东西和要求的正确答案对比，把所有的不同点都修正过来。这样做可以让你对程序里的错误、bug 以及其他问题更加敏感。

四、要问，不要盯着看

你只要写代码，就会出现 bug。Bug 意味着你写的代码有瑕疵、有错误、或者有问题。Bug 来源于一个传说，从前有一只飞蛾飞进了第一台计算机，造成了故障。修复它就需要“debugging”。在软件世界里，有着不计其数的 bug。

就像第一只飞蛾，你的 bugs 将会藏在你代码的某处，你必须找到它们。你不能只是坐在电脑前盯着屏幕上的代码，希望答案能自己跳出来。这样做不会有额外的信息，你需要额外的信息来解决问题，所以你得起来寻找这只飞蛾。

怎么寻找呢？你需要审问你的代码，问它现在是怎么回事儿，或者从另一个不同的视角去看待这个问题。在这本书里，我将会频繁地告诉你“别盯着看，要问”。我将会向你演示如何让你的代码告诉你正在发生的一切，并且如何找到可能的解决方案。我还会教你一些从不同角度看代码的方法，让你能够获取更多信息和洞见。

五、不要复制粘贴

你必须手动将每个练习打出来。复制粘贴会让这些练习变得毫无意义。这些习题的目的是训练你的双手和大脑思维，让你有能力读代码、写代码、观察代码。如果你复制粘贴，那你就是在欺骗自己，这些练习的效果也将大打折扣。

六、一个关于坚持练习的忠告

在你通过这本书学习编程时，我正在学习弹吉他。我每天至少练习 2 个小时，至少花一个小时练习音阶、和声、和弦，剩下的时间用来学习音乐理论和歌曲演奏以及训练听力等。有时我一天会花 8 个小时来练习，因为我觉得这是一件有趣的事情。对我来说，重复性练习是学好一样东西最自然而然的方法。并且我深知，要掌握一件事情，只有每天坚持练习。虽然有时候，我整个人状态很差（甚至经常这样），或者觉得实在太难。没关系，坚持尝试，到最后你会发现它越来越简单，并且开始越来越有趣。

在我写《笨办法学 Python》和《笨办法学 Ruby》的过程中，我发现了绘画的乐趣。我在自己 39 岁的时候爱上了这门视觉艺术，并且像学习吉他、音乐和编程一样每天花时间学习画画。我收集了相关的教材，并且按照书中所说，每天坚持画，同时专注于享受这种学习过程的乐趣。我完全不是一个艺术家，甚至差得很远，但我现在至少可以说我会画画了。我学习画画的方法就跟我在这本书里教你的一样。如果你把整个问题分解为一个个小练习和课程，并且每天做，你就可以学会几乎所有的东西。如果你专注于细微的进步，并且享受学习过程，你将会从中获益，无论你最后擅长到何种程度。

当你通过这本书学习编程的时候，要记住任何值得做的事情一开始都是困难的。也许你是一个害怕失败的人，一碰到困难就想放弃；也许你是一个缺乏自律的人，一碰到“无聊”的事情就不想上手；也许因为有人夸你“天赋异禀”而让你自视甚高，不愿意做这些看上去很笨拙的事情，怕有负你”神童”的称号；也许你太过激进，把自己跟有 20 多年经验的编程老手相比，让自己失去了信心。

无论是什么原因让你想要放弃，你一定要坚持下去。如果你碰到做不出来的课后练习，或者碰到一节看不懂的练习，你可以暂时跳过去，过一阵子回来再看。只要坚持下去，你总会弄懂的，因为编程的过程中总是会出现这样的问题。

一开始你可能什么都看不懂。这会让你感觉很不舒服，就像学习人类的自然语言一样。你会发现很难记住一些单词和特殊符号的用法，而且会经常感到很困惑。但是突然有一天，你一下子变得豁然开朗，以前不明白的东西忽然就明白了。如果你坚持练习下去，坚持去上下求索，你最终会学会这些东西。你可能不会成为一位编程大师，但你至少会明白程序是怎么运行的。

如果你放弃的话，你将永远达不到那种“豁然开朗”的时刻。你会在第一次碰到不明白的东西时（一开始就是所有东西）就选择放弃。如果你坚持尝试，坚持练习下去，坚持去弄懂习题的话，你最终一定会明白其中的内容。

如果你通读了这本书，却还是不知道怎么编程，那也没关系，至少你试过了。你可以说你已经尽过力但成效不佳，但至少你试过了。这也是一件值得你骄傲的事情。

练习0 配置环境

这个练习没有代码。它只是为了让你的计算机准备好运行 Python。你应该严格按照步骤来。（如果配置过程中遇到问题，可以在公众号“学习癌”后台留言，小编会为你答疑解惑。）

MacOS

做如下任务以完成练习:

1. 去 https://www.python.org/downloads/release/python-360/ 上下载 “macOS 64-bit/32-bit installer”，像安装其他软件一样安装它。
2. 去 https://atom.io/ 下载 Atom 文本编辑器, 然后安装。如果你用不惯 Atom，可以在这个练习的最后选择其他可用的编辑器。
3. 把 Atom 放在 Dock 中，以便快速打开。
4. 用苹果电脑搜索功能找到你的 Terminal 程序，找不到的话就想想办法，你可以的。
5. 把 Terminal 也放在 Dock.
6. 运行 Terminal 程序，它看起来不咋滴。
7. 在 Terminal 中运行 python3.6。在 Terminal 中运行程序只需要输入程序名然后敲 Return 即可。
8. 输入 quit(), Enter, 然后退出 python3.6。
9. 你应该回到你输入 python 之前看到的提示界面，如果不是，弄明白是什么原因。
10. 学会如何在 Terminal 中创建目录。
11. 学会如何在 Terminal 中切换目录。
12. 用你的编辑器在这个目录下创建一个文件，你可以先在编辑器里编辑，然后点击“保存”或者“另存为”，选择你创建的目录文件夹。
13. 用键盘快捷键切换回 Terminal 程序。
14. 回到 Terminal 后，用 ls 列示目录以查看你新建的文件。

0.1.1 MacOS: 你应该看到的

这是我在自己苹果电脑 Terminal 终端操作完的会话。你的可能会稍有不同，但大体应该是差不多的。

$ python3.6
    Python 3.6.0 (default, Feb	2 2017, 12:48:29)
    [GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang -700.1.81)] on darwin
    Type "help", "copyright", "credits" or "license" for more information
    >>>
    ~ $ mkdir lpthw
~ $ cd lpthw
    lpthw $ ls
# ...   Use your text editor here to edit test.txt....
lpthw $ ls
    test.txt lpthw $

Windows

1. 用浏览器访问 https://atom.io，下载 Atom 并安装，你可能需要用管理员身份运行。
2. 把 Atom 放在桌面或者快速启动栏以便快速访问，这些都可以在安装的时候进行设置。
   注：如果你的电脑运行很慢，打不开 Atom，你可以在本练习最后选择其他编辑器。
3. 在开始菜单搜索 Powershell，回车，运行。
4. 在桌面创建 Powershell 快捷键，或者把它添加到快速启动栏以方便打开。
5. 运行 Powershell （我之后会称它为 Terminal），它看起来不咋滴。
6. 从 https://www.python.org/downloads/release/python-360/ 下载 Python 3.6 然后安装。记得勾选“把 Python 3.6 添加到路径”（add Python 3.6 to your path）复选框。
7. 在 Powershell （Terminal）中输入 python 并回车，以运行 Python。
   注：如果你输入 Python 但它没有运行，你需要重新安装 Python 并确保在安装过程中勾选了“把 Python 3.6 添加到路径”（add Python 3.6 to your path）复选框。
8. 输入 quit() 以退出 Python。
9. 你应该回到你输入 python 之前看到的提示界面，如果不是，弄明白是什么原因。
10. 学会如何在 Powershell 中创建目录。
11. 学会如何在 Powershell 中切换目录。
12. 用你的编辑器在这个目录下创建一个文件，你可以先在编辑器里编辑，然后点击“保存”或者“另存为”，选择你创建的目录文件夹。
13. 用键盘快捷键切换回 Powershell 程序。
14. 回到 Powershell 后，用 ls 列示目录以查看你新建的文件。

从现在起，当我说“Terminal”或“Shell”时指的就是 Powershell。当我让你运行 Python 3.6 的时候你只用输入 python 即可。

1.2.1 Windows: 你应该看到

> python
>>> quit()
> mkdir lpthw
> cd lpthw
... Here you would use your text editor to make test.txt in lpthw
>
> dir
 Volume in drive C is
 Volume Serial Number is 085C—7E02

 Directory of C:\Documents and Settings\you\lpthw

04.05.2010  23:32   <DIR>   .
04.05.2010  23:32   <DIR>   ..      
04.05.201 0 23:32           6   test.txt
               1    File(s) 6 bytes
               2    Dir(s)  14 804 623 360 bytes free

>

如果你的显示跟我的略有不同也是正确的，但是大体上应该是一样的。

Linux

Linux 系统五花八门，软件安装方式也各不相同。我假设如果你用的是 Linux，你是知道如何安装软件包的，下面是你的操作步骤：

1. 用你的安装包管理器（package manager）安装 Python 3.6，如果无法安装，就从 https://www.python.org/downloads/release/python- 360/ 上下载并安装。
2. 用你的安装包管理器安装 Atom 编辑器。如果 Atom 不好用，你可以选择本练习最后的其他编辑器。
3. 把 Atom 放到你的窗口管理（window manager）菜单，以方便快速访问。
4. 找到你的 Terminal 程序，它可能叫 GNOME Terminal、Konsole、或者 xterm。
5. 把你的 Terminal 也放在 Dock。
6. 运行你的 Terminal 程序，它看起来不咋滴。
7. 在你的 Terminal 程序中输入 python3.6 以运行 Python 3.6。如果无法运行，试试输入 python。
8. 输入 quit() 然后敲 enter 退出 Python。
9. 你应该回到你输入 python 之前看到的提示界面，如果不是，弄明白是什么原因。
10. 学会如何在 Terminal 中创建目录。
11. 学会如何在 Terminal 中切换目录。
12. 用你的编辑器在这个目录下创建一个文件，你可以先在编辑器里编辑，然后点击“保存”或者“另存为”，选择你创建的目录文件夹。
13. 用键盘快捷键切换回 Terminal 程序。
14. 回到 Terminal 后，用 ls 列示目录以查看你新建的文件。

0.3.1 Linux: 你应该看到

$ python
    >>> quit()
    $ mkdir lpthw
$ cd lpthw
    # ...	Use your text editor here to edit test.txt ...
    $ ls test.txt
$

如果你的显示跟我的略有不同也是正确的，但是大体上应该是一样的。

从网上找答案

这本书中很重要的一部分就是要学会从网上搜索编程相关的东西。我会告诉你“从网上搜索”，你需要做的就是用搜索引擎找到答案。我之所以不直接告诉你答案而是让你自己去找，就是为了让你成为一个独立的学习者，能够自己从网上找到答案而不依赖于书本，这是我的目标。

给初学者的忠告

这个练习已经结束了，它的难易程度可能取决于你对你电脑的熟悉程度。如果你觉得很难，试着花时间去学习和克服困难，因为只有攻克了这些最基础的东西，你才能继续学习更多的编程技能。

如果有人告诉你学到这本书的某个练习就可以停下来，或者跳过某些练习，别去相信。任何对你隐瞒知识的人，或者更糟糕——让你从他们那里获得知识而不是通过你自己的努力去获取，都是在让你对他们形成依赖。别听他们的，老老实实地做这些练习，从掌握自我学习的本领。

程序员可能会让你用 MacOS 或者 Linux，因为他们很喜欢苹果电脑的字体和排版设计，或者觉得用 Linux 很酷。别听他们的，用你现在正在用的电脑系统就行，你需要的就是一个编辑器，一个终端，还有 Python。

最后，这个练习的目的就是为了让你准备好这三样东西，以便做后面的练习：

1. 用文本编辑器写练习。
2. 运行你写的练习。
3. 如果出错就试着修复。
4. 重复。

其他事情可能会烦扰到你，所以坚持按照以上计划来。

其他可选编辑器

文本编辑器对程序员来说非常重要，但是作为初学者，你只需要一个简单的编辑器即可。我推荐 Atom 是因为它是免费的，而且几乎在任何系统上都能运行。但是，Atom 可能不适合你的电脑，所以你也可以选择以下这些编辑器：

以上这些编辑器是根据好用程度排序的。由于这些项目可能被放弃、死掉、或者不再适用于你的电脑。所以如果你试了一个不行，就试试别的。而且以上排序是基于我自己的电脑，对于你的电脑来说情况可能不太一样。

如果你已经知道如何使用 Vim 或者 Emacs，那就放心用。如果你从来没用过，就不要考虑了。程序员可能会努力说服你用 Vim 或者 Emacs，但那只会让你误入歧途。你的目标是学习 Python，而不是学习 Vim 或者 Emacs。如果你尝试使用 Vim 但却不知道如何退出，就输入 :q! 或者 ZZ。

练习 1. 第一个程序

你可能已经花费了大量时间在练习 0 上，学习如何安装一个文本编辑器，运行编辑器以及 Terminal，并且学习如何操作它们。如果你还没有做这些，就不要继续，否则你会后悔的。这种练习前的警告我再说最后一次：不要擅自跳过练习自己往前学。

把下面的本文输入到一个名为 ex1.py 单个文件中，python 文件一般以 .py为后缀。

ex1.py

1   print("Hello World!")
2   print("Hello Again")
3   print("I like typing this.")
4   print("This is fun.")
5   print('Yay! Printing.')
6   print("I'd much rather you 'not'.")
7   print('I "said" do not touch this.')

你的 Atom 文本编辑器应该看起来像这样：

如果你的编辑器看起来不完全一样也不用担心，只要大体一致就行。

当你敲这个文件时，你得明白：

1. 左边这些数字不是我敲上去的，它印在书上是为了讲解的时候方便说明。比如“看第 5 行...”之类，所以不要把行数敲进 Python 脚本里。
2. 我输出的结果跟我在练习 1 的 ex1.py 中让你们输入的内容是一模一样的，而不是大致相同。所以每一个字符你都要严格按照我的要求来输入，当然颜色无所谓。

在终端这样输入就可以运行你的 Python 文件：

python3.6 ex1.py

如果你都做对了，你就会看到和我一样的结果，如果没有，你肯定是哪里出错了。不，相信我，不是电脑的问题。

你应该看到

在 MacOS 的 Terminal 上你应该看到这样的结果：

在 Windows 的 Powershell 上你应该看到这样的结果:

你可能会在 python3.6 命令行前面看到不同的名字，这不重要，重要的是你输入的命令要输出跟我一样的结果。

如果你出错了你可能会看到这个：

$ python3.6 python/ex1.py
File "python/ex1.py" , line 3
print (" I like typing this.
                                   ^
SyntaxError : EOL while scanning string literal

能读懂这些错误信息很重要，因为你接下来可能会出现很多这种错误，我也是。让我们一行一行来看。

1. 我们在 Terminal 运行 ex1.py 脚本。
2. Python 告诉我们 ex1.py 文件的第三行出错了。
3. 它把第三行的代码打印出来以便我们查看。
4. 然后它放了一个 ^ （插入符号）来指出哪里出了问题。注意到那个缺失的 " 了吗？
5. 最后，它输出“SyntaxError”，并告诉我们可能的错误信息。通常这些错误信息都比较隐晦，但是如果你用搜索引擎搜索以下，你就会发现别人也遇到过这样的错误，然后你很可能就会找到问题的解决办法。

课后练习

这个课后练习包括一些你应该尝试去做的东西，如果你不会，可以先跳过，随后再拐回来做。

对于这个练习，试试以下操作：

1. 让你的脚本再打印出一行。
2. 让你的脚本只打印一行。
3. 在任一行的开头放一个 # ，看看会发生什么？试着弄明白这个符号的作用。

从现在开始，我不会解释每个练习都是如何工作的，除非遇到特殊情况。

常见问题

以下是实际学习本节练习过程中学生们经常会问到的一些问题：

我能用 IDLE 吗？不，你应该用 Terminal 或者 Powershell。如果你不知道怎么用，就去学习附录 A 的命令行速成教程。

我怎么才能像你一样编辑代码时有颜色？先把你的文件另存为 .py ，比如 ex1.py 。然后你在输入的时候就会有颜色了。

我在运行 ex1.py 时遇到了 SyntaxError：invalid syntax 提示。你很可能是已经运行了 Python，然后又输了一次 python。关闭 Terminal，重新打开，然后只输入 python3.6 ex1.py。

我遇到了 can't open 'ex1.py': [Errno 2] No such file or directory. （“无法打开‘ex1.py’：[错误号 2] 没有该文件或目录”）。你需要和你创建的文件在同一个目录（文件夹）下。你要先使用 cd 命令切换到了那个目录下。比如，如果你把你的文件保存在 lpthw/ex1.py，那你就应该在运行 python3.6 ex1.py 之前先用 cd lpthw/ 切换到 lpthw/ 目录下。如果这段你看不懂，去学附录 A 的命令行速成教程。

我的文件不运行，我只是返回了提示符，没有任何输出。 你很可能以为我让你输入 print("Hello World!")只是让你输 "Hello World!"。并不是，你要完整地、一字不差地把代码敲出来。

练习 2 注释和井号

注释在程序中非常重要，它们可以用自然语言告诉你某段代码的功能时什么，还能在你想要暂时移除某段代码时禁用程序的一部分。以下是如何在 Python 中使用注释：

ex2.py

1   # A comment, this is so you can read your program later.
2   # Anything after the # is ignored by python. 
3
4   print("I could have code like this.") # and the comment after 5
6   # You can also use a comment to "disable" or comment out code
7   # print("This won't run.") 
8
9   print("This will run.")

从现在开始，我都会这样写代码。你得明白不是所有的东西都得在字面上保持一致，你的屏幕和程序可能看起来跟我的不一样，但是只要你在编辑器里输入的文本一样就行。事实上，我用任何文本编辑器都可以输出同样的结果。

你应该看到

练习 2 会话

$ python3.6 ex2.py
I could have code like this. This will run.

再说一次，我之后可能不会将所有的截图都贴出来，你得明白第一个 $ 和最后一个 $ 之间的内容才是你应该关注的。

课后练习

1. 弄清楚 # 符号的作用，而且记住它的名字。(中文为井号，英文为 octothorpe 或者 pound character)。
2. 打开你的 ex2.py 文件，从后往前逐行检查每个单词，与要求输入的内容进行对比。
3. 有没有发现什么错误？有的话就改正过来.
4. 读你写的习题，把每个字符都读出来。有没有发现更多错误？有的话改正过来。

常见问题

为什么在 print("Hi # there.") 里 # 就没有被忽略？ 因为 # 在一个字符串里，计算机会打印引号之间字符串的所有内容， # 在字符串里被认为是一个字符，而不是注释符号。

我如何把很多行变成注释？ 在每一行前面加一个 # 。

为什么我要倒着检查代码？ 这是一个让你的大脑不专注于每行代码意思的小技巧，这样做能够让你更准确地检查出错误，可以说是一个很好用的纠错技巧了。

练习 3 数字和数学

每一种编程语言都得和数字、数学打交道。不用担心：程序员总是自诩为数学天才，其实事实并非如此。如果他们是数学天才，他们就会去研究数学，而不是去写那些 bug 连篇的网站框架以便能开上豪车。

这个练习包含了很多数学符号。让我们看看它们的名字，在你输入的时候，试着说出名字，直到你烂熟于心为止。以下是这些符号的名字：

• + plus，加号
• - minus，减号
• / slash，斜杠
• * asterisk，星号
• % percent，百分号
• < less-than，小于号
• > greater-than，大于号
• <= less-than-equal，小于等于号
• >= greater-than-equal，大于等于号

有没有注意到以上只是些符号，没有运算操作呢？写完下面的练习代码后，再回到上面的列表，弄明白每个符号的作用。例如 + 是用来做加法运算的。

ex3.py

1   print("I will now count my chickens:")
2
3   print("Hens", 25 + 30 / 6)
4   print("Roosters", 100 - 25 * 3 % 4)
5
6   print("Now I will count the eggs:")
7
8   print(3 + 2 + 1 - 5 + 4 % 2 - 1 / 4 + 6)
9
10  print("Is it true that 3 + 2 < 5 - 7?")
11
12  print(3 + 2 < 5 - 7)
13
14  print("What is 3 + 2?", 3 + 2)
15  print("What is 5 - 7?", 5 - 7)
16
17  print("Oh, that's why it's False.")
18
19  print("How about some more.")
20
21  print("Is it greater?", 5 > -2)
22  print("Is it greater or equal?", 5 >= -2)
23  print("Is it less or equal?", 5 <= -2)

确保你在运行它之前准确输入了每一行代码，和我的要求做一下对比检查。

你应该看到

练习 3 会话

$ python3.6 ex3.py
I will now count my chickens: Hens 30.0
Roosters 97
Now I will count the eggs: 6.75
Is it true that 3 + 2 < 5 - 7? False
What is 3 + 2? 5
What is 5 - 7? -2
Oh, that's why it's False. How about some more.
Is it greater? True
Is it greater or equal? True

Is it less or equal? False

课后练习

1. 在每一行上面，用 # 写一句注释，向自己解释这行代码的作用。
2. 还记得你在练习 0 中是如何启动 Python 3.6 的吗？再次启动它，把 Python 当成一个计算器来做一些数学运算。
3. 找一些你需要计算的东西，然后写一个新的 .py 文件。
4. 用浮点数重新写一下 ex3.py，让它更精确一些，比如 20.0 就是一个浮点数。

常见问题

为什么 % 是一个模数，而不是百分比？ 这很可能只是设计者们选用的一个符号。在正常情况下你可以把它读作百分号，但是，在编程中 % 只是一个符号。

% 是如何工作的？ 可以这样讲，x 除以 y 余 J。比如 100 除以 16 余 4，% 求的就是余数 J。

运算顺序是怎样的？ 在美国我们遵循 PEMDAS 规则，即“括号，指数，乘，除，加，减（Parentheses Exponents Multiplication Division Addition Subtraction）。Python 也遵循这样的规则。很多人对 PEMDAS 规则存在误解，认为它们是严格按照先后次序来的，其实并不是，乘除是同时的，加减也是同时的，所以这个规则可能写成 PE(M&D)(A&S) 更合适。

练习 4 变量和名字

现在你已经能用 print 打印东西了，也能用 Python 做数学计算了。接下来我们要学习变量。在编程中，变量就是给某个东西起的名字，就像“写这本书的人”名叫“Zed”一样。程序员用这些变量让代码读起来更像自然语言。如果他们不给软件里面的东西起名字，当他们再次阅读他们写的代码时就会毫无头绪。

如果你在做这个练习的时候卡住了，记得我交给你的技巧，寻找不同点，并专注细节：

1. 在每行代码上面写上注释，跟自己解释这行代码的作用。
2. 倒着读你的 .py 文件。
3. 大声把你的 .py 文件读出来，字符也要读。

ex4.py

1   cars = 100
2   space_in_a_car = 4.0
3   drivers = 30
4   passengers = 90
5   cars_not_driven = cars - drivers
6   cars_driven = drivers
7   carpool_capacity = cars_driven * space_in_a_car
8   average_passengers_per_car = passengers / cars_driven     
9
10
11  print("There are", cars, "cars available.")
12  print("There are only", drivers, "drivers available.")
13  print("There will be", cars_not_driven, "empty cars today.")
14  print("We can transport", carpool_capacity, "people today.")
15  print("We have", passengers, "to carpool today.")
16  print("We need to put about", average_passengers_per_car,
17        "in each car.")

你会看到

练习 4 会话

$ python3.6 ex4.py
There are 100 cars available.
There are only 30 drivers available.
There will be 70 empty cars today.
We can transport 120.0 people today.
We have 90 to carpool today.
We need to put about 3.0 in each car.

附加练习

当我第一次写这个程序的时候我出了一个小错误，Python 是这样告诉我的：

Traceback ( most recent call last ):
   File "ex4.py" , line 8 , in <module>
     average_passengers_per_car = car_pool_capacity / passenger
NameError : name ' car_pool_capacity ' is not defined

用你自己的话解释这段错误信息，要用行号并解释清楚为什么。

更多附加练习：

1. 我给 space_in_a_car 赋予了 4.0 而不是 4，小数部分有必要加吗？如果只写 4 会怎么样？
2. 记住，4.0 是一个浮点数，浮点数就是有小数点的数字，要得到一个浮点数，你就得写成 4.0 而不是 4。
3. 给每一个变量写一些注释。
4. 确定你知道 = 就是给一个变量名（比如cars_driven，passengers）赋一个值（可以是数字、字符串等等）。
5. 记住 _ 是个下划线。
6. 像之前的练习一样把 Python3.6 当做一个计算器来运行，然后用变量名来做运算，比如用得比较多的 i、x、j 等。

常见问题

= 和 == 有什么区别？ = 把右边的值赋给左边的变量。== 用来检测左右两边的东西是不是有同样的值。你会在练习 27 中学到这块内容。

我们能把 x = 100 写成 x=100 吗？ 可以，但这种格式不好，加上空格阅读体验更好。

你说的“倒着读文件”是什么意思？很简单，假如你有一个 16 行代码的文件，从第 16 行开始，和我文件中的第 16 行开始对比，然后是第 15 行等等，直到你把整个文件过完。

为什么给 space_in_a_car 赋值要用 4.0？主要是为了让你知道什么是浮点数，以及问出这个问题，可以参考附加练习。

练习 5 更多变量和打印

现在我们要输入更多的变量并把它们打印出来。这次我们将用一个叫做“格式字符串”的东西。每次你用引号把一段文本引起来，你就是在创建一个字符串。字符串是你让计算机呈现给人看的内容。你可以打印字符串、把字符串保存到文件、或者发送到网络服务器等等。

字符串真的非常方便。你将在这个练习中学习如何创建包含变量的字符串。把你需要的变量放在 {} 里面就可以把变量嵌入在字符串中。你还需要在字符串前面加上字母 f （代表 format），比如 f"Hello, {somevar}"。双引号前面的 f 是为了告诉 python3： “这个字符串需要被格式化，把这些变量放在那儿。”

同样的，输入以下内容，哪怕你不理解，确保准确无误。

ex5.py

1   my_name = 'Zed A. Shaw'
2   my_age = 35 # not a lie
3   my_height = 74 # inches
4   my_weight = 180 # lbs
5   my_eyes = 'Blue'
6   my_teeth = 'White'
7   my_hair = 'Brown'
8
9   print(f"Let's talk about {my_name}.")
10  print(f"He's {my_height} inches tall.")
11  print(f"He's {my_weight} pounds heavy.")
12  print("Actually that's not too heavy.")
13  print(f"He's got {my_eyes} eyes and {my_hair} hair.")
14  print(f"His teeth are usually {my_teeth} depending on the coffee.")
15
16  # this line is tricky, try to get it exactly right
17  total = my_age + my_height + my_weight
18  print(f"If I add {my_age}, {my_height}, and {my_weight} I get {total}.")

你会看到

练习 5 会话

$ python3.6 ex5.py
Let's talk about Zed A. Shaw. He's 74 inches tall.
He's 180 pounds heavy.
Actually that's not too heavy.
He's got Blue eyes and Brown hair.
His teeth are usually White depending on the coffee.
If I add 35, 74, and 180 I get 289.

附加练习

1. 修改所有的变量，把前面的 my_ 删掉。要更改所有的变量名，而不只是有 = 的部分。
2. 试着写一些变量，把英尺（inches）和英镑（pounds）换算成厘米（ centimeters）和千克（kilograms），别自己直接把自己的数据进去，用 python 的数学运算来换算。

常见问题

我能创建一个这样的变量吗：1 = 'Zed Shaw'？不能，1 不是一个有效的变量名。变量名需要以字母开头，比如 a1 就可以，但 1 不行。

我如何给浮点数四舍五入取整数？你可以用 round() 函数，比如：round(1.7333)。

为什么我还是不理解这些代码？试着把这些数字换成你自己的。虽然有点奇怪，但是与你自己相关能够让这些代码看起来更接地气。而且，你还刚开始学习，肯定会有不理解的地方。继续努力，再做一些练习你就会慢慢理解的。

练习 6 字符串和文本

你已经写过字符串了，但你还是不知道它们是用来干嘛的。在这个练习中，我们会创建一些包含复杂字符串的变量，让你看看它们的作用。首先解释一下字符串的含义。

字符串通常是一些你想要让你的程序呈现给别人或者”输出“出来的文本信息。当你把双引号或者单引号括在一段本文外面时，Python 就会知道你想要把这些文本变成字符串。你在学习 print 的时候应该多次看到这种用法了，当你想要打印一些文本的时候，你就把这些文本放在双引号或者单引号里面。

字符串可以包含你的 Python 脚本中任意数量的变量。记住，变量就是让名字 = 一个值的那行代码。在本练习的代码中，types_of_people = 10 创建了一个名称为 types_of_people，值为 10 的变量。你可以用 {types_of_people} 的形式把这个变量放到任意字符串中。你还会看到我用了格式字符串（f-string），就像这样：

f"some stuff here { avariable }"
f"some other stuff { anothervar }"

Python 还有其他种类的格式，就像你在第 17 行看到的 .format() 语法。你还会看到当我想对一个已经创建的字符串应用一种格式的时候，我就会这样用，比如在一个循环里，我们会在后面的内容中涉及到。

我们现在要输入一整段字符串、变量和格式，然后把它们打印出来。你还会练习使用缩写作为变量名。程序员都喜欢使用简短的缩写来节省时间，但是那些缩写在你看来会十分晦涩难懂。所以我们得尽早开始学习阅读和书写这些东西。

ex6.py

1   types_of_people = 10
2   x = f"There are {types_of_people} types of people."
3
4   binary = "binary"
5   do_not = "don't"
6   y = f"Those who know {binary} and those who {do_not}."
7
8   print(x)
9   print(y)
10
11  print(f"I said: {x}")
12  print(f"I also said: '{y}'")
13
14  hilarious = False
15  joke_evaluation = "Isn't that joke so funny?! {}"
16
17  print(joke_evaluation.format(hilarious))
18
19  w = "This is the left side of..."
20  e = "a string with a right side."
21
22  print(w + e)

你会看到

练习 6 会话

$ python3.6 ex6.py
There are 10 types of people.
Those who know binary and those who don't.
I said: There are 10 types of people.
I also said: 'Those who know binary and those who don't.'
Isn't that joke so funny?! False
This is the left side of...a string with a right side.

附加练习

1. 复习一遍这个程序，并在每一行上面写上注释来解释它。
2. 找到所有把字符串放在字符串里面的地方，一共有 4 处。
3. 你确定有 4 处吗？你怎么知道？也许我爱撒谎呢。
4. 解释一下为什么把 w 和 e 两个字符串用 + 连起来能够弄成一个更长的字符串。

把代码打乱

你现在已经可以把代码打乱了。把它当成一个游戏，用一种最聪明或者最简单的方式把代码打乱。打乱之后，你需要修复它们。如果你跟你的朋友一起学习，你们可以相互打乱对方的代码，然后再试着修复它。把你的 ex6.py 发给你的朋友，让他们打乱，然后你再试着找出它们的错误，并修复它。记住，如果你已经写了一遍这些代码了，你可以再写一次。如果你打乱得太彻底了，就试着重新写一遍。

常见问题

为什么你在一些字符串外面放的是单引号，而其他的不是？大多数是因为格式。但是如果一个字符串已经用了双引号，我就会在这个字符串里面用单引号，看看第 6 行和第 15 行你就知道了。

如果你觉得一个笑话很好笑，可以写 hilarious = True 吗？ 可以的，你会在练习 27 中学习到这些布尔值。

练习 7 更多打印

现在我们要做更多的练习，你只用输入代码让它运行即可。我不会做过多的解释，因为跟前面基本是一样的，目的是为了让你建立起自己的技能。千万别跳过，也别复制粘贴！

ex7.py

1   print("Mary had a little lamb.")
2   print("Its fleece was white as {}.".format('snow'))
3   print("And everywhere that Mary went.")
4   print("." * 10) # what'd that do?
5
6   end1 = "C"
7   end2 = "h"
8   end3 = "e"
9   end4 = "e"
10  end5 = "s"
11  end6 = "e"
12  end7 = "B"
13  end8 = "u"
14  end9 = "r"
15  end10 = "g"
16  end11 = "e"
17  end12 = "r"
18
19  # watch that comma at the end. try removing it to see what h
20  print(end1 + end2 + end3 + end4 + end5 + end6, end=' ')
21  print(end7 + end8 + end9 + end10 + end11 + end12)

你会看到

练习 7 会话

$ python3.6 ex7.py
Mary had a little lamb.
Its fleece was white as snow.
And everywhere that Mary went.

..........
Cheese Burger

附加练习

接下来的附加练习基本也跟前面一样：

1. 回过头复习一遍代码，在每一行上面添加注释。
2. 倒着大声把每一行读出来，以发现你的错误。
3. 从现在开始，当你犯错了，就在本子上写下你的错误。
4. 当你学习下个练习之前，看看这些错误，以避免再犯。
5. 记住每个人都会犯错。程序员就像音乐家一样总让别人觉得他们很完美，从不犯错，但其实他们经常犯错。

把代码打乱

在练习 6 中你还喜欢这种方式吗？从现在开始你要打乱你写的全部代码，或者你朋友的。我不会在每个练习中都写到这部分，你要自觉来做这件事。你的目标是找到很多不同的方式来打乱你的代码，知道你试遍了所有可能的方法。在一些练习里我可能会提到一种人们通常使用的打乱方法。除此之外，把它当成一项标准的任务来完成吧。

常见问题

为什么你要用这个叫做 'snow' 的变量？事实上那不是一个变量，它只是一个里面有 snow 这个单词的字符串，变量不会用单引号的。

是不是写每一行代码都要加注释？ 不是，写注释只是为了向你自己解释一些难以理解的代码，或者你为什么要那样做。重要的是搞清楚为什么，然后你再试着写代码，让它实现一些事情。然而，有时候你不得不写一些让人讨厌的代码来解决一个问题，这个问题又需要你在每一行都写上注释，这时候你就应该严格地练练如何把代码用自然语言解释出来。

单引号或者双引号都可以用来创建字符串吗？在 Python 里面，两个都可以，不过严格来讲，像 a 或者 snow 这种比较短的字符串应该用单引号。

练习 8 打印，打印

接下来我们要学习如何做更复杂的格式字符串。虽然它看起来很复杂，但是如果你认真做注释，并且好好做 break down 练习（就是打乱代码再修复）的话，你一定能理解的。

ex8.py

1   formatter = "{} {} {} {}"
2
3   print(formatter.format(1, 2, 3, 4))
4   print(formatter.format("one", "two", "three", "four"))
5   print(formatter.format(True, False, False, True))
6   print(formatter.format(formatter, formatter, formatter, formatter))
7   print(formatter.format(
8   "Try your",
9   "Own text here",
10  "Maybe a poem",
11  "Or a song about fear"
12  ))

你会看到

练习 8 会话

$ python3.6 ex8.py
1 2 3 4
one two three four
True False False True
{} {} {} {} {} {} {} {} {} {} {} {} {} {} {} {}
Try your Own text here
Maybe a poem  
Or a song about fear

在这个练习中我用了一个“函数”（function）来把 formatter 变量变成其他字符串。当你看到我写 formatter.format(...) 时，我就是在告诉 Python 做如下的事情：

1. 在第一行定义 formatter 字符串。
2. 调用 format 函数，类似于让它来做一个名为 format 的命令行命令。
3. 把 4 个参数传给 format ，分别对应 formatter 变量中的 4 个 {} ，就像把参数传给命令行命令 format 一样。
4. 为 formatter 变量调用 format 函数的结果就是，一个新的字符串会用四个变量取代原来的 {} ，然后再被打印出来。

对于第 8 个练习来说，这样的信息量好像有点大，所以我希望你把它当成一道智力题。如果你真的不懂也没关系，因为这本书后面的内容会慢慢为你讲清楚。不过现在，试着学一学，看看会发生什么，然后再进行下面的练习。

加分练习

1. 检查你写的代码，把错误记下来，然后做下一个练习之前看一看，避免再犯同样的错误。

常见问题

为什么 one 要用引号，而 True 或者 False 却不用？ Python 把 True 和 False 当成代表“对“和”错“的关键词。如果你给它们加引号，它们就会变成字符串而无法工作。你会在练习 27 中学到相关内容。

我能用 IDLE 来运行代码吗？ 不，你得学着用命令行。它对学习编程非常重要，并且是一个很好的起点。当你继续往下学这本书，你就会发现 IDLE 不管用了。

练习 9 打印，打印，打印

到现在为止，你应该意识到了这本书的模式，就是用很多练习来教你学习新东西。我先让你敲一些你可能不懂的代码，然后通过更多的练习来解释其中的概念。如果你现在有不懂的东西，在你完成更多练习之后你就会明白。先把你不懂的地方记下来，然后往下进行。

ex9.py

1   # Here's some new strange stuff, remember type it exactly.
2
3   days = "Mon Tue Wed Thu Fri Sat Sun"
4   months = "Jan\nFeb\nMar\nApr\nMay\nJun\nJul\nAug"
5
6   print("Here are the days: ", days)
7   print("Here are the months: ", months)
8
9   print("""
10  There's something going on here.
11  With the three double-quotes.
12  We'll be able to type as much as we like.
13  Even 4 lines if we want, or 5, or 6.
14  """)

你会看到

练习 9 会话

$ python3.6 ex9.py
Here are the days: Mon Tue Wed Thu Fri Sat Sun
Here are the months:    Jan
Feb
Mar
Apr
May
Jun
Jul
Aug

There's something going on here.
With the three double-quotes.
We'll be able to type as much as we like.
Even 4 lines if we want, or 5, or 6.

附加练习

1. 检查你的代码，把错误记下来，以避免再犯。
2. 你有打乱你的代码然后重新修复吗？

常见问题

为什么我在三个双引号之间加了空格就报错了呢？ 你必须这样输入 """ ，而不能这样输入 " " " ，也就是说中间不能加空格。

如果我想让月份另起一行开始打印怎么办？ 你只需要在字符串前面加 \n 即可，就像这样："\nJan \nFeb \nMar \nApr \nMay \nJun \nJul \nAug" 。

如果我的错误总是拼写错误是不是很糟糕？ 很多编程初学者（甚至非初学者）都会犯拼写错误，不用担心，细心点就行。

练习 10 那是什么？

在练习 9 中我教了你一些新东西。这两天我们一直在学习字符串。我教了你两种创建多行字符串的方式，第一种是在月份中间加 \n ，它可以实现换行。

\ 这个字符可以把没法输入的字符转化成字符串。有很多你可能会用到的“转义字符”（escape scequence），我们会在接下来的练习中学到一些，以便你理解我说的意思。

一个很重要的转义字符就是转义单引号或者双引号。比如你要在一个用双引号引起来的字符串中再加一对双引号，就像这样："I "understand" joe."，python 就会懵掉，因为它会认为 understand 后面的双引号就代表这个字符串已经结束了。所以你需要用一种方式告诉 python 字符串里面的双引号并不是一个真正的双引号。

要解决这个问题，你得转义双引号和单引号，让 python 知道得把它们包含在字符串里。例如：

"I am 6'2\" tall." # escape double—quote inside string
'I am 6\'2" tall.'  # escape single—quote inside string

第二种方法是用三个双引号，即 """ ，这样就能像字符串一样运行，而且你可以多输入几行，最后再以 """ 结尾即可。我们来做个练习。

ex10.py

1   tabby_cat = "\tI'm tabbed in."
2   persian_cat = "I'm split\non a line."
3   backslash_cat = "I'm \\ a \\ cat."
4
5   fat_cat = """
6   I'll do a list:
7   \t* Cat food
8   \t* Fishies
9   \t* Catnip\n\t* Grass
10  """
11
12  print(tabby_cat)
13  print(persian_cat)
14  print(backslash_cat)
15  print(fat_cat)

你会看到

找一找你输入的 tab 符号（即 \t ），在这个练习中空格很重要，别弄错了。

$ python ex10 . py
        I'm tabbed in.
I'm split
on a line.
I'm \ a \ cat .

I'll do a list:
        *   Cat food
        *   Fishies
        *   Catnip
        *   Grass

转义字符

这是 python 支持的所有的转义字符了。你可能用不到这么多，但是记住它们的格式以及用法。在一些字符串里试着用用它们，看看能不能成功运行。

附加练习

1. 记住所有的转义字符。可以把它们添加到卡片上来记。
2. 改用三个单引号（'''），你知道什么情况下用它而不是三个双引号（"""）吗？
3. 把转义字符和格式字符串结合起来创建一个更复杂的字符串。

常见问题

我还是没完全理解前面的练习，我该继续往下学吗？ 是的，继续学，别停在这儿。把你不明白的东西记在本子上，定期复习，等你做完更多的练习看你能不能理解。有时候你可能需要回过头去重新做做之前的练习才能明白。

双反斜杠 \\ 和其他符号有什么区别？ 它只是为了让你能把单反斜杠 \ 打印出来，想想你为什么要用 \\ 。

我要是用 // 或者 /n 就不行。 因为你用的是斜杠而不是反斜杠。它们是不同的符号，有着不同的作用。

我不明白附加练习的第 3 题。你说的把转义字符和格式字符串结合起来是什么意思？ 我需要你理解一个概念，就是这些练习都可以结合起来解决问题。用你知道的关于格式字符串的东西和本练习学到的转义字符写一些新的代码。

''' 和 """ 用哪个更好？ 这完全基于风格。现在先用 ''' ，当你感觉用 """ 更好或者别人都用它的时候你可以用 """ 。

练习 11 问问题

现在可以缓一缓了。前面我们做了大量的打印练习，以让你熟悉这些简单的东西，但是的确，它们很无聊。我们现在要做的是在你的程序里放入数据。这块有点复杂，因为你得学着做两件你可能一下子理解不了的事情。但是相信我，无论如何先试试看。做几个练习之后你就会明白。

大多数软件就是做如下事情：

1. 从用户那里获得一些输入。
2. 改一改。
3. 打印出来一些东西以显示它变成了什么。

到现在为止你一直在打印东西，但是你还不知道怎么从用户那里获得 input（输入）。你甚至不知道“input”是什么意思。不管怎样，准确无误地输入这些代码，在下一个练习中我们会做更多的操作来解释 input 。

ex11.py

1   print("How old are you?", end=' ')
2   age = input()
3   print("How tall are you?", end=' ')
4   height = input()
5   print("How much do you weigh?", end=' ')
6   weight = input()
7
8   print(f"So, you're {age} old, {height} tall and {weight} heavy.")

你会看到

练习 11 会话

$ python3.6 ex11.py
How old are you? 38
How tall are you? 6'2"
How much do you weigh? 180lbs
So, you're 38 old, 6'2" tall and 180lbs heavy.

附加练习

1. 上网查查 python 的 input 是干嘛的。
2. 你能找到它的其他使用方式吗？输入你找到的一些例子。
3. 再写一个像这样的格式，来问一些问题。

常见问题

我如何从别人那里获得一些数字来做数学运算？ 这就有点高级了，你可以试试输入 x = int(input()) ，这样可以从 input() 里面获取到字符串形式的数字，再用 int() 把它们转化成数值。

我把我的体重作为 input 像这样输入进去：input("6'2") ，但是不能正常运行。 你别把你的体重放在那儿，你得直接在 Terminal 里面输入。首先，回去输入我让你输的代码；然后，运行脚本，当它暂停的时候，用你的键盘输入你的体重。这才是正确的做法。

练习 12 提示用户

当你输入 () 的时候，一定要确保输入完整，它们是成对出现的。对于 input 来说，你还可以给用户放一个提示，让他知道该输入什么。你可以把提示的字符串放在 () 里面，就像这样：

y = input("Name?")

这个提示告诉用户输入“名字”，然后把结果放到变量 y 里面。通过这种方式你就可以问用户问题然后得到他输入的答案。

这意味着我们可以重新写我们之前的练习，就用 input 来做所有的提示。

ex12.py

1   age = input("How old are you? ")
2   height = input("How tall are you? ")
3   weight = input("How much do you weigh? ")
4
5   print(f"So, you're {age} old, {height} tall and {weight} heavy.")

练习 12 会话

$ python3.6 ex12.py
How old are you? 38
How tall are you? 6'2"
How much do you weigh? 180lbs
So, you're 38 old, 6'2" tall and 180lbs heavy.

附加练习

1. 在 Terminal 里输入 pydoc input ，看看它会说什么。如果你用的是 Windows， 输入 python3.6 -m pydoc input 。
2. 输入 q ，退出 pydoc 。
3. 到网上查查 pydoc 命令的作用。
4. 用 pydoc 读一读关于 open，file，os，和 sys 的内容；浏览一遍即可，把有意思的东西记下来。

常见问题

为什么我每次运行 pydoc 都会收到错误信息：SyntaxError: invalid syntax？ 要么你没在命令行运行 pydoc，要么你先运行了 python3.6，先退出 python3.6 再运行 pydoc 。

为什么我的 pydoc 没有像你的一样暂停？ 有时候如果帮助文件很短，一屏足以放下的话，pydoc 就只会把它打印出来。

当我运行 pydoc 的时候我会收到 more is not recognized as an internal 。 一些 Windows 版本没有这个命令，你可以跳过这个小题，需要它的时候在网上搜搜 Python documentation 即可。

为什么我不能用 print("How old are you?", input()) ？你能，只不过 input() 的结果不会被保存到一个变量里，它会以一种奇怪的方式运行。你可以试试，然后试着打印你输入的东西，看看你能不能搞明白为什么它无法运行。

练习 13 参数，解包，变量

在这个练习中我们将会再涉及一种 input 方法，你可以用这种方法把变量传给一个脚本（也就是你的 .py 文件）。你知道如何运行 ex13.py 吧？输入 python3.6 ex13.py 就行（Windows 下输入 python ex13.py ）。这句命令的 ex13.py 就叫做参数（argument）。我们现在要做的就是写一个也接受参数的脚本。

输入这个程序，然后我会详细解释：

ex13.py

1   from sys import argv
2   # read the WYSS section for how to run this
3   script, first, second, third = argv
4
5   print("The script is called:", script)
6   print("Your first variable is:", first)
7   print("Your second variable is:", second)
8   print("Your third variable is:", third)

第一行我们进行了 “import”（导入），这能让你把 Python 功能库中的功能（features）添加到你的脚本中。Python 会问你你想用什么，而不是一次把所有的功能都给你。它会让你的程序很小，但是它同时也可以为其它阅读你代码的程序员提供参考。

这个 argv 是 “argument variable” ，一个在编程语言中非常标准的名字，你会在其它很多的语言中看到它的使用。当你运行 Python 脚本的时候，这个变量（variable）保存了你传给 Python 脚本的参数（argument）。在这个练习中，你会做更多相关的练习，看看会发生什么。

第三行“解包”（unpacks）了 argv ，而不是保留所有的参数，它分成了四个变量：script, first, second, 以及 third 。这可能看起来很奇怪，但是“解包”这个词可能是对这个操作的最好定义，就好像在说：“把 argv 里面的东西解包，然后按顺序分配给从左到右每一个变量。最后就像平常一样把它们打印出来即可。

等等！Features 还有另一个名字

我在这儿把它们叫做 features （就是你导入进来让 python 做更多事情的东西），但是很少有人叫它们 features。我用这个名字只是因为我想让你在专业术语之外思考它们的真正含义。不过在你继续学习之前，你需要知道它们真正的名字：modules （模块）。

从现在开始我们会把这些 features 说成导入模块，比如，“你想导入 sys 模块”。
它们还被有些程序员叫做“libraries”（库），但是我们就用模块这个名字吧。

你会看到

像这样运行这个程序，前面是你要传递的命令行参数：

练习 13 会话

$ python3.6 ex13.py first 2nd 3rd
The script is called: ex13.py
Your first variable is: first
Your second variable is: 2nd
Your third variable is: 3rd

当你做一些不同参数的运行时，你会看到：

练习 13 会话

$ python3.6 ex13.py stuff things that  
    The script is called: ex13.py
    Your first variable is: stuff
    Your second variable is: things
    Your third variable is: that
    $
$ python3.6 ex13.py apple orange  grapefruit
The script is called: ex13.py
Your first variable is: apple
Your second variable is: orange
Your third variable is: grapefruit

事实上你还可以把 first，2nd，3rd 替换成任何你想替换的东西。如果你没有正确运行，你会收到这样的报错：

练习 13 会话

$ python3.6 ex13.py first 2nd     
Traceback (most recent call last):
   File "ex13.py", line 3, in <module>    
      script, first, second, third = argv
ValueError: not enough values to unpack (expected 4, got 3)

这种情况一般是当你运行脚本的时候没有在命令行放足够的变量（在本例中只有 first 、2nd ）。注意当我运行的时候只给出 first 、2nd ，就会出现错误说“需要三个以上的值来解包”，这就是告诉你，你没有给到足够多的参数。”

附加练习

1. 试着给你的脚本三个以内的参数，看看你会收到什么样的报错，你是否能解释它。
2. 写一个参数少的脚本和一个参数多的脚本，给未解包的变量起个合适的名字。
3. 把 input 和 argv 结合起来创建一个脚本，从用户那里获取更多 input 。别想得太难，就用 argv 来获取一些东西，再用 input 从用户那里获取一些东西。
4. 记住模块给我们一些特征，记住它叫模块（modules），我们之后会用到。

常见问题

当我运行的时候我收到了 ValueError: need more than 1 value to unpack.还记得我说过，学习编程的一项重要技能就是注意细节。如果你看了“你会看到”那部分，你就会看到我是如何在命令行上运行有参数的脚本的，你应该准确按照我做的来。

argv 和 input() 之间的区别是什么？ 区别取决于用户在哪被要求输入，如果是在命令行，就用 argv。如果你想让它们在程序已经运行的情况下用键盘输入，那就用 input() 。

命令行参数是字符串吗？是的，它们是以字符串的形式进来的，即使你在命令行输入的是数字。你可以用 int() 把它们转化成数值，就像 int(input()) 。

你如何使用用命令行？” 你应该已经学过命令行的使用了，现在应该用得很 6 了。但是如果你还没有学，先去附录 A 学习命令行速成课程。

我不知道怎么把 argv 和 input() 结合在一起。 别把它想得太难。就在脚本最后加两行，用 input() 获取一些东西，再打印出来。然后试着用更多方式在同一个脚本中使用这两样东西。

为什么我不能这样用：input('? ') = x ? 因为它写反了，按我的要求写，就能运行。

练习 14 提示和传递

让我们来做一个把 argv 和 input 结合在一起的练习来问用户一些特别的问题。这些问题会在你学习下一个练习中阅读和写文件的时候用到。在这个练习中我们会用一种不同的方式使用 input ，就是让它打印出一个简单的 > 提示符。这有点像 Zork 或者 Adventure 这两款游戏。

ex14.py

1   from sys import argv
2
3   script, user_name = argv
4   prompt = '> '
5
6   print(f"Hi {user_name}, I'm the {script} script.")
7   print("I'd like to ask you a few questions.")
8   print(f"Do you like me {user_name}?")
9   likes = input(prompt)
10
11  print(f"Where do you live {user_name}?")
12  lives = input(prompt)
13
14  print("What kind of computer do you have?")
15  computer = input(prompt)
16
17  print(f"""
18  Alright, so you said {likes} about liking me.
19  You live in {lives}. Not sure where that is.
20  And you have a {computer} computer. Nice.
21  """)

我们把用户提示符设置成变量 prompt ，然后把它赋给 input 而不是一遍遍地输入它们。现在如果我们想把提示符变成别的东西，只要修改一个地方，然后重新运行脚本即可，非常方便。

你会看到

当你运行脚本的时候，记住一定要把你的名字赋给这个脚本，让 argv 接收到你的名字。

练习 14 会话

$ python3.6 ex14.py zed
Hi zed, I'm the ex14.py script.
I'd like to ask you a few questions.
Do you like me zed?
>   Yes
Where do you live zed?
>   San Francisco
What kind of computer do you have?
>   Tandy 1000

Alright, so you said Yes about liking me.
You live in San Francisco. Not sure where that is.
And you have a Tandy 1000 computer. Nice.

附加练习

1. 查查看 Zork 和 Adventure 游戏是什么，找来玩玩。
2. 把 prompt 变量改成别的东西。
3. 在你的脚本里再加一个参数，就像之前练习中 first, second = argv 一样。
4. 确定你理解了我是如何在最后一行把 """ 多行格式字符（style multiline string）和 {} 格式激活器（format activator）结合起来的。

常见问题

我运行脚本的时候收到了 SyntaxError: invalid syntax 。我再说一次，你得在命令行里运行它，而不是在 python 里。如果你输入 python3.6，然后再输入 python3.6 ex14.py Zed ，就会无法运行，因为你是在 python 里面运行 python。关掉窗口，然后只输入 python3.6 ex14.py Zed 。

你说的“改变提示符”是什么意思？我不太理解。看到这个变量 prompt = '>' 了吗？改变它的值。你知道的，它只是一个字符串，你已经做了 13 个练习来创建它们了，所以好好想想，把它弄明白。

我收到了报错信息：ValueError: need more than 1 value to unpack. 我前面说过，你需要看看“你会看到”那部分然后复制我的做法。这儿也一样，注意我是如何输入命令行的，以及我为什么有一个命令行参数。

我如何从 IDLE 来运行这些？不要用 IDLE。

我能在 prompt 变量外面用双引号吗？你完全可以，试试吧。

你有一台 Tandy computer？是的，在我很小的时候。

我运行的时候收到了报错信息：NameError: name 'prompt' is not defined 。 你要么把 prompt 变量拼写错了，要么把那行漏掉了。回过头去，从下到上比较每一行代码。你一旦遇到这种报错，就说明你拼写错误或者忘了创建变量。

练习 15 阅读文件

你已经知道如何用 input 或者 argv 来获取用户的输入了。现在你将学习如何阅读文件。你需要好好做这个练习，才能理解发生了什么，记住要仔细输入和检查。对文件进行操作很容易把文件删掉，所以你要千万小心。

在这个练习中你要写两个文件。一个是通常你要运行的 ex15.py ，一个是叫做 ex15_sample.txt 的文本文件。以下是文本文件中要输入的内容：

This is stuff I typed into a file.
It is really cool stuff.
Lots and lots of fun to have in here.

我们要做的就是在我们的脚本中打开这个文件并把它打印出来。然而，我们不想只是简单粗暴（hard coding）地把 ex15_sample.txt 这个文件名输入进去，hard coding 的意思是把一些应该从用户那里获取的信息直接放到源代码里。这样不好，因为我们随后会需要它载入别的文件。解决方法是用 argv 或者 input 来问用户应该打开哪个文件，而不是 hard coding 文件名。

ex15.py

1   from sys import argv
2
3   script, filename = argv
4
5   txt = open(filename)
6
7   print(f"Here's your file {filename}:")
8   print(txt.read())
9
10  print("Type the filename again:")
11  file_again = input("> ")
12
13  txt_again = open(file_again)
14
15  print(txt_again.read())

这个文件里发生了一些奇妙的事情，让我们快速分解来看一下：

第 1-3 行用了 argv 来获取一个文件名，然后第 5 行用了一个新的命令 open 。现在，运行 pydoc open 然后阅读说明。看见了吧，就像你自己的脚本和输入，它用了一个参数（parameter）然后返回了一个值，你可以把它赋给你自己的变量。你只是打开了一个文件。

第 7 行打印了一些信息，第 8 行就有一些新东西了。我们对 txt 用了一个叫做 read. 的函数，你从 open 那里得到的是一个文件，而且你还可以通过 . 命令名，以及参数，来给它一个命令，就像用 open 和 input 那样。区别是，txt.(read) 是说：txt ，执行不带参数的 read 命令！

剩下的部分基本上类似，但是我们会把分析留到附加练习里。

你会看到

我创建了一个叫做 ex15_sample.txt 的文件来运行我的脚本。

练习 15 会话

$ python3.6 ex15.py ex15_sample.txt  
Here's your file ex15_sample.txt:
This is stuff I typed into a file.
It is really cool stuff.
Lots and lots of fun to have in here.

Type the filename again:
>   ex15_sample.txt
This is stuff I typed into a file.
It is really cool stuff.
Lots and lots of fun to have in here.

附加练习

这部分可能比较难，在你往下进行之前，确保你尽力去做这个附加练习。

1. 在每行上面添加注释解释其含义。
2. 如果你不确定，上网搜，或者问别人，比如你不知道 open 的用法，直接搜 python3.6 open 即可。
3. 我在这儿用的是“命令”（command）这个词，不过，它也叫“函数”（function）或者“方法”（method）。你会在本书后面学到 functions 和 methods。
4. 把第 10-15 行删掉（或者用别的方法使其失效）然后再运行脚本。
5. 只用 input 来试试运行这个脚本。为什么要获取文件名的话一种方法比另一种方法更好？
6. 开启 python3.6 shell，然后就像这个程序中一样从提示界面用 open。注意你是如何从 python3.6 里面打开文件并运行 read 的？
7. 在你的脚本中对 txt 调用 close() 以及 txt_again 变量。当你对它们完成操作后关掉文件是非常重要的。

常见问题

txt = open(filename) 会返回文件的内容吗？ 不会。它其实是创建了一个叫做“文件对象”（file object）的东西。你可以把它想象成曾经的 DVD 播放器，你可以在里面移动然后“读取”它们。但是 DVD 播放器不是 DVD 本身，就像文件对象也不是文件本身一样。

我无法像你附加练习 7 中说的那样在 Terminal/PowerShell 里输入代码。 首先，在命令行输入 python3.6 然后敲回车。现在你已经在 python3.6 里面了。然后你可以输入代码，python 就会运行一些。试着这样玩玩，然后输入 quit() 并回车，退出。

为什么打开文件两次不会收到报错？
Python 不会限制你只能打开一次文件，事实上有时候确实需要打开多次。

from sys import argv 是什么意思？现在你只需要明白 sys 是一个包（package），这个短语是说从那个包里获取 argv 功能（feature）。你会在后面深入学习这块内容。

我把脚本文件名这样放进去：ex15_sample.txt = argv, 但是无法运行。 你不能这样做。严格按照我的代码来，然后用同样的方法在命令行运行它。你不用把文件名放进去，你得让 python 自己放。

练习 16. 读写文件

如果你做了上一节的附加练习，你应该看到了所有的命令（commands，modules，functions），你可以把这些命令施加给文件。以下是一些我想让你记住的命令：

• close - 关闭文件，就像编辑器中的 “文件->另存为”一样。
• read - 读取文件内容。你可以把读取结果赋给一个变量。
• readline - 只读取文本文件的一行内容。
• truncate - 清空文件。清空的时候要当心。
• write('stuff') - 给文件写入一些“东西”。
• seek(0) - 把读/写的位置移到文件最开头。

这些都是你需要知道的一些非常重要的命令。其中一些要用到参数，但是我们暂且不去重点关注。你只需要记住 write 命令需要你提供一个你要写入的文件的字符串参数。

让我们用这些命令做一个小小的编辑器：

ex16.py

1   from sys import argv
2
3   script, filename = argv
4
5   print(f"We're going to erase {filename}.")
6   print("If you don't want that, hit CTRL-C (^C).")
7   print("If you do want that, hit RETURN.")
8
9   input("?")
10
11  print("Opening the file...")
12  target = open(filename, 'w')
13
14  print("Truncating the file. Goodbye!")
15  target.truncate()
16
17  print("Now I'm going to ask you for three lines.")
18
19  line1 = input("line 1: ")
20  line2 = input("line 2: ")
21  line3 = input("line 3: ")
22
23  print("I'm going to write these to the file.")
24
25  target.write(line1)
26  target.write("\n")
27  target.write(line2)
28  target.write("\n")
29  target.write(line3)
30  target.write("\n")
31
32  print("And finally, we close it.")
33  target.close()

这真是一个很大的文件，可能是你输入过的最大的文件了。所以慢一点，写完检查一下，然后再运行。你也可以写一点运行一点，比如先运行 1-8 行，然后再多运行 5 行，然后再多几行，直到所有的都完成和运行了。

你应该看到

事实上你应该看到两样东西，首先是你新脚本的输出结果：

练习 16 会话

$ python3.6 ex16.py test.txt We're going to erase test.txt.
If you don't want that, hit CTRL-C (^C). If you do want that, hit RETURN.
?
Opening the file...
Truncating the file.    Goodbye!
Now I'm going to ask you for three lines.
line 1: Mary had a little lamb
line 2: Its fleece was white as snow
line 3: It was also tasty
I'm going to write these to the file.
And finally, we close it.

现在，用编辑器打开你创建的文件（比如我的是 test.txt），检查一下是不是对的。

附加练习

1. 如果你理解不了这个练习，回过头去按照给每行加注释的方法再过一遍，注释能帮助你理解每一行的意思，至少让你知道你不理解的地方在哪里，然后动手去查找答案。
2. 写一个类似于上个练习的脚本，使用 read 和 argv 来读取你刚刚创建的文件。
3. 这个练习中有太多的重复，试着用一个 target.write() 命令来打印 line1、line2、line3，你可以使用字符串、格式字符串和转义字符。
4. 弄明白为什么我们要用一个 'w' 作为一个额外的参数来打开。提示：通过明确说明你想要写入一个文件，来安全地打开它。
5. 如果你用 w 模式打开文件，那你还需要 target.truncate() 吗？ 读一读 Python 的 open 函数文件，来搞明白这个问题。

常见问题

truncate() 对于 'w' 参数来说是必须的吗？ 详见附加练习 5。

'w' 到底是什么意思？ 它真的只是一个有字符的字符串，来表示文件的一种模式。如果你用了 'w' ，就代表你说“用 ‘write’ 模式打开这个文件。此外还有 'r' 表示 read 模式，'a' 表示增补模式，后面还可能加一些修饰符（modifiers）。

我能对文件使用哪些修饰符？ 目前最重要的一个就是 + ，你可以用 'w+'， 'r+' 以及 'a+'。这样会让文件以读和写的模式打开，取决于你用的是那个符号以及文件所在的位置等。

如果只输入 open(filename) 是不是就用 'r' （读）模式打开？ 是的，那是 open() 函数的默认值。

练习 17. 更多文件

现在让我们对文件做更多新的操作。我们会写一个 Python 脚本来把一个文件复制成另一个。代码会非常短，但是能让你学会对文件做更多的操作。

ex17.py

1   from sys import argv
2   from os.path import exists
3
4   script, from_file, to_file = argv
5
6   print(f"Copying from {from_file} to {to_file}")
7
8   # we could do these two on one line, how?
9   in_file = open(from_file)
10  indata = in_file.read()
11
12  print(f"The input file is {len(indata)} bytes long")
13
14  print(f"Does the output file exist? {exists(to_file)}")
15  print("Ready, hit RETURN to continue, CTRL-C to abort.")
16  input()
17
18  out_file = open(to_file, 'w')
19  out_file.write(indata)
20
21  print("Alright, all done.")
22
23  out_file.close()
24  in_file.close()

你应该会很快注意到我们输出了另一个常用命令 exists。它会基于一个字符串里面的变量文件名来判断，如果一个文件存在，它就会返回 True，不存在就会返回 False。我们会在这本书的下半部分经常使用这个函数，现在你只用知道你是如何输出它的。

使用 import 可以调出海量的免费代码，这些是程序员已经写过的代码，你就不用重复造轮子了。

你会看到

像你其他的脚本文件一样运行 ex17.py ，再加上两个变量：一个是要复制的源文件，一个是要复制到的目标文件。我会使用一个叫 test.txt 的示例文件：

练习 17 会话
$# first make a sample file$
echo "This is a test file." > test.txt
$# then look at it$ cat test.txt
This is a test file.
$# now run our script on it$ python3.6 ex17.py test.txt new_file.txt
Copying from test.txt to new_file.txt
The input file is 21 bytes long
Does the output file exist? False
Ready, hit RETURN to continue, CTRL-C to abort.
Alright, all done.

它应该对每一个文件都适用，多试一些看看会发生什么。注意不要动重要的文件。

附加练习

1. 这个脚本真的很烦人。在复制之前其实没必要问你，而且它打印了太多内容，试着通过删掉一些特征让这个脚本更简洁一些。
2. 看看你把这个脚本缩到多短，我可以把它变成一行。
3. 注意“你会看到”部分，我用了 cat，这是一种把文件打印到屏幕的简单办法，你可以输入 man cat 来看看关于这个命令的作用。
4. 弄明白你为什么得在代码里写 out_file.close() 。
5. 去读读 Python 的 import statement，然后自己试试 import 一些东西，看能不能成功运行。不成功也没关系。

常见问题

为什么 'w' 要用引号？ 因为这是一个字符串。你已经用了一段时间字符串了，确保你知道它的含义。

你不可能把那些代码变成一行！ 那；取决于；你；如何；定义；一行；代码。

我觉得这个练习很难，这正常吗？ 是的，很正常。甚至到练习 36 的时候，或者学完这本书的时候，你可能还是会觉得很难。每个人的情况都不一样，所以坚持学下去，坚持做练习，要有耐心。

len() 函数是什么作用？ 它能够取字符串的长度，然后返回一个数字。你可以试着玩玩。

但我试着把这些代码缩短的时候，我在关闭文件时遇到了错误。 你可能用了 indata = open(from_file).read()，这意味着你不需要在之后再输入 in_file.close() ，因为你已经到了脚本的最后。一旦那一行运行过之后，它就已经被 Python 关掉了。

我收到了一个这样的错误：Syntax:EOL while scanning string literal 。 你忘了在字符串后面加引号了，再检查一遍的代码。

练习 18 名称，变量，代码，函数

这是一个很大的标题。接下来我要给你介绍一下函数。每一个程序员都要一遍一遍地用到函数，思考它们的作用以及如何使用它们，但是我会给你一些最简单的解释，让你能够快速上手。

函数一般就是做以下这些事情：

1. 它们为一些代码起名字，就像变量为字符串和数字起名字一样。
2. 它们像脚本获取 argv 一样获取参数（arguments）。
3. 通过 1 和 2 的操作，让你做一些你自己的“小脚本”或者“微命令”。

你可以通过在 Python 中使用 def 来创建一个函数。我会让你创建 4 个不同的函数，它们就像你的脚本一样运行，之后我还会想你展示每一个之间是如何关联的。

ex18.py

1   # this one is like your scripts with argv
2   def print_two(*args):
3       arg1, arg2 = args
4       print(f"arg1: {arg1}, arg2: {arg2}")
5
6   # ok, that *args is actually pointless, we can just do this
7   def print_two_again(arg1, arg2):
8       print(f"arg1: {arg1}, arg2: {arg2}")
9
10  # this just takes one argument
11  def print_one(arg1):
12      print(f"arg1: {arg1}")
13
14  # this one takes no arguments
15  def print_none():
16      print("I got nothin'.")
17
18
19  print_two("Zed","Shaw")
20  print_two_again("Zed","Shaw")
21  print_one("First!")
22  print_none()

让我们把第一个函数拆解一下，print_two 这是你从创建脚本中已经学到的最熟悉的东西：

1. 首先，我们告诉 Python 我们想要用 def （即 define）来创建一个函数。
2. 在 def 的同一行我们给了函数一个名字，本例中是 print_two，但是你也可以起名叫“peanuts”（花生），名字没关系，不过最好简短一些，并且能够说明这个函数的作用。
3. 然后我们告诉它我们想要 *args ，它很像参数 args ，只不过是为函数设的，必须放在括号里面才能工作。
4. 然后我们以 : 结束这一行，另起一行开始缩进。
5. 在 : 之后缩进四个空格的所有行都是关于 print_two 这个函数名的。我们第一个缩进的行就是用来解包这个参数（argument），跟之前的脚本一样。
6. 要表明它是如何工作的，我们把这些参数打印了出来，就像我们在脚本中所做的一样。

print_two 的问题是它不是创建一个函数最简单的方法。在 python 里面，我们可以跳过整个解包参数的过程，只用我们需要的 () 里面的名字即可，这也正是 print_two_again 所做的事情。

之后我们用一个参数创建了 print_one 这个函数。

最后我们创建了一个没有参数的函数 print_none。

你会看到

如果你运行了 ex18.py，你会看到：

练习 18 会话

$ python3.6 ex18.py
arg1: Zed, arg2: Shaw
arg1: Zed, arg2: Shaw
arg1: First!
I got nothin'.

现在你已经看到了函数是如何工作的。注意你使用函数的方式就像你使用 exists、open 等其他一些“命令”一样。其实我一直在跟你卖关子，因为在 python 里面，这些“命令”就是“函数”（学习癌注：哈哈哈哈哈老肖太坏了）。这意味着你可以创建你自己的命令然后在你的脚本中使用。

附加练习

创建一个如下的函数 checklist （核查表）用于后面的练习。把这些内容写在索引卡上，一直保留到你完成所有剩余练习的时候或者当你感觉你不再需要这些索引卡的时候：

1. 你是否用 def 来创建函数了？
2. 你的函数名是只包含字符和 _ （下划线）吗？
3. 你在函数名后面放 ( （左圆括号）了吗？
4. 你在左圆括号后面放参数（argument）了吗？参数之间是以逗号隔开的吗？）
5. 你的每个参数都是唯一的吗（即没有重名）？
6. 你在参数后面放 ) （右圆括号）和 : （冒号）了吗？
7. 你在与这个函数相关的代码行前面加上四个空格的缩进了吗？（不能多，也不能少）
8. 你是通过另起一行不缩进来结束你的函数的吗？

当你运行（使用或者调用）一个函数时，检查以下事项：

1. 你是通过输入函数名称来运行/调用/使用一个函数的吗？
2. 你运行的时候有在名称后面加 ( 吗？
3. 你有把你想要的值放在圆括号里并用逗号隔开了吗？
4. 你是以 ) 来结束调用这个函数的吗？

在接下来的课程中用这两个 checklist ，直到你不再需要它们为止。

最后，再强调以下，我说的“运行”（run）、“调用”（call）、“使用”（use）都是一个意思。

常见问题

函数名称有哪些要求？跟变量名一样，任何不以数字开头的字母、数字、下划线组合都可以。

*args 中的 * 是什么作用？这是告诉 Python 取所有的参数给函数，然后把它们放在 args 里放成一列，很像你之前学的 argv ，只不过这个是为函数设置的。这种不常用，除非有特殊需要。

这部分好无聊好烦人啊。这就对了，这说明你已经开始一边输入代码一边思考它的作用了。如果想让它不这么无聊，按照我的要求一字不差地输入进去，然后再故意打乱它们，看看你能不能修复好。

练习 19 函数和变量

函数是一个信息量巨大的东西，但是别担心，老老实实做练习，仔仔细细核对 checklist，你最终会掌握它的。

有个小点你可能没注意到，我们会在之后进行强化：你函数里面的变量跟你脚本里面的变量没有关联。通过下面这个练习思考一下这个问题：

ex19.py

1   def cheese_and_crackers(cheese_count, boxes_of_crackers):
2       print(f"You have {cheese_count} cheeses!")
3       print(f"You have {boxes_of_crackers} boxes of crackers!"
4       print("Man that's enough for a party!")
5       print("Get a blanket.\n")
6
7
8   print("We can just give the function numbers directly:")
9   cheese_and_crackers(20, 30)
10
11
12  print("OR, we can use variables from our script:")
13  amount_of_cheese = 10
14  amount_of_crackers = 50
15
16  cheese_and_crackers(amount_of_cheese, amount_of_crackers)
17
18
19  print("We can even do math inside too:")
20  cheese_and_crackers(10 + 20, 5 + 6)
21
22
23  print("And we can combine the two, variables and math:")
24  cheese_and_crackers(amount_of_cheese + 100, amount_of_crackers + 1000)

这个练习展示了我们可以给函数 cheese_and_crackers 赋值的几种不同的方式，我们可以直接给它数字，或者变量，亦或是数学运算，甚至是数学运算和变量的结合。

从某种程度上说，函数的参数有点类似于我们给变量赋值时的 = 符号 。事实上，如果你可以用 = 来定义一个东西，你就可以把它作为参数赋给函数。

你会看到

你应该研究一下这个脚本的输出结果，把它和你之前的脚本输出结果对比一下。

练习 19 会话

$ python3.6 ex19.py
We can just give the function numbers directly:
You have 20 cheeses!
You have 30 boxes of crackers!
Man that's enough for a party!
Get a blanket.

OR, we can use variables from our script:
You have 10 cheeses!
You have 50 boxes of crackers!
Man that's enough for a party!
Get a blanket.

We can even do math inside too:
You have 30 cheeses!
You have 11 boxes of crackers!
Man that's enough for a party!
Get a blanket.

And we can combine the two, variables and math:
You have 110 cheeses!
You have 1050 boxes of crackers!
Man that's enough for a party!
Get a blanket.

附加练习

1. 回顾一遍这个脚本，然后在每一行上方加上注释，解释它的作用。
2. 从下到上阅读每一行，说出所有重要的字符。
3. 写至少一个自己设计的函数，然后用 10 种不同的方式运行它。

常见问题

运行一个函数怎么可能有 10 种不同的方式？ 爱信不信，理论上讲，任何函数都有无数种调用方式。看看你对于函数、变量以及用户输入的创造力有多强。

有没有什么方法能分析函数是如何运行的，以帮助我更好地理解它？有很多方法，但是你先试试给每行加注释这种方式。其他方法包括大声把代码读出来，或者把代码打印出来然后在上面画图，来展示它是怎么运行的。

如果我想问用户关于 cheese 和 crackers 的数字呢？你需要用 int() 来把你通过 input() 获取的内容转化成数值。

在函数中创建 amount_of_cheese 这个变量会改变 cheese_count 这个变量吗？ 不会的，这些变量是相互独立并存在于函数之外的。它们之后会传递给函数，而且是“暂时版”，只是为了让函数运行。当函数退出之后，这些暂时的变量就会消失，其他一切正常运行。接着往下学，你会慢慢明白的。

像 amount_of_cheese 这样的全局变量（global variables）跟函数变量同名的话是不是不太好？是的，如果这样的话，你就不知道你说的到底是哪个变量了。不过你有时候可能不得不用同样的名字，或者你可能不小心同名了，不管怎么样，尽量避免这种情况。

一个函数里包含的参数有数量限制吗？这取决于 Python 的版本以及你的电脑，但是这个数量其实相当大。实践中一个函数包含 5 个参数为宜，再多就比较难用了。

你能在一个函数里面调用一个函数吗？可以，在之后的练习里你会创建一个小游戏，到时候就会用到这个。

练习 20 函数和文件

记住你的函数 checklist，然后在做这个练习的时候注意函数是如何和文件一起工作并发挥一些作用的。

ex20.py

1   from sys import argv
2
3   script, input_file = argv
4
5   def print_all(f):
6       print(f.read())
7
8   def rewind(f):
9       f.seek(0)
10
11  def print_a_line(line_count, f):
12      print(line_count, f.readline())
13
14  current_file = open(input_file)
15
16  print("First let's print the whole file:\n")
17
18  print_all(current_file)
19
20  print("Now let's rewind, kind of like a tape.")
21
22  rewind(current_file)
23
24  print("Let's print three lines:")
25
26  current_line = 1
27  print_a_line(current_line, current_file)
28
29  current_line = current_line + 1
30  print_a_line(current_line, current_file)
31
32  current_line = current_line + 1
33  print_a_line(current_line, current_file)

着重注意我们是如何在每次运行 print_a_line 的时候把当前行的数字传递出去的。

你会看到

练习 20 会话

$ python3.6 ex20.py test.txt
First let's print the whole file:

This is line 1
This is line 2
This is line 3

Now let's rewind, kind of like a tape.      
Let's print three lines:
1   This is line 1

2   This is line 2

3   This is line 3

附加练习

1. 在每一行上方添加注释解释它的作用。
2. 每次 print_a_line 运行的时候，你都在传入一个 current_line 变量。写出每一次调用函数的时候 current_line 等于什么，然后找出它是如何变成
print_a_line 里面的 line_count 的。
3. 找出每一个用到函数的地方，然后检查它的 def 确保你给出了正确的参数。
4. 在网上搜搜 seek 这个函数的作用。试着输入 pydoc file，看看你能否从这里看明白。然后试着输入 pydoc file.seek 再看看 seek 是用来干嘛的。
5. 搜一下简化符号 += ，然后用 += 重新写这个脚本。

常见问题

在 print_all 和其他函数里的 f 是什么东西？ f 是一个变量，就像你在练习 18 中函数的变量一样，只不过这次它是一个文件。文件在 Python 里面有点类似于一个老式电脑里面的磁带驱动器，或者一个 DVD 播放机。它有一个“读取头”（read head），你可以在文件里 seek （寻找）这个读取头所在的位置，然后在那里工作。每次你做 f.seek(0) 的时候你都会从移动到文件最开始，每次你做 f.readline() 的时候，你都在从文件里读取一行内容，并且把读取头移动到 \n 后面，也就是每行结束的地方。 我会在后面给你做更详细的解释。

为什么 seek(0) 没有把 current_line 设置为 0？ 首先，seek() 函数处理的是字节（bytes），不是行。seek(0) 这个代码把文件移动到 0 字节（也就是第一个字节处）。其次，current_line 只是一个变量并且跟这个文件没有任何实际联系。我们是在手动累加它。

什么是 += ？ 你知道在英语里我们可以把 “it is” 写成 “it's” ，或者把 “you are” 写成“you're” ，这叫缩写（contraction）。而 += 就像 = 和 + 两种运算的缩写。也就是 x = x + y 就等同于 x += y 。

readline() 是怎么知道每一行在哪儿的？ readline() 里面的代码能够扫描文件的每个字节，当它发现一个 \n 字符，它就会停止扫描这个文件，然后回到它发现的地方。文件 f 就负责在每次调用 readline() 之后维持文件的当前位置，以此来保证它能阅读到每一行。

为什么文件中的行之间会有空行？ readline() 函数返回文件中每行最后的 \n 。又在 print 函数的结尾加上一个 end = " " 来避免给每行加上两个 \n 。

练习 21 函数可以返回一些东西

你已经使用了 = 来命名变量并给变量赋予数值或字符串。接下来我会教你如何用 = 和一个新的 python 字符 return 来把函数中的变量设置为一个值。有一点需要密切注意，但是先输入如下代码：

ex21.py

1   def add(a, b):
2       print(f"ADDING {a} + {b}")
3       return a + b
4
5   def subtract(a, b):
6       print(f"SUBTRACTING {a} - {b}")
7       return a - b
8
9   def multiply(a, b):
10      print(f"MULTIPLYING {a} * {b}")
11      return a * b
12
13  def divide(a, b):
14      print(f"DIVIDING {a} / {b}")
15      return a / b
16
17
18  print("Let's do some math with just functions!")
19
20  age = add(30, 5)
21  height = subtract(78, 4)
22  weight = multiply(90, 2)
23  iq = divide(100, 2)
24
25  print(f"Age: {age}, Height: {height}, Weight: {weight}, IQ: {iq}")
26
27
28  # A puzzle for the extra credit, type it in anyway.
29  print("Here is a puzzle.")
30
31  what = add(age, subtract(height, multiply(weight, divide(iq, 2))))
32
33  print("That becomes: ", what, "Can you do it by hand?")

我们现在要做我们自己的加减乘除数学运算了。我说的要密切注意的是 add 函数里面的 return a + b ，这步做的是这些事情：

1. 我们的函数是以两个参数被调用的： a 和 b 。
2. 我们把函数所做的事情打印出来，在本例中是 “ADDING”。
3. 然后我们让 Python 做一些反向的事情：我们返回 a + b 的和。你可以这样描述：我用 a 加上 b ，然后返回它们的结果。
4. Python 把这两个数加起来。然后当函数终止的时候，运行了这个函数的任何一行都能够将 a + b 的结果赋予一个变量。

和这本书里其他内容比起来，这块你确实应该把节奏放慢一些，把代码打乱，然后试着琢磨一下每一步都发生了什么。

你会看到

练习 21 会话

$ python3.6 ex21.py
Let's do some math with just functions!  
ADDING 30 + 5
SUBTRACTING 78 - 4
MULTIPLYING 90 * 2
DIVIDING 100 / 2
Age: 35, Height: 74, Weight: 180, IQ: 50.0
Here is a puzzle.
DIVIDING 50.0 / 2
MULTIPLYING 180 * 25.0
SUBTRACTING 74 - 4500.0
ADDING 35 + -4426.0
That becomes:   -4391.0
Can you do it by hand?

附加练习

1. 如果你还不能真正理解 return 是干什么的，试着写几个你自己的函数，并且让它们返回一些值。你可以让它 return 任何东西，只要你把它们放在 = 右边即可。
2. 脚本的最后是一个难题。我在用一个函数的返回值作为另一个函数的参数，这是在一个链（chain）里面进行的，这样就用函数创建了一个公式。它看起来确实很难，但是如果你运行这个脚本，你就可以看到结果。你要做的就是试着弄明白创建同样操作的平常的函数是什么样的。
3. 一旦你有了可以解出这个难题的公式，试着对函数的某些部分做做改动，看看会发生什么。有意改动一些数让它产生一些不同的值。
4. 做相反的操作。写一个简单的公式，然后用同一种方式通过函数来计算它。

这个练习可能真的很让你头大，但是放松，慢点学，把它当成是一个小游戏。正是解决这样的难题让编程如此有趣，所以之后我还会再给你一些小问题让你解决。

常见问题

为什么 python 是“从后往前”（backward打印公式或者函数的？ 它其实不是从后往前，它是从里到外（inside out）。当你开始把代码打乱成分开的公式和函数时，你会看到它是如何工作的。试着理解我说的 “inside out” 而不是 “backward” 。

我如何使用 input() 来输入我自己的值？还记得 int(input()) 吗？这样做的问题是你不能输入浮点数，所以试着用 float(input()) 来代替。

你说的“写一个公式”是什么意思？ 先试试 24 + 34 / 100 - 1023 吧，变成使用函数来计算。然后自己想出一个类似的数学公式，要用变量让它看起来更像一个公式。

练习 22 你目前为止学到了什么？

这个练习和下个练习不会有任何的代码，因此也不会有“你会看到”和“附加练习”这两个部分。事实上，这个练习就像一个大的附加练习，我会让你对之前所有学过的内容做一个回顾复习。

首先，回顾一下你目前为止做过的每一个练习，写下你用过的每个单词和符号，确保你的符号列表是完整的。

在每个单词或符号的旁边，写下它的名字和作用。如果你在这本书里面找不到某个符号的名字，可以试试在网上找找。如果你不知道某个单词或者符号的作用，认真读读与它相关的内容，然后试着在代码中用用它们。

你可能会遇到一些你不明白或者无法解决的问题，把这些记在你的 list 上面，当你找到答案或者想明白以后可以补充上去。

一旦你有了自己的 list，花些时间重新写一遍这个 list，然后检查一下你写得对不对。这样做可能会很无聊，但是逼自己一下，把它落实下来。

如果你已经记住了这个 list 以及它们的作用，可以更进一步，写下字符表、它们的名字和作用，并争取记在脑子里。要是遇到你想不起来的内容，复习一下然后再记一遍。

你正在学的

当你在做一件无聊的、不用动脑子去记的练习时，知道“为什么”很重要，它能帮助你专注一个目标，并且知道你是为了什么而做这些努力。

在这个练习中，你在学习符号的名称，以便更容易地阅读源代码。就像学习英文字母表和基础单词一样，只不过 python 的字母表还有你可能不认识的符号。

如果觉得难了，就把节奏放慢一些，不要想破脑袋地去学。看 list 的时候，最好每次看 15 分钟然后休息一下，让大脑放松一会儿可以帮助你写得更快更轻松。

练习 23 字符串，字节和字符编码

要做这个练习你需要去下载一个名为 languages.txt 的文本文件（下载地址：https://learnpythonthehardway.org/python3/languages.txt，点开，右键，“另存为” txt 格式，放在你的练习文件夹，再打开。)

这个文件列了一个人类的自然语言列表来说明一些有趣的概念：

1. 现代计算机是如何储存自然语言然后显示和加工的，还有 python 3 是如何调用这些字符串的。
2. 你是如何（同时也是必须）把 python 的字符串 “编码”（encode）和“解码”（decode）成字节（byte）形式的。
3. 如何处理你字符串里以及字节处理过程中的错误。
4. 如何阅读代码并弄明白它的意思，即使你从来都没有看到过这些代码。

此外，你还会一睹 python 3 的 if 语句以及处理一系列东西的列表。你不用马上掌握这些代码或者理解这些概念，你会在接下来的练习中有足够的练习来学习。现在你只需要尝个鲜，并且弄明白前面所述的四个问题即可。

初始研究

我准备教你如何研究一段代码来发现它的奥秘。你要用到 languages.txt 文件，所以先确保你已经下载了这个文件。这个 languages.txt 文件包含了一个人类各种语言的列表，并且是以 UTF-8 进行编码的。

输入如下代码（新东西有点多，先敲完再说）：

ex23.py

1   import sys
2   script, encoding, error = sys.argv
3
4
5   def main(language_file, encoding, errors):
6       line = language_file.readline()
7
8       if line:
9           print_line(line, encoding, errors)
10          return main(language_file, encoding, errors)
11
12
13  def print_line(line, encoding, errors):
14      next_lang = line.strip()
15      raw_bytes = next_lang.encode(encoding, errors=errors)
16      cooked_string = raw_bytes.decode(encoding, errors=errors)
17
18      print(raw_bytes, "<===>", cooked_string)
19
20
21  languages = open("languages.txt", encoding="utf-8")  
22
23  main(languages, encoding, error)

你肯定很好奇这个文件是用来干嘛的，可以运行它看看，以下是运行结果（注意运行时需要输入包括文件名在内的三个参数）：

这些例子用了 utf-8 、utf-16 和 big5 编码来说明这种转换，以及你可能会遇到的错误类型。这些名字在 Python 3 中被称为 “codec”（编码器），但是你要用参数“encoding”。在这个练习的最后我列出了一个可用的编码表（encodings）以便你进行更多的练习（PDF文件里貌似没有这个编码表欸，找到的童鞋吱一声，大家也可以到网上查查）。我会在随后讲到这些东西的含义。你只用知道这些东西是如何工作的，这样我们就能在后面提及以及用到它们。

当你运行过几次之后，复习一遍你的符号列表，猜猜它们是做什么的，写下来。然后到网上找找它们的用法，是否跟你猜的一样。别担心你查不到，试试看。

开关、惯例（conventions）和编码

在我深入讲解这些代码的含义之前，你需要学习一些关于数据是如何存储在计算机中的基本知识。现代计算机非常复杂，但是核心就是大量的电灯开关。计算机用电来切换开关。这些开关可以以“开”代表 1，以“关”代表 0。以前有各种各样奇怪的计算机做的不只是 1 和 0 的事情，但现在所有的计算机都是一堆 1 和 0。1 代表着运行、有电、开着、进行、存在。0 代表着结束、完成、消失、关机、没电。我们把这些 1 和 0 叫做 “比特”（bits）。

但是，一个只能让你用 1 和 0 操作的计算机将会非常低效和无聊。计算机接收了这些 1 和 0 之后，会用它们来编码更大的数字，比如用 8 个 1 和 0 来编码 256 个数（0-255）。那么编码到底是什么意思？它其实就是一个关于比特序列如何表示数字的公认标准，比如人们约定 00000000 就代表数字 0，11111111 就代表数字 255，00001111 就代表数字 15。即便是在计算机诞生早期的世界级战争中，计算机也是用这些约定的 1 和 0 来做大规模计算的。

现在我们把一个“字节”（byte）称为 8 个比特（1 和 0）的序列。过去每个人都有他们自己对于字节的惯例（convention），所以你还是会遇到一些人说，这项规定应该灵活一些，比如可以是 9 个、7 个或者 6 个字节序列。但是现在我们都说一个字节是 8 个比特，这是我们的惯例，它定义了我们对于字节的编码。当然还有用 16、32、64 甚至更多个比特来给字节编码的。

一旦你有了字节，你就可以开始存储和显示文本了，不过要用另一种惯例来让数字映射（map）成文字。在计算机发展的早期，有很多关于映射的惯例，有 8 个比特的，7 个比特的（或者更多或更少）。但是最终美国信息交换标准编码（即 ASCII 码）成为最流行的惯例。这个标准建立了从一个数字到一个字母的映射，比如 90 是 Z，用比特的话就是 1011010，对应到计算机里面的 ASCII 码表。

你可以在 Python 里面试试这个（Windows 系统下在 Powershell 输入 python ，然后回车，就会出现 >>>，MacOS 输入 Python3.6）：

>>> 0b1011010
90
>>> ord ( ' Z ' )
90
>>> chr ( 90 )
' Z '
>>>

首先，我用二进制写了数字 90，然后我基于字母 'Z' 得到了对应的数字，接着我把这个数字转化成字母 'Z' 。你不用记这些内容，我用 python 用了这么长时间好像只写过两次这个东西。

一旦我们有了 ASCII 惯例来用 8 个比特（即一个字节）给一个字符编码，我们就可以把它们“串”（string）在一起来组成单词。比如如果我想写我的名字“Zed A. Shaw”，我只需要用 [90, 101, 100, 32, 65, 46, 32, 83, 104, 97, 119] 这样一系列字节就行了。大多数计算机上的早期文本都是存在存储器里的字节序列，计算机用它们把文字呈现给人看。同样的，这件事情的本质还是一些约定俗成的开关转换。

不过 ASCII 有一个问题，它只能编码英文以及一些相似的语言，而且一个字节只能表示 256 个数字（0-255，或者 00000000-11111111）。很显然，世界上正在使用的语言远远超过 256 个字符。因此不同国家创建了针对他们自己语言的编码惯例，虽然这些都管用，但是它们只适用一种语言。这就意味着，如果你想把一本英语书的书名放在一个泰语句子中，就会比较麻烦，你就需要一个泰语编码和一个英语编码。

为了解决这个问题，一群人创建了 Unicode，也就是针对所有人类语言的“统一编码”（Universal encoding）。Unicode 提供的解决方案跟 ASCII 码表类似，但是相比之下，前者更大。你可以用 32 个比特来编码一个 Unicode 字符，这比我们能找到的所有字符可能都要多。一个 32 位比特的数字意味着我们可以存储 4,294,967,295 个字符（2^32）, 这对任何一种人类语言，甚至外星语言来说，都够用了。现在我们用多余的空间来表示一些重要的东西，比如 emoji 表情。

我们现在有了针对任何字符的编码协定，但是 32 比特是 4 个字节，这就意味着对于大多数我们想要编码的文本会浪费很多空间。我们也可以用 16 比特（2 个字节），但仍然很浪费。因此后来出现了一种很妙的惯例：用 8 个比特来编码大多数通用字符，然后当我们需要编码更多字符的时候再使用更多的数字。这意味着我们有了一种压缩（compression）编码惯例，使得用 8 个比特来编码大多数常用字符，并在需要时切换成 16 或 32 个比特这件事成为可能。

在 Python 中编码文本的惯例叫做“utf-8”，即“Unicode Transformation Format 8 Bits”，它是一个把 Unicode 字符编码成字节序列（字节即比特序列，比特序列又即开关转换序列）的惯例。你也可以用其他编码惯例，但是 utf-8 是目前的标准。

分解输出结果

我们现在可以再看一下上面命令的输出结果。先看前面几行结果：

ex23.py 脚本其实就是把字节写在 b' ' 里面，然后把它们转换成 UTF-8 编码（或者其他你设定的编码）。左边是每一个 utf-8 字节对应的数字，右边是 utf-8 实际输出的字符。之所以这样呈现，是为了让你明白 <===> 左边是 Python 用来存储字符串的数字字节或者“原始”（raw）字节，设置 b' ' 是为了告诉 Python 这是“字节”（bytes）。这些原始字节之后被“加工”（cooked）然后显示在右边，以便让你看到你的终端呈现出来的真正的字符。

分解代码

我们已经对字符串和字节序列有了一定的理解。在 Python 中，一个字符串就是一个 UTF-8 编码的字符序列，用来显示或者进行文本操作。而字节是一些“原始”的字节序列，Python 用来存储这些 UTF-8 字符串并以 b' 开头来告诉 python 你正在处理原始字节。这些都基于 python 对于文本操作的惯例。

这是一个关于如何编码字符串和解码字节的 Python 会话展示：

你需要做的就是记住如果你有原始字节，那你必须用 .decode() 来获取字符串。原始字节没有相关惯例，它们只是一些没有意义的数字组成的字节序列。所以你必须告诉 Python“把这些解码成 utf 字符串”。

如果你有一个字符串，并且想要发送、保存、分享它，或者对它做一些其它的操作，通常情况下都可行，但是有时 Python 会扔出一个错误说它不知道如何编码。其实，Python 知道它内部的惯例，它只是不知道你需要的是哪个。在这种情况下，你必须用 .encode() 来获取你需要的字节。

记住这些的方法（虽然我其实都是每次要用才查的）就是记住 “DBES” 这个记忆符号，它代表“Decode Bytes Encode Strings”（解码字节，编码字符串），当你思考如何转换字节和字符串的时候，可以在脑子里默念“迪拜斯”（DBES 发音），有字节要字符串，解码字节，有字符串要字节，编码字符串。

把这个放进脑子里之后，咱们来一行一行分解一下 ex23.py 的代码：

ex23.py

1   import sys
2   script, encoding, error = sys.argv
3
4
5   def main(language_file, encoding, errors):
6       line = language_file.readline()
7
8       if line:
9           print_line(line, encoding, errors)
10          return main(language_file, encoding, errors)
11
12
13  def print_line(line, encoding, errors):
14      next_lang = line.strip()
15      raw_bytes = next_lang.encode(encoding, errors=errors)
16      cooked_string = raw_bytes.decode(encoding, errors=errors)
17
18      print(raw_bytes, "<===>", cooked_string)
19
20
21  languages = open("languages.txt", encoding="utf-8")  
22
23  main(languages, encoding, error)

第 1-2 行： 以通常的命令行参数开始，这个你已经学过了。

第 5 行： 我把这段代码的主体部分定义为一个叫“main"的函数，这个函数会在脚本最后运行东西的时候被调用。

第 6 行：这个函数所做的第一件事就是从给出的 languages 文件中读取一行。你之前已经做过这个操作了，所以这儿没什么新内容，就像以前一样读取文本文件即可。

第 8 行： 现在我用了一些新东西。你将会在这本书的后半部分学到相关内容，所以把这里当作一个尝鲜吧。这是一个 if 语句，它让你在 Python 代码中做决定。你可以“测试”一个变量的真假，基于其真假，运行或者不运行这段代码。在本例中，我测试了一行中是否有内容。当 readline 函数到达文件末尾的时候，它会返回空字符串，if 这一行就是为了测试这个空字符串。只要 readline 给了我们一些东西，结果就会是 true ，后面的代码就会运行（比如缩进的 9-10 行），当结果是 false 的时候， python 就会跳过 9-10 行。

第 9 行： 然后我调用了一个单独的函数来做这一行的真正打印。这简化了我的代码，并且让我更容易理解。如果我想学习这个函数的作用，我可以跳到那儿进行学习。一旦我知道了 print_line 是做什么的，我就可以把我的记忆附到 print_line 这个名称下，然后忘掉细节。

第 10 行： 我在这儿写了一小段非常神奇的代码。我在 main 函数内部又调用了 main 函数。其实也不神奇，因为在编程里面没有真正神奇的东西，所有你需要的信息都在那儿。这里我在一个函数里面又调用了它，好像看上去不太合理。但是问问你自己，为什么不合理？其实没有技术原因，如果一个叫 main 的函数只是跳到顶部，而我在这个函数的底部调用它，它就会回到顶部然后再次运行，这样就会形成一个循环（loop）。现在看第 8 行，你会看到 if 语句避免了这个函数无限循环。仔细研究研究这块内容，因为它是一个很重要的概念，不过如果你一下子理解不了也不用担心。

第 11 行 现在我开始定义 print_line 函数，它用来编码 languages.txt 文件中的每一行内容。

第 13 行 现在我终于获得了从 languages.txt 中收到的语言，并把它们编码成原始字节。还记得“DBES”这个辅助记忆词吗？“Decode Bytes, Encode Strings”，解码字节，编码字符串。next_lang 变量是一个字符串，因此要获得原始字节，我必须对它调用 .encode() 函数来“编码字符串”。我把我想要的编码以及如何处理错误传递给 encode() 。

第 14 行 然后我做了额外一步，通过从 raw_bytes 创建一个 cooked_string 变量来逆向展示第 15 行。记住，“DBES”说的是“解码字节”，raw_bytes 是字节，所以我对它调用了 .decode() 来获取一个 python 字符串。这个字符串应该和 next_lang 变量是一样的。

第 15 行 我已经定义完了所有函数，现在我想打开 languages.txt 文件。

第 16 行 在这个脚本的结尾只是用所有正确的参数运行了 main 函数，以保证一切正常运行，避免循环。记住这个之后会跳转到第 5 行 main 函数被定义的地方，然后在第 10 行又被调用了一次，会造成它的循环。不过第 8 行的 if 语句又会阻止它无限循环。

深入了解编码

我们现在可以用我们的小脚本去探索其他的编码。下面是我针对其他不同编码所做的一些操作，看看如何分解它们：

（注：英文版PDF中这里貌似把图片贴错了，贴的还是前面“分解代码”那一部分的图，所以这里大家就开下脑洞自己想象吧=.=）

首先，我做了一个简单的 UTF-16 编码，以便你了解和 UTF-8 比起来，它是如何变换的。你也可以用 “utf-32” 来看看它有多大，以及如何用 UTF-8 来节省空间。之后我尝试了 Big5，你会看到 Python 一点儿也不喜欢它。它扔了一个错误说 ’big6’ 无法在位置 0 上解码部分字符（我也不知道为什么是 6）。一个办法是告诉 Python 取代 Big5 编码下任何不好搞的字符。这是下一个例子，你会看到它在任何无法匹配 Big5 编码的地方放了一个 ? 符号。

拆解

你可以试试做以下事情：

1. 找到其他编码方式编码的文本字符串，然后把它们放到 ex23.py 文件中，看它如何分解。
2. 给一个不存在的编码方式，看看会发生什么。
3. 额外挑战：重新用 b'' 字节来写，不用 UTF-8 字符串，有效转换这个脚本。
4. 如果你可以做到上面这个，你也可以把这些字节通过移除部分的方式分解开，看看会发生什么。你需要移除多少来让 Python 分解？你能够移除多少来破坏字符串输出结果但是又能通过 Python 的解码系统。
5. 用你在第 4 点中学到的东西看看你能不能破坏这个文件。你得到的错误信息是什么？你能在文件通过 Python 的解码系统下带来多少破坏？

练习 24 更多练习

快到这部分的尾声了。现在你应该已经有了足够多的 Python 技能来继续学习编程到底是怎么回事儿，但是你应该做更多的练习，这个练习很长，纯粹是为了夯实基础。好好练吧，准确输入，仔细检查。

ex24.py

1   print("Let's practice everything.")
2   print('You\'d need to know \'bout escapes with \\ that do:')
3   print('\n newlines and \t tabs.')
4
5   poem = """
6   \tThe lovely world
7   with logic so firmly planted
8   cannot discern \n the needs of love
9   nor comprehend passion from intuition
10  and requires an explanation
11  \n\t\twhere there is none.
12  """
13
14  print("--------------")
15  print(poem)
16  print("--------------")
17
18
19  five = 10 - 2 + 3 - 6
20  print(f"This should be five: {five}")   
21
22  def secret_formula(started):
23      jelly_beans = started * 500
24      jars = jelly_beans / 1000
25      crates = jars / 100
26      return jelly_beans, jars, crates
27
28
29  start_point = 10000
30  beans, jars, crates = secret_formula(start_point)
31
32  # remember that this is another way to format a string
33  print("With a starting point of: {}".format(start_point))
34  # it's just like with an f"" string
35  print(f"We'd have {beans} beans, {jars} jars, and {crates} crates.")
36
37  start_point = start_point / 10
38
39  print("We can also do that this way:")
40  formula = secret_formula(start_point)
41  # this is an easy way to apply a list to a format string
42  print("We'd have {} beans, {} jars, and {} crates.".format(*formula))

你会看到

练习 24 会话

$ python3.6 ex24.py
Let's practice everything.
You'd need to know 'bout escapes with \ that do:

 newlines and   tabs.
--------------

  The lovely world
with logic so firmly planted cannot discern
 the needs of love
nor comprehend passion from intuition
and requires an explanation

     where there is none.
--------------
This should be five: 5
With a starting point of: 10000
We'd have 5000000 beans, 5000.0 jars, and 50.0 crates.
We can also do that this way:
We'd have 500000.0 beans, 500.0 jars, and 5.0 crates.

附加练习

1. 确保你做了检查：从后往前读代码，大声读出来，然后在不明白的地方加上注释。
2. 有意打乱这个文件，然后运行，看看你会收到什么样的错误信息，确保你能把它修复好。

常见问题

为什么你给变量叫 jelly_beans 但是后面又用的是 beans 这个名字？ 这是函数如何运行的一部分。记住，在函数内部变量是暂时的。当你返回它的时候，它可以被分配给一个变量以便之后使用。我只是创建了一个新的变量 beans 来保存返回的值。

你说的从后往前读代码是什么意思？从最后一行开始，把你的代码跟我的代码进行比较，如果完全一样，就转到上一行，直到你检查到这个文件的第一行。

这首诗是谁写的？是我，其实我写的不全是烂诗。

练习 25 更更多练习

接下来我们要做更多包含函数和变量的练习，来确保你完全掌握这些东西。这个练习你应该能直接输入、拆解并理解。

不过，这个练习有一些不同，你不是运行它，而是要把它导入 Python 然后自己运行这个函数。

ex25.py

1   def break_words(stuff):
2       """This function will break up words for us."""
3       words = stuff.split(' ')
4       return words
5
6   def sort_words(words):
7       """Sorts the words."""
8       return sorted(words)
9
10  def print_first_word(words):
11      """Prints the first word after popping it off."""
12      word = words.pop(0)
13      print(word)
14
15  def print_last_word(words):
16      """Prints the last word after popping it off."""
17      word = words.pop(-1)
18      print(word)
19
20  def sort_sentence(sentence):
21      """Takes in a full sentence and returns the sorted words
22      words = break_words(sentence)
23      return sort_words(words)
24
25  def print_first_and_last(sentence):
26      """Prints the first and last words of the sentence."""
27      words = break_words(sentence)
28      print_first_word(words)
29      print_last_word(words)
30
31  def print_first_and_last_sorted(sentence):
32      """Sorts the words then prints the first and last one.""
33      words = sort_sentence(sentence)
34      print_first_word(words)
35      print_last_word(words)

首先，用 python3.6 ex25.py 来运行这个脚本，找出你出错的地方，并把它们改正过来。然后对照“你会看到”部分看看运行结果是否一样。

你会看到

在这个练习中我们要在 python3.6 翻译器（interpreter）里与 ex25.py 文件交互，之前我们在做计算的时候也交互过。你在终端里这样运行 python3.6（Windows 下直接输入 python）：

$ python3.6
Python 3.6.0rc2 (v3.6.0rc2:800a67f7806d, Dec 16 2016, 14:12:21)
[GCC 4.2.1 (Apple Inc. build 5666) (dot 3)] on darwin
Type "help " , "copyright" , "credits" or "license" for more info
>>>

你的输出结果应该和我的一样，你可以在提示符（即 > ）后面输入 Python 代码，它会直接运行。我希望你用这种方式输入这个练习的每一行代码，然后看看会如何：

练习 25 会话

1   import ex25
2   sentence = "All good things come to those who wait."
3   words = ex25.break_words(sentence)
4   words
5   sorted_words = ex25.sort_words(words)
6   sorted_words
7   ex25.print_first_word(words)
8   ex25.print_last_word(words)
9   words
10  ex25.print_first_word(sorted_words)
11  ex25.print_last_word(sorted_words)
12  sorted_words
13  sorted_words = ex25.sort_sentence(sentence)
14  sorted_words
15  ex25.print_first_and_last(sentence)
16  ex25.print_first_and_last_sorted(sentence)

以下是交互模式下输入的结果：
练习 25 Python 会话

Python 3.6.0 (default, Feb 2 2017, 12:48:29)
[GCC 4.2.1 Compatible Apple LLVM 7.0.2 (clang-700.1.81)] on darwi
Type "help", "copyright", "credits" or "license" for more informa
>>> import ex25
>>> sentence = "All good things come to those who wait."
>>> words = ex25.break_words(sentence)
>>> words
['All', 'good', 'things', 'come', 'to', 'those', 'who', 'wait.']
>>> sorted_words = ex25.sort_words(words)
>>> sorted_words
['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']
>>> ex25.print_first_word(words)
All
>>> ex25.print_last_word(words)
wait.
>>> words
['good', 'things', 'come', 'to', 'those', 'who']
>>> ex25.print_first_word(sorted_words)
All
>>> ex25.print_last_word(sorted_words)
who
>>> sorted_words
['come', 'good', 'things', 'those', 'to', 'wait.']
>>> sorted_words = ex25.sort_sentence(sentence)
>>> sorted_words
['All', 'come', 'good', 'things', 'those', 'to', 'wait.', 'who']
>>> ex25.print_first_and_last(sentence)
All
wait.
>>> ex25.print_first_and_last_sorted(sentence)
All
who

当你过完每一行，保证你能找到在 ex25.py 中运行的函数，并且理解了每个函数是如何运行的。如果你得到了不同的结果或者出现错误，你得把代码改正过来，然后退出 python3.6 ，重新进入。

附加练习

1. 弄明白“你会看到”中各行的作用是什么，确保你理解你是如何在 ex25 模块中运行你的函数的。
2. 试试输入 help(ex25) 以及 help(ex25.break_words)（要在交互练习后输入，否则无法成功运行）。注意你是如何获取到关于这个模块的帮助的，以及帮助是如何放在 ex25 的每一个函数后面的 """ 字符串里的。 这些特殊的字符串被称为文件注释，我们会在后面看到更多。
3. 输入 ex25. 很无聊，可以走个捷径：from ex25 import * ，意思就是从 ex25 导入所有东西，程序员总喜欢倒着说。打开一个新会话，看看你的函数会如何。
4. 试着拆解你的文件，看看当你用它的时候，它在 Python 里是什么样的。你得先输入 quit() 来退出 python，再重新加载它。

常见问题

有些函数我什么都没打印出来。你可能有些函数忘了在后面输入 return。检查一遍你的代码，确保每一行都是对的。

当我输入 import ex25 之后，我收到了 -bash: import: command not found. 注意看“你会看到”部分我是怎么做的。我是在 Python 里面运行的，而不是在 Terminal，也就是说，你得先运行 Python。

当我输入 import ex25.py 时收到了这样的错误：ImportError: No module named ex25。 不要在后面加 .py ，Python 知道文件是以 .py 结尾的，所以你只用输入 ex25 即可。

我运行的时候遇到了这个错误：SyntaxError: invalid syntax。这意味着你漏掉了某些东西，比如少了一个 " 或者类似一对的符号。任何时候你只要收到这样的报错信息，你就从它提到的错的那行开始检查，看是不是所有字符都输入正确了，然后再回过头检查这一行上面的行是不是都输入正确了。

words.pop 函数是如何改变 words 变量的？这是个很复杂的问题，但是在本例中 words 是一个列表，正因为如此你可以给它一些命令。这就类似于当你操作文件和很多其他东西时候它们是如何运行的一样。

在函数里我什么时候应该用 print 而不是 return 呢？通过函数，return 能够给调用这个函数的那行代码返回一个结果，你可以把函数当成通过参数获取输入通过 return 返回输出。print 跟这个就完全不相关了，它只是把输出结果打印到终端。

练习 26 恭喜你，来做个测试吧！

现在已经大体完成了这本书的一半内容，后面一半会更有意思，你会学习逻辑以及能够做一些有用的事情，比如做决定。

在你继续之前，我为你准备了一个小测验。这个小测验很难，因为它需要你修复别人的代码。当你成为一个程序员，你会经常需要处理其他程序员的代码，甚至跟他们正面杠。

有些程序员会宣称他们的代码很完美，这些人一般比较蠢，很少考虑别人的感受。好的程序员会像科学家一样，假设他们的代码总是存在一定概率是错的。好的程序员一般会在软件出现问题的情况下，用所有可能的方式排查自己会犯的错误，直到最后得出结论可能真的是其他人的代码出了问题。

在这个练习中，你将会通过修复一个烂程序员的代码来练习和他们打交道。我把练习 24 和 25 复制到了一个文件里，然后随机删除一些字符并加入一些错误。这些错误大多数 Python 都会告诉你，不过一些可能是计算错误，或者是一些字符格式或拼写错误，需要你自己发现。

这些错误都是程序员经常会犯的，哪怕是经验丰富的程序员。

在这个练习中，你的工作就是纠正这个文件。用你所学过的所有技能把这个文件变得更好。首先，你需要先分析一下这些代码，你可以把它打印出来，就像修改学校的学习论文一样编辑它。把其中每个错误都修改好，然后运行它，直到这个文件能够完美运行。试着不去寻求帮助。如果你卡住了，休息一下再回来。

这个练习的重点不在于输入，而在于修复好一个现有的文件。你需要去官网下载这个：

https://learnpythonthehardway.org/python3/exercise26.txt

把这些代码复制到一个文件中，并命名为 ex26.py。这是唯一一次允许你复制粘贴的地方。

常见问题

我需要 import ex25.py 吗？或者我可以在里面引用它吗？ 都行。这个文件包含 ex25 中的函数，所以你可以先把它的引用补上。

我在修复它的时候可以运行代码吗？你很多时候都需要这么做。计算机就是为了帮你的，所以尽可能多地使用它吧。

练习 27 记忆逻辑

今天你将开始学习逻辑（logic）。目前为止你已经完成了很可能让你会在终端读写文件的所有内容，并且还学习了相当多 Python 中的数学计算。

从现在开始，你将开始学习逻辑。你不会学习学院派喜欢教的那套复杂理论，而只是简单的基本逻辑，它们是一些能让真实的程序运行，以及真正的程序员每天都需要的东西。

学习逻辑需要你先做一些记忆工作。我希望你能花一整个星期的时间来做这个练习。不要中途放弃，哪怕你已经烦闷不堪，坚持学下去。这个练习有一个逻辑表，你必须记住它们，这样在做后面的练习时才能更容易一些。

我得告诉你，这个练习一开始不会很有趣，甚至会冗长乏味，但是它会教给你作为程序员所需的一项重要技能。你需要记住这些重要的理念，当你掌握它们的时候，你会发现其中大多理念都非常令人激动。你会苦苦思索，就像 跟章鱼搏斗（wrestling a squid），直到有一天你最终理解它们。所有记忆工作的付出会在之后给你丰厚的回报。

以下是一些让你不至于抓狂的记忆技巧：

一天少记一些内容，给需要强化记忆的部分做上标记；别妄图一坐坐两个小时一下子把这些表全记住，这样不科学，你的大脑只会保留你前 15-30 分钟记的内容。相反，你应该创建一些索引卡，在表中左边列的内容（True or False）写在正面，右边的内容写在背面。然后你可以把它们拿出来，看着 “True or False” 直接说出 “True！”保持练习，直到你能够做到这样。

一旦你能够做到，你就可以开始每天晚上在笔记本上默写 truth table。不要只是复制，试着凭记忆默写。如果你卡住了，快速看一眼来刷新你的记忆。这样做会训练你的大脑记住整张表。

别花超过一个星期时间在这上面，因为随着你往下学习，你会逐步应用这些内容。

The Truth Terms

在 Python 中我们有下面这些词条（字符和短语）来判断某些东西是 “True” 还是 “False” 。计算机的逻辑就是看这些字符和变量的组合在特定程序和特定点下是不是 True。

• and
• or
• not
• != （不等于）
• == （等于）
• >= （大于等于）
• <= （小于等于）
• True
• False

你其实之前已经遇到过这些字符了，但是可能不是 terms。Terms （and, or, not）的运行方式就跟它们的意思一样。

The Truth Tables

我们现在要用这些字符来帮你记忆 truth tables 的内容。

现在照着这些表来写下你自己的卡片，然后花一周的时间记忆它们。记住，这本书里没有失败，只有每天不断的尝试和坚持。

常见问题

我可以只学习布尔代数（boolean algebra）背后的理论而不去记忆这些内容吗？你当然可以这样做，但是之后你在写代码的时候就得不停地回顾布尔代数的那些规则了。如果你先把这些记住，不仅可以构建你的记忆技巧，还能让你的操作更自然。在这之后，布尔代数的理念就非常简单了。当然了，选择最适合你的方式吧。

练习 28 布尔练习

你上个练习所学的逻辑组合叫做“布尔”逻辑表达（Boolean logic expressions）。布尔逻辑在编程中无处不在。它是数学计算的基础模块，掌握它就跟掌握音乐里面的音阶一样重要。

在这个练习中，你将试着在 Python 中运用你在上个练习中所记忆的逻辑表。给以下每一个逻辑问题写下你认为的答案，要么是 True，要么是 False。等你把答案写下来，再在终端里运行 Python，输入每个逻辑问题，来确认你的答案是否正确。

1. True and True
2. False and True
3. 1 == 1 and 2 == 1
4. "test" == "test"
5. 1 == 1 or 2 != 1
6. True and 1 == 1
7. False and 0 != 0
8. True or 1 == 1
9. "test" == "testing"
10. 1 != 0 and 2 == 1
11. "test" != "testing"
12. "test" == 1
13. not (True and False)
14. not (1 == 1 and 0 != 1)
15. not (10 == 1 or 1000 == 1000)
16. not (1 != 10 or 3 == 4)
17. not ("testing" == "testing" and "Zed" == "Cool Guy")
18. 1 == 1 and (not ("testing" == 1 or 1 == 0))
19. "chunky" == "bacon" and (not (3 == 4 or 3 == 3))
20. 3 == 3 and (not ("testing" == "testing" or "Python" == "Fun"))

我还会教你一个小诀窍来帮你弄明白更复杂的问题。

不论何时，当你看到这些布尔逻辑表达式，你可以通过以下简单的几步来解决它们：

1. 把每一个相等性测试（== 或者 !=）替换成真实性测试。

2. 先解决圆括号里面的 and/or。

3. 找到每一个 not，然后把它反转过来。

4. 找到剩余的 and/or，然后解决掉。

5. 当你完成的时候，你应该得到 True 或者 False。我会用一个变量来说明：

3 != 4 and not ("testing" != "test" or "Python" == "Python")

以下是我进行每一步逻辑运算的过程，最后我得出了一个单一的结果：

1、先解决每一个相等性测试：

3 != 4 是 True: True and not ("testing" != "test" or "Python" == "Python"；
"testing" != "test" 是 True: True and not (True or "Python" == "Python")；
"Python" == "Python": True and not (True or True)；

2、找到圆括号里的每一个 and/or：

(True or True) 是 True: True and not (True)

3、找到每一个 not，然后把它转换过来：

not (True) 是 False: True and False

4、找到其他剩余的 and/or 然后解决它们：

True and False 是 False。

这样我们就完成了这个测试，并且知道结果是 False。

你会看到

在你尝试给出所有答案后，这是你可能会在 Python 运行后看到的会话结果：

$ python3.6
Python 2.5.1 (r251:54863, Feb 6 2009, 19:02:12)
[GCC 4.0.1 ( Apple Inc . build 5465)] on darwin
Type "help" , "copyright" , "credits" or "license" for more information
>>> True and True
True
>>> 1 == 1 and 2 == 2
True

附加练习

1. Python 中有很多类似于 != 和 == 的运算符，试着尽可能多地找到这类“比较运算符”（ equality operators），比如 < 或者 <=。
2. 写下这些比较运算符的名字，比如我们把 != 叫做“不等于”。
3. 在 Python 中输入新的布尔运算，在你敲下回车之前先把答案说出来，别思考，说出你脑子里第一个冒出来的答案。写下来，然后敲回车。算一算你对了多少，错了多少。
4. 记完把纸扔掉，防止你下次再用。

常见问题

为什么 "test" and "test" 返回的是 test，1 and 1 返回的是 1 而不是 True？ Python 和其他很多语言喜欢返回布尔表达式的运算数而不是只是 True 或者 False。这意味着，如果是 False and 1，你会得到第一个运算数（False），如果是 True and 1，你会得到第二个运算数（1），试着玩玩这个。

!= 和 <> 有区别吗？ Python 已经不提倡使用 <> ，而是更多地使用 !=，除此之外，二者没有任何区别。

有捷径吗？有，任何包含一个 False 的 and 表达式结果都是 False。任何包含一个 True 的 or 表达式结果都是 True。但是你要掌握处理整个表达式的过程，后面会用到。

练习 29 if 语句

这个练习中的 Python 脚本将带你了解 if 语句。输入代码，准确运行，然后我们来看看你都学到了什么。

ex29.py

1   people = 20
2   cats = 30
3   dogs = 15
4
5
6   if people < cats:
7       print("Too many cats! The world is doomed!")
8
9   if people > cats:
10      print("Not many cats! The world is saved!")
11
12  if people < dogs:
13      print("The world is drooled on!")     
14
15  if people > dogs:
16      print("The world is dry!")
17
18
19  dogs += 5
20
21  if people >= dogs:
22      print("People are greater than or equal to dogs.")
23
24  if people <= dogs:
25      print("People are less than or equal to dogs.")
26
27
28  if people == dogs:
29      print("People are dogs.")

你会看到

练习 29 会话

$ python3.6 ex29.py
Too many cats! The world is doomed!     
The world is dry!
People are greater than or equal to dogs.
People are less than or equal to dogs.
People are dogs.

附加练习

在附加练习中，试着猜猜 if 语句是什么以及它是干什么的。在继续进行下个练习之前，试着用自己的话回答以下这些问题，

1. 你认为 if 对它下面的代码起什么作用？
2. 为什么 if 下面的代码要缩进 4 个空格？
3. 如果没有缩进会发生什么？
4. 你能从练习 27 里面把一些布尔表达式放进 if 语句吗？试试看。
5. 如果你改变 people，cats 和 dogs 的初始值会发生什么？

常见问题

+= 是什么意思？ x += 1 就相当于 x = x + 1 ，但是输入的内容更少。你可以把它叫做“累加”（increment by）运算符。之后你还会学到 -= 这样类似的表达。

练习 30 Else 和 if

在上个练习中你学到了一些 if 语句，思考了它的含义和作用。在你学习更多内容之前，我会解释一下上个附加练习中的问题。首先确定你做了那些练习。

1. 你认为 if 对它下面的代码起什么作用？

if 语句在代码中创建了一个“分支”（branch），有点类似于在一本冒险书中，你选择了哪个答案，就翻到对应的一页，如果你选择了不同的答案，就会去到不同的地方。if 语句就是告诉脚本，如果这个布尔表达式是 True，那就运行它下面的代码，否则的话就跳过。

2. 为什么 if 下面的代码要缩进 4 个空格？

通过一行代码结尾的冒号告诉 Python 你在创建一个新的代码块，然后缩进四个空格告诉 Python 这个代码块中都有些什么。这就跟本书前半部分中你学的函数是一样的。

3. 如果没有缩进会发生什么？

如果没有缩进，你很可能收到一个错误提示。Python 一般会让你在一个带 ： 的代码行下面缩进一些内容。

4. 你能从练习 27 里面把一些布尔表达式放进 if 语句吗？试试看。

试试吧，你可以的。你可以把它们写得很复杂，不过复杂的东西一般风格都很糟糕。

5. 如果你改变 people，cats 和 dogs 的初始值会发生什么？

因为你在比较数字，所以如果你改变了数字，不同的 if 语句将会得出不同的判断结果，那么下面某些代码块就有可能运行。回到练习中给这些变量一些不同的数值，然后看看你能否在脑中判断出来哪些代码块会运行。

把我的答案和你的比较一下，然后确保你真的理解了代码块的概念。这对你进行接下来的练习很重要。把下面的代码输入进去然后运行。

ex30.py

1   people = 30
2   cars = 40
3   trucks = 15
4
5
6   if cars > people:
7       print("We should take the cars.")
8   elif cars < people:
9       print("We should not take the cars.")
10  else:
11      print("We can't decide.")
12
13  if trucks > cars:
14      print("That's too many trucks.")
15  elif trucks < cars:
16      print("Maybe we could take the trucks.")
17  else:
18      print("We still can't decide.")
19
20  if people > trucks:
21      print("Alright, let's just take the trucks.")
22  else:
23      print("Fine, let's stay home then.")

你会看到

练习 30 会话

$ python3.6 ex30.py
We should take the cars.
Maybe we could take the trucks.
Alright, let's just take the trucks.

附加练习

1. 试着猜猜 elif 和 else 的作用是什么。
2. 改变 cars，people，和 trucks 的数值，然后追溯每一个 if 语句，看看什么会被打印出来。
3. 试试一些更复杂的布尔表达式，比如cars > people 或者 trucks < cars。
4. 在每一行上面加上注释。

常见问题

如果多个 elif 块都是 True 会发生什么？ Python 从顶部开始，然后运行第一个是 True 的代码块，也就是说，它只会运行第一个。

练习 31 做决定

在这本书的前半部分你主要学习了调用函数、打印东西，但是这些基本都是直线运行下来的。你的脚本从上面开始运行，然后到底部结束。如果你用了一个函数，你可以随后再运行它，但是仍然不会有分叉需要你做决定的情况。现在你学习了 if，else，以及 elif，你就可以让脚本来做决定了。

在上个脚本中你写出了一个简单的问问题的测试集。在这个练习中你将问用户一些问题，并基于他们的回答做决定。写下这个脚本，然后多玩几遍，把它弄明白。

ex31.py

1   print("""You enter a dark room with two doors.
2   Do you go through door #1 or door #2?""")
3
4   door = input("> ")
5
6   if door == "1":
7       print("There's a giant bear here eating a cheese cake.")
8       print("What do you do?")
9       print("1. Take the cake.")
10      print("2. Scream at the bear.")     
11
12      bear = input("> ")
13
14      if bear == "1":
15          print("The bear eats your face off. Good job!")
16      elif bear == "2":
17          print("The bear eats your legs off. Good job!")
18      else:
19          print(f"Well, doing {bear} is probably better.")
20          print("Bear runs away.")
21
22  elif door == "2":
23      print("You stare into the endless abyss at Cthulhu's retina.")
24      print("1. Blueberries.")
25      print("2. Yellow jacket clothespins.")
26      print("3. Understanding revolvers yelling melodies.")
27
28      insanity = input("> ")
29
30      if insanity == "1" or insanity == "2":
31          print("Your body survives powered by a mind of jello.")
32          print("Good job!")
33      else:
34          print("The insanity rots your eyes into a pool of muck.")
35          print("Good job!")
36
37  else:
38      print("You stumble around and fall on a knife and die. Good job!")

这里很关键的一点是你现在在 if 语句里面又放了一个 if 语句。这在创建“嵌套”（nested）决定的时候非常有用，每一个分支指向另一个选择。

确保你理解了在 if 语句中嵌套 if 语句的理念。你可以通过做附加练习来真正掌握它。

你会看到

这是我玩这个冒险小游戏的结果，我可能玩儿得没那么好。

练习 31 会话

$ python3.6 ex31.py
You enter a dark room with two doors.     
Do you go through door #1 or door #2?
>   1
There's a giant bear here eating a cheese cake.
What do you do?
1.  Take the cake.
2.  Scream at the bear.
>   2
The bear eats your legs off. Good job!

附加练习

1. 给这个游戏加一些新内容，同时改变用户可以做的决定。尽可能地扩展这个游戏，直到它变得很搞笑。
2. 写一个完全不同的新游戏。可能你不喜欢我的这个，你可以做一个你自己的。

常见问题

我能用一系列的 if 语句来代替 elif 吗？在某些情况下可以，但是取决于每个 if/else 是怎么写的。如果这样的话还意味着 Python 将会检查每一个 if-else 组合，而不是像 if-elif-else 组合那样只会检查第一个是 false 的。你可以多试几次，感受一下区别。

我如何表示一个数字的区间？有两种方式：一种是 0 < x < 10 或者 1 <= x < 10 这种传统表示方法，另一种是 x 的区间是 (1, 10)。

如果我想在 if-elif-else 代码块中放更多的选择怎么办？为每种可能的选择增加更多的 elif 块。

练习 32 循环和列表

你现在可以做一些更有意思的程序了。如果你一直跟着我们的节奏，你应该可以把所有学过的东西用 if 语句和布尔表达式结合起来，让你的程序做一些好玩的事情。

不过，程序仍然需要快速做一些重复的事情。我们要在这个练习中用一个 for-loop 来创建和打印各种列表。你在做练习的时候，得想想它们是什么。我不会立马告诉你，你得自己去想。

在你能够用一个 for-loop 之前，你需要一种方法来把这些循环的结果储存在某处。最好的办法就是用列表。列表顾名思义就是一个按顺序从头到尾组成的某种东西的容器。它并不复杂：你只需要学习一个新的语法。首先，你可以这样创建列表：

hairs = ['brown', 'blond', 'red']
eyes = ['brown', 'blue', 'green'] weights = [1, 2, 3, 4]

以左方括号（ [ ）开始打开列表，然后把你想要的条目用逗号隔开放进去，有点类似于函数的参数。最后，用右方括号（ ] ）来表明列表的结束。Python 会选取这个列表以及它的所有内容并把它们分配到变量里。

我们现在要用 for-loops 来创建一些列表，然后把它们打印出来。

ex32.py

1   the_count = [1, 2, 3, 4, 5]
2   fruits = ['apples', 'oranges', 'pears', 'apricots']
3   change = [1, 'pennies', 2, 'dimes', 3, 'quarters']
4
5   # this first kind of for-loop goes through a list
6   for number in the_count:
7       print(f"This is count {number}")
8
9   # same as above
10  for fruit in fruits:
11      print(f"A fruit of type: {fruit}")
12
13  # also we can go through mixed lists too
14  # notice we have to use {} since we don't know what's in it
15  for i in change:
16      print(f"I got {i}")
17
18  # we can also build lists, first start with an empty one
19  elements = []
20
21  # then use the range function to do 0 to 5 counts
22  for i in range(0, 6):
23      print(f"Adding {i} to the list.")
24  # append is a function that lists understand
25      elements.append(i)
26
27  # now we can print them out too
28  for i in elements:
29      print(f"Element was: {i}")

你会看到

练习 32 会话

$ python3.6 ex32.py
This is count 1
This is count 2
This is count 3
This is count 4
This is count 5
A fruit of type: apples
A fruit of type: oranges
A fruit of type: pears
A fruit of type: apricots
I got 1
I got pennies
I got 2
I got dimes
I got 3
I got quarters
Adding 0 to the list.
Adding 1 to the list.      
Adding 2 to the list.
Adding 3 to the list.    
Adding 4 to the list.
Adding 5 to the list.     
Element was: 0
Element was: 1
Element was: 2
Element was: 3
Element was: 4
Element was: 5

附加练习

1. 看看你是如何使用 range 的。查阅上面的 range 函数并理解掌握。
2. 你能在第 22 行不使用 for-loop，而是直接把 range(0, 6) 赋给 elements 吗？
3. 找到 Python 文档关于列表的部分，然后读一读。看看除了 append，你还能对列表做哪些操作？

常见问题

如何创建一个二维列表？可以用这种列表中的列表：[[1,2,3],[4,5,6]]

列表（lists）和数组（arrays）难道不是一个东西吗？这取决于语言以及实现方法。在传统术语中，列表和数组的实现方式不同。在 Ruby 中都叫做 arrays，在 python 中都叫做 lists。所以我们就把这些叫做列表吧。

为什么 for-loop 可以用一个没有被定义的变量？变量在 for-loop 开始的时候就被定义了，它被初始化到了每一次 loop 迭代时的当前元素中。

为什么 range(1, 3) 中的 i 只循环了两次而不是三次？ range() 函数只处理从第一个到最后一个数，但不包括最后一个数，所以它在 2 就结束了。这是这类循环的通用做法。

element.append() 的作用是什么？它只是把东西追加到列表的末尾。打开 Python shell 然后创建一个新列表。任何时候当你遇到类似的用法，试着多玩几次，去体会它们的作用。

练习 33 While 循环

现在我们来看一个新的循环： while-loop。只要一个布尔表达式是 True，while-loop 就会一直执行它下面的代码块。

等等，你应该能理解这些术语吧？如果我们写一行以 : 结尾的代码，它就会告诉 Python 开始一个新的代码块。我们用这种方式来结构化你的程序，以便 Python 明白你的意图。如果你还没有掌握这块内容，先回去复习一下，再做一些 if 语句、函数以及 for-loop，直到你掌握为止。

之后我们会做一些练习来训练你的大脑读取这些结构，就像我们训练你掌握布尔表达式一样。

回到 while-loop，它所做的只是像 if 语句一样的测试，但是它不是只运行一次代码块，而是在 while 是对的地方回到顶部再重复，直到表达式为 False。

但是 while-loop 有个问题：有时候它们停不下来。如果你的目的是让程序一直运行直到宇宙的终结，那这样的确很屌。但大多数情况下，你肯定是需要你的循环最终能停下来的。

为了避免这些问题，你得遵守一些规则：

1. 保守使用 while-loop，通常用 for-loop 更好一些。
2. 检查一下你的 while 语句，确保布尔测试最终会在某个点结果为 False。
3. 当遇到问题的时候，把你的 while-loop 开头和结尾的测试变量打印出来，看看它们在做什么。

在这个练习中，你要通过以下三个检查来学习 while-loop：

ex33.py

1   i = 0
2   numbers = []
3
4   while i < 6:
5       print(f"At the top i is {i}")
6       numbers.append(i)
7
8       i = i + 1
9       print("Numbers now: ", numbers)
10      print(f"At the bottom i is {i}")
11
12
13  print("The numbers: ")
14
15  for num in numbers:
16      print(num)

你会看到

练习 33 会话

$ python3.6 ex33.py
At the top i is 0      
Numbers now: [0]
At the bottom i is 1
At the top i is 1    
Numbers now:    [0, 1]
At the bottom i is 2
At the top i is 2
Numbers now:    [0, 1, 2]
At the bottom i is 3
At the top i is 3
Numbers now:    [0, 1, 2, 3]
At the bottom i is 4
At the top i is 4
Numbers now:    [0, 1, 2, 3, 4]
At the bottom i is 5
At the top i is 5
Numbers now:    [0, 1, 2, 3, 4, 5]
At the bottom i is 6
The numbers:
0
1
2
3
4
5

附加练习

1. 把这个 while-loop 转换成一个你可以调用的函数，然后用一个变量替代 i < 6 里面的 6。
2. 用这个函数重新写一下这个脚本，试试不同的数值。
3. 再增加一个变量给这个函数的参数，然后改变第 8 行的 +1，让它增加的值与之前不同。
4. 用这个函数重新写这个脚本，看看会产生什么样的效果。
5. 用 for-loop 和 range 写这个脚本。你还需要中间的增加值吗？如果不去掉这个增加值会发生什么？

任何时候你在运行程序的时候它失控了，只用按下 CTRL-C ，程序就会终止。

常见问题

for-loop 和 while-loop 的区别是什么？ for-loop 只能迭代（循环）一些东西的集合，而 while-loop 能够迭代（循环）任何类型的东西。不过，while-loop 很难用对，而你通常能够用 for-loop 完成很多事情。

循环好难，我应该如何理解它们？人们不理解循环的主要原因是他们跟不上代码的运行。当一个循环运行的时候，它会过一遍代码块，到结尾之后再跳到顶部。为了直观表现这个过程，你可以用 print 打印出循环的整个过程，把 print 行写在循环的前面、顶部、中间、结尾。研究一下输出的内容，试着理解它是如何运行的。

练习 34 获取列表元素

列表（list）真的非常有用，前提是你要能获取到它们里面的内容。你已经能够按顺序遍历列表中的元素，但是如果你要取其中的第5个元素，你该怎么操操做？你需要知道如何获取一个列表里面的元素。下面是如何获取列表中第一个元素的方法：

animals = ['bear', 'tiger', 'penguin', 'zebra']
bear = animals[0]

你创建了一个动物列表，然后用 0 来取列表的第一个元素？！为什么呢？因为数学就是这样的，Python 列表的第一个元素是从序号 0 开始，而不是从 1 开始。这样虽然看起来有点奇怪，但是好处多多。

最好的解释可能是它反映了人使用数字和程序使用数字的区别。

想象一下你正在观察列表中的四个动物（熊，老虎，企鹅，斑马）赛跑，它们纷纷冲过了终点线，我们也得到了它们的次序。比赛非常激烈，因为最终它们都没有吃掉彼此。你的一个朋友来晚了，他想知道哪个动物胜出了。他肯定会说“谁得了第一名？”而不是“谁是第零个？”

这是因为动物们的次序非常重要。你不能在没有第一名的情况下就有第二名，同理没有第二名也不可能有第三名。而第零名毫无意义，因为零意味着什么都没有。你怎么可能在异常比赛里面什么都没有呢？这说不通。我们把这些能排序的数字叫做序数（ordinal numbers），因为它们能代表一定的顺序。

然而，程序不会这么想。它们能从一个列表中任意取出一个元素来。对程序而言，动物们的列表更像是一叠卡片。如果它们想要老虎，就直接去拿。如果想要斑马，也能直接去拿。这就需要这些元素能有一个恒定的地址（address），或者索引（index），以便程序能够以一种随机的方式把它们从列表中拿出来。最好的办法就是让指标（indices）从 0 开始。相信我，这样在数学上更为便捷。这种数字叫做基数（cardinal number），它意味着你可以随机取数，所以必须要有一个 0 元素。

ai酱注：这里感觉老肖没太解释清楚，在百度知道上看到一个回答，可以供大家参考：https://zhidao.baidu.com/question/1693009495708807428.html

不知道以上解释能否帮助你理解列表？很简单，每次你对自己说，“我要第 3 个动物，”的时候，把 3 这个序数通过 -1 转换成 2 这个基数就行了。第 3 个动物就是索引为 2 的企鹅。你一生都在使用序数，现在你需要用基数来思考，只用减去 1 就行，没那么难。

记住：序数 == 排序，第一；基数 == 随机卡片，0。
（ordinal == ordered, 1st; cardinal == cards at random, 0.）

让我们练习一下。用如下动物列表，跟着我列出来的序数或基数要求，写出你从列表中取到的动物。记住，如果我说“第1个”（1st）、“第2个”（2nd），那我就是在用序数，直接减1就可以了。如果我说“第1位”（at 1），那我就是在用基数，直接按这个数字取就行。

animals = ['bear', 'python3.6', 'peacock', 'kangaroo', 'whale', '

（注：为了不造成混淆，以下内容保留英文原文）

1. The animal at 1.
2. The third (3rd) animal.
3. The first (1st) animal.
4. The animal at 3.
5. The fifth (5th) animal.
6. The animal at 2.
7. The sixth (6th) animal.
8. The animal at 4.

使用完整的表述格式进行回答，例如: “The first (1st) animal is at 0 and is a bear.” 然后反过来说一遍: “The animal at 0 is the 1st animal and is a bear.”

用 python 验证你的答案。

附加练习

1. 基于你所学的不同类型数字之间的区别, 你能解释为什么“2010年1月1日”中的2010年真的是2010年而不是2009年？（提示：你不能随机去取年份）
2. 多写一些列表，搞明白列表元素的索引，知道你能够准确掌握。
3. 用 python 验证你的答案。

练习 35 分支和函数

目前为止你已经了解了 if 语句，函数以及列表。现在是时候深入学习一下了。照例输入如下代码，看看你能否明白程序在做什么。

ex35.py

1   from sys import exit
2
3   def gold_room():
4       print("This room is full of gold. How much do you take?")
5
6       choice = input("> ")
7       if "0" in choice or "1" in choice:
8           how_much = int(choice)
9       else:
10          dead("Man, learn to type a number.")
11
12      if how_much < 50:
13          print("Nice, you're not greedy, you win!")
14          exit(0)
15      else:
16          dead("You greedy bastard!")
17
18
19  def bear_room():
20      print("There is a bear here.")
21      print("The bear has a bunch of honey.")
22      print("The fat bear is in front of another door.")
23      print("How are you going to move the bear?")
24      bear_moved = False
25
26      while True:
27          choice = input("> ")
28
29          if choice == "take honey":
30              dead("The bear looks at you then slaps your face")
31          elif choice == "taunt bear" and not bear_moved:
32              print("The bear has moved from the door.")
33              print("You can go through it now.")
34              bear_moved = True
35          elif choice == "taunt bear" and bear_moved:
36              dead("The bear gets pissed off and chews your leg.")
37          elif choice == "open door" and bear_moved:
38              gold_room()
39          else:
40              print("I got no idea what that means.")
41
42
43  def cthulhu_room():
44      print("Here you see the great evil Cthulhu.")
45      print("He, it, whatever stares at you and you go insane.")
46      print("Do you flee for your life or eat your head?")
47
48      choice = input("> ")
49
50      if "flee" in choice:
51          start()
52      elif "head" in choice:
53          dead("Well that was tasty!")
54      else:
55          cthulhu_room()
56
57
58  def dead(why):
59      print(why, "Good job!")
60      exit(0)
61
62  def start():
63      print("You are in a dark room.")
64      print("There is a door to your right and left.")
65      print("Which one do you take?")
66
67      choice = input("> ")
68
69      if choice == "left":
70          bear_room()
71      elif choice == "right":
72          cthulhu_room()
73      else:
74          dead("You stumble around the room until you starve.")
75
76
77  start()