孩子们的-Python-项目-全-

孩子们的 Python 项目（全）

原文：zh.annas-archive.org/md5/1178ade1e249892b914a80a672ac8313

译者：飞龙

协议：CC BY-NC-SA 4.0

前言

如您从标题中可以猜到的，这本书旨在向孩子们教授 Python 的基本概念。本书使用几个小型项目，让孩子们学习如何使用 Python 解决问题。

Python 已经成长为一个非常流行的编程语言，用于开发网络应用程序、数据分析以及教授人们如何编写代码。Python 因其使用简单而闻名，因为它读起来就像自然语言一样，而且它能够非常快速地进行数据分析，使其成为创建处理大量数据的网站的理想语言。Python 的另一个优点是，人们一直在开发游戏库，如 pygame，这样人们就可以使用 Python 创建图形程序。使用简单的图形制作短游戏是一种有趣的学习编程结构的方法，对于视觉学习者来说尤其好。

本书涵盖的内容

第一章，欢迎！让我们开始吧，讨论了 Python 以及在 Windows、Mac 和 Linux 操作系统上设置 Python 开发环境。

第二章，变量、函数和用户，涵盖了 Python 数据类型和函数，以及如何编写 Python 程序从用户那里获取信息，存储这些信息，并在以后使用它们。

第三章，计算这个！，使用 Python 制作了一个具有多个数学函数的计算器。我们还学习了在文件结构中工作以及保存代码文件的正确方法。

第四章，做出决定 – Python 控制流，涵盖了if、elif和else的使用，以及for和while循环的使用，以帮助创建基于用户操作的决策程序。

第五章，循环和逻辑，基于前几章所学内容，使我们能够构建一个数字猜谜游戏。我们将构建游戏的不同难度版本。

第六章，处理数据 – 列表和字典，解释了如何使用列表和字典来存储数据。列表和字典之间的区别被解释，我们还花时间构建了一些小的列表和字典。

第七章，你的背包里有什么？，允许我们使用函数、循环、逻辑、列表和字典来构建一种不同类型的猜谜游戏。我们还将学习嵌套字典和列表。

第八章，pygame，讨论了一个在 Python 中用于制作小型游戏的流行图形库。我们将学习这个库的基本方面，并尝试一些代码。

第九章，“迷你网球”，这个游戏是一个流行游戏的克隆版。我们将使用本书中学到的所有技能重新创建这个游戏。这是本书的主要项目。

第十章，“继续编码！”，展示了您阅读本书后将会出现的所有机会。

附录，“快速任务答案”，包含章节中所有快速任务问题的答案。

您需要为本书准备的东西

本书适用于 Windows 10、Mac OS X 或 Ubuntu Linux 操作系统。这些操作系统的其他版本可能也能工作；然而，本书是专门针对这些系统编写的。此外，您还需要互联网下载一些工具，例如为您的操作系统推荐的文本编辑器。所有推荐的下载都是开源的。

本书面向的对象

本书是为那些准备从基于图形的编程环境（如 Scratch）过渡到基于文本的环境的孩子们而写的。准备创建自己项目的孩子们将参与本书的学习，尤其是那些玩过游戏的孩子。完成本书中的项目不需要任何先前的编程经验；本书是为 10 岁及以上的孩子们准备的，他们准备学习 Python 编程。

术语

在本书中，您将找到许多文本样式，用于区分不同类型的信息。以下是一些这些样式的示例及其含义的解释。

文本中的代码单词、数据库表名、文件夹名、文件名、文件扩展名、路径名、虚拟 URL、用户输入和 Twitter 昵称如下所示：“为什么不尝试给电脑的name变量赋予你的名字，然后是height变量赋予你的身高？”

代码块如下设置：

def name():
      first_name = input('What is your first name?')
      print('So nice to meet you, ' + first_name)

   name()

任何命令行输入或输出都如下所示：

python
>>>print("Hello, world!")

注意

警告或重要注意事项以如下框中的形式出现。

小贴士

小技巧和技巧看起来是这样的。

读者反馈

我们欢迎读者的反馈。请告诉我们您对本书的看法——您喜欢或不喜欢的地方。读者反馈对我们来说很重要，因为它帮助我们开发出您真正能从中获得最大收益的标题。

如要向我们发送一般反馈，请简单地发送电子邮件至 <feedback@packtpub.com>，并在邮件主题中提及书籍标题。

如果您在某个主题上具有专业知识，并且您对撰写或为本书做出贡献感兴趣，请参阅我们的作者指南www.packtpub.com/authors。

客户支持

现在您已经是 Packt 图书的骄傲拥有者了，我们有一些事情可以帮助您从您的购买中获得最大收益。

下载示例代码

您可以从www.packtpub.com的账户下载本书的示例代码文件。如果您在其他地方购买了此书，您可以访问www.packtpub.com/support并注册，以便将文件直接通过电子邮件发送给您。

您可以通过以下步骤下载代码文件：

1. 使用您的电子邮件地址和密码登录或注册我们的网站。

2. 将鼠标指针悬停在顶部的支持标签上。

3. 点击代码下载与勘误。

4. 在搜索框中输入书籍名称。

5. 选择您想要下载代码文件的书籍。

6. 从下拉菜单中选择您购买此书籍的地方。

7. 点击代码下载。

您也可以通过点击 Packt Publishing 网站上书籍网页上的代码文件按钮来下载代码文件。您可以通过在搜索框中输入书籍名称来访问此页面。请注意，您需要登录到您的 Packt 账户。

文件下载完成后，请确保使用最新版本的软件解压缩或提取文件夹：

• WinRAR / 7-Zip for Windows

• Zipeg / iZip / UnRarX for Mac

• 7-Zip / PeaZip for Linux

下载本书的彩色图像

我们还为您提供了一个包含本书中使用的截图/图表彩色图像的 PDF 文件。彩色图像将帮助您更好地理解输出的变化。您可以从www.packtpub.com/sites/default/files/downloads/PythonProjectsforKids_ColorImages.pdf下载此文件。

勘误

尽管我们已经尽一切努力确保内容的准确性，但错误仍然可能发生。如果您在我们的书中发现错误——可能是文本或代码中的错误——如果您能向我们报告此错误，我们将不胜感激。通过这样做，您可以节省其他读者的挫败感，并帮助我们改进本书的后续版本。如果您发现任何勘误，请通过访问www.packtpub.com/submit-errata，选择您的书籍，点击勘误提交表单链接，并输入您的勘误详情来报告它们。一旦您的勘误得到验证，您的提交将被接受，勘误将被上传到我们的网站或添加到该标题的勘误部分下的现有勘误列表中。

要查看之前提交的勘误，请访问www.packtpub.com/books/content/support，并在搜索字段中输入书籍名称。所需信息将出现在勘误部分下。

侵权

在互联网上盗版受版权保护的材料是一个跨所有媒体的持续问题。在 Packt，我们非常重视我们版权和许可证的保护。如果您在互联网上发现任何形式的我们作品的非法副本，请立即提供位置地址或网站名称，以便我们可以寻求补救措施。

请通过 <copyright@packtpub.com> 与我们联系，并提供疑似盗版材料的链接。

我们感谢您在保护我们作者和我们为您提供有价值内容的能力方面所提供的帮助。

问题

如果您对本书的任何方面有问题，您可以联系我们的 <questions@packtpub.com>，我们将尽力解决问题。

第一章。欢迎！让我们开始吧

如果你选择了这本书，那么你正在迈出第一步，使用代码构建令人惊叹的项目。你们中的一些人可能想制作游戏，而其他人可能想更多地了解所有你喜欢的网站和应用程序实际上是如何工作的。如果你跟随本书中的练习，你将能够做到以下事情：

• 创建与家人和朋友一起玩的有趣游戏

• 了解你的应用程序的内部运作

• 学习如何掌控你的电脑

为你准备的 Python 项目

在这本书中，你将学习 Python 代码。具体来说，你将学习如何从头开始设计一个计算机程序。如果你以前从未编码过，这无关紧要，因为本书中的每个练习都是为了让你准备好编码。如果你以前编码过，你会发现这本书有一些非常有帮助的练习，可以帮助你的代码变得更好。此外，书中还有一些更高级的项目在书的末尾，你绝对应该看看！

你可以用 Python 做什么？

如果你查看网络并搜索 Python 工作，你会发现许多最高薪的工作都是在 Python 领域。为什么？

Python 在以下方面是一个非常灵活和强大的语言：

• 它可以用来浏览数百万行数据

• Python 可以在不访问网站本身的情况下搜索网站上的信息

• 它甚至被用来托管和设计网站

那么，学习 Python 需要什么？如果你从未编程过，你可能希望按顺序跟随每一课，这样你就可以构建制作游戏或其他类型计算机程序所需的技能。本书的最终项目将是一个游戏。如果你有一些其他编程经验，比如修改你的电脑游戏，使用 Scratch 或 Logo 程序，或者尝试一些互联网上的免费编程课程，那么你可能决定先快速浏览这本书，看看你已经知道了什么。仍然建议你按照书中内容的顺序来学习，因为每个项目都是建立在上一章解释的项目之上的。

为什么你应该学习 Python

Python 教授了面向对象编程语言的所有基础知识，并且仍然非常强大。实际上，许多互联网公司，最著名的是 Mozilla Firefox 和 Google，在它们的部分或全部产品中使用 Python！Python 也被用来构建 Django，一个用于制作网站的免费框架。

它也被用来构建许多小型视频游戏，这些游戏是由学习 Python 的人以及更高级的程序员制作的。最后，Python 可以用来快速读取和分析数百万行数据！通过学习 Python，你将准备好构建各种有趣的项目，如果你选择这样做，你将获得学习其他编程语言所需的技能。

Python 的先决条件

在您开始之前，您需要以下基本材料：

• 一台可以运行 Windows 7 或更高版本、Mac OS X 10.6 或更高版本或 Ubuntu 12.4 或更高版本的计算机。您也可以使用 Raspberry Pi，因为它预装了 Python、pygame 以及完成本书中项目所需的其它软件。

• 互联网连接是必要的，因为您可能需要在计算机上安装的一些软件可能尚未安装。例如，Windows 操作系统没有预装 Python，因此需要互联网连接；pygame 也没有在 Windows、Mac 或 Linux 系统上预装。

• 除了互联网连接外，您还需要一个网络浏览器，例如 Firefox、Safari、Chrome 或 Internet Explorer，这将允许您访问 Python 文档页面。

注意

本书中的所有代码示例都可以在 Packt Publishing 网站上下载。

设置您的计算机

有许多不同的计算机操作系统，但最常见的操作系统是 Macintosh（Mac）、Windows 和 Linux。您应遵循与您的操作系统相对应的安装步骤。这些系统之间存在一些微妙但重要的差异。

对于本书中的项目，我们将使用 Python 2.7。虽然还有比这更高的版本（3.x），但这些版本在 Windows、Mac 或 Ubuntu Linux 上与 pygame 的兼容性尚未稳定。然而，本书将编写为使用适用于两种 Python 版本的约定，以便在 Raspberry Pi（使用专门配置了 pygame 的 Python 3.x）上只需进行少量修改即可轻松完成项目。这些修改将予以注明。

对于 Mac 和 Ubuntu Linux 用户

Mac 和 Linux 系统之间有足够的相似性，使用 Mac 或 Linux 的人可以遵循相同的指令集。这些指令将注明 Mac 和 Ubuntu Linux 之间的任何差异。

Python 2.7

在撰写本书时，Mac OS X El Capitan 预装了 Python 2.7，因此在此阶段无需做任何额外操作。

Ubuntu Linux 15.10 默认安装了 Python 2.7.10，因此使用这个最新版本（撰写本书时）的 Linux 用户在此阶段也无需做任何额外操作。

终端 – 命令行和 Python 壳

Mac 和 Ubuntu Linux 用户默认拥有 Python，但如果您不知道在哪里查找，找到 Python 会很困难。在 Mac 和 Linux 操作系统中都有一个名为终端的程序。这个程序允许您以这种方式对您的计算机进行大量控制：

• 在 Mac 上，转到查找器 | 应用程序 | 实用工具，然后点击终端。终端应用程序将打开，您应该会在屏幕上看到一个小的白色窗口。

• Ubuntu 用户可以在桌面上搜索“终端”，程序将在他们的开始菜单中显示。当您点击终端时，您将在屏幕上看到一个小的黑色窗口。

• 当给出运行 Python 的命令时，终端也充当 Python 壳。我们将在稍后学习这一点。

文本编辑器

文本编辑器是编写和编辑 Python 程序的有用工具。终端是测试 Python 代码片段的好地方，但当我们想要编辑和保存代码以便再次使用时，我们需要一个文本编辑器。尽管 Mac 和 Linux 系统都自带了文本编辑器，但也有一些非常好的免费编辑器，它们具有很好的功能。jEdit就是这些编辑器之一。

注意

对于 Mac 和 Linux，请访问 www.jedit.org/ 并下载 jEdit。按照安装说明进行操作。

要成功完成本书中的所有练习，您通常需要在屏幕上同时打开终端和文本编辑器。

这是在 Mac 和 Linux 中文本编辑器应用 jEdit 的样子：

对于 Windows 用户

Windows 用户，这个设置可能需要你父母的帮助。由于 Windows 上默认没有安装 Python，因此需要对系统进行一些调整才能在您的计算机上成功运行 Python。如果您不确定自己执行这些系统更改，请务必寻求帮助：

1. 首先，您需要下载 Python 2.7.11 版本。

   注意

   在 www.python.org/downloads/release/python-2711/ 使用官方 Python 网站下载 Windows 的最新版本。

   使用 Windows，您需要确定您正在运行 32 位还是 64 位，以便您可以下载正确的 Python 版本。为了帮助您确定哪个是正确的，请访问

   windows.microsoft.com/en-gb/windows/32-bit-and-64-bit-windows#1TC=windows-7。

   如果您的计算机运行的是 32 位 Windows，请下载x86only。大多数用户会下载 x86-64 版本的 Python。

2. 选择可执行安装程序，您将看到下载进度。

3. 下载完成后，您将看到一个运行 Python 的提示。点击运行。

4. 当出现安装提示时，请查看窗口底部并点击添加 Python 2.x 到 Path旁边的框。然后，选择现在安装。

5. 按照安装说明进行操作。每一步可能需要几分钟。安装完成后，您将在 Windows 搜索栏中搜索Python时找到 Python 2.7.11 的图标。这将打开一个特殊的 Python 壳，您可以从那里运行和测试 Python 代码。

命令提示符

在 Windows 10 中，您将看到一个称为命令提示符的终端。与 Mac 或 Linux 相比，Windows 中的命令提示符有显著的不同。

要在 Windows 10 中找到命令提示符，请执行以下步骤：

1. 前往屏幕底部的搜索栏并搜索 cmd 或 command。

2. 当你这样做时，你会看到命令提示符桌面应用程序出现。点击此应用程序以打开命令提示符，它看起来像这样：

文本编辑器

在 Windows 中，Notepad 是默认的文本编辑器。然而，Notepad++ 是一个更好的替代品。

要获取 Notepad++，请执行以下步骤：

1. 前往 notepad-plus-plus.org/ 并下载最新版本。

2. 一旦程序已下载，点击 运行。

Notepad++ 看起来像这样：

在命令行中编写和运行你的第一个程序

现在你已经设置好了，是时候在 Python 中编写你的第一行代码了！对于第一次编程的人来说，这一行代码几乎是一种传统，它允许我们使用 Python 语言中最基本但最有用的功能之一。

首先，你需要开始运行一个 Python 壳。在 Mac 或 Linux 上，打开你的终端并输入以下内容：

python

在 Mac 或 Ubuntu 终端中，你的 Python 壳将看起来像这样：

>>>

在 Windows 中，在页面底部的搜索栏中输入 Python。然后，从你的应用程序中选择 Python 2.7.11。你还将打开一个 Python 壳：

>>>

一旦你看到这个符号，你的电脑现在就可以开始使用 Python 代码工作了。在你的终端或 IDLE 中，输入以下内容：

>>>print("Hello, world!")

输入此内容后，请再次检查以确保所有空格都与原文完全一致。在 Python 中，每个空格实际上都很重要。每个标点符号都很重要。检查完你的代码后，按 Enter。

你的结果或代码的输出是什么？如果输出看起来像以下图片，那么太好了！你正确地输入了所有代码，所以电脑会理解你想要它做什么。预期的输出将类似于这里所示：

对于 Windows 用户，输出窗口将看起来像这样：

因此，如果你的输出看起来不像前面的代码，你需要找出它的问题所在。以下是一些可能的原因：

• 你犯打字错误了吗？

• 你忘记为 'Hello, world!' 使用括号或圆括号 () 吗？

• 你忘记为 Hello, world! 使用单引号 '' 吗？

如果你仍然有问题，将你的代码与示例输入代码进行比较，并修复任何错误。然后，再次尝试运行代码。

备注

Python 是一种所谓的 大小写敏感 语言。Python 注意大小写、空格。你需要注意你输入的内容。如果你打字错误或语法错误，你的电脑可能会显示一些奇怪的消息。

创建一个工作文件夹

在我们开始任何大型项目之前，我们需要创建一个工作文件夹。在下一章中，你将开始编写需要运行的整个代码文件；因此，我们需要一个地方来存放这些文件。既然你现在正在设置，让我们创建一个文件夹。

如果你非常擅长在电脑上操作，你可以把你的文件夹放在你想要的地方。

如果你不太擅长在电脑上操作，你可能想把你的文件夹放在你的桌面上。

在 Mac 和 Windows 机器上，你可以在桌面壁纸的任何位置右键单击，会出现一个带有几个选项的框。其中一个选项会说是 新建，当你将鼠标悬停在 新建 上时，你会得到几个其他选项。选择 新建文件夹，一个新文件夹图标将出现在你的桌面上。它将被命名为 untitled，所以你应该给它一个更好的名字。

要在 Mac 或 Linux 终端中找到你的文件夹，分别打开其中一个并执行以下步骤：

1. 运行 cd .. 命令，直到你到达根目录，这通常是你的电脑名称。你可能需要运行这个命令三到四次。

2. 现在，你将能够通过输入 python3.5program.py 来运行 Python 程序。

要在 Windows 命令行中找到你的文件夹，打开命令提示符并执行以下步骤：

1. 运行 cd .. 命令，直到你到达根目录或 C:\>。你可能需要运行这个命令三到四次。

2. 现在，你将能够通过输入 python program.py 来运行 Python 程序。

给你一个快速任务

现在你已经完成了这一章，你能回答这些问题吗？

Q1. 终端（Mac/Linux）或命令提示符（Windows）是什么？

1. 终端用于在不使用桌面图标的情况下将数据放入或从电脑中取出。

2. 终端可以用来编写计算机程序。

3. 终端可以用来进行复杂的工作，例如在 Python 代码上提供提示。

4. 终端可以做所有上述事情。

Q2. 当你第一次打开终端/命令提示符时，你需要做什么才能开始阅读和编写 Python 代码？

1. 开始输入代码。

2. 输入单词 python。

3. 等待 Python 启动。

4. 以上都不是；做些不同的事情。

Q3. Python shell 与命令行有何不同？

1. 它们完全一样。

2. 命令行不能运行 Python 命令。

3. 通过在命令行中输入单词 python 来启动 Python shell。

4. Python shell 可以用来测试 Python 代码的行。

注意

将你的答案与你在书后面的答案进行比较。

摘要

如果你正在阅读这篇文章，那是因为你已经成功完成了学习使用 Python 进行编程项目的一些棘手工作。恭喜你！设置环境总是很艰难。希望你在计算机工具方面学到了更多，比如每个程序员日常工作中都会使用的文本编辑器和终端。此外，你还学习了 Python 的print()函数，现在你应该能够在你 Python 的 shell 中打印出信息了。有趣的部分才刚刚开始，因为我们还有更多东西要学习！

在下一章中，你将学习 Python 程序的基础构建块。我们将从变量开始，了解我们可以放入其中的所有不同类型的信息。然后，我们将构建一些函数，将这些变量组合起来，帮助我们创建具有特殊任务的代码块。最后，我们甚至将学习如何让计算机向用户提问并存储他们的答案，这样我们的程序就可以变得交互式了！

第二章：变量、函数和用户

在上一章中，你学习了如何在你的计算机上安装 Python。你还学习了如何在 Python 中使用print语句，并使用你的 Python shell 打印了一些消息。我们现在将深入很多细节，以便我们可以一起构建我们的第一个项目。它将包括以下内容：

• 变量

• 变量名

• 字符串、整数和浮点数

• 函数

变量

变量是指用一个字母或单词来代表不同的字母、单词、数字或值。一种思考变量的方式是想象你正在编写计算机程序，以便它可以记住东西。例如，我的名字是 Jessica。如果我正在编写一个计算机程序，并且想让这个程序记住我的名字，我会将我的名字分配给一个变量。这看起来像name = 'Jessica'。变量是name。Jessica在内存中。

也许我还想让计算机记住关于我的其他信息。也许我想要计算机程序记住我身高 64 英寸，或者大约 128 厘米。我会说height_inches = 64或height_centimeters = 128。这里的变量是height_inches和height_centimeters。这些记忆是我的身高（英寸）和我的身高（厘米）。

你为什么不尝试给计算机一个包含你名字的name变量，然后一个包含你身高的height变量？

首先，打开你的 Python shell 并输入以下代码：

name = 'yourname'
height = 'your height'

现在变量已经存储了，你可以输入print(name)或print(height)。由于你为计算机创建了一个包含你的名字和身高的记忆，计算机将打印出你给出的记忆。如果你查看我的 Python shell 的截图，你会看到计算机打印出了我分配给它的记忆。注意，我们不需要在变量名周围使用单引号：

如果你分配给变量的值或记忆在 Python 终端中打印出来，那么就是完美的。如果没有，你可能有一个错误。由于许多原因，可能会发生错误。你可能以违反 Python 约定的方式输入了变量名或信息。一些常见的错误包括使用大写字母。

变量命名 - 遵循的约定

在 Python 中命名变量有一些约定。关于命名事物的指南可能看起来很愚蠢，但遵循这些约定非常重要，因为它有助于其他人阅读你的代码。此外，Python shell 被设计为与这些约定一起工作。

为了避免错误，你的变量名应该使用小写字母。如果你的变量由多个单词组成，例如height_inches变量，那么它应该使用下划线来连接单词。

如果你用两个单词来命名你的变量并且没有用下划线连接它们，你会得到一个错误。看看下面的截图，看看它说SyntaxError: invalid syntax在哪里。注意这个错误发生是因为height centimeters变量没有用下划线来连接单词：

变量能记住什么？

Python 变量可以被编程来记住各种信息！你会在我们的原始示例中注意到，我们存储了一个单词然后是一个数字。我们将使用三种不同类型的信息来构建我们的计算器，在第三章，计算这个！，字符串、整数和浮点数。每条信息输入和输出的方式都略有不同。

字符串

在 Python 中，字符串是任何被两个单引号包围的数据，即这些符号' '。有时也会使用双引号。例如，我可以有一个看起来像这样的字符串变量：

sentence = 'This is a sentence about Python.'

这个字符串变量包含字母和单词。大多数字符串变量都是这样。然而，只要这个数字在单引号中，你也可以把它作为一个字符串存储：

 number_string = '40'

如果我们可以将所有信息作为字符串存储，为什么还需要其他数据类型呢？嗯，当我们把数字作为字符串存储时，我们不能对数字进行数学运算！把这个问题输入到你的 Python 壳中，然后你就会看到为什么我们除了字符串之外还需要数据类型：

 first_number = '10'
 second_number = '20'
 print(first_number + second_number)

在你的 Python 壳中发生了什么？你可能预计打印的输出会是30，因为10加20等于30。然而，Python 把每个数字都看作是一个文本字符串，只是简单地把两个文本字符串并排放置。所以，你的结果可能是1020。这就是它在 Python 壳中的样子：

整数

计算机在数学方面真的很擅长，数学将使我们能够执行更复杂的程序，例如游戏。Python 将整个数字数据存储为整数。

让我们从整数开始：

• 整数就是一个简单的纯整数。如果我们想让变量存储整数，我们就去掉引号。

• 然后，当我们把两个变量相加并打印输出时，我们会得到一个数学结果。

尝试一下！让我们用这些变量做一些数学运算：

1. 在你的 Python 壳中输入以下两个变量：

    first_number = 10
    second_number = 20
   
   

2. 然后，通过输入print和变量来打印输出：

    print(first_number + second_number)
   
   

完成步骤 2 后，按Enter。你的结果应该是30。这是因为 Python 将数字读作整数，Python 理解带有数学运算符的整数。事实上，Python 对数学的理解如此之好，以至于你可能会注意到不需要等号来告诉 Python 输出答案。看看这个截图：

浮点数（浮点数）

希望你现在更好地理解了 Python 如何处理整数（整数）。然而，人和计算机通常需要使用分数数。在 Python 中，这些数字被称为浮点数，但许多人将其简称为floats：

• 浮点数实际上是一种非常花哨的说法，即使用小数表示的数字

• 浮点数之所以被称为这样，是因为小数点可以在数字中的任何位置，允许有不同大小的分数

• 将数字设置为浮点数允许我们使用分数数进行更复杂的数学运算

• 要将变量设置为浮点数，你不需要做任何特殊或不同于设置整数的事情

• Python 知道带有小数点的数字输入（例如变量）是浮点数，如果问题明确，Python 将输出答案作为浮点数

在你的 Python 壳中，尝试使用浮点数而不是整数来解决这个问题：

 first_number = 10.3
 second_number = 20.3
 print(first_number + second_number)

这次，在你的 Python 壳中，你应该注意到 Python 已经识别变量 input 为浮点数，并且能够输出完整且正确的答案，而无需我们使用额外的指令。你的print语句的输出应该是30.6，正如你在 Python 壳的截图中所见：

组合字符串、整数和浮点数

到目前为止，我们只尝试组合具有相同数据类型的项。我们添加了两个字符串、两个整数或两个浮点数。当你尝试添加不同类型的信息时会发生什么，比如一个字符串和一个整数？在你的 Python 壳中，输入以下代码行并注意输出：

 first_number = '10'
 second_number = 20
 print(first_number + second_number)

你可能会注意到你收到的错误。需要关注的重要行是TypeError: cannot concatenate 'str' and 'int' objects。Python 告诉我们它不能处理这两种不同的数据类型，这是有道理的。所以，如果你在输入时出错或尝试在两种不同的数据类型中执行操作，你可能会得到这样的错误：

函数

一旦我们有了变量，我们就可以使用它们做一些非常有趣的事情。最有趣的事情是构建函数。Python 函数是我们可以构建以执行特定任务的代码块。我们只需构建一次这些函数，然后只需通过输入名称就可以在代码中重复使用它们。这非常有帮助。例如，如果我要编写一个程序来添加两个数字（例如计算器），我不想每次添加两个数字时都不得不编写三行或四行的代码。相反，我想编写一个可以相加两个数字的函数，然后在我需要添加数字时使用这一行。

在我们开始构建自己的函数之前，我们还需要知道 Python 有很多内置的令人惊叹的函数。Python 的一些函数是我们将经常使用的。其他的一些函数在这本书中不会讨论，但随着你成为一名更熟练的程序员，你将了解更多关于 Python 内置函数的知识。

内置函数

下面是一些关于内置函数及其作用的内容：

• int(): 这将字符串或浮点数转换为整数

• float(): 这将字符串或整数转换为浮点数

• raw_input(): 这从用户那里获取信息并将其存储在计算机中以供以后使用

• str(): 这将整数、浮点数或其他信息转换为字符串

• help(): 这提供了访问 Python 的帮助

我们将在下一章中用这些函数来帮助我们构建我们的第一个项目。

注意

如果你好奇其他内置函数是什么，或者你想了解更多信息，你可以访问 Python 文档在 docs.python.org/2.7/library/functions.html?highlight=built%20functions#。

初始时，文档可能看起来令人不知所措，因为它们非常详细。有时细节会使文档难以理解，但文档非常有帮助，并被许多程序员使用。

函数的组成部分

当你想构建自己的函数时，有一些基本部分需要考虑。首先，这是添加两个数字的基本函数：

 def addition():
 first_number = 30
 second_number = 60
 print(first_number + second_number)

这段代码的第一行是新的，因此我们需要理解它的含义：

• 首先要注意的是单词 def。在 Python 中，这是 define 的缩写，用于定义一个新的函数。

• 下一个需要注意的事项是函数的名称。函数的命名规则与变量的命名规则相同。函数需要使用小写字母，并且当它包含多个单词时，每个单词之间需要使用下划线。

• 在 addition() 函数的名称之后，你会注意到括号 ()。在这个函数中它们是空的，但有时它们不是空的。即使它们是空的，括号也必须是您创建的函数的一部分。

• 最后，函数的第一行以冒号结尾。冒号（:）标志着函数第一行的结束。

一个函数可以很短，比如这个 addition() 函数，总共只有四行，或者它可以非常长。Python 函数中第一行之后的每一行都需要使用空格缩进。在我们本章下一节构建自己的函数时，你将学习如何在 Python 命令行中设置缩进。我们还将讨论文本编辑器中的适当间距。

为了编写函数，有很多新的细节需要记住。如果你忘记了某个细节会怎样？如果你忘记缩进一行，Python 会告诉你并输出错误。你的函数将不会运行，你的代码将不会工作。Python 使用缩进的方式被称为空白字符，Python 中关于空白字符的使用有一些规则。

到现在为止，你对在 Python 中进行加法操作已经很熟悉了，所以我们将继续使用加法代码。在 Python shell 中编写函数有一些特殊的注意事项。因为函数是一段代码块，当我们试图在 shell 中执行函数时，想要遵循以下指南：

• 在输入第一行并按下Enter键后，确保在输入每一行之前按下Tab键。

• 当你完成所有行的输入后，按两次Enter键，这样 Python shell 就知道你已经完成了函数的创建。

在你的 Python shell 中，将addition()函数输入得与这里显示的完全一致：

 def addition():
 first_number = 30
 second_number = 60
 print(first_number + second_number)

注意函数在 Python shell 中的样子：

现在你已经输入了函数，你需要学习如何使用这个函数。要在 Python shell 中使用函数，输入函数的名称和括号：

 addition()

输入函数也被称为调用函数。当你调用 Python shell 中的addition()函数并按下Enter键时，你会得到一个输出作为问题的答案。注意这里是如何显示的：

将你的结果与前面截图中的结果进行比较。一旦你知道你的函数按预期运行，你可以通过让他们查看你的代码来向你的父母和朋友展示。一个好的主意是通过用不同的数字重新输入函数来测试你的函数。

与你的程序交互的用户

我们刚刚构建了一个将两个数字相加的函数。学习编写执行数学运算的程序很有趣，但我们的函数有限，因为我们的addition()函数需要手动更改变量来计算不同数字的结果。

如果有一种方法可以从用户那里获取信息并将该信息存储在变量中，以便每次可以使用加法或减法函数来使用它，那会怎么样？任何使用过任何类型的计算器的人都知道这是可能的。Python 有一个名为raw_input()的函数，允许我们告诉程序向用户提问。raw_input()函数非常有用。我们可以通过这种方式从用户那里获取各种信息，并且可以根据用户输入与计算机进行交互。

我们可以使用 Python shell 来测试raw_input()函数的工作方式。尝试将这些两行代码输入到你的 Python shell 中：

 name = raw_input('What is your name?')
 print(name)

这里发生了什么？让我们看看：

• 应该发生的事情是，你应该在终端中看到一个提示，询问 'What is your name?' 然后，你可以输入你的回答。

• 在你的回答后，按 Enter。什么也不会发生（现在不应该发生任何事情！）。

• 你已经给计算机提供了存储在 name 变量中的信息（一个内存），但现在你需要从 name 变量中获取信息。

• 你可以通过打印 name 变量来获取用户输入的内存输出。

在这个屏幕截图中，你可以看到 Python 壳中的整个序列：

使用文本编辑器和命令行

到目前为止，我们使用 Python 壳来编写和测试代码。壳很棒，因为我们输入一行代码或甚至几行代码，然后立即运行它们以查看它们是否工作。然而，你可能已经注意到没有保存我们编写的任何代码的方法。

为了程序能够运行，它需要拥有所有可用的代码。使用文本编辑器就像写报告、电子邮件或论文一样：我们编写代码并保存它；然后，如果我们想修改，就回去编辑它。为了使 Python 使用并理解我们的文件，我们需要使用命令行并告诉 Python 运行该文件。

为了完成本书中的下一个任务以及剩余的任务，我们将同时使用我们的文本编辑器和终端/命令提示符。现在，让我们一起来了解一下文本编辑器和命令行的设置。

你需要做的第一件事如下：

• 创建一个特殊的文件夹，用于存放你的代码文件，并记住如何找到这个文件夹！（查看第一章，欢迎！让我们开始吧，获取说明。）

• 这个文件夹，或目录，非常重要，因为这将是你存放本书其余部分所创建工作的地方

• Python 需要能够访问这个目录来运行所有程序，不久我们将编写使用其他文件的文件；因此，所有文件都需要生活在同一个地方

一旦你确定你有一个特殊的文件夹，你就可以打开我们在第一章中设置的文本编辑器程序，欢迎！让我们开始吧。你还会在终端或命令提示符中打开一个新窗口。

构建自己的函数 – name()

因此，你已经了解了变量以及它们如何存储信息。你还了解了这些变量如何在函数内部使用。最后，你学习了如何使用特殊的 Python 函数，如 input()，来帮助从用户那里获取信息并将其存储在计算机中。你现在可以使用变量和 input() 构建自己的函数。

设置你的项目文件

我们现在要构建的函数叫做 name()。这个函数的目的将是询问用户他们的名字，存储（记住）这个名字，然后向用户打印一条友好的信息。

要启动这个函数，请按照以下步骤操作：

1. 在你的文本编辑器中打开一个新文件。

2. 前往保存并命名文件为name.py。

   小贴士

   你需要在所有代码文件末尾使用.py，这样文件才能在终端/命令提示符中运行。Python 只识别.py文件。

3. 将文件保存在你为所有 Python 工作创建的文件夹中。

开始你的项目

一旦你设置好了项目文件，你可能想要做的第一件事就是在你的文件中添加一条简短的注释。注释允许人类快速理解代码中正在发生的事情。无论你写的是非代码内容，都应该以井号（#）开始这一行。井号是告诉计算机“忽略这个！”的一种方式，但它允许人类阅读文本。在你的文件中输入以下行：

# 这是我的第一个名为 name 的函数。它将询问名字并打印一条消息。

编写代码

你接下来输入的行将开始计算机可读代码。首先，确保你写的注释和第一条计算机可读代码之间有一个空格。正如我们之前学到的，你将使用 Python 单词def来开始函数。然后，你将输入一个空格和函数名：

 def name

接下来，你将在第一行添加括号()和冒号:：

 def name():

现在，是时候进入下一行了。对于下一行，你需要进行缩进。使用空格键插入四个空格。在 Python 中，空格很重要。使用制表符键，或者混合使用制表符和空格，在 Python 中会引发错误。

由于我们正在请求用户输入他们的名字，如果你愿意，可以使用first_name作为变量名：

 def name():
 first_name =

first_name变量将存储问题的答案，“你的名字是什么？”记住，尽管如此，我们必须使用raw_input()函数来获取用户回答问题！因此，我们将添加raw_input()函数和问题到代码中：

 def name():
 first_name = input('What is your first name?')

到目前为止，我们已经编写了一种让计算机询问用户名字的方法，并且我们创建了一个名为first_name的变量来记住信息字符串。

尽管我们有一个包含一些代码行的文件，如果我们现在运行我们的代码，什么都不会发生。我们需要一种方法来向用户显示他们的名字，如果我们可以发送一个欢迎消息那就更好了。我们需要编写程序输出的代码。

我们一直在使用print从第一章，“欢迎！让我们开始吧”，以及在这一章中输出我们的信息，print在这里也很有用。我们可以告诉我们的函数打印first_name信息，并且我们可以将这条信息与一条友好的消息结合起来。将以下行添加到你的代码中：

 print('So nice to meet you, ' + first_name)

name()函数的总代码应该看起来像这样：

def name():
 first_name = input('What is your first name?')
 print('So nice to meet you, ' + first_name)

下面是程序在文本编辑器中的样子示例：

我们只需要添加最后一行代码，即调用 name() 函数。如果我们不调用函数，它将不会运行。要调用函数，你应在 print 后留一个空行，然后在新的行上缩进并输入 name()。看看这个代码示例，并将 name() 函数添加到你的代码中：

def name():
 first_name = input('What is your first name?')
 print('So nice to meet you, ' + first_name)

name()

现在我们已经创建了此函数，我们可以用它来问候任何人，因为用户每次都会告诉我们 first_name 应该是什么。我们已经创建了一个可重用的代码块。

运行你的程序

现在你必须保存你的工作：

1. 前往你的文本编辑器的 保存 选项，并将 name.py 的工作保存。

2. 保存完这项工作后，你应该转到你的终端/命令提示符。

3. 确保你处于正确的文件夹中。

   提示

   如果你不确定，你可以输入 pwd（Mac/Linux）或 echo %cd%（Windows）来找出你所在的文件夹。

4. 当你在与你的工作相同的文件夹中时，输入：

    python name.py
   
   

5. 然后，按 Enter。你的程序应该开始运行。

输入名称后，输出应该看起来像这样：

你现在有一个可以与家人和朋友分享的程序，他们会觉得非常神奇，特别是如果他们以前从未编程过的话！

走得更远一些

所以，如果你真的想理解所有这些，就走得更远一些！尝试你刚刚创建的代码，看看什么有效，什么无效。如果你遇到奇怪的错误，你总是可以将错误复制并粘贴到互联网搜索引擎中；我们迄今为止看到的大多数错误都发生在其他人身上。以下是一些帮助你实验并获得精通的提示：

• 更改输入问题

• 更改用户的消息

• 更改函数名

• 更改变量名

• 添加第二个变量和第二个输入问题

• 将第二个变量添加到输出问题中

一个快速的任务给你

现在你已经完成了这一章，你能回答这些问题吗？

Q1. 函数必须以什么开始？

1. def

2. 函数

3. 输入

4. 空白字符

Q2. 用来命名变量和函数的约定有哪些？

1. 必须使用小写字母

2. 多个单词需要用下划线连接

3. 不能以数字开始命名

4. 所有上述

Q3. 函数的第一行之后的每一行必须是什么？

1. 使用数字命名

2. 有一个冒号，:

3. 缩进

4. 使用括号 ()

Q4. 如果你想让代码文件在 Python 中运行，你需要以什么结束？

1. .txt

2. .odt

3. .pdf

4. .py

Q5. 在终端中运行代码文件，你需要做什么？

1. 在终端中输入文件的名称

2. 在运行 Python 时，在终端中输入文件名

3. 在正确的文件夹中，输入 Python 和文件名

4. 所有上述步骤按顺序

摘要

在本章中，我们学习了如何将信息存储在变量中，以便计算机可以在以后记住它。我们学习了如何使用变量来创建一个可以将两个预编程数字相加的函数。然后，当我们学习如何让计算机提问并记住用户的答案时，事情变得有趣起来！使用raw_input()，我们学习了如何将答案作为变量存储起来，以便在我们一起构建的name()函数中使用。我们开始将我们的工作保存在.py文件中，这样我们就可以在我们的终端/命令提示符中运行和重新运行我们的文件，而无需每次都重新输入文件。

在下一章中，你将构建一个四功能计算器，在命令行中运行，使用本章所学到的所有技能！

第三章。计算这个！

在上一章中，你学习了变量的用途、不同的数据类型和函数。你创建了自己的函数，并学习了如何使用 raw_input() 函数从用户那里获取基本信息。使用这些构建块，你可以开始设计基本程序。

我们制作的第一个程序将是一个具有五个功能的计算器，它将计算两个输入数字。这个计算器将帮助我们学习理解 Python 中作为一部分的数学函数，这将在本书结尾的游戏中很有用。此外，这个计算器将为第五章中的更复杂计算器奠定基础，循环和逻辑。

计算器

第一个计算器是在 1966 年由德州仪器公司发明的(www.ti.com/corp/docs/company/history/timeline/eps/1960/docs/67-handheld_calc_invented.htm)，能够进行加法、减法、乘法和除法。计算器有十八个按键，可以在屏幕上显示十二个数字。虽然一开始看起来并不多，尤其是与我们现在所享受的技术相比，但一个基本计算器执行的操作中包含了大量的代码和决策。

当我们想要弄清楚某物是如何工作时，我们需要将其分解成更小的部分。让我们看看计算器是如何将数字相加的：

1. 首先，计算器需要电源。

2. 用户输入第一个数字。

3. 用户按下操作键（+，-，**，或 /）。

4. 用户输入第二个数字。

5. 用户按下 = 键。

6. 然后，将答案打印到屏幕上。

在基本的计算器上，计算机不会在屏幕上保留所有数字。计算机必须将其用户输入的第一个数字存储在内存中。

我们将在终端/命令提示符中运行我们的第一个计算器程序，因此除了如何存储数字之外，我们还需要考虑其他事情。例如：

• 我们将如何提示用户获取我们所需的信息？

• 如果用户输入的是文本字符串而不是整数或浮点数，会发生什么？

• 如果用户输入的是字符串而不是整数或浮点数，会发生什么？

这些只是在我们计划编写自己的计算器程序时需要考虑的一些逻辑问题。你能想到其他需要解决的问题吗？

基本功能

我们在本章的开头了解到，第一台电子计算器有四个基本功能：加法、减法、乘法和除法。我们将致力于编写每个这些功能，我们还将学习一个可以为我们计算器编程的第五个数学函数，称为取模。

到本章的开头，我们将使用addition()函数作为我们的例子。一旦我们创建并测试了一个能够完成我们想要的功能的addition()函数，我们就会构建我们的其他函数。

让我们回到第二章中关于加法函数的例子，变量、函数和用户。回忆一下我们是如何编写这个函数的：

上一张截图中的加法函数确实执行了正确的加法并打印了答案。然而，以这种方式设计addition()函数存在一些问题。一个问题是这个程序只能反复添加相同的两个数字。另一个问题是，在这个程序中，我们只使用了一种数学运算（加法）。这个addition()函数本身太不灵活了；我们需要设计一个更用户友好的函数。

为了设计一个更好的数学函数，我们需要通过让用户改变计算中的数字来解决用户输入的问题。我们还需要设计一个计算器，让用户能够执行除了加法以外的数学函数。

对两个数字进行操作

我们将使用在第二章中学习的raw_input()函数，变量、函数和用户。回想一下，从本章开始，我们无法对两个字符串进行加法运算。实际上，我们无法对字符串执行任何类型的数学运算。

以下代码请求用户输入并将输入存储在计算机中作为字符串。在您的 Python 壳中输入以下代码以查看结果：

def addition():
 first = raw_input('I will add two numbers. Enter the first number')
 second = raw_input('Now enter the second number.')
 print(first + second)

当你调用addition()函数时会发生什么？如果你调用addition()函数，你会看到加法并没有发生。这个程序只是按照用户输入的顺序将两个数字并排放在一起打印出来：

虽然将信息并排放置对组合单词成短语或句子很有用，但正如我们在第二章中发现的，它对进行数字计算并不很有帮助。相反，您可能希望将用户的答案转换为数字，以便可以对数字执行数学运算。要将input()函数转换为数字，您将使用int()或float()函数。

将数据转换为数字 – int()和float()

为了将raw_input()函数中输入的用户数据从字符串转换为数字，我们需要使用整数函数int()或浮点数函数float()，以便让计算机将答案解释为数字。

浮点数转换为整数

要尝试一个例子，请在您的 Python 壳中输入以下内容，并注意结果：

a = int(44.5)
b = float(44.5)
print(a)
print(b)

在前面的例子中，使用44.5时，你应该注意到int()函数将数字向上舍入到44，而float()函数则保持数字为44.5。这是因为int()喜欢整数，并自动向下舍入数字。看看这个来自 Python shell 的截图：

整数到浮点数转换

现在，尝试相反的操作。使用以下代码在 Python shell 中将整数转换为整数和浮点数：

 a = int(24)
 b = float(24)
 print(a)
 print(b)

在前面的示例代码中，你可以看到int()函数保持数字为24，而float()函数在数字上添加一个小数位，使其打印为24.0。这是因为 float 被设计用来处理数字及其小数位。你可以在 Python shell 的此截图中看到结果：

文本字符串在 int()和 float()中失败

如果你尝试将文本字符串输入到int()或float()函数中，你会得到一个错误。实际上，你只能将这两行中的第一行输入到你的 Python shell 中。这将立即将int('hello')代码评估为错误：

 int('hello')
 float('hello')

这是因为int()和float()专门应用于数字，并且不处理无法转换为数字的事物。在下面的截图，注意 Python shell 返回了一个称为 traceback 的错误代码，有三行错误信息：

在整本书中，我们将交替使用int()和float()，这样你就能习惯使用这两个函数：

• int(): 此函数将数据转换为整数

• float(): 此函数将数据转换为带小数的数字

现在我们已经了解了将字符串转换为数字的方法，让我们重新编写我们的加法函数，从用户那里获取输入，并使用float()函数将输入转换为十进制数字。你可以直接将此代码复制到你的文本编辑器中：

 def addition():
 first = float(input('What is your first number?'))
 second = float(input('What is your second number?'))
 print(first + second)

在下面的截图，你可以看到定义了加法函数的 Python shell。你还可以看到，当调用加法函数时，每行raw_input都会打印出来，用户通过输入一个数字来回答。第一个和第二个输入已经转换为整数，所以当答案相加时，你会注意到输出现在根据标准的加法规则是正确的：

创建我们的第一个计算器文件

在我们继续之前，请保存你的工作。打开你的文本编辑器，创建一个名为 first_calc.py 的文件，然后将你刚刚创建的加法函数输入到该文件中。确保将文件保存在你之前在桌面上的第一章，欢迎！让我们开始吧中创建的工作文件夹中。保持你的工作井然有序，这样你就可以运行你的代码来测试它并展示它：

新函数 - 减法、乘法和除法

现在我们已经创建了一个 addition() 函数，该函数接受用户输入并将其转换为数字，我们准备创建减法、乘法和除法的函数。

如果你是在休息后回到这里的，请执行以下步骤：

1. 打开你的 Python 壳，以便你在编写代码时可以测试它。

2. 接下来，打开你的文本编辑器（Mac/Linux 上的 jEdit 和 Windows 上的 Notepad ++）。

3. 在你编程时，请确保在桌面上同时打开两个窗口。

4. 当你在 Python 壳中成功编写并测试了一行或几行代码后，将这行代码复制到你的文本编辑器中，然后保存你的工作到本章前面创建的 first_calc.py 文件中。

小贴士

尽早并尽可能频繁地保存你的工作！避免因为意外删除代码而感到沮丧！

减法

对于我们计算器的下一部分，我们将创建我们的减法函数。我们将遵循与加法函数相同的提示来创建一个执行减法的第二个函数。在你的 Python 壳中，尝试以下步骤来创建减法函数：

1. 使用 def 来开始你的函数。

2. 为你的函数命名。

3. 添加适当的语法，即括号 () 和冒号 :.

4. 将剩余的行缩进四个空格。

5. 从用户那里请求第一个数字。

6. 从用户那里请求第二个数字。

7. 使用减号（-）来打印输出。

一旦你在 Python 壳中尝试创建这个函数，尝试使用以下代码行来调用函数：

 subtraction()

如果函数调用成功，那么你可以将你的代码直接输入到你的代码文件中，就像它在 Python 壳中显示的那样。如果你的 subtraction() 函数没有运行，确保你在壳中输入代码时没有犯任何错误。仔细检查你的代码并重新运行，直到它运行顺畅。如果你卡住了，你可以将以下代码行复制到你的 Python 壳中；它们将对两个整数执行减法：

def subtraction():
 first = int(raw_input('What is your first number?'))
 second = int(raw_input('What is your second number?'))
 print(first - second)

subtraction()

一旦你在壳中测试了你的代码，你就可以将其输入到你的文本编辑器中。记住，将你的工作保存在你的 first_calc.py 文件中。你的 first_calc.py 文件现在应该看起来像这样：

乘法

到现在为止，你可能已经观察到了我们函数中的模式。乘法函数将遵循与加法和减法函数相同的格式和逻辑规则。你可以继续要求用户输入每个数字，然后计算机将执行正确的计算。

以下代码是乘法函数的代码。你可以直接复制它，但最好是自己尝试创建乘法函数。如果你尝试创建函数，你将知道你学到了多少关于创建函数的方法。当你准备好时，你将看到乘法函数的以下代码：

def multiplication():
 first = int(raw_input('What is your first number?'))
 second = int(raw_input('What is your second number?'))
 print(first * second)

一旦你在 Python 命令行中测试了你的代码，记得在文本编辑器中输入该函数，并将你的工作保存在 first_calc.py 文件中：

除法

除法是我们将为我们的第一个计算器程序编写的最后一个基本操作。与乘法一样，你在计算器的除法部分已经做了大部分工作。看看你是否能回忆起如何从头创建一个除法函数。一旦你测试了你的代码，将其与以下代码进行比较，看看是否匹配：

def division():
 first = int(raw_input('What is your first number?'))
 second = int(raw_input('What is your second number?'))
 print(first / second)

一旦你测试了你的代码，记得将你的工作保存在 first_calc.py 文件中：

找到余数 – 取模

取模可能看起来像是一个奇怪的概念。实际上，除非你是程序员，否则你很可能从未听说过取模。取模是一个数学函数，它允许我们进行除法问题，但只返回余数。这有什么用呢？为什么这是一个好主意，我们应该关心吗？

通常，我们想知道除法问题的整个答案——商和余数。然而，有时我们可能只想知道除法问题的余数。我们只关心剩余的部分。取模就像一个怪物在吃我们的甜点：我们给怪物数字来除，它只给我们剩下的部分。

虽然取模在学校的算术中不是特别有用，但它可以在游戏中移动对象时非常有用。因此，构建一个取模函数并学习取模的工作原理对我们来说很好。

要构建一个取模函数，你需要获取用户输入，就像你创建的所有其他函数一样。然后，你将调用取模函数。取模的符号是 %。你可以将取模运算符放在你通常放置除号的位置。以下是一个示例，将以下代码复制到你的 Python 命令行中：

def modulo():
 first = int(raw_input('What is your first number?'))
 second = int(raw_input('What is your second number?'))
 print(first % second)

在前面的屏幕截图中，你可以看到我们如何将取模函数添加到其他函数中。如果你仍然觉得取模很困惑，不要急于担心。只需知道，当你设计游戏时，它可能会出现，你可以在这里查看，也可以进行网络搜索，以更好地理解取模。

运行你的程序

要运行你的程序，进入你的命令行或终端窗口，并输入以下命令：

python first_calc.py

你的程序应该能够运行加法、减法、乘法、除法和取模运算，并且对于用户输入的每一组数字打印出答案。如果程序运行时出现错误，你的计算机的错误信息通常会告诉你哪里出了问题。错误信息甚至会告诉你文件中哪一行代码有问题，这样就可以更容易地调试（查找和修复）你的代码。

一个快速的任务给你

Q1. input()函数返回什么类型的数据？

1. 元素

2. 小数

3. 字符串

4. 整数

Q2. int()函数的作用是什么？

1. 将数据转换为整数

2. 将数据转换为字符串

3. 不做任何事情

4. 将一个函数转换为另一个不同的函数

Q3. float()函数与int()函数有什么不同？

1. 它们没有区别，它们做的是同一件事

2. float()函数仅处理字符串

3. float()函数仅将数据转换为浮点数

4. float()函数将文字转换为数字

Q4. 如果你在你的 Python shell 中创建了一个名为addition()的函数，你该如何运行这个加法函数来测试它？

1. 在你的 Python shell 中输入addition

2. 在你的 Python shell 中输入type def addition

3. 在你的 Python shell 中输入type addition()

4. 在你的 Python shell 中输入type addition()

概述

现在你已经阅读了这一章，你希望有一个可以运行的计算器程序！这个程序比你的第一个程序更具有交互性，可以做更多的事情，所以你应该把这个程序分享给你的家人和朋友，向他们展示你如何提高了你的技能。

在下一章中，我们将学习如何做出决策，我们将通过教它如何让用户选择要执行的操作以及要输入多少个操作数（数字）来改进我们的计算器程序。我们将涉及一些更复杂的内容，但我们将会一步一步地进行，这样你就可以理解我们所做的每一部分。

第四章。做出决定 – Python 控制流

恭喜！在第三章“计算这个！”中，你编写了一个计算器程序。如果你遵循了指示并纠正了错误，那么你就有了一个可以运行两个数字的所有数学函数的程序。虽然这对第一个程序来说很棒，但这样的有限计算器不会给用户太多选择。当用户运行计算器时，程序将不会结束，直到所有五个函数都运行完毕，或者由于错误而结束程序。

如果我们能够编程我们的计算器根据用户回答我们的问题的方式执行某些操作，而不是执行整个数学运算，那会怎么样？作为程序员，我们可以使用 Python 来解释用户数据并改变程序的操作方式。在本章中，你将学习如何使用控制流，以便我们的计算器程序可以做出选择，并且只运行用户选择的代码。

在本章结束时，你将有一个可以根据用户想要做什么来选择执行哪种数学运算的计算器程序。你将能够根据你如何使用控制流来定制这个程序。

是等于、不等于，还是其他什么？

在学习条件语句之前，你需要意识到计算机是根据比较运算符做出决定的。这些帮助我们比较两件事，以便计算机可以决定接下来做什么。以下是一个运算符列表：

比较运算符

小于

小于或等于

大于

大于或等于

等于

不等于

这些运算符中的每一个都允许我们比较两个值。最令人困惑的运算符是等于运算符，因为它使用了两个等号。之所以这样，是因为当我们设置变量时，我们使用一个等号。我们不希望计算机在我们比较两个值时感到困惑，所以我们使用两个等号。当我们使用比较运算符与if、elif和else一起使用时，我们的程序可以编写得更好，以便做出更好的决策。

为了查看这些运算符在实际生活中的工作方式，打开你的 Python 壳并输入以下代码行：

1 < 1
1 <= 1
1 > 1
1 >= 1
1 == 1
1 != 1

在每一行代码之后，将打印出True或False。请查看以下截图，了解如何使用数字1评估这些语句。尝试使用其他数字，看看会发生什么，并了解运算符及其功能：

条件语句 – if，elif，else

在 Python 中，有三种语言结构经常用于控制程序的结果。这些结构是if、elif和else：

• if语句告诉程序“如果用户这样做，则执行程序的这个部分”。

• else 语句用于捕获用户所做的任何不在程序中的操作。例如，你可以将 if 和 else 结合使用：如果用户选择 add，则执行加法，否则执行其他操作。

  注意

  elif 代表 else if，这意味着 如果第一个条件不成立，那么就在可能性的列表中执行下一个操作，直到用户的选项与可能性匹配。

• elif 用于当你想给程序提供超过两个选择时。你可以根据需要多次使用 elif。

• else 是向你的计算机程序发出结束可能选择信号的标志。else 的意思是 如果程序中没有发生其他事情，或者如果用户做了意外的事情，那么结束这段代码块。else 语句始终位于以 if 开头的代码块末尾。

在下一节中，你可以查看 if、elif 和 else 的使用方法。然后，你可以通过实验你的计算器代码，并添加一些这些语句来使你的计算器更加灵活。

获取更好的输入

为了使 if、elif 和 else 能够工作，我们需要获取更好的用户输入。为了实现这一点，我们需要提出更好的问题！你将在每个 if、elif 和 else 的示例中看到，我们将添加更多的 raw_input() 语句来获取用户更多的信息。然后，我们将使用 if、elif 和 else 语句来使用这些信息，使我们的计算器程序更能满足用户的需求。

为了练习提出更好的问题，让我们打开我们的 Python 壳，并练习编写以下代码：

raw_input('add, subtract, multiply, divide, or modulo?')

因此，我们现在要求用户通过将操作名称作为问题的答案来选择他们想要执行的操作。当我们的程序运行时，它会询问用户这个问题。我们的程序将如何知道如何处理这个答案？

if

if 语句告诉程序，如果用户做出选择，则执行一些特殊操作。为了更好地理解这一点，让我们使用这个示例问题并询问用户他们希望计算器执行什么操作：

为了练习的目的，让我们假设用户输入 addition 作为他们的答案。目前，我们的程序不知道或关心用户想要做加法。我们的程序无法对那个答案做出任何反应！我们需要使用 if 语句来告诉我们的程序该做什么。

因此，我们现在将创建一个特殊函数，并将我们告诉计算机如何处理用户的新信息。为此，我们将使用我们的文本编辑器添加新代码，并在保存代码后使用命令提示符来运行代码。提醒一下，你的命令提示符的工作目录应该设置为你的项目文件夹。

注意

如果你忘记了如何找到你的工作目录，可以参考第一章，欢迎！让我们开始吧。

一旦你在文本编辑器中打开了你的计算器程序，将此函数添加到程序中：

def calc_run():
 op = raw_input('add, subtract, multiply, divide, or modulo?')
 if op == 'add':
 addition()

然后，通过在程序文件末尾添加这一行来调用你的新 calc_run() 函数：

calc_run()

现在，你将擦除你在整个程序中对加法、减法、乘法和除法函数的调用，因为我们并不总是需要它们。我们希望它们只在用户做出选择时发生。

在我们现在创建的 calc_run() 函数中，我们告诉计算器提出一个问题。一旦用户回答了问题，计算机将检查答案是否等于加法。如果是，那么计算机将运行加法函数。

elif

elif 语句让我们可以为用户提供许多选择，这对于可能想要从加法、减法、乘法和除法函数中选择用户来说更加合理。使用 elif 允许我们给用户提供在多个操作之间的选择。你可以写多少次 elif 语句没有限制。

如果你想要为 100 种不同的信息创建响应，你可以写 100 个 elif 语句。然而，这真的很繁琐，所以我们不会这样做。你可以看看以下代码中的一些更改，这将展示你如何使用 elif 为每个数学运算提供用户选择：

def calc_run():
 op = raw_input('add, subtract, multiply, divide, or modulo? ')
 if op == 'add':
 addition()
 elif op == 'subtract':
 subtraction()
 elif op == 'multiply':
 multiplication()
 elif op == 'divide':
 division()
 elif op == 'modulo':
 modulo()

你会注意到我们使用了四个 elif 语句。每个 elif 都匹配我们想要的响应。现在，我们将测试我们的程序。希望你在文本编辑器中保存了你的工作。始终记得尽可能经常保存！

按照以下步骤尝试运行你的程序：

1. 打开你的命令提示符或终端。

2. 导航到你的项目文件夹。

3. 输入 python first_calc.py。

else

else 是一种管理用户可能执行的所有其他我们无法预测的行为的方式。当用户输入某些内容以触发 else 时，我们可以向他们返回一条消息，甚至可以结束程序。你的程序不需要使用 else 语句；然而，为你的用户提供你想要的选项，并尽可能使它们清晰是很不错的。在下面的示例中，如果用户没有选择加、减、乘、除或取模，我们将向用户打印一条消息：

def calc_run():
 op = raw_input('add, subtract, multiply, divide, or modulo? ')
 if op == 'add':
 addition()
 elif op == 'subtract':
 subtraction()
 elif op == 'multiply':
 multiplication()
 elif op == 'divide':
 division()
 elif op == 'modulo':
 modulo()
 else:
 print('Thank you. Goodbye')

现在，当你运行代码时，如果你输入的答案不是加法、减法、乘法或除法，你的程序应该打印 Thank you. Goodbye。测试你的程序以检查你的 else 语句是否工作！

循环

循环是一种控制流，但它们会反复运行相同的代码块，直到有其他东西告诉循环停止重复。这与条件语句有点不同，因为它们只会运行一次代码块。两种循环类型是 while 和 for。这两种类型的循环都非常有用。

while

while 是一种循环。当我们创建一个 while 循环时，程序会重复执行，直到发生一个给定的代码块。在编程 while 循环时，我们需要创建一些规则，否则我们的程序将永远运行。

例如，我们可以制定以下规则：当计算器开启时，执行以下步骤：

1. 运行计算器。

2. 提示用户继续计算。

3. 当用户遇到 else 语句时，关闭计算器。

让我们一步一步地通过每个代码更改；您需要这些更改才能使 while 循环工作。

全局变量和 quit() 函数

我们将创建一个全局变量，用于我们的 quit() 函数。以这种方式使用变量将允许我们让 quit() 函数像一个“关闭”开关一样工作，从而停止 calc_run() 函数的运行。在下一节中，我们将编写我们的全局变量，然后创建我们的 quit() 函数。

首先，我们将创建一个全局变量，名为 calc_on。这是我们为计算机计算器创建一个“开启”按钮的方法之一。这个全局变量应该在代码文件顶部编写，不要缩进，写为 NO：

calc_on = 1

全局变量可以在程序中的任何函数中使用。如果您想在函数中使用全局变量，可以在函数内部变量的名称旁边输入 global。稍后您将看到一个示例。

现在我们已经有一个可以在代码的任何地方使用的 开启按钮 全局变量，我们将创建 while 循环所需的组件。我们需要添加一种让程序不断重复的方法，这样用户就可以在每次计算时无需重新启动程序。此外，我们还需要添加一种让用户退出程序的方法。我们将从后往前工作，首先创建 quit() 函数：

def quit():
 global calc_on
 calc_on = 0

我们刚刚编写了 quit() 函数的代码。第一行使用了我们的 calc_on 全局变量。第二行将 calc_on 的值更改为 0。通过将值从 1 更改为 0，我们告诉程序关闭计算器并停止运行代码。

使用 quit() 函数

在我们的代码中，我们将更改 else 语句，使其运行 quit() 函数而不是打印一条消息。请看以下代码示例，以了解我们对 else 的更改：

def calc_run():
 op = raw_input('add, subtract, multiply, divide, or modulo? ')
 if op == 'add':
 addition()
 elif op == 'subtract':
 subtraction()
 elif op == 'multiply':
 multiplication()
 elif op == 'divide':
 division()
 elif op == 'modulo':
 modulo()
 else:
 quit()

现在我们已经创建了“开启”按钮 calc_on、“关闭”按钮和 quit()，我们可以将“退出”选项添加到我们的程序中。在获取用户信息的代码行中，我们将添加单词 quit 作为选项：

op = raw_input('add, subtract, multiply, divide, modulo, quit?')

使用 while 循环控制程序

退出是用户可以通过简单地输入 quit 来做出的一个选择。然而，我们希望允许用户在需要时保持程序运行。为此，我们将使用一个 while 循环。在代码底部，我们将简单地写下：

while calc_on == 1:
 calc_run()

while 循环表示只要开关键处于开启状态，就运行 calc_run() 函数。如果有人做了改变，将 calc_on 的值改为不是 1 的值，那么停止运行 calc_run() *程序。

希望你能注意到我们的 quit() 函数将 calc_on 的值改为 0，这意味着我们的程序停止运行。while 循环对于运行程序的一部分非常有用，并且可以使用简单的变量来开始或停止循环，这与我们在计算器中做的类似：

for

for 循环是另一种循环。我们将使用 for 循环为我们的计算器创建一个奖励函数。for 和 while 之间最大的区别是，当程序员确切知道需要循环重复多少次时，才会使用 for 循环。在 while 循环中，我们不知道用户何时会完成计算器。用户可能只想进行一次计算，或者可能想进行 10 次计算，而 while 循环是灵活的。for 循环更加严格。

为什么不总是使用 while 呢？嗯，有些时候我们知道完成工作需要什么，我们不想在任务完成后让程序继续运行。for 循环非常适合说明重复循环的次数。例如，假设你有一个数字列表，你想要打印列表中的所有数字。假设你想要打印数字 1 到 10。如果你必须单独写出它们，看起来会是这样：

 print(1)
 print(2)
 print(3)
 print(4)
 print(5)
 print(6)
 print(7)
 print(8)
 print(9)
 print(10)

这是一段很多行的代码，它们都在做同样的事情！多么浪费空间，而且输入这些代码是多么浪费时间。与其输入前面的代码，不如在下面的 for 循环中输入代码：

 for n in range(1, 11):
 print(n)

首先，你注意到我们在 range(1, 11) 中输入了 n。这意味着介于 1 和 11 之间的每一个数字，不包括 11。

你还会注意到我们调用了一个名为 range() 的函数，这是一个内置的 Python 函数，允许我们指定一系列数字而不是全部写出来。range() 函数不包括最后一个数字，所以你可以看到第二个数字是 11，而不是 10。

你可以通过将范围扩展到 range(1, 1000) 来在这些数字范围内进行实验。现在会发生什么？这是一个基本的 for 循环，但我们会发现，当我们想要对数字、字母、单词或对象列表重复代码时，使用这个 for 循环非常有帮助。

奖励 - count_to_ten() 函数

为了让我们的计算器更有趣，让我们创建一个 count 函数，该函数将打印从 1 到 10 的数字。然后我们可以将此函数添加到我们的选择列表中。首先，考虑我们是如何使用前面的 for 循环的。然后，将 count_to_ten() 函数复制到 modulo() 函数和 quit() 函数之间，并将其放入你的 first_calc.py 程序中：

 def count_to_ten()
 for number in range(1, 11):
 print(number)

将选择ten添加到你的op变量中，如下所示：

 op = raw_input('add, subtract, multiply, divide, modulo, ten, or quit?')

最后，将elif添加到你的if/elif/else控制流程中，用于ten：

 elif op == 'ten':
 count_to_ten()

这将打印出用户的选择，然后，当用户输入ten时，计算机会打印出从 1 到 10 的所有数字。这个截图显示了代码的工作原理：

一个快速的任务

在本章中，你学到了很多关于如何编写能够做出决策的程序的知识。以下是一些需要回答的问题：

Q1. elif语句在if/elif/else流程中可以出现多少次？

1. 只一次

2. 两次

3. 需要多少次就运行多少次

4. 十

Q2. 哪个语句开始了一个用于做出决策的条件代码块？

1. else

2. if

3. elif

4. while

Q3. 哪个语句仅在条件代码块的末尾使用？

1. else

2. if

3. elif

4. while

Q4. 什么是全局变量？

1. 只在一个函数中使用的变量

2. 可以与许多函数共享的变量

3. 如果变量在函数内部，其名称前使用全局变量

4. 2 和 3 都可以

Q5. 什么是while循环？

1. 只运行一次代码的循环

2. 运行固定次数代码的循环

3. 重复执行代码直到发生不同的事情，然后停止的循环

4. 一个什么也不做的循环

摘要

在本章中，你学到了许多新概念。你学习了比较运算符，这些符号允许我们比较两个项目。你还学习了if、elif和else，这三个条件词让我们能够告诉程序如何根据用户输入的信息做出不同的决策。你学习了for和while循环；这两个循环在制作提供反馈的程序中都非常重要。你还了解了一些如何使用全局变量的知识，这些变量可以与代码文件中的所有函数共享。

希望你能跟上我们到目前为止所讨论的所有内容！这可能感觉有点令人不知所措，但我们将通过在下一章中构建一些新的项目来继续复习本章学到的概念。

第五章。循环和逻辑

在上一章中，你学习了如何使用逻辑，例如 if、elif 和 else，来帮助设计能够以多种方式响应用户输入的程序。你还学习了如何使用 while 和 for 循环。在本章中，我们将构建我们的第一个迷你游戏，称为 Higher 或 Lower。这个游戏是一个数字猜谜游戏，我们将用它来结合逻辑和循环，制作一个能够响应用户许多请求的游戏。

小贴士

记得经常保存你的工作，这样你就可以对你的代码进行修改！

Higher 或 Lower

Higher 或 Lower 是一个数字猜谜游戏。在这个游戏中，计算机选择一个随机数字，用户尝试猜测计算机选择了哪个数字。有很多人不同的方式来构建这个游戏，很多人已经构建了不同版本的这个游戏。

我们的游戏版本将有两个难度级别：

• 简单难度

• 困难难度

计算机将首先在 1 和 100 之间选择一个随机、秘密的数字。在简单难度下，用户将有无限的机会猜测正确的数字。在困难难度下，用户只有三次猜测正确数字的机会，然后他们将输掉游戏。

这个游戏可以用不同的方式编写，并且仍然可以很好地工作——这是编写代码最酷的事情之一。然而，我们将专注于编写使用 while 循环的简单版本和 for 循环的困难版本的代码。这将让我们练习我们的循环，并构建一个具有不同挑战级别的游戏。

要在本章中取得成功，请按步骤逐节进行，确保在进入下一节之前理解正在发生的事情。按照文本中的指示运行你的程序以测试你的代码，这样你可以了解事物是如何工作的。在本章结束时，你将拥有你的第一个完全功能性的游戏！

游戏文件设置

当你开始思考像 Higher 或 Lower 这样的小型游戏时，你可以像写一本书的大纲一样编写一些代码，也就是说，你可以使用注释将所有逻辑放置在你的代码中，即使你不确定代码是如何工作的。在我们的文件中，我们需要为简单版本和困难版本设置代码，一个用于开始游戏的函数和一个用于结束游戏的函数。

要开始规划游戏，你需要准备好你的编码工具：

• 打开你的 Notepad++（Windows）或 jEdit（Mac/Linux）来编写代码

• 打开你的命令提示符（Windows）或终端（Mac/Linux），导航到你的项目文件夹

• 打开你的 Python 命令行，这样你可以在工作时测试代码

在你的文本编辑器中创建一个新文件，并将其保存为 higher_lower.py。

然后，为简单版本编写注释。Python 代码中的单行注释以井号或磅符号开头：

# this is a comment

在你的文件中写下以下注释，并在每行注释之间留出一些空格，然后保存你的工作：

# imported libraries go here

# global variables go here

# function for easy version

# function for hard version

# function to start game

# function to stop game

# function calls go here

看看以下截图，了解这将在你的文本编辑器中看起来是什么样子：

导入库

对于这个高低游戏，我们将导入 random 库。这个库包含我们将用于选择每个游戏开始时 random 数字的函数。每次都以 random 数字开始意味着游戏体验对于玩家来说将是新的，因为他们每次玩游戏时都需要猜测一个不同的数字。要导入 Python 库，我们使用 import 语句和库的名称。在你的代码文件中，将 # imported libraries go here 替换并注释掉以下内容：

import random

导入 random 库允许我们访问许多以不同方式创建 random 数字和字符串的函数。甚至有创建安全字符串和数字的方法，如果你需要编写密码生成程序，这将非常适用！

设置和初始化全局变量

现在我们已经导入了所需的库，我们将设置我们的全局变量。提醒一下，全局变量是可以在整个代码文件中使用的变量。正如我们在计算器中看到的那样，全局变量非常有用，因为我们可以使用它们来定义程序的状态或状态，并在不同的函数中改变程序的状态。

例如，在我们的计算器中，我们有一个名为 calc_on 的全局变量。在这个高低游戏中，我们将设置一些全局变量。将 # global variables go here 替换并注释掉以下这些行：

game_on = None
guesses = None

secret = None

game_on 变量持续运行程序。guesses 变量表示用户将获得的猜测次数。secret 变量是计算机随机选择的数字，每次游戏重新开始时都会改变。

这些全局变量与之前章节中使用的不同。这些全局变量被设置为等于 None。为什么？好吧，将全局变量设置为 None 简单地允许它们在程序中每次被调用时从 None 或零重置。你将查看我们调用全局变量的地方，然后重置其值。

什么是布尔值？

我们将使用 True 和 False 这两个词来帮助运行游戏的简单和困难版本。在计算机编程中，在大多数语言中，这些词有一个特殊的名称：布尔值。什么是布尔值？

布尔值只能有两个值：true 或 false。当变量只有这两种可能性时，布尔值非常有用。例如，一个游戏可以是开启或关闭的。我们有一个名为 game_on 的全局变量。如果这个变量设置为 True，则表示我们的游戏正在运行。如果它设置为 False，则表示我们的游戏已经停止。

在第四章中，做出决策 – Python 控制流，你学习了如何比较两个语句可以打印出True或False语句。在本章中，我们将使用True和False条件来控制程序是否运行。

构建简单版本

现在我们已经设置了全局变量并导入了我们的库，我们可以着手编写实现游戏简单版本的逻辑。这段代码告诉计算机，如果用户决定玩游戏的简单版本，它应该做什么。

首先，我们需要命名并定义函数：

 def difficulty_level_easy():

给你的函数起一个名字，这样你就能记住它做什么。在命名函数后，我们首先需要的是来自全局变量的信息。我们将在这个函数中设置秘密变量的全局变量。我们在函数的前两行引入这些变量，并且必须在变量名前键入global：

 def difficulty_level_easy():
 global secret
 secret = int(random.randrange(0,100))

我们已经使用int(random.randrange(0,100))将secret全局变量从None重置为一个介于0和99之间的整数。这意味着当游戏开始时，将选择一个介于0和99之间的数字作为用户必须猜测的秘密数字。现在，我们需要创建人们所说的胜利条件。换句话说，我们需要编程来定义胜利和失败的含义。让我们来思考这个问题。

注意

你能解释一下赢得游戏和输掉游戏的意义吗？你能画一个图吗？在复制代码之前，先自己试一试！

希望你在查看这本书的这一部分之前，已经尝试去理解游戏是如何运作的。解决困难问题是构建游戏的关键部分，而解决问题的能力是通过实践培养的。因此，我们现在将编写决定玩家是赢还是输的代码。

游戏简单版本的胜利条件是用户在所需次数的猜测中猜对了正确的数字。为了使游戏继续进行，我们将使用我们在第四章中学习的while循环。while循环在我们不知道循环需要运行多少次时非常有用。我们的while循环将在game_on = True的情况下运行。对于简单游戏，我们将假设game_on是True。我们稍后会编写game_on函数：

 def difficulty_level_easy():
 secret = float(random.randrange(0,100))
 while game_on:

我们已经编写了设置数字并运行游戏的代码。现在，我们需要在while循环中添加一些命令，以便它知道该做什么。我们首先希望用户猜测数字，因此我们需要使用raw_input()函数从用户那里获取信息。我们将添加这一输入行到我们的函数中：

 def difficulty_level_easy():
 secret = float(random.randrange(0,100))
 while game_on:
 guess = int(input('Guess a number. '))

看看我们添加的最后一行代码。变量 guess 被设置为用户的输入。我们使用 int() 将用户输入从字符串转换为数字，因为游戏正在生成随机数字，而不是 随机字符串。我们想要比较数字与数字。实际上，我们必须比较数字与数字。如果不添加 int() 在 raw_input() 函数周围，程序将无法工作。在继续前进之前，确保你理解最后一行代码的含义。

此外，你可能注意到在原始输入语句中句号后有一个额外的空格：guess = int(input('Guess a number. '))。在句号后和字符串末尾之间添加一个空格将告诉计算机打印一个额外的空格，这样用户阅读代码会更容易。请参见以下截图，它们显示了空格带来的差异。

下面是没有额外空格的代码：

注意，当我们句号后添加一个额外的空格时，输出更容易阅读：

比较数字

我们接下来的代码行涉及决策。我们必须告诉计算机如果用户猜的数字太高或太低时该怎么做。我们还必须告诉计算机当用户获胜时该怎么做。为了告诉计算机该怎么做，我们可以执行以下三个步骤：

1. 将用户猜测与秘密计算机数字进行比较。

2. 根据用户猜得太高、太低还是刚好，向用户输出指示。

3. 要比较数字，我们将使用我们在第四章中学习的比较运算符，做出决策 – Python 控制流。我们需要三个运算符：大于 (>)、小于 (<) 和等于 (==)。

因为有三个可能的选择，我们需要使用 if、elif 和 else 来告诉计算机可能发生的事情。

首先，让我们用语言解释一下逻辑。然后，我们可以将其转换为代码。在开始编码之前学会思考这些问题是很好的。这有助于你知道可以期待什么结果：

• if 用户输入的数字小于秘密计算机数字，打印 你的猜测太低了

• 或者 else (elif)，如果用户的数字高于秘密计算机数字，打印 你的猜测太高了

• 或者 else，如果用户的数字与秘密计算机数字相同，则打印 你赢了！

注意

在查看下一部分之前，你能画出、写出或想象出这段代码将如何工作吗？

既然你已经思考了下一部分的逻辑，下面是代码添加到函数后看起来是什么样子：

 def difficulty_level_easy():
 global secret
 global gameOn
 while gameOn == 'true':
 guess = float(input('Guess a number. '))
 if guess > secret:
 print('your guess is too high. Try again.')
 elif guess < secret:
 print('your guess is too low. Try again.')
 elif guess == secret:
 print('You win!')
 play_again()

我们为用户可能输入的每个可能性添加了七行新的代码：

• 如果用户猜测太高，用户必须输入另一个数字，并且 while 循环返回再次运行代码

• 如果用户猜测的数字太低，则用户必须输入另一个数字，并且while循环将返回再次运行代码

  注意

  由于这是简单版本，while循环将一直运行，直到用户最终猜到正确的数字，无论用户犯了多少次错误。

• 当用户猜测的数字与计算机的数字相同时，程序将打印You win!并调用名为play_again()的函数

play_again()

我们在difficulty_level_easy()函数的末尾添加了一个名为play_again()的函数。我们在另一个函数内部调用了一个函数，我们之前已经这样做过。然而，我们必须创建这个play_again()函数，因为它还不存在。

play_again()函数将询问用户是否想再次玩游戏，然后决定是否运行程序。当while循环最终运行play_again()函数时，它将结束difficulty_level_easy()函数中的代码循环，并继续运行其自己的代码。在下一章的下一部分，我们将创建启动、停止和再次玩游戏的函数：

开始、停止、再次玩

所以，如果你在这里，是因为你构建了游戏的简单版本，并想测试它，玩一玩，看看它是否真的能工作。如果你现在尝试运行代码，两种情况之一会发生：如果它是完美的，那么什么也不会发生。如果你在代码中有问题，你会得到一个错误信息。无论如何，你现在不能运行程序，因为你的程序没有启动自己的方法！

让我们构建一些辅助函数，这些函数将启动我们的代码，并允许我们再次玩游戏。我们将编写两个辅助函数：start_game()和play_again()。我们可以在start_game()和play_again()函数的末尾结束循环，并将game_on布尔值更改为False。

start_game()

在你的higher_lower.py文件中，在写了# function to start game注释的地方，写上以下内容：

 def start_game():

我们已经定义了一个函数，它将启动我们的游戏。下一步是调用（使用）我们的game_on全局变量，并将变量设置为True。这告诉函数游戏处于开启状态：

 def start_game():
 global  game_on
 game_on = True

一旦我们告诉计算机开始，我们需要用户告诉计算机他们想做什么。使用raw_input()函数，我们准备好从我们的玩家那里获取信息。我们将创建一个名为level的变量。该变量将从用户那里获取输入。我们将给用户三个选择：简单、困难或退出。在你的文件中添加以下代码行，并确保保存你的工作：

 def start_game():

 global game_on
 game_on = True    level = input('Welcome. Type easy, hard, or quit .')

现在我们已经将用户的信息存储在level变量中，我们可以使用它来通知比较运算符，并且我们可以使用if/elif逻辑来决定在程序中做什么。

这里有一些例子：

• 如果用户输入easy，则计算机将运行difficulty_level_easy()函数

• 或者（elif），如果用户输入hard，则计算机将运行游戏的困难版本（difficulty_level_hard()函数）

• 或者（elif），如果用户决定退出，我们将通过将game_on布尔值设置为False来停止程序运行

为计算机根据用户选择启动正确的游戏添加逻辑需要六行新的代码：

 def start_game():
 global game_on
 level = input('Welcome. Type easy, hard, or quit. ')
 if level == 'easy':
 difficulty_level_easy()
 elif level == 'hard':
 difficulty_level_hard()
 elif level == 'quit':
 game_on = False

关于最后一行代码的一个重要注意事项是我们将全局变量game_on更改为False，导致程序结束。注意我们的start_game()函数如何调用其内部的其他函数。因此，当我们输入easy时，我们制作的difficulty_level_easy()函数开始运行。

play_again()

最后一个辅助函数是play_again()函数。这个函数，我们在difficulty_level_easy()函数的末尾使用，允许用户选择是否再玩一次。到现在，你可能开始看到我们如何使用raw_input中的信息来帮助计算机做出选择。我们使用if、elif和else来比较用户的选项与我们已编程的选项集。然后，我们编程选择的后果为我们想要的结果。

对于play_again()函数，用户将被询问是否想要再玩一次。我们将提示用户输入Yes或No：

 def play_again():
 global game_on
 game_on = True
 play = input('Play again? Yes or No. ')

在我们的程序中，我们只接受两个用户选择，这样我们就可以使用if和else来解释应该发生什么。如果用户输入Yes，则start_game()函数将运行，我们的程序将继续。如果用户输入No，则game_on变量将被设置为False，程序将停止。因此，我们将添加四行更多的代码：

def play_again():
 global gameOn
 play = input('Play again? Yes or No.')
 if play == 'Yes':
 start_game()
 else:
 gameOn = 'false'

游戏测试

一旦你编写了play_again()函数，你只需要再添加一行代码来测试你游戏的简单版本！你的代码文件最后一行将调用start_game()函数。将以下代码添加到你的游戏文件底部：

 start_game()

一旦添加了start_game()行，你将能够测试你游戏的简单版本。现在是停止、保存和测试的好时机。多次玩游戏以确保你完全理解它的工作原理。也可以请其他人来玩。

你可能决定更改一些输入问题以增加幽默感，使它们变得有趣或得到不同的结果。测试你的代码更改并确保它们工作，这取决于你！

注意

保存你的工作并测试你的代码！前往你的终端并导航到你的项目文件夹。

当你输入以下代码行时，你的代码应该开始在命令提示符或终端中运行。为了测试代码，确保你输入easy，这样你就可以运行你制作的代码版本：

 python higher_lower.py

构建困难版本

游戏的困难版本与简单版本的胜利条件完全相同。只有一个区别。

困难版本只允许玩家在游戏重置之前进行三次猜测！因此，我们可以使用for循环来定义，如果玩家没有猜出正确的数字，程序只运行三次。

首先，我们将定义游戏的困难版本函数：

 def difficulty_level_hard():

接下来，我们将添加全局变量。在游戏的困难版本中，我们需要使用全局变量guesses，我们将将其设置为3，用于这个程序：

 def difficulty_level_hard():

 global guesses
 guesses = 3

现在，我们需要创建逻辑。在这里，我们将使用for循环，这样我们的循环只运行我们希望它运行的次数。所以，我们将添加一行代码，即i in range(guesses)，这意味着对于猜测数范围内的每一个数字，运行我们的代码。

首先，让我们添加这一行代码，然后我们将逐一讲解每个部分：

 def difficulty_level_hard():

 global guesses
 guesses = 3
 for i in range(guesses):

字母i用来表示一个单独的数字。单词range用来告诉计算机遍历猜测的总数，我们将其设置为3。

接下来，我们将编写代码以获取用户输入，将用户数字与秘密计算机数字进行比较，并使用if/elif逻辑向用户打印输出消息并再次运行循环。

在你将for循环的代码复制到你的程序之前，想想你能否写出、画出或解释for循环将如何与while循环的工作方式不同。如果你能理解这些差异，你将学会更多关于你的for循环是如何工作的知识。

比较数字 – 困难版本

使用for循环而不是while循环的逻辑究竟是什么？正如我们之前提到的，for循环更适合运行特定次数的操作。所以，在我们的for i in range(guesses)中，我们实际上是在说：

• 对于第一次猜测，做这件事

• 对于第二次猜测，做这件事

• 对于第三次猜测，如果玩家仍然猜错，停止for循环，打印消息，并运行play_again()函数

现在你已经对逻辑有了更好的理解，让我们将这些代码行添加到difficulty_level_hard()函数中的for循环里：

def difficulty_level_hard():
 global random
 global guesses
 for i in range(guesses):
 guess = float(input('Guess a number. '))
 if i == 2:
 print('Game over. Too many guesses.')
 play_again()
 elif guess > secret:
 print('your guess is too high. Try again.')
 elif guess < secret:
 print('your guess is too low. Try again.')
 elif guess == secret:
 print('You win!')
 play_again()

正如你所见，在for循环下面的第一行代码中，我们使用了一个raw_input()函数，并将其分配给变量guess以从用户那里获取信息。然后，我们为游戏的困难版本设置胜利条件。在这种情况下，如果i（猜测次数）等于2，则游戏重新开始。这是因为我们使用的range函数从0开始计数，所以计算机的三个数字是0、1和2。我们的for循环的前两行使用比较运算符（==）来检查用户是否猜得太多次。如果用户已经尝试了太多次数，则循环结束，并打印出“游戏结束。猜测次数过多”的消息。

我们已经决定了如果用户在for循环中猜得太多次会发生什么。现在，我们将定义如果玩家猜得太高或太低会发生什么。我们使用与简单版本中相同的比较运算符，即大于（>）、小于（<）和等于（==），如果用户猜得太高或太低，我们会打印一条消息。

注意我们调用了两次play_again()函数。我们给用户机会play_again()，如果他们因为猜得太多次而输掉，或者赢了。输和赢都是for循环停止运行的时候，所以我们需要确保我们在这两个条件之后都添加了play_again()函数：

测试整个程序！

现在你可以看到你做得怎么样了！前往你的终端，通过输入以下命令再次运行你的程序：

 python higher_lower.py

首先，确保程序能正常工作。如果你立即遇到错误，请仔细检查你的代码，确保它没有问题，例如：

• 空格或缩进

• 错别字

• 语法（标点符号）

这些是人们在他们的程序中遇到的一些常见问题。通常，你会得到一个名为Trace或stacktrace的错误信息，它会告诉你代码中的哪一行导致了问题。以下是一个用户输入单词three而不是数字3时发生的情况的例子：

在让其他人玩游戏之前，你可能会想尝试一些称为测试用例的东西。优秀的程序员需要考虑他们的程序是如何工作的，他们还需要考虑用户可能会做的可能会破坏程序的事情。以下是一些你可以运行的测试。有些可能会破坏你的程序：

• 你的游戏在简单和困难版本中都能工作吗？

• 如果你输入quit会发生什么？

• 如果你输入一个大于 99 的数字会发生什么？

• 当你输入单词three而不是数字3时会发生什么？

• 你能强迫程序打印错误信息吗（有让程序出错的方法，所以要有创意）？如果是这样，注意你的错误信息，并思考如何防止错误。

你可能会遇到一些你不理解的错误，这是正常的。你总是可以执行网络搜索来查找错误信息，并查看其他人对此有何了解。

一旦你测试了游戏并觉得准备好分享它，请其他人来玩并观察他们如何与你的游戏互动。在你观察用户玩游戏的同时，问自己一些问题：

• 用户容易理解的是什么？

• 用户难以理解的是什么？

• 用户犯了什么错误？

• 我该如何修改游戏代码来使游戏变得更好？

作为程序员，你将学习如何成为一个有创造力的问题解决者。如果你在这个程序中看到你想重写的东西，你应该试试！保留你工作代码的备份副本，然后开始尝试一些不同的选项。以下是一些你可以使用的示例：

• 将困难程序的取值范围扩大，以便用户更难猜对正确答案（0, 1000）

• 给每条消息添加你自己的个人风格

• 添加一个变量来获取用户名并打印它

上述每个示例都是你可以挑战自己并进一步扩展程序的方式！将你的程序与以下截图进行对比，并找出你是否能回答一些关于本章所学内容的快速问题：

一个快速的任务给你

Q1. 布尔值是什么？

1. 一个要么是True要么是False的语句

2. 具有许多可能结果的语句

3. 用作变量名

4. 用作占位符

Q2. 为什么全局变量很有用？

1. 它们的功能是有限的

2. 它们可以在设置它们的文件中的任何函数中使用

3. 它们可以在函数内部更改

4. 选择 2 和 3

Q3. for循环与while循环类似。for循环与while循环有什么不同？

1. for循环用于循环指定次数

2. for循环仅用于文本

3. for循环仅用于数字

4. for循环只能与字典一起使用

Q4. 在游戏中何时使用while循环是一个好时机？

1. 运行指定次数的游戏

2. 永远运行游戏

3. 当某个条件为真时保持游戏进行

4. 结束游戏

Q5. 在代码中，用于编写非代码部分的符号是什么？

1. ?

3. ()

摘要

在本章中，我们学习了如何使用循环和逻辑构建游戏。这个游戏，高低游戏，有简单版本和困难版本。游戏使用玩家的输入来决定接下来将运行什么代码。

在下一章中，我们将学习如何处理一些数据，包括如何存储和检索信息。这些技能将帮助我们学习如何做一些事情，比如请求玩家姓名，在我们的游戏中包含玩家姓名，并在程序中存储分数。所有这些技能对于构建一个完整且有趣的游戏体验都至关重要。

第六章. 处理数据 – 列表和字典

在上一章中，你学习了如何使用详细的逻辑编写循环，以帮助你的程序做出决策。到目前为止，你还没有学习如何处理数据。我们还没有创建或存储数据。然而，我们知道视频游戏会存储数据！视频游戏有时会存储玩家的名字以及玩家所达到的最高分数。一个计算机程序是如何记住所有这些信息的呢？在本章中，你将了解一些 Python 存储和检索数据的方法，例如列表和字典。

对于本章的练习和代码，你的 Python shell 将是最好的工具，这样你可以输入你的列表和字典，然后检查你的编码结果。否则，一旦你的提示符可用，你可以输入列表和字典，你的 shell 将记住你输入的信息，然后你可以测试如何检索、添加和删除信息。

注意

如果你在本章的任何时间关闭 Python shell，你所有的工作都将丢失。Python shell 不会在会话之间记住信息，因此列表和字典不会被保存。

列表

列表在编码中有许多不同的用途，并且可以对列表执行许多不同的操作，这得益于 Python。在本章中，你将只了解列表的许多用途中的一些。

注意

如果你想要了解更多关于列表的信息，Python 文档非常详细，可以在docs.python.org/3/tutorial/datastructures.html?highlight=lists#more-on-lists找到。

首先，一些关于 Python 列表的事实：Python 列表是可变的。这意味着列表中的数据可以被更改。可以使用直接作用于列表的函数添加或删除项目。此外，列表中的项目可以混合在一起。数字、浮点数和字符串都可以在同一个列表中。

列表的组成部分

列表，像其他类型的数据一样，被分配给一个变量。然后，列表项被放置在[ ]中：

在你的 Python shell 中，输入以下三个列表，每个列表一行：

fruit = ['apple', 'banana', 'kiwi', 'dragonfruit']
years = [2012,  2013,  2014,  2015]
students_in_class = [30,  22,  28,  33]

你输入的每个列表内部都包含特定类型的数据。fruit 列表包含字符串，years 列表包含整数，而 students_in_class 列表也包含整数。然而，列表的一个特点是它们可以在同一个列表中混合不同的数据类型。例如，我创建了一个包含字符串和整数的列表：

computer_class = ['Cynthia', 78, 42, 'Raj', 98, 24, 35, 'Kadeem', 'Rachel']

使用列表

现在我们已经创建了列表，我们可以以多种方式处理列表的内容。实际上，一旦你创建了一个列表，计算机就会记住列表的顺序，并且顺序会保持不变，直到有意地更改。我们检查列表顺序是否保持不变的最简单方法是运行我们已创建的fruit、years、students_in_class和computer_class列表的测试。

Python 列表的第一个项目始终被计为0（零）。因此，对于我们的第一个测试，让我们检查请求项目0是否确实给出了我们列表中输入的第一个项目。使用我们的fruit列表，我们将在print语句中输入列表名称，然后添加方括号[]和数字0：

 print(fruit[0])

你的输出应该是apple，因为苹果是我们之前创建的列表中的第一种水果：

现在，我们有证据表明 Python 中的计数确实从0开始，而且我们的列表编写正确。接下来，我们可以尝试打印fruit列表中的第四个项目。你会注意到我们在print命令中输入的是3。这是因为第一个项目从0开始。将此代码输入到你的 Python 壳中：

 print(fruit[3])

你的结果是什么？你是否预期答案是dragonfruit？如果是这样，很好，你正在学习如何计算列表中的项目。如果不是，请记住列表中的第一个项目是项目0。通过练习，你将更好地学会在短 Python 列表中计数项目：

为了额外练习，使用我们之前创建的其他列表，并尝试使用此代码样本从这些列表中打印不同的项目：

在代码中提到list_name的地方，写下你想要使用的列表名称。在代码中提到item_number的地方，写下你想要打印的项目编号。记住，列表从0开始计数。

更改列表 – 添加和删除信息

即使列表保持其顺序，它们也可以被更改。可以向列表中添加项目，从列表中删除它们，或者更改它们。再次强调，与列表交互的方式有很多。我们在这里只会讨论其中的一些，但你总是可以阅读 Python 文档以获取更多信息。

向列表中添加项目

例如，要向我们的fruit列表中添加一个项目，我们可以使用一个名为list.append()的方法。要使用此方法，请输入列表名称，一个点，方法名称append，然后输入括号，并在其中放入你想要添加的项目。如果项目是字符串，请记住使用单引号。输入以下代码将orange添加到我们已创建的水果列表中：

 fruit.append('orange')

然后，打印水果列表以检查orange是否已添加到列表中：

 print(fruit)

从列表中删除项目

现在，假设我们不再希望dragonfruit出现在我们的列表中。我们将使用一个名为list.remove()的方法。为此，我们将输入我们列表的名称，一个点，remove方法名称，以及我们希望移除的项的名称：

 fruit.remove('dragonfruit')

然后，打印列表，确认dragonfruit已被移除：

 print(fruit)

如果你列表中有多个相同的项，list.remove()只会移除该项的第一个实例。具有相同名称的其他项需要单独移除。

列表和循环

列表和for循环配合得非常好。使用列表，我们可以做一种叫做迭代的事情。单独来说，这个词的意思是重复一个过程。我们知道for循环会有限制和特定次数地重复。因此，我们可以使用for循环来遍历项目列表。

在这个示例中，我们的列表中有三种颜色。在你的 Python 壳中创建这个列表：

colors = ['green', 'yellow', 'red']

使用我们的列表，我们可能会决定对于列表中的每种颜色，我们想要打印出I see这个语句并添加我们列表中的每种颜色。通过使用颜色列表的for循环，我们只需输入一次print语句，就会返回三个句子。在你的 Python 壳中输入以下for循环：

 for color in colors:
 print('I see  ' + color  +  '.')

你会注意到，在代码的第二行，我们使用加号运算符（+）将字符串相加。第一个字符串I see是每个句子的开头。第二个字符串color来自我们编写for循环时创建的变量。第三个字符串是一个句号（.）来结束句子。一旦你输入完打印行并按下两次Enter键，你的for循环就会开始运行，你应该会在你的 Python 壳中看到以下语句被打印出来：

 I see green.
 I see yellow.
 I see red.

注意，打印的句子按照它们在列表中出现的顺序打印颜色。顺序在列表中得到了保留：

如你所想，列表和for循环结合使用时非常强大。我们不需要输入三行代码，每行代码都不同，我们只需输入两行代码。

我们的for循环，仅用这两行代码，如果列表中有二十种颜色甚至两百种颜色也能正常工作。我们将在下一章和迷你游戏中进一步探索使用列表的强大功能。

字典

字典是组织数据的一种不同方式。乍一看，字典可能看起来就像一个列表。然而，字典与列表有不同的任务、规则和语法。

字典的组成部分，就像列表一样，字典也有不同的组成部分需要使用来使它们工作——名称，使用花括号来存储信息。例如，如果我们想创建一个名为numbers的字典，我们将把字典条目放在花括号内。以下是一个简单的示例，你可以将其输入到你的 Python 壳中：

numbers = {'one': 1, 'two': 2, 'three': 3}

字典中的键/值对

如前一个截图所示，字典使用称为键和值的事物来存储信息。例如，在一个物品字典中，我们可能有键告诉我们每个物品的名称，以及值告诉我们我们在库存中有多少个这样的物品。一旦我们将这些物品存储到我们的字典中，我们就可以添加或删除新物品（键），添加新的数量（值），或者更改现有物品的数量。如果您曾经使用过电子邮件或智能手机中的联系人列表，您可能会发现它与键（人的名字）与值（他们的电子邮件 ID 或电话号码）相匹配。键和值不一定要是字符串和整数的格式，但为了我们下一个示例，我们将使用字典来存储一个游戏英雄在任务中可能拥有的所有物品。

以下是一个可以存储游戏信息的字典示例。假设我们游戏中的英雄有一些生存所需的物品。以下是我们的英雄物品的字典；将此物品字典输入到您的 Python 壳中：

items = {'arrows' : 200, 'rocks' : 25, 'food' : 15, 'lives' : 2}

现在我们有一个提供关于我们的英雄拥有的物品信息的字典。与列表不同，字典不会按它们被输入的顺序保留项目。您可以通过多次打印一个小字典并注意结果来看到这一点。要打印字典，我们输入print，然后在打印语句中放置字典的名称：

print(items)

您会注意到代码的输出结果与您输入的顺序不同。它可能会以相同的顺序打印，但更有可能以不同的顺序打印。请看下面的截图作为示例：

因此，我们的字典有诸如arrows、rocks、food和lives这样的键。存储为值的每个数字都告诉我们我们的英雄有多少个物品。要找出键的值，我们使用一个包含items字典名称和arrows键的print语句。注意，arrows键放在方括号中。语法很重要。在您的 Python 壳中输入以下代码以返回arrows的值：

print(items['arrows'])

这个print语句的结果应该输出200，因为这代表我们的英雄在库存中有 200 支箭：

修改字典 – 添加和删除信息

Python 有几种与字典数据交互的方式。有许多我们可以使用的函数。现在，我们将专注于那些允许我们从字典中添加和删除东西的函数。

注意

要了解所有字典方法，请访问www.tutorialspoint.com/python/python_dictionary.htm。

向字典中添加物品

考虑一种情况，在我们的游戏中，我们允许玩家在游戏后期发现和收集火球。要向字典中添加一个项目，我们将使用所谓的下标方法向我们的字典添加一个新的键和新的值。

要创建一个下标，我们将使用字典的名称。然后，在方括号中，我们写下我们希望添加的项目（键）的名称。项目是字符串类型，所以它需要用单引号括起来。最后，我们将值设置为我们要放入字典中的项目（键）的数量。要将火球添加到你的字典中，请在你的 Python 命令行中复制以下代码：

 items['fireball'] = 10

如果你打印了整个项目字典，你会看到fireball已经被添加。在你的 Python 命令行中输入以下代码：

 print(items)

你的结果应该包括fireball作为其中一项。然而，请记住，你的代码可能不会和这本书中的代码顺序相同，因为字典不记得顺序：

更改现有项目的值

我们还可以更改字典中键的值。例如，假设我们的英雄在游戏中收集岩石，然后因为它们用来建造岩石墙而失去了岩石。我们的游戏将如何跟踪游戏中库存中添加或删除的每一块岩石？

dict.update()方法允许我们更改字典中键的值。对于我们的字典，我们将更改岩石的值，因为我们的英雄收集或使用岩石。要使用dict.update()，我们将dict替换为我们的字典名称，即items。然后，在括号()中，我们使用{}来输入我们希望更新其值的项目的名称。

我们使用冒号（:）然后写下我们希望在字典中看到的新项目数量。在你的 Python 命令行中试一试：

 items.update({'rocks':10})
 print(items)

你会注意到，如果你执行了print(items)函数，你现在将有10块岩石而不是25。我们现在已经成功更新了物品的数量。

从字典中删除项目

要从字典中删除某个东西，你必须引用键或项目的名称，然后删除该项目。这样做，与项目相关的值也会被删除，因为键和值是配对的。

在 Python 中，del语句可以用来从字典中删除键/值对。这意味着使用del加上字典的名称和你要删除的项目（键）的名称。

让我们以items字典为例。我们将使用del语句，items字典的名称，以及放在方括号内的lives键的名称。因此，我们可以使用print语句来测试和检查lives键是否与lives的值2一起被删除：

 del items['lives']
 print(items)

如果你的del语句起作用了，lives键不再在字典中，lives的数量也不再是2。这就像从印刷的字典中删除一个单词一样。如果你删除了单词，你还需要删除定义。项目列表现在看起来是这样的：

与列表相比，字典在存储和检索信息方面有所不同，但我们仍然可以执行添加和删除信息以及更改信息的相同操作。

列表或字典

你已经学习了两个伟大的 Python 数据结构，列表和字典。现在，我们需要知道何时使用这些工具。虽然这两个工具都存储信息，但它们以非常不同的方式存储。让我们比较这两个结构，以便我们更好地理解每个结构如何被使用。

当我们想要跟踪项目并需要记住这些项目的顺序时，列表是很好的选择。我们在日常生活中使用了很多符合这些标准的列表。

以下是一些列表的示例：

• 包含不同食品项目的购物清单

• MP3 播放器中歌曲标题的列表

• 图书馆中可用的小说书名列表

• 网站上可供购买的项目列表

这些事物都有一定的顺序，这是一个理想的特性，列表中的项目可以添加或删除。如果我们想用 Python 编写一个简短的程序来跟踪我们的小说书名或查找 MP3 播放列表中的歌曲，列表可能是一个好的起点。

列表可以与循环一起使用来完成许多强大的功能。其中一些包括使用循环创建自己（是的，真的）的列表或从大量用户输入中创建列表。由于它们会自动从开始搜索，列表的搜索速度较慢。

当数据不需要顺序但需要与其他事物配对时，字典更有用。例如，也许你拥有小说和非小说书籍，你想编写一个程序来存储标题、作者和类型。使用字典会更好，这样你可以快速根据书名找到作者，或者找到你拥有的所有小说书籍。你还可以与你的字典交互来做出更改。此外，由于它们不需要从头开始搜索，字典可以非常快速地进行搜索。

注意

编程中使用的字典示例是同义词词典。这是一个列表的字典。

一个快速的任务

现在你已经熟悉了列表和字典，这里有一个快速的任务来检验你的知识。

Q1. 创建字典时应该使用什么正确的语法？

1. ( )

3. " "

4. [ ]

Q2. 一个列表中可以包含哪些类型的数据？

1. 只有字符串

2. 只有浮点数

3. 整数和浮点数

4. 所有数据类型都可以包含在列表中

Q3. 创建列表时应该使用什么正确的语法？

1. ( )

3. " "

4. [ ]

摘要

在本章中，你学习了如何创建自己的列表和字典。你还尝试了对列表和字典进行一些基本操作，包括如何添加和删除数据。最后，你学习了列表和字典之间的语法差异以及列表和字典的最佳使用方法。

在下一章中，我们将继续前进，制作一个名为 我的背包里有什么？ 的游戏。这个游戏将是一个简单的两人游戏，要求两个用户将一些物品放入背包中，然后允许每个用户猜测另一个用户背包里的内容。

我们将编写代码向列表中添加项目，跟踪用户名、物品和分数在列表和字典中，然后使用 for 循环来跟踪游戏。我们下一款游戏有很多组成部分，制作一个有两名玩家的游戏将会非常有趣！你准备好了吗？让我们开始吧！

第七章. 你的背包里有什么？

在第六章中，处理数据 – 列表和字典，我们探讨了如何使用 Python 中的列表和字典来存储、检索和更改数据。在本章中，我们将构建一个名为你的背包里有什么？的双人游戏。这个游戏将需要我们回顾自本书开始以来所学的所有技能。我们使用我们的技能来创建循环，使用raw_input()函数从用户那里获取信息，然后将这些信息存储在列表或字典中。

准备学习一些可能看起来很复杂的新技能。我们将尝试一种称为嵌套或把一个东西放在另一个里面的方法。通过嵌套列表和字典，我们有了更灵活的数据存储。使用我们学到的其他技能和这种新的嵌套技能，我们将创建一个可以由两个用户玩或调整以供多个用户玩的游戏。

设置我们的编码环境

本章将包含我们编写的最大量的代码。由于我们将进行大量的编码，因此准备我们的工具非常重要，这样我们就可以频繁地测试运行我们的代码并经常保存。

小贴士

在编写代码的过程中进行测试和保存，让你能够尝试新事物并纠正任何错误！

要进行这个游戏，建议你打开 Python shell，这样你可以在将代码放入文本编辑器之前测试小段代码。

此外，你还需要打开你的文本编辑器（Mac/Linux 上的 JEdit 或 Windows 上的 Notepad++），并创建一个名为backpack.py的新文件。最后，你需要打开你的命令提示符，这样你可以在编写游戏时运行backpack.py程序以测试它。希望你现在对用于创建计算机程序的不同工具感到更加自在。如果你不记得如何打开 Python shell 或命令提示符，请参阅第一章，欢迎！让我们开始吧。

如果你对此有疑问或想了解更多关于你在电脑上使用的 Python shell、命令提示符或文本编辑器的信息，请进行网络搜索并了解更多关于这些工具的信息。

注意

要了解本书中使用的工具、文档和高级技术，你可以参考以下链接：

www.jedit.org/

notepad-plus-plus.org/

docs.python.org/3.5/library/idle.html

www.macworld.co.uk/feature/mac-software/get-more-out-of-os-x-terminal-3608274/

windows.microsoft.com/en-US/windows-vista/Open-a-Command-Prompt-window

计划编写你的游戏

在我们深入编程之前，我们需要批判性地思考我们正在构建的内容，并提前做一些规划；这有助于我们确定我们需要使用哪些编程技能来使我们的程序工作。

因此，让我们想象这个游戏，每位玩家都有自己的虚拟背包：

• 每位玩家输入他们的名字，然后在他们背包中放置四个物品。

• 然后，每位玩家都有机会猜测另一位玩家背包中的物品。

• 如果玩家猜对了，将打印一条信息，并将一分加到分数上。

• 如果玩家猜错了，将打印不同的信息，并且不会增加分数。

• 最后，一个信息询问玩家是否想要再次玩游戏。

• 如果他们输入yes，整个过程将再次进行。如果他们输入no，则打印每位玩家的分数，整个游戏停止。

已经有很多事情要做。提到的每个点都是一个需要使用我们的编码技能解决的问题。在阅读下面的代码示例之前，问问自己你会如何尝试解决每个问题。也许可以画一些图，或者为程序成功执行所需做的每一件事编写一个大纲。然后，随着你通过本章并编写你的背包游戏，保存这些想法。你可能尝试一些你的想法，并检查它们是否可行！如果可行，那就太好了。你会发现并没有一种“正确”的编程方式。有些方法比其他方法更好，但尝试任何东西从不是错的。

制作程序所需的技能

现在，我们将回顾制作成功游戏所需的元素列表，并头脑风暴每个元素的解决方案。现在花时间弄清楚我们想要如何解决问题，有助于我们创建一个一旦组件组合在一起就能良好工作的程序。

每位玩家输入他们的名字，然后在他们背包中放置四个物品。为了将玩家名字输入到电脑中，我们需要创建一个变量来保存每位玩家的名字。我们将使用raw_input()获取物品并将物品存储在电脑中：

每位玩家都有机会猜测另一位玩家背包中的物品。

记得我们的“高或低”游戏吗？这个功能将类似于高或低。我们将比较第一位玩家的猜测与第二位玩家背包中的物品。我们需要使用raw_input来提示猜测。然后，我们需要一些if/elif/else逻辑来比较猜测并给出用户输出。输出将通过print打印到屏幕上。

如果玩家猜对了，将打印一条信息，并将一分加到分数上。

如果玩家猜错了，将打印不同的信息，并且不会增加分数。

得分、再玩还是退出？

当玩家获胜或用完所有的猜测时，我们将使用if/elif/else逻辑输出一个消息，询问玩家是否想要再次玩游戏。

如果玩家输入yes，游戏将再次运行。

如果玩家输入no，那么每个玩家的分数将被打印出来，游戏将停止运行。

获取和存储玩家信息

我们的首要任务是弄清楚我们将如何从玩游戏的人那里获取和存储信息。我们需要采取几个步骤，包括询问玩家的名字，然后存储玩家的名字。我们还会在后台执行一些代码来存储我们尚未询问的玩家信息。这是一段相当有趣且巧妙的编码，如果你愿意，这将让你能够扩展你的游戏。让我们一步步来。

制作玩家列表

我们首先要做的是创建一个空列表来存储每个玩家的信息。我们将把这个列表命名为players，但我们目前不会在列表中放入任何内容。为什么？因为每个游戏中的玩家可能都不同，他们也会有不同的信息，所以我们需要允许我们的游戏在玩家将信息输入电脑时存储这些信息。下面是players列表的样子：

players = []

现在我们已经创建了列表，我们可以向这个列表中添加玩家。回想一下，我们还将创建一个档案来存储关于玩家的信息。实际上，这个档案将存储在我们列表内部创建的一些小字典中！

新技能！将一个物品放入另一个物品中。这被称为嵌套。接下来，我们将学习如何在列表中嵌套字典。

玩家档案

在接下来的步骤中，我们将为每个玩家创建一个字典。我们创建的字典将包含玩家名字、玩家的背包物品和玩家的分数的占位符：

想象一下，字典中的所有信息都是一个player档案。player档案将由我们从玩家与我们的游戏互动中获得的信息填写。下面截图中的代码是我们玩家完成的代码：

在你编写任何代码之前，让我们阅读并分解代码。前两行是注释，提醒我们我们在做什么，第 5 行是我们创建空列表的地方。第 7 行的代码，这是计算机关心的第一条代码，允许我们执行以下操作：

• 使用range()函数设置玩家数量：由于 Python 中的计数从零开始，而range()函数不包括最后一个数字，因此我们正在为player 0和player 1创建配置文件（参考第六章，与数据一起工作 – 列表和字典，我们在那里花费时间打印和计数列表，以刷新你对列表项计数的记忆）。

• 为每个玩家创建配置文件的for循环：对于player 0和player 1，我们将创建一个包含信息的玩家配置文件。

• player.append()函数：这个函数为每个玩家配置文件添加一个信息类型。在这种情况下，名字是string，得分是int，背包是一个empty列表。

backpack字典键是特殊的，因为它是一个列表，将存储配置文件内的所有背包物品。它允许用户在同一位置存储多个物品：

玩家配置文件 – 它们是如何工作的？

现在，让我们思考玩家配置文件中的所有信息。我们有一个名为players的列表。在players列表内部，我们为每个玩家都有一个字典。字典是存储玩家配置信息的地方。在每个玩家的字典内部，我们为项目列表留出了空间。这个项目列表被称为backpack，它的作用是记住玩家配置文件中的所有列表项。试着想象这个配置文件就像一棵树，随着它从树干和树枝分离，叶子越来越多：

我们所做的事情被称为嵌套。嵌套是指我们将一个东西放在另一个东西里面。在这里，我们在另一个数据类型（字典）内部嵌套了一个数据类型（players列表）。

提示

如果还没有保存，请保存你的代码！

添加玩家到配置文件

因此，我们已经设置了一个名为玩家配置文件的数据结构，作为存储每个玩家信息的方式。现在，我们需要编写代码来提示玩家将他们的信息输入到我们的程序中。我们将使用raw_input()函数从玩家那里获取信息，并将这些信息存储在用户配置文件中。我们的用户信息请求将延续在for循环内部。

首先，阅读此截图中的代码第 15-20 行：

在代码的第 15 行，你会注意到我们的raw_input()命令，它会要求玩家输入他们的名字。你注意到使用了name字典键吗？你注意到在name键之前使用了players[i]吗？这意味着Enter your name提示的答案将被存储在字典下的name键下。将创建一个玩家配置文件，并等待有关背包物品和游戏得分的详细信息。

玩家编号由i设置。小写的i代表一个玩家。所以，第 15 行要求我们输入玩家i的名字。它是如何知道选择哪个数字的？i从哪里得到这个信息？如果你回到for循环，你会注意到for i in range(2)。这意味着对于两个玩家中的第一个玩家，执行循环中的所有操作。当第 15 行第一次运行for循环时，它会从player 1那里获取输入；当for循环第二次运行时，它会从player 2那里获取输入。一个range(2)的for循环只运行两次，所以获取并存储player 2的输入后，for循环停止循环。

向虚拟背包中添加物品。

现在我们已经添加了玩家的名字，我们想要为玩家添加四个物品到他们的虚拟背包中。虚拟背包实际上是在字典中的一个列表。我们将存储每个玩家虚拟背包中的物品列表，它位于每个玩家的档案中。让玩家多次回答相同的问题提出了一个新的编程挑战。我们将如何限制我们的程序只请求四个物品？我们将如何将每个物品添加到正确玩家的背包中？

限制虚拟背包中的物品。

为了确保我们只向每个虚拟背包中添加四个物品，我们正在使用另一个for循环（在我们的第一个for循环内部）。内部循环说for item in range(4)。这意味着对于四个物品中的每一个，执行循环中的所有操作。在我们的背包循环中，这意味着我们将使用raw_input()函数将物品 0、1、2 和 3 输入到背包中。

在players[i]backpack字典中，我们通过使用append(backpack_item)将物品添加到背包内部的列表中。因为我们想要四个物品，所以我们的for循环在询问玩家的名字和物品后运行四次。当这个backpack_item代码运行完成后，整个玩家循环将再次开始，询问第二个玩家的名字和物品。在这个过程中，我们得到了填写存储在player 1和player 2字典中的玩家档案所需的信息：

为了复习，当你运行你的代码时，你应该期望看到以下内容：

1. 为玩家 1创建一个名字和档案—输入玩家 1 的名字。

2. 请玩家 1将物品放入他们的背包中—输入 4 个物品放入你的背包中。

3. 玩家输入四个物品。

4. 为玩家 2创建一个名字和档案—输入玩家 2 的名字。

5. 请让玩家 2将物品放入背包中—输入 4 个物品放入你的背包中。

测试你到目前为止的代码。

你现在已经编写了游戏的所有数据存储元素。如果你还没有这样做，请再次保存你的代码，并测试你所编写的代码。

首先，对你的backpack.py代码文件进行视觉测试。确保你的代码缩进正确。寻找语法错误，如错位的引号、句号、方括号、花括号和括号。确保一切拼写正确。每次修复错误后都保存。

接下来，使用你的命令提示符（Windows）或终端（Mac/Linux）通过运行你的程序来测试你的代码。当你运行程序时，你应该会被要求输入玩家 1 的名字，输入四个物品，输入玩家 2 的名字，并输入另外四个物品：

如果你想要确保你输入的背包物品被正确存储，你可以使用截图中的第 20 行的测试代码。只需取消注释（删除第 20 行前的井号），然后再次运行代码。使用第 20 行的 print 语句来检查计算机存储的内容。有时，计算机的读取方式可能与我们预期的不同，所以有一个 print 语句来双重检查你的工作是很好的：

如果你犯了错误，你会得到一个错误信息。通常，错误信息会告诉你代码中问题的位置。如果你做错了什么，看看你的错误信息，并使用这些信息来找出出了什么问题。当你纠正错误时，你可以在代码中做一个笔记或者甚至添加一个注释，以便你回忆起你是如何解决问题的。

一个游戏循环

我们已经计划和编写了如何从玩家那里获取信息的方法。现在，我们需要编写一个游戏循环。什么是游戏循环？游戏循环通过使用用户操作来启动游戏并更新游戏状态（如果需要），然后继续操作直到游戏结束，停止循环。

我们的游戏循环让我们能够开始游戏，使用玩家存储的信息来改变游戏状态，并打印输出，以便我们知道猜测是正确还是错误，或者游戏结束时得分是多少。我们的游戏循环也会在条件改变时关闭，以停止游戏。我们已经在我们的 Higher or Lower 游戏中使用了一个游戏循环，这个游戏循环将是相似的。使用游戏循环，我们可以编写代码来完成我们的游戏。

恢复 while 循环

所以，你可能记得在第四章“做出决策：Python 控制流”和第五章“循环和逻辑”中使用了while循环。我们将再次使用while循环来设置游戏循环。游戏循环（while循环）中发生了很多事情，所以让我们一步一步地看看。首先，看看这个游戏循环中所有代码的截图：

你看到的第一件事是注释，告诉任何阅读代码的人代码正在做什么。注释不是必需的，但在编写程序时有时可能会有所帮助。这个注释只是告诉我们下一部分是游戏循环。

游戏循环从game_on变量开始。game_loop变量被设置为等于True（记住，True是一个布尔值）。下一行说while game_on:；这意味着由于while循环是True，所以会继续运行while循环，直到发生某些事情使其变为False（不真实）。由于while game_on:是True，游戏将使用我们在游戏开始时收集的信息继续运行。游戏只有在game_on = False时才会结束。

在我们的游戏循环中还有一个for循环。当一个循环嵌套在另一个循环中时，它们是嵌套的。你可能注意到这个for循环几乎与第 7 行的for循环相同。这段代码运行for i in range(2)，这意味着对于两位玩家中的每一位玩家，都要在循环中做所有的事情。

在这个从第 26 行到第 36 行的for循环中，游戏的主要内容发生。这个循环中的事情包括以下内容：

• 请求第一位玩家猜测第二位玩家背包中的物品

• 打印第一位玩家是否正确或错误

• 如果正确，为第一位玩家的得分加分

• 轮到第二位玩家

• 请第二位玩家猜测第一位玩家背包中的物品

• 打印第二位玩家是否正确或错误

• 如果正确，为第二位玩家的得分加分

• 询问玩家是否想要再次玩游戏

• 如果选择YES再次玩游戏，则重新启动循环并重做所有操作

上述列表包含了在代码第 25 行开始的for循环中发生的所有事件。我们将在本章的下一节中分解使这些事件发生的代码。

比较猜测与背包物品

在数学章节中，我们学习了一种叫做模的概念。现在，它又回来了。在背包游戏中，我们比较一位玩家背包中的物品与另一位玩家的猜测。然后，玩家们交换位置！计算机将如何跟踪查看哪个背包以及选择哪个玩家？我们可以使用模运算来帮助我们始终在游戏的两人版本中选择正确的玩家。

这里是使用模运算的代码行（第 27 行）：

other_player = players[(i+1) % 2]

这行代码使用模运算通过查找我们在第 5 行制作的players列表中的玩家来识别对立的玩家。基本思路如下：

• Erin（玩家 1）= 0，Tanvir（玩家 2）= 1。

• 正在玩游戏的玩家需要将他们的答案与另一位玩家的背包进行比较。

• 要获取另一位玩家的背包，我们告诉计算机“嘿，我们需要现在没有猜对的玩家的背包。”我们用数学来做这件事。

• Erin 需要使用 Tanvir 的背包来做出猜测。记住，Tanvir = 1。

  • （0 + 1）% 2 = 1。

  • 这个公式表示（Erin + 1）模 2 = Tanvir 的背包。

  • 如您所见，这个数学公式等于 1，所以它在询问坦维尔的背包。

  • 艾琳想要猜出坦维尔背包里的东西，所以这是正确的。

• 坦维尔需要猜出艾琳背包里的东西。记住，艾琳 = 0。

  • (1 + 1) % 2 = 0。

  • 这个公式表示（坦维尔 + 1）模 2 等于艾琳的背包。

  • 如您所见，这个公式等于 0，所以它在询问艾琳的背包。

  • 坦维尔想要猜出艾琳背包里的东西，所以这是正确的。

使用公式，我们从players列表中选择玩家配置文件。您知道我们使用列表，因为我们使用了名为players的名称，我们在程序的第五行定义了它，我们使用方括号[ ]来说明我们想要使用哪个列表项。在方括号内，我们放入一个等于我们列表中某个项的数学公式。

记分

为了在游戏中计分，使用了以下代码行：

players[i]["score"] += 1

您会注意到一个新的符号，+=。+=符号是一个快捷方式，它允许我们取一个值（score），向这个值添加一个数量（我们添加 1 分），然后使score的值等于新值。

这行代码表示，如果第一个玩家匹配到第二个玩家背包中的物品，那么第一个玩家的新分数将是score += 1。您会记得，在游戏开始时，我们在字典中为每个玩家设置了分数为零。现在，我们正在更新这个分数为score += 1。每当第一个玩家得分时，score将增加1，电脑会记住新的分数。

结束游戏

一旦我们玩腻了游戏，我们可以回答问题“你想再玩一次吗？输入 YES 或 NO：”，使用NO。一旦我们这样做，您会注意到代码中出现了game_on = False来停止while循环。一旦循环停止，最后一行代码将被执行：

这行代码仅在游戏循环完成后打印出每个玩家的分数。这行代码位于for循环和游戏循环之外。如果您只玩了一次游戏，最高分只能是一。然而，如果您玩了五次或十次，那么您的最高分可能高达五或十，具体取决于每个玩家猜对了多少项。

测试您的游戏

现在，是真相大白的时候了！首先，查看每一行代码。检查缩进错误和语法错误。一旦您校对完代码，保存您的作品。准备好后，运行您的代码，自己玩游戏以查看代码是否工作。使用您的命令提示符（Windows）或终端（Mac/Linux）运行您的代码。

预期的行为是每个玩家将有一次机会猜测对方背包的内容。然后，您将被询问是否想继续。如果您按 yes，猜测将再次开始。如果您按 no，则将打印分数，游戏将停止：

• 如果你的游戏按预期工作，你可以向其他人展示并看看它是如何为他们工作的

• 打印出正确或错误猜测的不同信息

• 制作一个结束信息，例如 感谢游玩

这些只是你可以改变游戏规则的许多方法中的一部分。通过玩代码，你可以了解更多关于它如何表现的信息，并获得更深入的了解为什么以及事物是如何工作的。我们鼓励你多次玩游戏，自己玩，和别人一起玩，以获得关于如何改变你的代码以改变游戏的想法，以及彻底理解每一行代码。

一个快速的任务给你

Q1. 嵌套是什么？

1. 当鸟儿建造家园时

2. 当一个物品在另一个物品内部时

3. 当使用游戏循环时

4. 当使用字典时

Q2. 在这个游戏中，名为 players 的列表组织了什么？

1. 它组织分数

2. 它组织玩家姓名

3. 它组织属于每个玩家的所有物品

4. 它组织背包

Q3. players 列表中有什么类型的物品？

1. 玩家想要的任何物品

2. 一条字符串

3. 一个整数

4. 一个字典

Q4. 游戏循环是什么？

1. 一个永远继续的循环

2. 一个包含游戏逻辑的循环

3. 一个使游戏继续运行的循环

4. 2 和 3

摘要

本章做了很多工作。我们回顾了我们迄今为止学到的几乎所有技能！我们在if/else语句中使用了逻辑。我们使用了布尔值，如True和False，来改变游戏状态。我们运行for循环来控制某些事件发生的次数，并运行while循环作为游戏循环。最后，我们使用了列表和字典来存储自定义信息，并允许在游戏过程中更改信息，如玩家得分。在本章中，我们学习了一个新技能：嵌套。我们的背包游戏使用了嵌套列表和字典。我们还使用了嵌套循环，例如我们的while循环，其中包含for循环。

本章使用了制作这个游戏的许多方法之一。我们的目的是使用我们 Python 工具箱中的所有工具。制作背包游戏的方法有很多。有些可能更简单，有些可能更复杂。在你继续之前，探索一下尝试在继续之前制作这个游戏的变体。你可以使用这段代码作为起点，并通过网络搜索和 Packt 出版公司的其他书籍来帮助你提高 Python 技能。

在下一章中，我们将学习如何使用 Python 制作图形。我们将学习一些可以应用于开发最终游戏的图形库功能。我们将学习的一些功能包括如何制作游戏屏幕、绘制形状以及移动物体。我们甚至将学习如何使一个物体从另一个物体上弹跳（提示：这是一个错觉！）。下一章还将需要一些软件安装，这可能需要你拥有对计算机的密码访问权限。

第八章. pygame

在上一章中，我们使用书中学到的每一个技能来创建一个简单的、两人猜谜游戏。在本章中，你将了解 pygame 模块以及它们是如何使用 Python 实现游戏创建的。

什么是 pygame？

如最新的 pygame 网站www.pygame.org/hifi.html上所述，pygame 是一组用于编写游戏的 Python 模块。pygame，就像 Python 一样，是免费和开源的，这意味着它可以免费使用并与他人共享。pygame 的开发者确保它与几种不同的图形显示引擎兼容，这意味着使用 pygame 开发的游戏可以在各种环境中运行。安装 pygame 是一个细致的过程，你可能需要父母或其他成人的帮助，因为有一些步骤。我们将在本章的下一节讨论 Windows、Mac、Linux 和 Raspberry Pi 系统的 pygame 安装。

pygame 非常受欢迎，在撰写本文时，网站正在进行修订。有时，你会看到网站的旧部分，而有时你会看到网站的新部分。pygame 网站的新部分看起来像这样：

同时，pygame 网站的老部分背景是绿色的，如下所示：

你可以使用网站上的搜索栏在任何部分查找你需要的信息。

一旦安装了 pygame，你将了解 pygame 的一些特性，这些特性将对我们最终的项目最有用，在第九章 小型网球 中。由于这是我们第一个使用视觉的游戏，我们不会在我们的第一个项目中使用 pygame 提供的所有功能。我们将使用大多数制作交互式、两人游戏的必需的基本功能。然而，一旦你准备好了，我们鼓励你查看 pygame 网站(www.pygame.org/hifi.html)，pygame 文档（可在 pygame 的安装中以及网站上找到），以及 Packt Publishing 出版的更高级的 pygame 书籍，Instant Pygame for Python Game Development How-to，Ivan Idris，以更好地理解 pygame 提供的更复杂工具。

安装 pygame

在每个操作系统上安装 pygame 的方式略有不同。本章的下一部分包含了在 Windows、Mac、Linux 和 Raspberry Pi 系统上安装 pygame 的说明。你可以跳到有关于如何在你的操作系统上安装 pygame 的说明部分，如果你不是 100%确定你在做什么，请继续并寻求这一部分的帮助。记住，你需要一个互联网连接来安装 pygame，安装的一些部分可能需要一些时间。

安装 pygame – Windows

要在 Windows 上安装 pygame，您需要访问www.pygame.org/hifi.html。如果您不知道 pygame 的 Windows 版本在哪里，请在搜索栏中输入download并转到下载页面。您应该会看到一个包含以下信息的屏幕：

在那个截图的底部，您将找到大多数 Windows 计算机的安装说明。遵循这些说明：

1. 访问 pygame 网站。

2. 下载此版本的 pygame：pygame-1.9.2a0.win32-py2.7.msi。

3. 前往您的下载文件夹。

4. 双击pygame-1.9.2a0.win32-py2.7.msi文件。

5. 选择运行：

6. 选择从注册表中安装 Python 选项：

7. 允许安装完成。

最后，一切应该就绪。为了测试安装是否成功，打开您的 Python shell，并输入以下内容：

import pygame

如果没有错误消息，那么您的安装成功了！恭喜！如果它没有成功，请检查您的步骤，并且不要害怕寻求一些帮助。

安装 pygame – Mac

在我们实际上在 Mac 上安装 pygame 之前，我们需要做一些准备工作来使 pygame 工作。pygame 在 Mac 上运行需要一些依赖项或其他程序：

• Xcode (免费，可在 App Store 获取)

• XQuartz (免费，开源)

• Homebrew (免费，开源)

• 互联网连接

您可能还需要让成年人帮助您安装，尤其是如果您对终端不是 100%舒适的话。pygame Mac Wiki 上有一些简要的说明，位于pygame.org/wiki/macintosh。

安装 Xcode

首先，打开您的终端。转到您首次安装 Python 的目录（如果您忘记了如何到达您的家目录，请参阅第一章，欢迎！让我们开始吧）。一旦您进入 Python 目录，您将安装 Xcode。Xcode 是一个功能强大的开发者工具，其功能远超本书所涉及的内容。如果您对 Xcode 感兴趣，可以在developer.apple.com/xcode/找到文档。

目前，我们将通过在终端/命令提示符中输入以下内容来安装 Xcode：

xcode-select --install

如果您的计算机已经安装了 Xcode，您将收到一条错误消息，表明它已经安装。如果没有，那么 Xcode 将开始安装。一旦 Xcode 安装完成，您就可以继续下一步。请耐心等待，因为 Xcode 安装需要一些时间。为了测试安装是否成功，请再次尝试输入安装命令。您将看到它已经安装：

安装 Homebrew

下一步是安装一个名为 Homebrew 的包管理器。这听起来可能很复杂，但它的意思只是你将能够更容易地获取一些酷炫的东西。Python 有一个叫做 pip 的东西，它可以安装 Python 软件包。我们将安装另一个系统，称为 homebrew。Homebrew 用于管理多种类型的软件包，也可以用于故障排除。

这里是如何使用 curl 命令安装 homebrew 的方法：

ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install

上述代码应该在一条命令中输入。如果你的终端需要更多空间，文本会自动换行。一旦你输入该命令，homebrew 的安装就会开始。Homebrew 会询问你问题，并在每个步骤中提供良好的安装建议，所以请注意，它应该会顺利工作。更多信息，你可以访问 homebrew 网站：

brew.sh

使用 homebrew 安装程序

一旦 homebrew 安装完成，你可以使用它来安装安装 pygame 所需的其他依赖项。我们需要访问 Mercurial 和 Git。这两个都是版本控制系统，所以每次代码更改时，它们都会跟踪：

 brew install mercurial
 brew install git
 brew install sdl sdl_image sdl_mixer sdl_ttf portmidi

这些软件包的安装可能需要几分钟，这是正常的。一旦它们安装完成，你最终将能够安装 pygame。安装 pygame 的命令在开头使用了一个叫做 sudo 的东西，你需要知道你的计算机的管理员密码才能使用它。

小贴士

如果你不知道你的计算机密码，找一个知道的人。

sudo pip3 install hg+ http://bitbucket.org/pygame/pygame

一旦安装完成，你应该准备好使用 pygame。在我们继续之前，让我们来测试一下。打开一个 Python 命令行界面，并在其中输入以下内容：

import pygame

如果你注意到屏幕上出现 import error: no module named pygame，那么你的安装可能出现了问题。检查你的安装，如果你需要帮助，不要害怕寻求一些帮助。如果你按下 Enter 后没有任何反应，那么 pygame 的安装是正确的！

在 Ubuntu Linux 上安装 pygame

这些安装说明是为撰写本文时的最新版本的 Ubuntu Linux 定制的，即版本 15.04。首先，你可能想要安装 pip 包管理器，如果它还没有安装的话：

sudo apt-get install python-pip

你会注意到再次使用了 sudo，这意味着你需要你的计算机的管理员密码。接下来，我们将使用 apt-get 安装 pygame：

sudo apt-get install python-pygame

现在，为了测试和检查 pygame 是否正确安装，你将打开一个 Python 命令行界面并输入以下命令：

import pygame

如果出现错误信息，这意味着你的安装中存在问题。重新阅读安装说明并再次尝试。如果你需要帮助，不要害怕寻求帮助。如果你在导入 pygame 后面有一个空行，这意味着一切正常，你可以继续到下一部分！

在 Raspberry Pi 上安装 pygame

如果你正在使用树莓派并且使用 Pi 的操作系统之一，你一切就绪！Python 和 pygame 在这些系统上预先安装。你可以通过阅读本章的其余部分来学习 pygame 的基本功能和模块。

pygame

为了测试 pygame 函数，打开你的文本编辑器，创建一个名为sample.py的文件，并将此文件保存在你的工作文件夹中。一旦创建了此文件，你就可以开始学习 pygame。为了使用 pygame，我们在sample.py文件的第一个行导入 pygame 模块：

import pygame

初始化 pygame

接下来，我们需要查看我们需要的方法来启动 pygame 的实例。为了启动 pygame，我们需要初始化所有 pygame 模块的实例。我们通过调用init()函数来完成这个操作：

pygame.init()

一个 pygame 游戏循环与我们在以前的项目中使用过的游戏循环相同。在本章中，它将是一个使用while True的while循环，以表示游戏循环应该反复执行，直到停止：

设置游戏屏幕大小

一旦我们设置了 pygame 并初始化，我们就会想知道如何创建一个基本的背景屏幕。首先，你将学习如何设置屏幕的大小。然后，你将学习如何设置背景颜色。pygame 有模块可以完成这两项任务，以及更多高级的背景设置。

在本节的任务中，我们将使用pygame.display和pygame.Surface模块。我们的第一个任务是设置显示大小。为此任务，我们将创建一个screen_width和screen_height变量，并使用pygame.display.set_mode()函数。在pygame.init()下编写这三行代码：

 screen_width = 400
 screen_height = 600
 pygame.display.set_mode((screen_width, screen_height))

这是最基本的设置显示的方式，如果我们只使用这种基本设置，pygame 将能够选择最适合我们系统的颜色数量。

注意

在www.pygame.org/docs/ref/display.html#pygame.display.set_mode探索高级背景设置选项。

将你的代码与截图中的代码进行比较：

设置游戏屏幕颜色

首先，我们将创建代码，这样我们就可以在游戏中使用颜色。在计算机编程中，颜色由数字表示。每种颜色由三个数字组成。每个数字代表红色、绿色和蓝色的饱和度，顺序如下。你可以使用介于0和255之间的数字。当所有数字都是0时，game_screen将是黑色。当所有选择都是255 (255, 255, 255)时，game_screen将是白色，(255, 0, 0)代表红色，(0, 255, 0)代表绿色，(0, 0, 255)代表蓝色。

我们不会在我们的代码中反复使用数字，而是为每种颜色创建一个全局变量，并使用颜色的名称来代替。让我们从sample.py文件的第五行开始添加一个全局变量的列表：

 black = (0, 0, 0)
 white = (255, 255, 255)
 red = (255, 0, 0)
 green = (0, 255, 0)
 blue = (0, 0, 255)

对于我们的下一个任务，我们将设置游戏表面的颜色。为了设置颜色，我们使用fill()函数。我们可以通过几种方式设置背景颜色。我们将创建game_screen = pygame.display.set_mode((screen_width, screen_height))变量。然后，我们将使用带有fill()函数的变量来设置屏幕颜色。将game_screen变量添加到sample.py文件的第 14 行代码中：

game_screen = pygame.display.set_mode((screen_width, screen_height))

然后，在第 15 行添加填充屏幕颜色的代码：

game_screen.fill(black)

制作静止对象

现在你将学习如何在画布上设置静止（静止）的物品。这通常被称为绘制对象。为了知道放置对象的位置，我们需要了解网格和坐标。如果你在数学课上使用过类似x轴和y轴的网格，这将很有帮助，因为我们也会使用相同的。我们将使用x和y坐标来设置每个对象在网格上的位置。

在数学课上，(0,0)坐标通常位于网格中心。在 pygame 中，(0,0)坐标位于屏幕的左上角。随着你沿着x轴从左到右移动，数字会变大。所以，对于我们的屏幕(400, 600)，我们的x轴从左边的0开始，一直延伸到400，这是我们的最大屏幕宽度。

当你沿着y轴从屏幕的左上角移动到底左角时，数字会增加。所以，我们的y轴从顶部的0开始，当我们到达屏幕底部时，它达到600，这是我们的最大屏幕高度。

我们需要了解这一点，以便了解我们在屏幕上绘制对象时它们将去哪里。例如，为了在屏幕中心绘制一个圆圈，圆心的位置需要落在(200, 300)。绘制这个圆圈的代码如下：

pygame.draw.circle(Surface, color, pos, radius)

你可以看到我们需要定义许多参数；让我们逐一查看：

• Surface将是game_screen，它标识了绘制圆圈的位置。

• 对于color，我们可以使用我们为每种颜色创建的全球变量之一。在这种情况下，我们可以使用绿色。

• pos参数表示圆心所在的位置。由于它是(x, y)，所以它将是括号中的两个数字。

• radius参数告诉计算机圆心和边缘之间的距离，并用于确定大小。

现在你已经知道每个参数的作用，让我们在sample.py文件的第 18 行添加一个圆圈：

pygame.draw.circle(game_screen, red, (250, 300), 20)

因此，我们前面的代码将在主屏幕中心绘制一个红色的圆圈，直径为 40 像素（从圆心到边缘的 20 像素），带有 2 像素宽的边框。然后，屏幕将更新以显示圆圈。

我们可以使用 pygame 绘制大量形状和对象，非常适合制作各种游戏。我们可以绘制矩形、多边形、圆形和椭圆形，以及不同粗细和颜色的线段。以下是从我们编写的代码中绘制的一个简单圆的截图。一旦我们编写了while循环，你就可以运行它了：

while 循环 – 查看屏幕

如果我们能看到我们正在绘制的形状，那就太好了，所以让我们添加一些代码，让我们能够查看我们的屏幕。我们将创建一个while循环，并将所有动作，如绘制和制作屏幕，都放在while循环中。首先，看一下while循环的截图，这样你就可以看到最终产品的样子：

你会注意到我们在第 17 行创建了一个while True循环。这使用True布尔值在循环运行时保持所有动作。将while循环添加到sample.py文件的第 17 行：

while True:

在while循环下面，你已经编写了绘制圆的代码。将其缩进四个空格。在第 19 行，我们将添加pygame.display.update()函数：

pygame.display.update()

现在已经编写了while循环，你应该能够运行你的代码并看到你的第一个视觉屏幕！为了测试你的代码，打开你的终端/命令提示符，然后使用以下命令运行你的代码：

python sample.py

制作更多形状

现在你已经知道如何绘制圆，你就可以准备制作其他形状了。我们将回顾一些基本形状的代码。你可以在while loop中添加不同形状的代码，并制作一些可以与他人分享的优秀的 Python 艺术作品。

矩形

要绘制矩形，基本函数是pygame.draw.rect(Surface, color, (x, y, width, height))。Surface参数是game_screen；颜色可以设置为任何你喜欢的。x和y变量将决定矩形的左上角的位置。宽度和高度决定了矩形的像素大小。要将矩形添加到你的代码中，将此行复制到你的sample.py文件的第 18 行：

pygame.draw.rect(game_screen, blue, (20, 20, 50, 80))

将代码放在pygame.display.update()代码之前。在这个练习中，pygame.display.update()函数应该是你文件中的最后一行代码。

椭圆

我们可以使用pygame.draw.ellipse(Surface, color, (x, y, width, height))函数绘制椭圆。你会注意到，ellipse函数接受与rectangle函数相同的参数，除了椭圆将在矩形内绘制一个圆而不是填充整个矩形。如果你想在你代码中添加一个椭圆，将以下行复制到第 19 行：

pygame.draw.ellipse(game_screen, white, (300, 200, 40, 80))

保存并尝试运行你的代码，以查看黑色背景下的红色圆圈、蓝色矩形和白色椭圆：

python sample.py

如果你没有错误地编写代码，你应该期望看到类似这样的东西：

尝试不同的形状

现在你已经知道如何制作圆、矩形和椭圆，你可以开始尝试每个参数。改变形状的半径、宽度或高度会改变大小。改变 x 轴、y 轴或两者都会改变形状在屏幕上的位置。以下是一些实验尝试：

• 改变圆的半径

• 改变每个形状的 x 和 y 坐标

• 改变矩形和椭圆的宽度和高度

• 改变每个形状的颜色

更高级的形状

你可以使用 pygame 创建一些更高级的形状，包括你喜欢的任意多边形的正多边形。你可以通过访问 pygame 文档来探索 pygame.draw 模块中的不同函数。

注意

要了解更多关于 pygame 中形状的信息，请访问 www.pygame.org/docs/ref/draw.html。

制作移动对象

现在，值得玩的游戏都有移动的对象。移动对象比静止对象有更多的问题需要解决。以下是关于移动对象的一些问题：

• 你想在屏幕上的哪个位置创建对象？

• 对象是如何移动的？

• 对象是如何知道移动速度的？

• 当对象撞击另一个对象（碰撞）时，它如何响应？

• 当对象撞击屏幕边缘时，它如何响应？

• 对象是如何知道何时停止移动的？

我们创建移动对象的方式与创建静止对象的方式相同——在屏幕上绘制它。

使用键盘移动对象

假设我们想要将我们的红色圆圈在屏幕周围移动。我们需要考虑的是，对象实际上并没有移动。相反，对象看起来在移动。这就是如何使对象移动的方法：

• 绘制一个对象

• 从按下的键中获取用户的输入

• 使用 pygame.display.update() 根据用户操作重新绘制对象

pygame.key 模块包含用于处理键盘的方法。在游戏循环期间，我们需要知道用户是否按下了键来移动蓝色矩形。为了确定用户是否按下了键来移动矩形，我们会使用如下代码行，例如：

pygame.key.get_pressed()

现在，如果我们想要控制当用户按下键时计算机如何接收输入，我们可以使用如下代码行：

pygame.key.set_repeat()

这行代码告诉计算机当有人按住键或重复按下键时（这在游戏中经常发生）应该做什么。我们会使用这些键函数来设置一些 if/else 逻辑，关于当按下某些键时我们的蓝色矩形如何移动。你将在下一章中看到这个逻辑。

现在，键盘上有许多键。在进入下一章之前，回顾 pygame 的文档并学习如何选择你的键是一个好主意。例如，如果你想使用向下箭头键，你会使用 [pygame.K_DOWN] 来标识该键，然后使用其他代码来查看当按下向下键时会发生什么。

注意

键的文档可以在以下位置找到

www.pygame.org/docs/ref/key.html.

给你一个快速的任务

Q1. 如何启动 pygame？

1. pygame.display.set_mode()

2. pygame.init()

3. pygame.exit()

4. pygame.quit

Q2. 在 pygame 中物体是如何移动的？

1. 物体通过速度移动

2. 物体通过重力移动

3. 物体通过碰撞检测移动

4. 物体看起来是在移动，但实际上它们是不断被重新绘制的。

Q3. 在 pygame 中物体是如何被重新绘制的？

1. pygame.rerender()

2. pygame.display.object()

3. pygame.display.update()

4. pygame.rect()

Q4. 在 pygame 中用来标识键的缩写是什么？

1. pygame.K_keyname

2. pygame.keyname

3. pygame.keys.K.name

4. pygame.key

摘要

在本章中，你学习了制作交互式游戏所需的 pygame 方面。你从在操作系统上查找和安装软件开始。然后，你学习了如何导入和初始化 pygame 以与计算机交互。你设置了游戏屏幕的特性，包括大小和颜色。你向游戏屏幕添加了静止的物体，并学习了如何更改这些物体的一些方法。你得到了移动物体的代码解释，这是我们将在最终游戏中创建的。

在我们接下来的章节中，我们将使用本书中构建的所有技能来制作一个完整的游戏。建议你再次阅读本书，并重复任何你不完全理解的练习。强烈建议你访问 pygame 文档并尽可能多地阅读。本章中使用的描述和示例将有助于你在下一章中。你准备好把所有东西组合在一起了吗？让我们继续进入第九章，迷你网球。

第九章。迷你网球

在上一章中，你学习了 pygame 中的基本模块、类和函数。你学习这些函数是为了能够构建一个名为迷你网球的新游戏。迷你网球将是一款双人游戏，使用键盘上的按键来控制两个挡板，挡板来回击球。虽然当你观看这个游戏时，它看起来很简单，但制作一个可玩的游戏需要很多不同的部分。

游戏编程原则简介

本章中有很多游戏编程原则适用于我们的项目。首先，记住空间中对象的运动是我们创造的幻觉。与现实不同，我们创建的对象看起来会移动，因为我们会在不同的地方定期绘制和重绘对象。

我们讨论的另一个原则是游戏循环。游戏循环非常重要，因为它控制着游戏中需要发生的所有事情，包括对象的移动和重绘。游戏循环的时间安排很重要，因为这会告诉计算机游戏循环需要运行多少次。每次游戏循环的运行也被称为帧，游戏循环运行的速率被称为帧率。

最后，考虑到玩家如何与游戏互动是游戏设计的一个重要部分。这意味着我们将考虑玩家如何使用键盘，以及他们的分数如何存储在程序的内存中并在屏幕的某个位置显示。

游戏计划

在我们开始编写任何代码行之前，我们需要打开我们的 Python 壳、终端和文本编辑器。在我们编写和测试本章中的代码行时，我们将在这三个工具之间来回切换。调整你的显示器，以便你可以在每个窗口之间舒适地切换。

在设置好你的工作区后，转到文本编辑器窗口。我们将使用注释在文本编辑器窗口中概述我们的游戏，这样我们可以更好地组织我们的工作。

创建游戏部分的概述

我们将分四个部分来制作这个游戏。游戏的部分如下：

• 第一部分：导入、全局变量和绘图

• 第二部分：移动挡板

• 第三部分：移动球

• 第四部分：绘制屏幕和跟踪分数

在你的文本编辑器中创建一个名为tiny.py的文件。然后，将以下行输入到你的tiny.py文件中：

# imports, globals and drawing

# moving the paddles
# moving the ball
# keeping score

在输入前面的行之后，保存你的文件。现在这个文件提供了一个创建游戏所需工作的概述。你的文件看起来会是这样：

我们正在遵循一种特定的方法来制作这款迷你网球游戏。需要注意的是，编写这款游戏代码有许多可能的方式。我们在这里所采用的方法使我们能够回顾在这本书中学到的所有概念。在本章的结尾以及下一章中，我们将讨论一些更高级（且更简洁）的编码技术，这些技术可以帮助你使这款游戏执行更多操作，并且更有效率。不过，现在，让我们开始这款游戏吧！

第一部分 – 导入、全局变量和绘图

在本节中，我们将编写所有代码来设置游戏的不同部分。这包括导入库、定义所有全局变量，以及告诉计算机如何绘制屏幕、球和挡板。

导入库

我们编写的第一行代码将用于将必要的库导入到游戏中，包括 pygame。在游戏中，我们将使用三个库：pygame、math 和 random。正如我们在上一章所讨论的，pygame 使我们能够在游戏中添加视觉元素。Python 附带的标准库 random，使我们能够在游戏中选择和使用随机数。Python 附带的 math 库允许进行浮点数运算。要在你的代码中使用这些模块和库，请在tiny.py文件中#导入、全局变量和绘图注释下面输入以下几行代码：

import pygame
import random
import time

小贴士

确保现在你已经添加了一些新行，保存你的tiny.py文件。养成尽可能频繁保存代码的习惯。

如果代码中的注释有助于你组织思路，你可以添加注释。现在，我们还将初始化 pygame，以便我们能够使用所有功能，包括启动屏幕、绘制图形和运行游戏循环。要初始化 pygame，我们使用init()函数。要初始化它，在你的导入下面输入以下两行代码：

 # initialize pygame
 pygame.init()

使用pygame.init()启动 pygame 进程，pygame 进程将持续运行，直到玩家退出 pygame 时程序停止运行。这使我们能够在整个游戏中访问 pygame 内部的所有内容。随着我们继续编写游戏，你会看到这一点有多么重要。现在，再次保存你的tiny.py文件：

引入全局变量

现在我们已经导入了所需的库，我们将为游戏的一些部分创建全局变量。提醒一下，全局变量，或称全局变量，是我们可以在整个文件中使用的变量。我们将为所有希望使用的颜色设置全局变量。我们还为屏幕、挡板和球设置了全局变量。

定义颜色

首先，我们将为每种颜色创建全局变量。正如我们在第八章中学习的，颜色，在pygame中，由括号内列出的三个不同的数字表示，也称为元组。为了避免重复编写这些数字，我们将为每种颜色创建一个全局变量，这样我们就可以在整个游戏中使用所有颜色的名称。

根据您喜欢的颜色，您可能希望为所有颜色或仅为一小部分创建全局变量。实际上，决定添加哪些颜色到您的代码中完全取决于您。以下是一份您可能在游戏中希望使用的常见颜色列表。您应该将每种颜色的代码添加得与这里显示的完全一致：

 red = (255, 0, 0)
 orange = (255, 127, 0)
 yellow = (255, 255, 0)
 green: (0, 255, 0)
 blue = (0, 0, 255)
 violet = (127, 0, 255)
 brown = (102, 51, 0)
 black = (0, 0, 0)
 white = (255, 255, 255)

上述列表显示了您可以在游戏代码中包含的基本颜色。如果您想包含更高级的颜色，您可以在搜索引擎中搜索rgb 颜色代码表，例如 Google，您会发现每种颜色都有不同的变化，您可以根据自己的喜好进行更改，例如浅蓝色或深蓝色。一旦您将所有颜色更改到您喜欢的样子，请确保保存您的作品：

调整屏幕大小

我们还将使用全局变量来定义屏幕显示的部分。这使我们能够显示主屏幕的大小、颜色和文本。以下是颜色全局变量；我们将添加以下代码行以定义屏幕的宽度和高度：

 # screen globals
 screen_width = 600
 screen_height = 400

现在我们已经创建了screen_width和screen_height变量，我们可以在整个代码中使用这些变量，这使得我们的代码更容易阅读。此外，如果我们决定更改屏幕宽度或高度，我们可以在这个全局变量中逐个更改，而我们的所有代码仍然可以正常运行。

绘制屏幕

因此，screen_width和screen_height变量是 pygame 设置实际游戏屏幕所需的基本信息。pygame 有一个名为pygame.display.set_mode()的函数，它接受screen_width和screen_height变量来设置屏幕显示。现在，编写pygame.display.set_mode ((screen_width, screen_height))确实很长，尤其是如果我们一直这样做的话。相反，我们将将其设置为名为game_screen的全局变量：

 game_screen = pygame.display.set_mode((screen_width, screen_height))

创建屏幕标签

我们接下来使用的函数集将设置屏幕顶部的文本和游戏屏幕的字体。第一行代码定义了我们想要看到的文本字符串，在下一行中，我们定义了字体和大小。如果字体和大小不可用，字体将默认使用系统上最初设置的字体。这对于 Windows、Mac 和 Linux 系统都是正确的：

 pygame.display.set_caption("Tiny Tennis")
 font = pygame.font.SysFont("monospace", 75)

因此，我们现在已经设置了创建游戏屏幕所需的所有基本变量。保存您的作品，当您准备好时，继续创建我们需要的球、挡板和计分的全局变量。您的屏幕代码应该看起来像以下代码示例：

球 - 起始位置

在“迷你网球”游戏中，球是游戏最重要的部分之一。我们需要做很多事情来让它工作。首先，我们需要给球一些全局特性，以便它可以被绘制和重绘，从而产生运动的错觉。

首先，我们需要设置球的 x，y 坐标。通过为这个坐标创建一个全局变量，我们可以告诉计算机在哪里重绘球，而无需为球的每次移动编写特殊的代码。我们将设置 x 和 y 的默认值，使球从屏幕中心开始。将以下几行代码写入你的 tiny.py 文件：

 # ball globals
 ball_x = int(screen_width / 2)
 ball_y = int(screen_height / 2)

球 - 设置速度和方向

现在我们已经告诉球默认从屏幕中心开始，我们需要通过给出移动的 x 和 y 坐标来告诉球移动多远：

 ball_xv = 3
 ball_yv = 3

ball_xv = 3 表示球每次重绘时将在 x 轴上移动 3 像素。ball_yv = 3 表示球每次屏幕重绘时将在 y 轴上移动 3 像素。这很好，因为它将帮助我们保持球以我们喜欢的速度和方向移动。在这里，v = 速度，这是速度（大小）和方向（x,y）的量。所以当我们说 ball_xv = 3 时，我们实际上是在说 球每次屏幕重绘时沿 x 轴以 3 像素的速度移动。

球 - 设置大小

我们将要定义的关于球最后的东西是它的半径。半径是球总宽度的二分之一，如像素所示。通过设置半径，我们设置了大小。将以下代码行写入你的 tiny.py 文件以表示球半径：

 ball_r = 20

现在我们已经定义了球的特点，请确保保存文件。没有人愿意重写正在工作的代码行！看看这个代码段的例子：

球拍 - 起始位置和大小

在我们的游戏中，我们将有两个球拍。回想一下，在本章的开头，提到我们做某些事情的方式不止一种。有更高级的方法来制作球拍，但了解球拍的每个部分非常重要，因此我们将非常简单地分解我们的代码。一旦你完成了这个游戏，你可以做一些关于创建对象的研究，并尝试将球拍作为对象创建。

我们将给我们的球拍四个特性：x 轴上的起始位置，y 轴上的起始位置，宽度和高度。这些数字都是像素表示。在球的全局变量下方，在第 34 行，将以下五行代码添加到你的 tiny.py 文件中：

 # draw paddle 1
 paddle1_x = 10
 paddle1_y = 10
 paddle1_w = 25
 paddle1_h = 100

你可能已经注意到我们编写的代码是针对paddle1的。Tiny 网球需要两个挡板。我们希望给每个玩家一个公平的开始，所以我们将创建paddle2，使其大小相等，但位于paddle1的对侧。为了创建第二个挡板，从第 40 行开始，写下以下五行代码：

 # draw paddle 2
 paddle2_x = screen_width - 35
 paddle2_y = 10
 paddle2_w = 25
 paddle2_h = 100

你会注意到挡板 2 的x坐标结合了screen_width变量，这是最大的x坐标数（600），然后减去挡板的宽度（25）加上挡板 1 的x坐标值（10）。这种数学运算使我们能够确保挡板与屏幕右侧的距离与屏幕左侧的距离相同。如果你感到困惑，将代码复制到你的文件中并保存。你可以调整数字并查看挡板如何根据每个值变化：

初始化分数

为了有一个分数，我们将为每个玩家创建一个变量，该变量从默认分数零开始。由于这是一个全局变量，就像其他整数一样，它将在游戏循环运行时改变。现在，我们只需要为每个玩家提供占位符。因此，从第 46 行开始，将以下代码行添加到你的游戏中：

 # initialize score
 player1_score = 0
 player2_score = 0

我们现在已经创建了所有必要的全局变量，以便编写易于理解的代码。记住，这些被称为全局变量，因为它们可以在整个代码文件中使用。保存你的文件。然后，将你的代码与这个截图中的完成代码进行比较：

测试部分 1

现在我们已经导入了库，初始化了 pygame，并为颜色、屏幕、球和挡板创建了全局变量，我们可以运行我们的第一个测试来检查一切是否正常。为了测试游戏，你需要在终端/命令提示符中找到你保存tiny.py文件的目录。在早期的游戏中，我们在桌面上创建了此目录。一旦你导航到保存tiny.py的目录，你就可以从终端/命令提示符中运行以下命令来查看你的游戏进度：

 python tiny.py

当你运行这个命令时，你应该会看到一个窗口弹出然后关闭。窗口不会保持打开，因为我们还没有编写运行游戏的任何代码；然而，如果代码运行且终端/命令提示符中没有错误，那么你可以有信心继续前进。

如果你的代码中有错误，现在是修复它们的好时机。一些可能发生的常见错误包括语法错误（使用错误的符号）、拼写错误（如拼写 Python 关键字错误）或尝试从错误的目录运行你的文件。如果你有错误，检查这些常见错误，并修复代码中的错误。

如果你遇到的不是上述常见错误之一，你总是可以通过进行网络搜索来提问，了解你遇到的问题。即使是经验丰富的开发者也很常见，他们会使用网络搜索来寻找帮助以修复错误，而且有许多网站和博客是由人们维护的，以帮助他人学习。

第二部分 – 移动球拍

现在我们终于可以编写将使我们的球拍出现在屏幕上并允许我们控制球拍的代码了。

这是我们有机会使用我们在前面章节中学到的逻辑和循环的地方。在像 Tiny Tennis 这样的游戏中，许多决策都非常快地做出。计算机擅长根据我们的指令做出快速决策。以下是下一节中将包含的代码部分：

• 创建 while 循环

• 键盘事件

我们将逐步编写这些代码，然后通过运行代码来测试是否有任何错误。建议你在开始编码之前阅读整个部分，以便知道可以期待什么。一旦你阅读完所有内容，乐趣就开始了！

循环前动作

在我们实际创建 while 循环之前，我们将编写两个动作。第一个是确保当光标移过游戏屏幕时，光标消失，这样就不会造成干扰。在 pygame 中有一个特殊的功能来实现这种行为：

 pygame.mouse.set_visible(0)

通过将可见性设置为 0，我们使鼠标/光标对游戏不可见。由于我们不需要在游戏中使用鼠标，这样做对我们来说是可以接受的。

第二个动作是设置我们的 while 循环的全局变量。我们将把我们的主游戏循环变量命名为 do_main。我们将设置 do_main = True：

 do_main = True

小贴士

记住，语法和大小写（大写或小写）很重要。注意 大写 字母 T，并确保完全按照它复制。记住，True 是一个布尔值，需要用大写 T 来书写。现在，我们已经准备好编写我们的 while 循环了。

创建 while 循环

我们的游戏循环将是一个 while 循环。我们将使用 do_main 作为我们的 True 语句。因此，你将会有另一行代码看起来像这样：

 while do_main:

确保你在行的末尾放置一个冒号 (:)。此外，游戏循环中的所有其他代码行至少缩进一次，因为它们都需要在循环内运行才能执行。以下是 while 循环的截图：

移动球拍 – 键盘事件

while 循环中的第一组事件是键盘事件。这些事件发生在按键或一组按键被按下时。这些事件使用 if/elif 逻辑。所有这些事件至少缩进一个制表符，有些则缩进两个或更多制表符。记住，在 Python 中缩进是一种组织工具，有助于我们跟踪某些代码应该在何时运行。

注意截图中的第 54 行代码。在第 54 行，我们将创建一个名为 pressed 的变量，并将其设置为pygame.key.get_pressed()函数。这将给我们一个更短的函数引用。将此代码输入到第 54 行：

 pressed = pygame.key.get_pressed()

在第 55 行，我们使用pygame.key.set_repeat()函数。这告诉计算机，一旦按下某个键，该键执行的动作应继续，直到用户松开该键。将下一行代码输入到你的tiny.py文件的第 55 行：

 pygame.key.set_repeat()

现在我们已经设置了键盘事件的变量和特性，我们将创建第一个循环，一个用于查找玩家是否退出的for循环。使用for循环，我们将遍历使用pygame.event.get()函数找到的每个事件。如果事件是QUIT事件，则while循环将自动结束。你会注意到我们在这里也使用了我们的if逻辑，以便告诉计算机在找到退出事件时做出决定。为了创建这个for循环，你将编写以下代码行，从你的代码文件的第 56 行开始：

 for event in pygame.event.get():
 if event.type == pygame.QUIT:
 do_main = False

现在我们已经告诉计算机如何以及何时结束while循环，我们可以告诉计算机在按下某些键时应该做什么。对于我们的 Tiny Tennis 游戏，我们需要分配键来退出游戏，以及控制 1 号和 2 号橡皮球的键。

注意

想要选择不同于本书中使用的键？你可以在 pygame 网站上找到如何使用每个键盘键的完整列表，网址为www.pygame.org/docs/ref/key.html。

退出游戏 – Esc 键

要退出游戏，我们将使用Esc键。你会注意到我们使用了 pressed 变量，后面跟着Esc键的键码。从第 60 行开始，输入以下两行代码：

 if pressed[pygame.K_ESCAPE]:
 do_main = False

代码行数告诉计算机，如果按下Esc键，则do_main全局变量应设置为False。当do_main设置为布尔值False时，while循环将停止。我们将在稍后编写结束游戏的代码。

橡皮球控制 – 玩家 1

为了让玩家 1 的橡皮球向上移动，我们将使用W键。为了让玩家 1 的橡皮球向下移动，我们将使用S键。这些是非常典型的用于电脑游戏控制的键。注意哪些字母是大写，哪些是小写，并确保从第 63 行开始完全复制它们：

 if pressed[pygame.K_w]:
 paddle1_y -= 5
 elif pressed[pygame.K_s]:
 paddle1_y += 5

橡皮球控制 – 玩家 2

玩家 2 也需要有键盘控制，以便在玩家 1 同时上下移动橡皮球时移动他的/她的橡皮球。这意味着我们必须为第二个橡皮球分配不同的键。对于这个游戏，我们使用上箭头键来移动 2 号橡皮球向上，使用下箭头键来移动 2 号橡皮球向下。将以下代码行输入到你的tiny.py文件中，从第 68 行开始：

 if pressed[pygame.K_UP]:
 paddle2_y -= 5
 elif pressed[pygame.K_DOWN]:
 paddle2_y += 5

小贴士

保存你的工作！

增加和减少值（-= 和 +=）

你会注意到代码中的-= 和 += 符号。这些符号用作增加或减少某个值值的快捷方式。在移动挡板的代码中，我们使用这些符号在按下挡板键时添加或减去值。 -= 和 += 符号对于每次用户移动挡板时设置正确的挡板位置都非常重要。

测试部分 2

是时候再次测试我们的代码了。在你的终端/命令提示符中，找到你保存tiny.py文件的目录。在早期的游戏中，我们在桌面上创建了此目录。一旦你导航到保存tiny.py的目录，你可以在终端/命令提示符中运行以下命令来查看你的游戏进度：

 python tiny.py

在这次测试中，你将看到一个窗口打开，顶部写着Tiny Tennis，其他部分完全空白。请看以下截图：

如果你遇到了错误，请记住检查你的代码是否有拼写错误、语法错误和大小写错误。

第三部分 – 移动球

现在我们已经编写并测试了挡板的代码，我们需要编写移动球的代码。我们将通过一些代码更改球的位置，并创建一个称为碰撞检测的东西。

移动球 – 更新位置

首先，我们需要根据我们在全局变量中设置的球的速度，不断计算球的x和y坐标。这允许我们在玩游戏的过程中不断更新。为了确保球的x和y坐标随着球的运动而更新，你将输入以下代码行，从第 74 行开始：

 # location of ball is updated
 ball_x += ball_xv
 ball_y += ball_yv

碰撞检测

我们接下来的任务是编写一个称为碰撞检测的代码。这意味着我们可以编程让计算机知道两个物体何时相互碰撞。我们还可以告诉计算机当物体碰撞时我们希望它做什么。在 Tiny Tennis 中，我们想要检测三种类型的碰撞：

• 球与屏幕顶部和底部的碰撞

• 挡板与屏幕顶部和底部的碰撞

• 球与挡板的碰撞

球与屏幕顶部和底部的碰撞

接下来，我们将使用我们的if语句来定义如果球击中屏幕的顶部或底部会发生什么。基本上，我们希望球在击中屏幕的顶部或底部时弹回。从你的tiny.py文件的第 77 行开始输入以下代码：

 # collision of ball with top/bottom of screen
 if ball_y - ball_r <= 0 or ball_y + ball_r >= screen_height:
 ball_yv *= -1

第一行，以if开头，基本上表示如果从 y 坐标减去半径且结果小于或等于零，或者如果将半径加到 y 坐标且结果大于屏幕高度数（400），那么就对此采取行动。

冒号之后的代码的第二行告诉我们该做什么：球的 y 坐标速度应反向。代码的第二行ball_yv *= -1意味着y坐标的速度被反转，因为它乘以了-1。任何数乘以-1都会变成其原始符号的相反数，在这种情况下，反转符号意味着反转球的方向。

那么，为什么这段代码能工作呢？让我们来思考一下。顶部的y坐标是零。如果球试图穿过顶部，它的y值将小于零，这意味着它将超出屏幕。为了使球保持在屏幕上，我们在y坐标值小于零时改变球的方向。

底部的y坐标是400。因此，如果球的y值大于400，那么我们就改变球的方向，让它向上移动。我们通过将球的速度乘以-1来实现这些方向变化，从而改变方向。

在继续之前，比较你的代码与以下代码：

球拍与屏幕上下方的碰撞

我们希望球拍在达到屏幕的顶部或底部时停止。为了实现这一点，我们需要创建一个代码，它可以识别球拍的y值，然后阻止球拍移动超过创建屏幕边界的两个y值。这两个值是屏幕顶部的0和屏幕底部的400。将以下代码行复制到你的程序中，从第 81 行开始。确保你的缩进级别是正确的：

 # collision of paddle with top/bottom of screen
 if paddle1_y < 0:
 paddle1_y = 0
 elif paddle1_y + paddle1_h > screen_height:
 paddle1_y = screen_height - paddle1_h

 if paddle2_y < 0:
 paddle2_y = 0
 elif paddle2_y + paddle2_h > screen_height:
 paddle2_y = screen_height - paddle2_h

这段代码与球代码的工作方式不同，因为我们不希望球拍在屏幕周围弹跳！相反，我们希望球拍在碰到屏幕的上下方时停止。所以，你会注意到，每当球拍 1 或球拍 2 超出屏幕的障碍（0和400），球拍值就会重置为等于边界值0或400，具体取决于球拍的位置在哪里（是在屏幕顶部还是底部？）。完成添加此代码后，保存你的工作。

球与球拍的碰撞

球与球拍的碰撞将决定球击中球拍时会发生什么。有两个球拍，如果你能添加一些使用井号#作为注释的代码来跟踪左侧球拍（球拍 1）和右侧球拍（球拍 2）的代码，这将很有帮助。

现在我们已经进行了一些碰撞检测，让我们考虑球和挡板。当球击中挡板时，我们想让球看起来像是从挡板弹回的。因此，我们需要确保球和挡板碰撞的结果是球反转并朝相反方向移动。这实际上是我们用来让球从屏幕边缘弹回的行为，但现在我们需要概述挡板 1 和挡板 2 的所有部分。将这些代码行复制到你的文件中：

 # left paddle
 if ball_x < paddle1_x + paddle1_w and ball_y >= paddle1_y and ball_y <= paddle1_y + paddle1_h:
 ball_xv *= -1
 # right paddle
 if ball_x > paddle2_x and ball_y >= paddle2_y and ball_y <= paddle2_y + paddle2_h:
 ball_xv *= -1

看看这张截图，比较一下你的代码：

测试 – 第三部分

你几乎完成了游戏的编写！现在是我们再次测试代码的时候了。在你的终端/命令提示符中，找到你保存tiny.py文件的目录。你可以从终端/命令提示符中运行以下命令来检查游戏到目前为止的进度：

 python tiny.py

在这次测试中，如果一切正常，你的结果将与第二部分的测试相同。将打开一个空白屏幕，并被称为 Tiny Tennis。恭喜你！

如果你的程序在运行时出现一些错误，查看错误信息以检查你是否能找出问题所在。寻找语法错误、拼写错误、缩进错误或代码中的任何其他错误。确保你使用空格进行缩进，而不是制表符，否则你也可能会遇到问题。

第四部分 – 绘制屏幕并跟踪得分

因此，我们知道球会从屏幕的顶部和底部以及挡板弹回。然而，如果用户用挡板没有接住球，球会发生什么？玩家和他们的得分会发生什么变化？

在这个游戏部分，我们使用x坐标的位置来判断球是否在屏幕上，或者它是否已经过了挡板，现在在屏幕外。我们使用if语句告诉计算机该做什么。x轴的0坐标是屏幕的最左侧。如果球的x值小于0，那么另一边的玩家（玩家 2）得了一分，因为玩家 1 没有挡住球。如果你阅读代码行，你会注意到我们将ball_x和ball_y坐标重置为屏幕中心，以便新游戏可以开始。将以下四行代码复制到游戏中以放置此逻辑：

 if ball_x <= 0:
 player2_score += 1
 ball_x = int(screen_width / 2)
 ball_y = int(screen_height / 2)

你会注意到接下来的四行代码几乎完全相同，只有两个变化。球的x值现在正在与最大屏幕宽度600进行比较。如果球的x值大于600，这意味着玩家没有接住球，球现在在屏幕外。现在，玩家 1 得分了，因为玩家 2 没有挡住球。为了确保这个逻辑也在游戏中，将以下四行代码复制到你的文件中：

 elif ball_x >= screen_width:
 player1_score += 1
 ball_x = int(screen_width / 2)
 ball_y = int(screen_height / 2)

小贴士

确保你保存了你的工作！

渲染屏幕 – 显示发生了什么

我们需要编写的最后一部分代码是重绘屏幕和所有对象的代码，这样运动的画面就会看起来像真的发生了。接下来的几行代码绘制了我们游戏中的五个对象。没有必要使用变量名来绘制挡板、网或球，除非这样做确实使它们更容易找到，如果你想要修复或更改代码的这一部分。同样，这些代码行是缩进的，这样它们就位于 while 循环内部：

 game_screen.fill(black)
 paddle_1 = pygame.draw.rect(game_screen, white, (paddle1_x, paddle1_y, paddle1_w, paddle1_h), 0)
 paddle_2 = pygame.draw.rect(game_screen, white, (paddle2_x, paddle2_y, paddle2_w, paddle2_h), 0)
 net = pygame.draw.line(game_screen, yellow, (300,5), (300,400))
 ball = pygame.draw.circle(game_screen, red, (ball_x, ball_y), ball_r, 0)

game_screen.fill(black) 代码使用我们的 game_screen 变量，并告诉 fill() 函数通过在括号中放入颜色 black 来使我们的屏幕变黑。你注意到我们在这一行代码中使用了两个全局变量 game_screen 和 black 吗？想象一下，如果没有这些变量，代码会变得多长。想象一下，它可能更难阅读和修改。

你会注意到 pygame.draw.rect() 函数被用来绘制挡板，因为它们只是矩形。挡板有以下特性：

• 游戏屏幕（告诉它们应该去哪里）

• 颜色

• 一个 x 坐标

• 一个 y 坐标（提供起始位置）

• 宽度

• 高度

如果你查看 line() 和 circle() 对象，你会注意到它们与矩形并没有太大的区别。它们都有 game_screen 和颜色属性。线对象接受定义线长、宽度和 x 值的参数。圆对象接受定义 game_screen、颜色和球特性的参数。由于我们在本章早期使用全局变量定义了球特性，因此我们可以在 circle() 代码中使用它们。

显示玩家分数

我们接下来的几行代码将在屏幕上绘制玩家分数：

 score_text = font.render(str(player1_score) + " " + str(player2_score), 1, white)
 game_screen.blit(score_text, (screen_width / 2 - score_text.get_width() / 2, 10))

我们游戏分数代码的最上面一行提供了 score_text 变量的定义，该变量用于我们刚刚添加的代码的第二行。每次我们的屏幕重绘时，game_screen.blit() 函数都会复制我们的分数文本，因为如果两个玩家都没有错过球，分数文本可能长时间不会改变。

最后，pygame.display.update() 函数更新了程序存储的新信息所显示的图像。因为计算机的速度可以无限快于人类，所以我们添加了一个 sleep 选项，允许我们控制更新的间隔：

 pygame.display.update()
 time.sleep(0.016666667)

结束程序

代码的最后一行将是结束 pygame 的初始化，这是我们代码开始时执行的。为了结束这个，我们将在代码的最外层缩进级别输入 pygame.quit()。这将放在 while 循环之外，这样它只会在 while 循环停止运行时发生：

 pygame.quit()

一旦你输入了这些，你的最终游戏代码行应该看起来像这样：

一旦你将你的代码与章节中的截图进行双重检查，确保保存你的tiny.py文件。现在你准备好真正对你的游戏进行测试了！

玩 Tiny 网球！

Tiny 网球最好的部分是你可以自己玩，这使得测试游戏和实验游戏的各个部分变得容易。现在，当你从你的终端运行文件时，应该会弹出一个看起来像这样的窗口：

球应该立即向屏幕的一侧或另一侧移动。你可以通过确保屏幕两侧的球拍能够击中球并且它们不会超出屏幕空间来测试游戏。你可以测试得分机制，确保适当的玩家在越过对方玩家时获得每击的分数。然后，你可以邀请其他人和你一起玩游戏。

如果你对游戏的部分不满意，你可以更改它们。例如，你可能会为球、球拍和屏幕选择不同的颜色。也许你希望球拍更长或更短，或者更薄。也许你想要通过改变半径来使球更大或更小。

你可能会决定想要球拍移动得更快，以便游戏更具挑战性，或者如果你正在为年幼的孩子设计游戏，你可能希望球拍移动得更慢。设计选择是出于许多原因，现在你有一个可玩的游戏，你可能会决定做出一些不同的设计决策。

你可以通过复制你的游戏代码并测试你的副本中的任何修改来测试你的决策。保留你工作代码的备份是个好主意，这样如果你编写了有错误的代码，你就有了一个可以返回并重新开始的地方。

摘要

恭喜你构建了你的第一个游戏！你学到了很多可以做的事情。然而，代码最伟大的地方在于，做任何事情都有很多种方法。有些方法更容易理解，但可能没有其他方法那么高效。有些代码非常高效，但可能不容易被其他程序员理解。最好的代码既容易理解，又以尽可能高效的方式编写。

在上一章中，我们使用了一种易于理解但可能不是最有效率的代码组合。这是因为我们在学习 pygame 中的许多新原则，而且像碰撞检测这样的东西可能很难编写。在你玩了几款游戏之后，你可能会决定以不同的方式做事！

在下一章中，我们将回顾这本书中学到的所有内容，我们还将看看 Python 在世界上的一些其他用途，因为 Python 是一种非常有用的语言。最后一章见！

第十章。继续编码！

在上一章中，我们使用 pygame 在图形环境中构建了一个完整的两人游戏。在这本书的最后一章中，我们将回顾你在这一旅程开始时学到的所有内容，然后探索一些你可以尝试的新编码技能的其他想法。其中许多想法将是游戏，但也有一些想法将涉及 Python 可以使用的其他方式。

我们学到了什么以及你的下一步

在这本书的开头，你开始学习关于你的电脑。你学习了如何安装 Python 以及使用不同的免费工具，如文本编辑器、Python 外壳和终端/命令行来运行你的游戏。此外，你还学习了如何导航到你的桌面目录并保存你的工作，以便你可以完成每个项目。接下来的步骤包括以下内容：

• 在你的电脑上导航到其他文件夹和目录

• 学习更多终端/命令提示符命令

我们随后开始了我们的编码之旅，通过创建函数和变量，并使用不同的数据类型。我们创建了一些用于数学运算的函数，然后将这些函数组合起来创建了一个计算器。你学习了如何通过使用input()命令给出提示来从某人那里获取信息。

我们使用了if和else这样的逻辑来教会计算机如何根据用户决定的行为做出决策。我们还使用了循环来帮助我们完成游戏中的不同任务。接下来的步骤将包括以下内容：

• 查找并尝试理解嵌套的if语句

• 使用循环处理大量文本或数据集

你学习了在 Python 中使用和存储数据的不同方式，例如字典和列表。了解 Python 中数据是如何存储的很有帮助，Python 的一个最快特性是其存储和检索数据非常快速的能力。

在第一章，“欢迎！让我们开始吧”，和第九章，“迷你网球”中，我们构建了几个项目来展示你如何使用所学的技能。理解如何使用 Python 的强大功能来解决问题非常重要。了解每个工具意味着你可以更好地想象如何使用你的编码技能来解决问题。在本章的剩余部分，让我们看看我们可以解决的一些问题，这将扩展我们的 Python 技能。

类和对象——非常重要的下一步！

立即，你需要开始学习关于类和对象的知识。这些是简化可能重复代码的绝佳方式。例如，在 pygame 中有一个名为Sprites的类。pygame.Sprites模块中的类使得管理不同的游戏对象变得更加容易。

注意

要了解更多关于精灵（Sprites）的信息，最好查阅文档：

www.pygame.org/docs/tut/SpriteIntro.html。

要了解更多关于类和对象的信息，一个好的主意是在互联网上搜索诸如面向对象编程（这是 Python 使用的编程类型）以及更具体地说，类和对象等内容。如果你觉得类和对象很困惑，不要担心。这是一个需要一些时间来适应的概念。

注意

这里有一些资源可以帮助你了解类和对象：

www.tutorialspoint.com/python/python_classes_objects.htm

www.learnpython.org/en/Classes_and_Objects

游戏中的更多乐趣

由于本书的重点是制作游戏项目，我们将探讨一些更复杂的事情，这些事情在你更深入地了解 pygame 之后可以进行。你可以通过以下方式开始使 Tiny Tennis 变得更加复杂：

• 添加音乐文件

• 添加图形

在游戏中添加音乐

pygame 允许你在游戏中添加音乐。有一个音乐模块，允许你将几种格式的音乐添加到游戏文件中。有一些限制，包括文件类型。例如，使用普遍支持的.ogg文件类型比使用如.mp3这样的文件类型更好，因为后者并不是所有操作系统都原生支持的。

注意

如需更多信息，你可以访问 pygame 网站www.pygame.org/docs/ref/music.html，了解如何添加你喜欢的声音。

在游戏中添加图形

虽然你已经学会了如何制作一些基本形状，但如果我们的世界只有矩形、圆形和方形以及基本颜色，那将会非常无聊。通过实验使用pygame.image()模块等模块，你可以学习如何处理 pygame 之外创建的图像。如果你有一个有艺术天赋的兄弟姐妹或朋友，或者你自己就是艺术家，你可以在电脑上创建或扫描艺术品，然后将其添加到你的游戏中。

注意

你可以在www.pygame.org/docs/ref/image.html了解pygame.image()模块。

重做或设计游戏

如果你想要一个全新的挑战，你可以尝试自己重做一个经典游戏。有很多经典游戏，如 PacMan、Asteroids 或 Zelda 传奇。一个不错的挑战是尝试使用你的技能重做这些游戏的一个版本。这个练习将要求你做一些重要的事情：

• 提前规划你的程序

• 确定你的程序中是否需要类

• 确定如何在程序中使用对象

• 管理程序中的循环

• 管理程序中的if/else决策

• 在你的程序中管理用户信息，如姓名和分数

一旦你制作了几款基于经典游戏的电子游戏，你可能会有一些自己游戏的灵感。如果你确实有想法，请在你的电脑上的一个文件中记下它们。当你考虑一个新的游戏时，你需要做与重新创建一个经典游戏相同的事情，除了你需要做出关于游戏目的、游戏胜利条件和控制器的其他决定。

其他游戏

许多程序员已经用 Python 制作了小型游戏来练习他们的编程技能。首先，你可以查看一些人们已经在 pygame 网站上制作并发布的其他游戏。导航到pygame.org/tags/pygame，查看一些人们的贡献。

PB-Ball

PB-Ball 是一款使用 pygame 开发的篮球游戏，它增加了类和对象。当你导航到项目页面时，你会看到一些指向代码的不同链接。以下链接将帮助你找到游戏并查看代码。当你查看代码时，你会注意到有用于图像和声音的文件夹。因此，为了创建一个具有更复杂背景的游戏，你需要学习许多新技能。以下是一些游戏的截图和一些链接，以便你可以查看代码并学习：

注意

这是 PB-Ball 游戏的链接：

pygame.org/project-PB-Ball-2963-.html

这里有一个链接到主代码，包括两个类和源代码：

bitbucket.org/tjohnson2/pb-ball/src/88e324263a63eb97d6a2427f7ea719df85010dfe/main.py?fileviewer=file-view-default

这里有一些包含游戏所需图像和声音的文件：

bitbucket.org/tjohnson2/pb-ball/src

蛇

许多人玩过的游戏之一是蛇游戏，玩家开始时是一条短蛇，随着游戏的进行，蛇会变长。保持生存的唯一规则是蛇不能碰到自己的尾巴。互联网上有许多这种游戏的样本。你可以查看一些代码样本，并检查你是否能够重新创建这个游戏。

注意

从以下链接了解更多关于蛇游戏的详细信息：

programarcadegames.com/python_examples/f.php?file=snake.py

github.com/YesIndeed/SnakesForPython

github.com/xtur/SnakesAllAround（这是一个多人游戏！）

除了前面提到的游戏，还有一些程序员非常努力地让 Python 游戏指令对新程序员可用！一些这样的书籍在互联网上免费提供。请参考：

《使用 Python 进行快速游戏开发》（Richard Jones 著）richard.cgpublisher.com/product/pub.84/prod.11。

Python 的其他用途

Python 除了制作游戏之外还有很多用途。学习 Python 可以打开通往数据科学、网络应用开发或软件测试等职业的大门。如果你真的想在计算机编程方面建立职业生涯，那么查看 Python 可以做的不同事情是一个很好的主意。

注意

好奇 Python 在现实世界中的应用吗？了解 Python 在许多不同领域的应用！访问www.python.org/about/success/获取更多详情。

SciPy

SciPy库有一系列开源（免费）的程序，可用于数学、科学和数据分析。这里将介绍其中的两个程序。尽管一些程序在功能上相当先进，但它们也可以用来做简单的事情。如果你想在数学或科学相关的工作中使用 Python，那么了解这个程序套件是很有价值的。

注意

了解所有程序，请访问www.scipy.org/。

iPython

iPython是一个程序，类似于我们用于项目的 Python 外壳，包括IDLE或终端。然而，iPython 有一个服务器，使用笔记本来跟踪你的代码以及你与代码一起做的其他笔记。该项目正在进行一些积极的改进。

注意

了解 iPython 笔记本，请访问ipython.org/。

Packt Publishing 提供了一本名为《学习 IPython 进行交互式计算和数据可视化》（Cyrille Rossant 著，2015 年）的入门书籍，帮助你学习如何使用 iPython：

www.packtpub.com/big-data-and-business-intelligence/learning-ipython-interactive-computing-and-data-visualization。

MatPlotLib

MatPlotLib是一个高级工具，可以使用 Python 编写代码来创建简单或复杂的图表、图形、直方图，甚至动画。它是一个开源项目，因此它也是免费的。有许多使用这个工具的方法，这对于任何 2D 可视化特别有用。有关其下载和安装的所有说明都在其网站上。有许多依赖项，但如果你对数学或 2D 图形表示（或两者）感兴趣，那么你应该查看网站和代码示例。

树莓派

流行的树莓派是一款专为计算和机器人实验设计的小型计算机板。其操作系统与 Windows 和 Mac 不同，预装了 Python 和 pygame，因此它是开始游戏开发的一种非常方便的方式，因为你不需要做我们在第一章中做过的所有工作。

要使用树莓派，你需要电源、一个带有 HDMI 输入的显示器、一根 HDMI 线、一个键盘和鼠标，如果你打算使用互联网，还需要一个 Wi-Fi 转换器或以太网线。此外，你还需要一张 SD 卡来安装最新的树莓派操作系统。有了这些物品，你可以将树莓派作为你的主要计算机使用并进行实验，知道如果你崩溃了，你只需免费制作另一个操作系统的副本即可！

许多人已经使用树莓派制作游戏，甚至小型便携式游戏系统！除了制作游戏，人们还使用树莓派制作机器人项目和媒体中心项目。关于树莓派的一个非常酷的特点是，你可以学习更多关于构建计算机的知识，并尝试为不同的用途制作计算机。你可以使用 Python 和树莓派编写控制开关、门铃甚至家用电器的代码！你可以访问树莓派的官方网站来了解更多关于其硬件和基于 Linux 的操作系统。

注意

访问www.raspberrypi.org/并阅读 Samarth Shah 的《学习树莓派》（Packt Publishing，2015 年）和 Tim Cox 的《Python 程序员树莓派食谱》（Packt Publishing，2014 年 4 月）以获取更多关于树莓派的信息。

编码挑战

除了你可以用 Python 代码做的所有酷炫的事情之外，你可以通过寻找编码挑战并独自或与朋友一起完成它们来练习 Python 编码。这些挑战从简到繁，从易到难，是保持项目之间技能锐利的好方法。编码挑战通常针对每个特定的编码技能，如下所示：

• 打印

• 循环迭代

• 创建变量、字符串和整数

• 数据管理

• 函数

• if/elif/else

• 嵌套 if/elif/else

• 嵌套逻辑

• 递归

如果你对这些术语完全不熟悉，查查它们，了解更多关于它们的信息，并尝试一些编码挑战来加强你的技能。以下是一些提供 Python 编码挑战的网站：

• codingbat.com/python

• www.pythonchallenge.com/

• usingpython.com/python-programming-challenges/

• wiki.python.org/moin/ProblemSets

• www.hackerrank.com/login

你可以在这些链接中找到数百个练习问题！

摘要

希望这本书为你提供了对 Python 基本概念的坚实基础。你绝对不是专家，因为 Python 是一种功能强大的语言，它可以做很多一本书无法展示的事情。然而，如果你完成了每个游戏，你将有一个坚实的 Python 基础，可以在此基础上继续前进。

继续使用 Python 的一种方法是继续在挑战和游戏中工作，同时深入研究代码架构、类和对象，以及使用对象、自定义图像、声音和其他效果进行更高级的游戏编程。Python 不用于传统的游戏系统，但游戏设计概念在任何面向对象的语言中都适用。一旦你在 Python 中感到舒适，你可以更容易地转向更常见的游戏设计语言，如 C++。

使用 Python 的另一种方法是更多地了解数据应用以及如何使用 Python 处理不同类型的数据和数学。这是深入了解探索 Python 并创建一份可以展示给中学甚至大学的工作集的极好方式。互联网上有关于各种主题的大量数据集，包括人口和天气等。

最后，你可能决定你想了解使用 Python 构建的 Web 应用程序。如果你选择这样做，你可以查看 GitHub 或 Bitbucket 这样的地方，程序员们在那里保存他们的代码，有时甚至允许免费获取。阅读其他程序员的代码是学习新且有趣的使用代码方式的一种极好方法。此外，寻找并帮助构建免费程序，也称为开源，是帮助社区在编程方面变得更好的极好方式。你还可以提出很好的问题并得到回答。

在你努力写出更好的游戏和更好的代码的征途中，祝你好运！继续学习！

附录 A.快速任务答案

本附录包含所有章节末尾出现的快速任务问题的答案。现在，让我们看看各个问题的答案。

第一章，欢迎！让我们开始吧

问题	答案
Q1. 什么是终端（Mac/Linux）或命令提示符（Windows）？	终端可以做所有上述操作。
Q2. 当你第一次打开终端/命令提示符时，你需要做什么才能开始读取和编写 Python 代码？	输入单词python。
Q3. Python shell 与命令行有何不同？	在命令行中输入python单词来启动 Python shell。

第二章，变量、函数和用户

问题	答案
Q1. 函数必须以什么开始？	def
Q2. 用来命名变量和函数的约定有哪些？	所有上述选项
Q3. 函数的第一行之后的每一行必须是什么？	缩进
Q4. 如果你想让代码文件在 Python 中运行，你需要以什么结尾？	.py
Q5. 在终端中运行代码文件时，你需要做什么？	在正确的文件夹中，输入python和文件名

第三章，计算这个！

问题	答案
Q1. input()函数返回什么类型的数据？	字符串
Q2. int()函数的作用是什么？	将数据转换为整数
Q3. float()函数与int()函数有何不同？	float()函数仅将数据转换为浮点数
Q4. 如果你在 Python shell 中创建了一个名为 addition()的函数，你如何运行这个加法函数来测试它？	在你的 Python shell 中输入addition()

第四章，做出决策 – Python 控制流

问题	答案
Q1. elif语句在if/elif/else流程中可以出现多少次？	需要多少次就出现多少次
Q2. 哪个语句用于开始一个条件代码块，用于做出决策？	if
Q3. 哪个语句仅在代码条件块的末尾使用？	else
Q4. 什么是全局变量？	2 和 3
Q5. 什么是while循环？	一个重复代码直到发生不同的事情然后停止的循环

第五章，循环和逻辑

问题	答案
Q1. 什么是布尔值？	一个要么是True要么是False的陈述
Q2. 为什么全局变量很有用？	选择 2 和 3
Q3. for循环与while循环类似。for循环与while循环有何不同？	for循环用于循环指定次数
Q4. 在游戏中何时使用while循环比较好？	当某个条件为True时保持游戏进行
Q5. 在代码中写注释时，使用什么符号？	#

第六章，与数据一起工作 – 列表和字典

问题	答案
Q1. 创建字典时应该使用什么正确的语法？
Q2. 一个列表中可以包含哪些类型的数据？	所有数据类型都可以包含在列表中
Q3. 使用什么正确的语法来创建一个列表？	[ ]

第七章，你的背包里有什么？

问题	答案
Q1. 什么是嵌套？	当一个项目在另一个项目内部时
Q2. 在这个游戏中，列表players组织了哪些内容？	它组织了属于每个玩家的所有项目
Q3. players列表中包含的是什么类型的项？	一个字典
Q4. 游戏循环是什么？	2 和 3

第八章，pygame

问题	答案
Q1. 如何启动 pygame？	pygame.init()
Q2. 在 pygame 中对象是如何移动的？	对象看起来在移动，但实际上它们是不断重绘的
Q3. 使用 pygame 如何重绘对象？	pygame.display.update()
Q4. 在 pygame 中用来标识键的缩写是什么？	pygame.K_keyname