面向青少年的 Python 教程（一）

原文：Python for teenagers

协议：CC BY-NC-SA 4.0

一、计算机编程和 Python 简介

计算机编程——通常被酷孩子称为“编码”——是创建应用或软件的艺术。这些程序允许我们做任何事情，从解决简单的数学问题和观看我们最喜欢的 YouTube 视频(我对跳伞牛头犬百看不厌)，到在我们最喜欢的视频游戏中摧毁成群猖獗的外星人，甚至将现实生活中的宇宙飞船发射到外太空。

我称计算机编程为“艺术”，因为它就是。任何时候你创造东西，你都在沉迷于一种艺术形式。当然，计算机代码，也就是我们输入到 shell 中来创建程序的单词(稍后会有更多内容！)，对于街上的普通人来说可能看起来并不漂亮——你的代码很可能永远不会看到艺术展览的内部——但是当你的程序的一部分做了你创建它的目的时……几乎没有什么比这更神奇的了。

也许那些跳伞斗牛犬。

计算机程序可以有多种形状和大小。除了在你的桌面系统上运行的应用或在你最喜欢的视频游戏控制台上玩的游戏，程序还以移动应用的形式出现在手机上。你甚至可以找到操作冰箱、你妈妈的小货车，甚至像烤面包机这样简单的东西的软件。

还有机器人。机器人大军。

但稍后会详细介绍。

现在，我们知道计算机程序是一组代码，用一种编程语言创建，告诉设备执行一组指令。

编程语言概述

如上所述，计算机程序是使用编程语言编写的。就像你、我和世界上其他人每天说的真正的语言一样，计算机语言有各种各样的形式和大小。虽然对于受过训练的人来说，它们中的大多数是有意义的，但如果一个代码新手试图在日常对话中使用它们，听起来就像一个疯子在胡言乱语。该对话可能看起来像这样:

Normal Person: Hello, how are you?
Programmer (You): Print I am fine! Input, how are you?

幸运的是，对所有参与者来说，计算机在编程语言方面都很流利(这部分要感谢我们的朋友编译器——但稍后会有更多的介绍！)并能轻松理解您键入的最复杂的句子。

出于本书的目的，我们将坚持使用最通用、最容易学习的语言之一， Python 。虽然这个名字听起来很可怕，但请记住，它可能更糟:它可能被称为眼镜蛇。事实上，这种语言根本不是以一种爬行动物命名的，而是来自英国的一部古老的电视喜剧《??:巨蟒和飞行马戏团》。

这是你的第一个任务:去问问你父母关于那个节目的事。几小时后见！

哦，你回来了。太好了。他们说的有意义吗？可能不会。不过没关系；你不需要理解英国喜剧的复杂性来学习如何使用这本书编程。你所需要的只是学习的欲望，一台电脑，和你面前的书页。

Python 概述

Python 是一种高级的、动态的、解释的、面向对象的编程语言。虽然所有这些听起来有点吓人，但不要害怕！到本书结束时，你将能够用比上面更令人畏惧的句子来打动你的朋友！这句话的真正意思是，Python 不是一种基本的机器语言，因此，它需要一个“解释器”来将其“编译”成机器语言，以便计算机可以理解您试图告诉它的内容。

这个解释器获取你的代码，并将其转换——或编译—成一系列计算机能明白的 1 和 0。所有这些都是在后台发生的，所以如果你还没有完全理解，不要担心。

Python 是一种相对较新的编程语言，创建于 20 世纪 80 年代末——那时你的父亲留着很大的滑稽小胡子，你的母亲听着名字像 Wham 这样的乐队。和毒。

创造这种语言的人是一位名叫吉多·范·罗森的计算机天才，他被赋予了一个奇特而荒谬的头衔，终身仁慈的独裁者。像技术一样，编程语言也在发展，Python 也不例外。多年来，它经历了几个版本，目前被称为 Python 3。

Python 和其他编程语言有什么不同？

Python 与其他编程语言在许多不同但重要的方面有所不同。首先，Python 通常比同类语言(如 Java 和 C++)更容易学习和使用。用 Python 创建的程序也花费更少的时间，因为它需要更少的代码(一般来说)。这部分是由于 Python 的数据类型——我们将在下一章详细介绍这个术语。

Python 也是极其通用的。虽然 Python 可能不是首选，但它可以用于几乎每个领域的应用，包括游戏、桌面软件、移动应用，甚至虚拟现实。它也是网络编程的必备工具，是计算机安全工具箱中的必备工具。

Python 的优势

Python 是当今世界上最常用的编程语言，也是发展最快的语言。有充分的理由。下面是 Python 可以让程序员受益的几个方面:

• 提高生产力:根据一些报告，Python 可以提高程序员的生产力——他们在给定时间内可以完成多少工作——十倍之多！它真的比子弹还快！

• 可扩展性:Python 的一个巨大优势是它有一个非常广泛的库。库是一组可以添加到程序中的现有代码。这些库涵盖了程序的常见特性，让您不必自己一遍又一遍地编写代码。例如，不需要编写一段代码来执行一个复杂的数学方程，你可以提供使用一个库来为自己省去一个大麻烦。

• Python 易于阅读:作为一名程序员，一个棘手的问题是，有时你的代码无法工作。当这种情况发生时，你可能会发现自己在重读自己的代码——或者更糟，重读别人的代码——试图找出为什么你的程序没有正常运行。幸运的是，Python 易于阅读，大部分语言一看就明白。这使得发现问题比更复杂的语言容易得多。

• 可移植性:Python 可以在许多平台和系统上运行，这意味着您的程序可以面向更广泛的受众。

• 物联网(IoT):物联网可能听起来像是一个充满数字野兽的神奇世界，从某些方面来说，的确如此。物联网由智能物体组成，包括电灯开关、门把手、烤面包机、家用电器，你可以在日常生活中找到它们。这些家用电器可以通过语音命令和移动设备进行控制，使它们比原始的前辈更具交互性。我的意思是，当然，你的父母总是对着洗碗机大喊——但是它听进去了吗？现在，由于物联网和 Python 等语言，它可以做到！你仍然要把你的盘子放在里面，但是仍然！

• Python 框架:框架就像程序的骨架——它们允许你快速地为某些类型的应用建立基础，而不需要编写你正在开发的软件类型中通常存在的通用元素。这节省了程序员的时间，并减少了手工编码时可能出现的错误。Python 得到了大量框架的支持，这使得启动一个新程序变得非常迅速！

• Python 很有趣:Python 是一门有趣的学习语言；如上所述，不仅入门容易，Python 社区还举办了许多有趣的活动和挑战。例如，许多人以诗歌的形式编写他们的 Python 代码，每年都有大量的 Python“挑战”来帮助测试一个程序员的技能。

• Python 是灵活的:因为 Python 有如此多的用途，被世界上如此多的公司使用，所以学习 Python 后找工作比学习其他语言更容易。此外，如果您不喜欢某个给定的领域，您可以随时使用您的 Python 技能尝试不同的途径。例如，如果你发现编写应用很无聊，你可以转到网络管理或在 IT 安全公司工作。

这些只是 Python 提供的一些好处和优势。

野生蟒蛇的例子

虽然很难说世界上有多少公司使用 Python，但是有许多有趣的业务依赖于这种语言。以下只是其中的一小部分:

• 韦恩企业(蝙蝠侠的另一个自我的公司):嗯，我们真的不知道，但那不是很酷吗？

• Google:搜索引擎巨头和未来的统治者 Google 从一开始就使用 Python，部分原因是开发人员可以用它快速构建程序，也因为代码易于维护。

• 脸书和 Instagram:虽然 Python 不是这两个社交媒体平台使用的唯一语言，但它是它们最重要的语言之一。脸书使用 Python，部分原因是因为它有丰富的库。与此同时，Instagram 是 Python 的主要 web 框架之一——Django 的坚定支持者。我们将在本书的后面详细讨论 web 框架。

• 网飞:如果你是流媒体电影的粉丝，那么你对网飞一定不陌生。该公司主要将 Python 用于其数据分析功能和安全目的——以及其他领域。

• 电子游戏:《战地 2》和《文明 4》只是两款都依赖于 Python 的电子游戏。有趣的是，文明使用 Python 作为人工智能(AI)脚本。

• 政府机关和机构:政府机关和机构包括美国宇航局、国家气象局和中央情报局都使用 Python——尽管如何使用它是绝密的！带着装满钱的公文包在车库等我们，我们会告诉你一切！

你的第一个 Python 程序

现在，您可能想知道 Python 代码是什么样子的。别害怕！我将向您展示一个样本片段。稍后，在我们在您的计算机上安装 Python 和 IDLE(集成开发环境)之后，您可以尝试执行或运行代码来查看它的运行情况。但是现在，我认为在深入研究这种语言之前，让您体验一下是一个好主意。

传统上，当程序员编写他们的第一行代码时，他们会创建一个名为“Hello，World”的程序，作为向世界介绍自己的一种隐喻方式。然而，作为崭露头角的超级英雄——或者恶棍(这里不做评判)——我们需要一些更闪亮的东西。

看，你的第一个 Python 程序！

print("Look up in the sky! Is it a bird? Is it a plane?")
print("Dun dun dun dun dun dun dun dun dun dun dun dun dun dun dun dun")
print("No you dummy. That's just some guy flying around in his pajamas. Now get back to work!")

如果您运行这段代码，结果将是:

Look up in the sky! Is it a bird? Is it a plane?

Dun dun dun dun dun dun dun dun dun dun dun dun dun dun dun dun

No you dummy. That's some guy flying around in his pajamas. Now get back to work!

让我们更仔细地检查一下代码。说明 print() 的部分被称为函数，它的工作是告诉计算机——在这个例子中是—在用户的屏幕上打印一些东西。左括号和右括号()之间的文本是我们提供给函数的参数。引号" "之间的字符称为字符串。

如果这还没有完全理解，请不要担心——我们将在下一章详细讨论这个话题。现在，只要知道这就是 Python 代码的样子。很有可能，在我告诉你之前*，你能够准确地说出这个程序将做什么；这只是 Python 如此伟大的原因之一——它的可读性！*

安装 Python

在本节中，我们将学习如何在各种操作系统上安装 Python。操作系统是一种让你与计算机互动的软件。你可能很熟悉那些更受欢迎的，比如微软 Windows (如果你有个人电脑的话)和 Mac OS X (如果你有苹果电脑的话)。您安装的 Python 版本将根据您的计算机使用的版本而有所不同。此外，我们还将学习如何在 Linux 和 Ubuntu 系统上安装 Python。

在 Windows 上安装 Python

首先，打开 web 浏览器，导航到 Python 官方网站及其下载页面: www.python.org/downloads/ (图 1-1 )。

图 1-1

Python。org 网站

Python 目前的版本是 3 . 6 . 5；等你读到这本书的时候，可能还会更高。无论是哪种情况，点击下载 Windows 最新版本标题下的“下载 Python”按钮。或者，您可以向下滚动并下载以前的版本(只要确保它们是版本 3。x 或更高版本，因为版本 2 之间存在不兼容问题。x 和 3。x)；但是，出于本书的目的，最好使用 3.6.5 或更高版本。

将出现一个图像，询问您是否要保存该文件。点击“保存文件”(图 1-2 )，将其保存到您的桌面或易于记忆的地方。

图 1-2

Python 安装文件的保存文件对话框

导航到您的桌面(或您保存文件的位置)并双击它。它应该类似于图 1-3 中的图像。

图 1-3

Python。EXE 安装文件图标

安装程序将启动，并询问您是希望“立即安装”还是“自定义安装”为方便起见，我们将允许安装程序“立即安装”但是，在单击该按钮之前，请确保“为所有用户安装启动器”和“将 Python 3.6 添加到路径”都已选中。然后点击“立即安装”选项(图 1-4 )。

图 1-4

Python 安装设置屏幕

Windows 可能会弹出一个窗口，询问您是否允许继续安装。如果是这样，请允许程序继续运行。将出现一个新的弹出窗口，显示设置进度(图 1-5 ):

图 1-5

Python 安装进度屏幕

设置完成后，您将看到如下所示的屏幕。点击“关闭”按钮完成安装(图 1-6 )。

图 1-6

Python 安装设置成功窗口

现在，您的计算机上应该已经安装了 Python。您可以在您的“开始”菜单中找到它，标签为 Python 3.6(或您安装的任何版本)。

当您启动 Python 时，首先看到的是 shell，它是开发环境的一部分，您可以在其中编写一行代码、测试代码、运行代码和创建 Python 文件。图 1-7 显示了 Python Shell 启动后的外观示例。

图 1-7

Python 外壳

在这个 shell 窗口的顶部，您可以看到 Python 的当前版本和一些其他信息。您还会看到三个大于号或箭头(> > >)。这些被称为命令提示符，您将在这里向 Python 输入指令。

准备好开始了吗？让我们输入一些简单的代码，看看会发生什么！在提示符下输入以下内容:

print("Look up in the sky! Is it a bird? Is it a plane?")

完成后，按回车，你应该会看到如下结果(图 1-8 ):

图 1-8

用 Python Shell 编写的示例代码

如果没有，请重新检查您的代码，确保拼写正确，并记住插入括号()和引号“”。

因为我们直接在 shell 中工作，所以我们的代码会被实时执行。在这个例子中，它运行了一行代码，告诉计算机在屏幕上打印一行文本。

在现实世界中，我们想要创建实际的 Python 文件，以便我们可以保存我们的程序供以后使用，并帮助我们在每次运行我们的程序时避免重新编写数千行代码。

幸运的是，Python IDLE——或开发环境——允许我们创建 Python 文件，即以扩展名结尾的文件。py，相当容易。你所要做的就是点击文件，然后新文件(见图 1-9 、 1-10 和 1-11 )。

图 1-11

显示 Python 目录的保存对话框

图 1-10

用. py 文件编写的示例代码

图 1-9

新创建的。py 文件

将弹出一个新窗口。这是您可以编写代码并保存以备后用的地方。也就是说，让我们输入刚才使用的示例代码。然后点击文件，再保存。

接下来点击文件，然后保存。

输入文件名，点击保存按钮，完成文件创建。出于本书的目的，让我们保持简单，将我们的文件命名为 Example1.py 。

现在，你已经创建了你的第一个真实世界的 Python 程序。要运行该程序，请单击“运行”,然后选择“运行模块”。您的程序现在将在 Python shell 中执行！(图 1-12 )。

图 1-12

的结果。py 文件在 Python Shell 中运行

现在，让我们总结一下:还记得我们在本章开始时写的第一个程序吗？让我们将它输入到 Example1.py 文件中，完成后单击保存。下面是代码:

print("Look up in the sky! Is it a bird? Is it a plane?")
print("Dun dun dun dun dun dun dun dun dun dun dun dun dun dun dun dun")
print("No you dummy. That's just some guy flying around in his pajamas. Now get back to work!")

一旦你保存了文件，点击运行并选择运行模块来查看运行中的完整代码！(图 1-13 )。

图 1-13

Python Shell 中运行的. py 文件的另一个例子

在其他操作系统上安装 Python

本书使用安装在基于 Windows 的计算机上的 Python 虽然里面的代码可以在任何一台计算机上运行，但是 Python 的实际安装会因操作系统的不同而有所不同。

要在 Mac OS X 上安装 Python，请打开 web 浏览器并导航至 www.python.org/downloads/mac-osx/ 。选择“最新 Python 3 版本”链接，按照说明和提示完成设置和安装过程。

要在 Unix/Linux 系统上安装 Python，打开浏览器，进入 www.python.org/downloads/source 。单击“最新 Python 3 版本”的链接，并按照说明完成设置和安装过程。

在这一集里！

我们在这一章中确实讲了很多，但与我们在下一章将要揭示的相比，这根本不算什么！这里有一个简短的列表——如果你愿意的话，是一个总结——列出了我们到目前为止所涉及的内容(嘿，我们现在是编程英雄了，我们也要说行话了！)

• Python 是一种编程语言，可以让你对计算机、移动设备、视频游戏、人工智能系统、物联网(IoT)设备、基于网络的应用，甚至虚拟现实/增强现实(VR/AR)进行编程。

• 程序或应用是一组代码，让你给计算机或设备一组指令来执行。

• 了解 Python 的程序员可以从事编程、网络管理、IT 安全、视频游戏开发、移动应用创建、法医计算机科学等职业。

• Python 可以跨多个平台工作，包括 Windows PCs、Mac 计算机、移动设备、Unix/Linux 驱动的计算机等等。

• Python 可以通过一组被称为“道德黑客”工具的技能和模块来防止黑客攻击。

• IDLE 代表集成开发环境；这是我们创建 Python 代码和文件的地方。

• Python 创建的文件以文件扩展名结尾。py”。

• 在撰写本文时，Python 的当前版本是 3.6.5。如果你在读这本书，一定要用这个版本或者更新的版本。

• print()功能允许您将文本打印到用户的屏幕上。例如，print("Hello Wall!")将打印文本:Hello Wall！对着电脑屏幕。

• 全球许多组织和公司都在使用 Python，包括脸书、谷歌、Snapchat、NASA、中情局等等！

• Python 是世界上使用最多的——也是发展最快的——计算机编程语言。

二、把一切加起来

既然我们都穿上了隐喻的斗篷和超级英雄的装备(也就是说，我们已经安装了 Python 并学会了如何使用 IDLE)，是时候测试我们的新超能力了！我们的第一个恶棍？也许是有史以来最邪恶、最卑鄙、最轻蔑的野兽之一；一个学校系统的罪犯，横行无忌，威胁要摧毁——或厌烦——它所经过的每一个学生。反派的名字？

数学。

我知道，这不是最令人兴奋的话题。至少，乍一看不是。然而，事实是，数学，更重要的是，数学函数是编程世界的面包和黄油。没有数学，我们就无法做计算机和移动设备允许我们做的任何漂亮的事情。不会有电脑游戏，不会有太空飞船，不会有未来的机器人来帮助我们打扫肮脏的房间。

没有数学，我们将真正成为一个失落的文明。

因此，本章的目的将是如何使用 Python 的一些内置的数学函数来处理数学和创建简单或复杂的数学方程。

类似于我们在第一章中学到的 print()函数，我们将要讨论的数学函数将让我们对数据执行预先构建的操作，而不必编写应用的公共元素。所以，举个例子，而不是写一大堆代码向计算机解释什么是加法，如何实际相加数字(记住，计算机只能做我们告诉它的事情；它不能独立思考——至少现在不能！)，如果我们从头开始，这将需要数千行代码，我们所要做的就是键入一些简单的内容，例如:

1+1

继续——将它输入 Python shell。当你这样做时，它应该忠实地返回答案:2。

就像你在学校学到的数学一样，Python 天生就能理解基本的数学函数。如果你看到这个:8/2，你的大脑知道这个等式涉及除法。如果看到+ 符号，很明显是加法，a -表示减法。Python 也理解这些符号，并将基于它们执行数学运算。尝试在 Python shell 中键入以下内容:

2+2-1

在这个实例中，Python 将返回 3，表明它能够理解常见的数学运算符。Python 中的运算符包括:+、-和/-等等。

乘法怎么样？键入以下内容:

2x2

那里发生了什么？程序没有像我们预期的那样返回 4。相反，它返回了一个语法错误:无效语法异常。SyntaxErrors 意味着您输入到 shell 或 Python 文件中的语法(即书面文本)有问题，导致程序无法正常运行。

换句话说，Python 不懂你。

这里，解决方案很简单:在 Python 中，乘法运算符不是“x”，而是一个星号(*)。要修复我们的语法错误，我们所要做的就是用正确的乘法运算符替换错误的乘法运算符，就像这样:

2*2

现在，如果你输入，它将返回预期的响应——数字 4。

运算符优先级

邪恶的反派数学的超能力之一就是用看起来太难把握的概念来迷惑我们。不要害怕！凭借我们超级英雄的计算能力，即使是最复杂的数学谜语也难不倒我们。

不是说它不会尝试，请注意！

在 Python 中执行计算时，我们必须时刻注意一个叫做操作符优先级的东西。这只是对 Python 处理数学问题的顺序的一种想象。某些运算符的优先级比其他运算符高，这意味着它们排在第一位。可以想象，这可能会让程序员感到困惑，即使是最有经验的老手也会在输入计算时出错。

为了让您更清楚地了解运算符优先级是如何工作的，下面是 Python 中的一个运算符列表，按照优先级或等式中谁先开始排序。注意:其中一些操作符可能对您来说并不熟悉——现在不要太担心；我们将在本书中详细介绍它们。

• **(取幂运算)

• *、/(乘法和除法)

• +，-(加法和减法)

• 在，不在，是，不是，，> =，！=，==(这些被称为比较，允许您将一个值与另一个值进行比较)

• 不是 x

• 单位

• 或者

• 语句

为了简单起见，让我们使用基本运算符:*、/、+ 和-(乘法、除法、加法和减法)。在您的 shell 中键入以下内容:

10+10 * 20

在这个等式中，我们在问 10 加上 10 乘以 20 的值是多少。通常，我们认为答案应该是 400，因为第一个值 10 加 10 应该等于 20。然后，我们将答案(20)乘以 20，得到 400。然而，当我们在 shell 中输入代码时，我们得到了一个令人惊讶的结果，如图 2-1 所示。

图 2-1。

运算符优先级示例

你的第一个想法可能是:Python 数学不好吗？怎么得出的答案:210？出现这种情况是因为运算符优先级。请记住，在我们的运算符优先级列表中，乘法优先于加法。因此，Python 首先对乘法的求值，然后进行数学运算。在这个例子中，Python 是这样看待我们的等式的:20 * 10 + 10。

我知道你在想什么:我头疼。

乍一看，这似乎令人困惑，但幸运的是，有一个简单的解决方案。我们可以通过使用括号来强制 Python 使用一个求值顺序——执行计算的顺序。这有两个效果:首先，它确保 Python 执行我们想要的计算，并且不会混淆我们的优先级。第二，它让其他程序员看一眼就知道你真正想要的是什么。

让我们试一试。在您的 shell 中键入以下内容:

(10+10)  * 20

如图 2-2 所示，现在我们得到了想要的结果。通过将(10+10)放在括号内，我们告诉 Python——以及其他编码人员——我们打算首先执行等式的这一部分(见图 2-2 )。

图 2-2。

使用括号强制排序的运算符优先级示例

让事情变得稍微复杂一点，我们还可以做一些被称为嵌套的事情。这意味着您将圆括号放在其他圆括号的内，以进一步指示应该执行什么顺序计算。在这种情况下，首先计算最里面的括号，然后是最外面的，然后是等式的其余部分。考虑一下这个:

((10+5) * 10) / 2

如果您将该等式输入 Python，它将按照以下方式执行求值顺序:

• 十加五等于十五

• 15 * 10 等于 150

• 150 / 2 等于 75

然而，如果我们不使用括号，Python 会这样理解:

10 + 5 * 10 / 2

或者

• 10 / 2 等于 5

• 5 * 5 等于 25

• 25 + 10 等于 35

这也是因为在考虑运算符优先级时，Python 在加法和减法之前执行乘法和除法*。*

所以，为了避免任何混淆，除了简单的数学运算之外，在执行任何运算时都要使用括号。

数据类型:了解你的敌人

超级恶棍有各种形状和大小。你有你的邪恶科学家，一心想用死光和转基因大猩猩毁灭世界；有邪恶的绿色的，荡漾着肌肉和充满愤怒，因为…嗯，没有真正的好理由。还有一些人一直在笑，尽管没有人讲过一个笑话。

有成千上万种类型的恶棍，作为一个初出茅庐的超级英雄，你可以打赌很难让他们都井然有序。Mindblower 先生是一个超级聪明的人，还是一个被人误解的无法统一行动的恶棍？神秘的斯蒂芬·金刚(Stephen King Kong)——半大猩猩半恐怖的作家——他到底是什么？他是怎么用大猩猩的大指关节写出这么多书的？

这足以让你失去理智。

还是那个吹牛老爹又在工作了？

幸运的是，有一种方法可以让所有这些恶棍组织起来。这叫做原型。

在 Python 中，我们也有类似的问题。有各种各样的数据在流动。首先我们有数字和文字。更糟糕的是，我们有不同类型的数字。有常规数字，有带小数的数字，还有代表时间或金钱的数字。甚至有一些数字的行为方式与单词的行为方式相同。

幸运的是，在 Python 中有一种叫做数据类型的东西。这些是定义或分类你输入到程序中的数据类型的方法。虽然这似乎应该是常识——有时确实如此——但事实是，Python 只知道您告诉它知道的东西。所有的计算机语言都是如此。事实上，所有的计算机语言都有数据类型，就像 Python 一样，所以数据类型的概念是你在学习其他语言时可以随身携带的。

我们将在本书中讨论几种数据类型的形式，但在本章中，我们将集中讨论一个特定的集合:数字。

一般来说，Python 将数字识别为数字，但是，正如您所想象的，并不是所有的数字都是平等的。简单来说，现在，你看到的任何一个整数或者没有小数点的数字都叫做整数。整数包括 0、2、5、10、100、1000、1032 等数字。

尝试以下代码:

print(122)

您的结果应该是这样的(参见图 2-3 ):

图 2-3。

打印整数

正如我们前面看到的，整数不仅仅是打印到用户的屏幕上——我们还可以进行计算。让我们试试下面的方法:

print(5/2)

这段代码运行时会发生一些有趣的事情，如图 2-4 所示:

图 2-4。

在 print()函数中执行数学运算

返回的数字不符合整数的标准，尽管我们对两个整数执行了数学运算。每当一个数字有小数时，它就不再被认为是整数数据类型；相反，它是一个浮点数。

正如我们可以在整数上执行等式一样，我们也可以在浮点数上执行等式。我们在图 2-5 中展示了一个例子:

图 2-5。

浮点数据类型

当一个 float 被添加到另一个 float 时，结果是另一个 float。即使这个数字看起来应该是一个整数，也是如此。比如我问 2.5 + 2.5 的结果，你大概会回答:5。让我们看看 Python 对此有什么看法:

从图 2-6 中可以看到，Python 做了一些我们可能没有预料到的事情:它返回了 5.0——一个浮点数。

图 2-6。

在两个浮点数上执行数学运算

虽然这是一个合适的结果，但我们可能会发现自己处于需要更改数字的数据类型的情况。例如，我们可能有一个程序，其中我们不想显示小数点或想四舍五入我们的数字。在这种情况下，一种选择是转换我们的数字。

然而，在我们了解这一点之前，让我们再尝试一件事。当我们对一个整数和一个浮点数执行数学运算时会发生什么？尝试以下操作(参见图 2-7 ):

图 2-7。

从整数中减去浮点数的结果

print(5 - 2.5)

你的结果应该是:

任何时候你对一个整数和一个浮点数执行数学运算，结果都是一个浮点数。

转换数字数据类型

我们要学习的第一件事是如何将一个整数转换成一个浮点数。在前面的例子中，我们使用了一个简单的方法将整数转换成浮点数:除法。我们可以实现相同效果的另一种方法是使用 Python 的内置函数之一，称为float()。

使用float()非常简单——你所要做的就是把你想要转换的整数放在括号()内。让我们试一试！

float(12)

如果您在 Python Shell 中键入该内容，将会得到以下结果:

图 2-8。

将整数转换为浮点数

如图 2-8 所示，你的结果应该是 12.0 (而不是仅仅常规的没有小数点的 12)。

要做相反的事情——将浮点数转换成整数——我们使用 Python 的另一个超级方便的内置函数。请看，int()！

功能int()的工作原理与float()相同。只需在括号中输入你想要转换的数字，Python 就会完成剩下的工作。尝试一下:

int(12.0)

这将返回:

图 2-9。

将浮点数转换为整数

如图 2-9 所示，我们取了一个浮点数——12.0——并通过去掉小数点将其转换为整数 12。

如果我们有一个不以. 0 结尾的浮点数会怎么样？让我们通过一个简单的测试来了解一下。在您的 Python Shell 中键入以下内容:

int(12.6)

当你按下回车键，你会得到结果:12。为什么不是 13？当您将浮点数转换为整数时，Python 会删除小数点后的所有内容并忽略它。如果你想向上取整(或向下取整)，你需要使用一个不同的函数，我们将在本书的后面介绍。

有许多数据类型可以转换成其他数据类型，我们将在本书中介绍其余的数据类型。然而现在，给自己一点掌声吧——你的武器库中又增加了两个新的超级能力:int()和float()函数！

什么是变量？

到目前为止，我们已经学习了一些基本的数学运算符和函数，可以用来将数据类型从一种转换为另一种。然而，为了让我们拥有真正的力量，我们需要了解一种被称为变量的秘密武器。

有几种简单的方法可以让变量变得更容易理解。一种方法是把它们想象成一个盒子，你可以在里面存放东西。在我们的例子中，我们存储的是数据。这些数据可以是数字，可以是文本，可以是货币价值，可以是你的狗的名字，可以是一段文字，也可以是你秘密巢穴的安全密码。

变量在 Python 和其他编程语言中有许多功能。变量的最大用途之一是存储信息，这样我们就不必一遍又一遍地不断输入信息。例如，您可能有一长串经常使用的数字。不用每次需要的时候都输入这个长长的列表，你可以把它存储在一个变量中，然后调用这个变量。

要使用一个变量，你只需要给它一个名字，然后定义它的值。例如:

a = 8675309

这段代码创建变量名“a”，然后给它赋值，在本例中是 8675309。

当然，存储数据是一回事；使用这些数据是另一回事。让我们继续创建一个简单的程序，它将为两个变量提供一些数据，然后将其打印到用户的屏幕上。还记得如何从我们的第一个程序示例中创建新的 Python 文件吗？在 Python Shell 中，点击文件，然后新建文件。将弹出一个新窗口。在新窗口中输入以下代码:

a = 500
b = 250
print(a)
print(b)

接下来，点击文件，然后保存。将文件命名为 VariableTest.py 。要查看运行中的代码，请单击运行，然后单击运行模块。

代码将在 Python Shell 中运行，如图 2-10 所示:

图 2-10。

打印两个变量的值

如你所见，我们给变量 a 赋值 500，然后给变量 b 赋值 250。然后，使用 print 函数，我们打印出两个变量的值。现在来点真正的乐趣吧！

公平地说，打印出变量的值相当无聊。然而，打印并不是我们可以对变量做的唯一事情。让我们修改 VariableTest.py 的代码。将以下代码添加到文件中，使其看起来像这样:

a = 500
b = 250
print(a)
print(b)

print(a+b)

保存文件，然后再次运行以查看结果，结果应与图 2-11 相匹配:

图 2-11。

显示了添加和打印两个变量的结果

这里，我们创建了两个变量，并给它们赋值，就像之前一样。我们还把它们打印了出来。然而，这次我们也对它们进行了一些数学运算，并打印出了结果。行中的代码:print(a +b)告诉 Python 打印 print()函数的括号()内的任何内容——在本例中，我们说打印等式(a) + (b ),即 750。

请注意，这个不会改变变量“a”或“b”中的数据值——它只是使用它们执行数学运算。要更改变量内部的数据，我们有几个不同的选项。让我们创建一个新文件，并将其命名为 VariableChange.py。

a=500
b=250

a=a+b

print(a)

运行代码查看结果(如图 2-12 所示):

图 2-12

将两个变量的结果赋给一个变量

这里发生了什么？首先，我们命名并定义了变量“a”和“b”的值。然后，我们将两个变量的值相加，并重新分配变量“a”的值，以匹配该方程的结果。然后，我们打印出变量“a”来显示新值，即 750。

当我们输入 a=时，我们告诉 Python 将“a”的值改为等号(=)后面的值。接下来，Python 将“a”和“b”相加，并将该值赋回“a”。等号(=)被称为赋值运算符。

如果我们不想改变变量“a”的值，我们也可以创建一个全新的变量。让我们修改 VariableChange.py 中的代码，使其符合以下内容:

a=500
b=250

c=a+b

print(c)

这一次，我们没有改变“a”的值，而是简单地创建了一个新变量“c”，并赋予它“a”+“b”的值，然后打印出“c”的内容。

超级英雄发电机 3000

现在我们已经有了一些代码经验，让我们用它来构建我们将在本书结束时创建的程序的基础。该计划将是一个超级英雄生成器，让用户创建英雄(或恶棍)完成统计数据，随机名称，随机生成的权力和统计数据。

下面的一些代码将向我们的程序添加文本，我们将在第三章中详细介绍。现在，我们将只使用这些文本作为标签，所以你理解代码应该没有问题。

每个英雄都有一定的身体和精神属性。如果你以前玩过角色扮演游戏——或者 RPGs 那么你应该对这个概念很熟悉。如果没有，不用担心！看看你周围的人，观察他们。举例来说，你的体育教练可能有肌肉，而且身材很好。这意味着他比你的科学老师更有力量和耐力。

另一方面，你的科学老师可能比你的体育教练更聪明、更有智慧，这意味着他有更多的智力和智慧。让我们从这些属性开始，作为我们的前四个统计数据。我们可以在以后添加更多。

为了确定每个值，我们需要指定一个从低到高的范围。我们现在可以使用 0-20 的范围，0 代表低，20 代表高。所以，如果我们讨论的是力量，那么 0 代表非常弱，20 代表大力士。因此，平均值为 10。

同样，对于智力，我们可以说 0 是门把手(因此有“像门把手一样笨”的说法)，20 是阿尔伯特·爱因斯坦。任何在 10 分范围内的人都被认为智力一般。

现在，我们可以允许玩家设置他们自己的属性分数，但是，我们知道每个人都会把他们设置为 20，成为最强壮，最聪明的人。虽然这确实完美地定义了你和我，但其他凡人达不到这些高标准。

相反，我们想要做的是随机地给它们的属性赋值*。Python 能够使用一个名为random()的函数非常容易地创建随机数。*

*使用random()和其他函数有点不同。要使用它，我们首先要把它import成 Python。我们用一行简单的代码做到了这一点:

import random

random()函数像其他函数一样工作，因为您可以将参数赋给它的括号。创建名为 RandomGenerator.py 的新 Python 文件，并输入以下代码:

import random

strength = random.randint(1,20)

print(strength)

在这段代码中，我们首先导入 random()模块，然后创建一个名为“strength”的变量。关于变量有一点需要注意。在编程界有一种叫做命名约定的东西。这意味着在给事物命名时，你应该遵循某些“规则”。对于一个变量，你总是想给它们起一个名字，让你或未来的程序员知道变量中保存的是什么类型的数据。例如，将一个变量命名为“a ”,并不能给我们提供多少信息。将其命名为“强度”告诉我们里面的数据到底是干什么用的。

如果您的变量名中有多个单词，请始终将它们作为一个单词，只需将第二个单词的第一个字母大写。例如，如果我们的变量是“英雄强度”，我们会将其命名为 Hero Strength。如果是“英雄力量统计”，我们会用 heroStrengthStats。

第二条经验法则是尽可能保持简洁。记住，变量是用来节省输入代码的时间的，所以长名字会使目的落空。

回到代码…

在创建了我们的变量“强度”之后，我们想给它赋值。代码的下一部分调用 random()模块，并使用一个名为randint的属性。Randint 是 random()的一部分，它告诉 Python 不仅要创建一个随机数，还要创建一个随机整数。我们放在括号中的值是随机数的范围。记住，我们希望我们的统计范围在 1 到 20 之间，因此，我们输入的值是(1，20)。

尝试多次运行 RandomGenerator.py 中的代码。每次都应该得到一个随机数:

现在我们已经有了我们的随机数生成器，并且了解了如何使用它，让我们添加一些更多的统计数据:

import random

strength = random.randint(1,20)
intelligence = random.randint(1,20)
endurance = random.randint(1,20)
wisdom = random.randint(1,20)

接下来，我们需要将这些值打印到屏幕上进行测试。为此，我们将使用一些文本作为标签，然后在标签后打印每个变量的值。在变量后添加以下代码:

print("Your character's statistics are:")
print("Strength:", strength)
print("Intelligence", intelligence)
print("Endurance", endurance)
print("Wisdom", wisdom)

这里我们遇到了 print()函数的不同用法。之前，我们使用 print()打印数字和变量。然而，现在我们使用一种新的数据类型，称为字符串。字符串就是文本。它可以包含任何字母、特殊字符(！、@、#、$、%、^、&、、-、+、=等。)，以及任何数字。但是，要将其视为文本，它的必须*放在引号" "之间。如果不是，Python 会把它解释成别的东西。现在不要太担心这个——我们会在第三章中详细讨论。现在，让我们检查一行代码:

print("Your character's statistics are:")

这段代码实际上告诉计算机将“你的角色的统计数据是:”打印到屏幕上。

下一条指令略有不同:

print("Strength:", strength)

这个 print()函数做两件事。首先，它说打印括号之间的文本:“强度:”。然后，我们添加一个逗号(，)，告诉 Python 对 print()函数有进一步的说明。接下来，我们包括我们想要打印其内容的变量的名称——在本例中，变量 strength 。请注意，变量不在引号中。如果是，它将只打印单词“strength ”,而不是名为 strength 的变量的内容。

现在，您的 RandomGenerator.py 文件应该如下所示:

import random

strength = random.randint(1,20)
intelligence = random.randint(1,20)
endurance = random.randint(1,20)
wisdom = random.randint(1,20)

print("Your character's statistics are:")
print("Strength:", strength)
print("Intelligence", intelligence)
print("Endurance", endurance)
print("Wisdom", wisdom)

让我们运行几次代码。请记住，我们的程序创建随机生成的数字，因此每次执行代码时，结果都会有所不同。图 2-13 显示了它应该看起来的样子:

图 2-13。

生成随机统计数据

恭喜您，您刚刚创建了超级英雄生成器 3000 应用的开始部分！

在这一集里！

在这激动人心的一集里，我们涉及了很多内容。你开始只是一个年轻的助手，但是你的力量正在稳步增长！很快你就会从神奇小子变成…神奇侠？我不知道——我们会想出名字的。真正重要的是，你已经像超级英雄一样迈出了编码之路的第一步。

前方有什么危险？下一章，我们将看看如何处理文本，并继续构建我们的超级英雄生成器 3000 应用。我们也将开始记录和评论我们的工作，如果你希望成为其中一个伟大的人，这是一个强制性的编程练习！

在我们继续之前，让我们先看看在这一期中我们学到了什么:

• 数据类型:数据类型存在于所有编程语言中，有助于定义程序处理的数据种类。integer–或 int–是整数的数据类型，而 float 是浮点数或带小数的数字的数据类型。

• 运算符优先级:在执行等式时，某些运算符优先于其他运算符。

• 运算符:常见的运算符有+(加)、-(减)、*(乘)、和/(除)。

• 赋值操作符:等号(=)是一个赋值操作符，允许你给一个变量赋值。

• 运算顺序:数学运算的执行顺序称为运算顺序。我们可以通过在括号中封装部分来控制在一个等式中首先执行哪种数学运算。例如:(1+1) * 10 确保 1+1 在乘法之前执行，尽管事实上乘法的运算符优先级高于加法。

• 转换数据类型:int()和 float()分别允许我们将浮点数转换为整数，将整数转换为浮点数。

• 变量:变量是数据的存储单位。您也可以将它们视为指向数据位置的标签，但是将它们视为可以包含一条信息的盒子可能更容易。我们通过命名变量并用赋值操作符给它们赋值来创建变量。比如:a = 12。

• 命名约定:命名约定是一些松散的规则，有助于简化编码——对于你和任何将来阅读你的代码的程序员。请将它们视为“最佳实践”例如，在给一个变量命名时，第一个单词总是用小写字母，后面的任何单词都用大写字母。一定要把多个单词组合成一个单词。比如:socialSecurity 好。社会保障不好，会导致语法错误。此外，尽量用简短的名称命名变量，以描述变量中的数据的用途。

• random()和 randint(): random()是一个可以生成随机数的模块。您必须使用代码 import random 将它导入到您的程序中。要随机生成具有给定数字范围的整数，请分别键入 random.randint(1，20)或 random.randint(5，100 )(如果要随机生成 1 到 20 或 5 到 100 的数字)。如果您想生成 0 到 20 之间的数字，您必须在代码中指定，例如:random.randint(0，20)。*

三、把东西串起来

欢迎无畏的英雄回来！关于超级英雄和反派(尤其是反派)，你应该知道一件事——他们往往相当担心。谢天谢地，这一章是关于增加你的能力，给你新的超能力来处理所有文本和文本相关的事情！

我们将学习处理和操作文本的基础知识，包括常见的文本函数和关于文本数据类型的细节。我们还将讨论格式化文本和将文本转换成不同的数据类型。最后，我们将讨论好的文档的重要性，以及如何对代码进行注释，从而为您和未来的程序员省去很多麻烦。

所以穿上你的亮绿色紧身衣，戴上橙色的口罩。清除你的神奇男孩(或女孩)标志上的番茄酱污渍，让你的手指变得漂亮灵活。

准备编码！

在门口留下你的评论

在我们更深入地研究编程语言之前，有必要讨论一个我们已经提到过但目前还在回避的话题。就像正确的命名惯例一样，注释或记录代码的艺术是一个好的程序员经常实践的最佳实践之一。这有点像在你离开家之前熨你的斗篷。当然，你可以跳过它，但这样你就冒着你的死对头取笑你的风险。

有几个理由来评论你的代码。首先，程序员经常不得不在比他们第一次编程时更晚的时间回顾他们的代码。这可能是几天，几周，几个月，甚至几年。回顾成千上万行代码是很费力的，尤其是当你必须确定每一部分是做什么的时候。如果您对您的部分进行了标记并提供了简短的描述，那么导航和找到问题区域或部分就变得更加容易，您可能需要在以后进行更新。

你应该练习记录你的代码的另一个原因是其他程序员可能需要在某个时间点回顾它。这些程序员可能是你的老板，你的同事，或者是未来的程序员，他们甚至在被雇佣之前就需要对你写的东西进行修改。

最后，有时候你会在另一个程序中重用一个程序的代码——我们称之为效率(当然，前提是你的公司允许你这么做！).在这些情况下，如果您已经注释/记录了您的工作，找到您正在寻找的代码片段将会快得多。

程序员留下评论有许多不同的方式——每个人都有自己的风格。一些公司可能要求你用一种非常具体的、格式化的风格来记录你的代码，而其他公司则由你来决定。

另一件事:当注释写在你的代码中时，解释器或编译器会忽略它们。这意味着它们根本不会影响您的代码——除非您使用错误的语法输入它们。

要进行注释，可以使用标签或#符号。该行剩余部分中出现在#之后的任何内容都被视为注释。下面是一个注释示例:

# This block of code randomly calculates a hero's stats.

如果运行这段代码，也不会发生任何事情，因为 Python 忽略了注释。他们不是为了计算机消费而存在的，只是为了人类和次人类(也就是程序员)。

让我们看看代码旁边的注释是什么样子的。还记得上一章的 RandomGenerator.py 文件吗？将其打开，并向其中添加以下文本:

import random

# This block of code randomly calculates a hero's status.

strength = random.randint(1,20)
intelligence = random.randint(1,20)
endurance = random.randint(1,20)
wisdom = random.randint(1,20)

print("Your character's statistics are:")
print("Strength:", strength)
print("Intelligence", intelligence)
print("Endurance", endurance)
print("Wisdom", wisdom)

正如您所看到的，这使得更容易看到那段代码的确切用途。我们可以在代码片段的末尾添加另一个注释，使其更加清晰:

import random

# This block of code randomly calculates a hero's status.

strength = random.randint(1,20)
intelligence = random.randint(1,20)
endurance = random.randint(1,20)
wisdom = random.randint(1,20)

# End random calculation code

print("Your character's statistics are:")
print("Strength:", strength)
print("Intelligence", intelligence)
print("Endurance", endurance)
print("Wisdom", wisdom)

这里的想法是指出代码中做不同事情的每一部分的结束和开始点。正如您所想象的，这种文档很容易让人忘乎所以，但是它也有它的好处。你评论的多少或者多长时间评论一次取决于你自己，但是作为一个规则，记录总比不记录好。

阻止评论

除了常规注释，还有一种注释形式叫做块注释。当您需要不止一行来解释一段代码时，可以使用这种类型的注释。如果您需要记录编写代码的日期、编写代码的人等等，也可以使用它。请看下面演示块注释的代码:

# Importing the random function
import random

# This code was written by James Payne
# To be published in Python for Teenagers by Apress Books
# This block of code randomly calculates a hero's status.

strength = random.randint(1,20)
intelligence = random.randint(1,20)
endurance = random.randint(1,20)
wisdom = random.randint(1,20)

# End of random number generator code

#Prints out player statistics
print("Your character's statistics are:")
print("Strength:", strength)
print("Intelligence", intelligence)
print("Endurance", endurance)
print("Wisdom", wisdom)

如您所见，要阻止注释，您需要做的就是在您要留下注释的每一行的开头添加一个散列符号(#)。

内嵌注释

另一种注释方式叫做内联注释。这意味着你在代码的同一行留下一个注释。它们不像其他形式的注释那样常见，但是如果您需要记录特定代码行的作用，它们会很有用。例如，在我们的 RandomGenerator.py 文件中，我们从导入 random 开始。虽然这一行代码对于查看您的代码的程序员来说应该是显而易见的，但是我们可以留下一个行内注释来解释它。

这是它看起来的样子:

import random      # Importing the random module

通常，尽量避免使用行内注释，除非你觉得需要解释一行代码的作用。

注释的其他用途

在代码中留下注释的最后一个用途是:查找错误。虽然这听起来不合常规，但实际上非常实用。有时您的代码可能会给您带来错误，您可能需要缩小代码的哪个部分是罪魁祸首。你可以只注释掉部分，而不是大规模删除 Python 的部分。请记住，当 Python 看到#符号时，它会忽略该行中跟在它后面的任何字符。

如果我们注释掉下面的代码，它的运行方式将与以前不同:

import random

strength = random.randint(1,20)
intelligence = random.randint(1,20)
endurance = random.randint(1,20)
wisdom = random.randint(1,20)

print("Your character's statistics are:")
# print("Strength:", strength)
# print("Intelligence", intelligence)
print("Endurance", endurance)
print("Wisdom", wisdom)

有了这段代码，我们就不会在屏幕上看到角色的力量或智力，因为我们注释掉了那部分代码。相反，只有耐力和智慧会显示出来。

要让程序回到正常状态，我们只需删除#符号。您可以随意在代码中添加注释，并注释掉部分代码，看看它对您的程序有什么影响。

发短信——不用手机

既然我们已经理解了注释的重要性以及如何注释来记录我们的代码，我们可以继续处理下一个数据类型， strings 。

字符串数据类型由您可以键入的任何字符组成，只要它包含在引号" "中。本质上，它是任何字母、数字或特殊符号。它可以是一个字母、一个句子，也可以是字母、数字和特殊符号的组合。

让我们创建一个名为 LearningText.py 的新文件。向其中添加以下文本:

# This is how you print text

print("Holy smokes, it's the Grill Master!")

如果您愿意，也可以选择使用单引号来编写代码:

# This is how you print text

print('Holy smokes, it's the Grill Master!')

然而，如果您运行第二个版本的代码，您将得到一个无效的语法错误。你能找出为什么会这样吗？让我们更仔细地检查一下代码。我们知道 print()函数将打印引号之间包含的任何内容。虽然我们的句子以单引号结束和开始，但如果你仔细看，你会看到第三个引号——在单词“it’s”中。

当我们在打印函数中使用单引号时，我们必须小心，因为 Python 无法区分在缩写中使用的引号和撇号。当它看到单词 Holy 前的第一个引号时，它开始参数。然后，当它遇到单词 it’s 中的撇号时，解释者会感到困惑，并将其视为结束引用。最后，它遇到第三个单引号并抛出一个错误。

有几种方法可以避免这类问题。首先，作为一个规则，总是使用双引号。第二，在你需要或者想要使用单引号的情况下，一个转义可以解决你的问题。

escape 键本质上是一个反斜杠()字符，它告诉 Python 将单引号视为常规字符。要使用它，只需将它添加到希望 Python 将其视为纯文本的字符之前。你应该这样编码:

# This is how you print text

print('Holy smokes, it\'s the Grill Master!') # Notice the use of the escape key

现在，如果您运行代码，您将得到如图 3-1 所示的结果:

图 3-1

使用 escape 键格式化打印语句

为了简单起见，现在让我们回到在代码中使用双引号。去改变吧，我会在这里等你。

完了？太好了。让我们再添加几行文本:

# This is how you print text

print("Holy smokes, it's the Grill Master!")
print("His sizzling meats are too good to resist!")
print("Quick Wonder Boy! Get some Wonder Bread and make me a sandwich!")
print("To quote a genius: 'Man Cannot Live On Bread and Water Alone!'")

该代码的目的有两个。首先，它向您展示了如何打印几行文本。其次，它展示了一个可以互换使用双引号和单引号的例子。当使用正确的语法时，当引用某人的话时，必须使用单引号。

在这种情况下，单引号不需要转义。这是因为我们用双引号开始了 print()函数。只有当我们用单引号开始函数时，我们才需要担心转义另一个单引号，该单引号并不是用来结束函数的。

使用字符串和变量

就像我们处理数字一样，字符串可以存储在变量中。该方法类似于存储一个数字，只是略有不同:

name = "Grillmaster"

print(name)

我们首先创建名为“name”的变量，然后向其中添加一些文本。请注意，与我们对数字所做的不同，我们用引号将值括起来。这意味着我们正在向变量中添加一个字符串。接下来，我们使用 print()函数将变量打印到用户屏幕上。

这就是事情变得有趣的地方。创建一个新文件，并尝试以下代码:

age = "42"
graduation = 27

print(age + graduation)

如果您试图运行这段代码，您会得到一条错误消息。为什么呢？原因很简单:当我们声明名为“age”的变量时，我们给它赋值“42”。然而，由于我们用引号将值括起来，Python 将该数据解释为 string 数据类型。与此同时,“毕业”变量被指定为数字数据类型。当我们试图对两个变量执行数学运算时，它不起作用，因为你不能对一个字符串执行数学运算。

有趣的是，你可以在字符串上使用某些数学运算符。在 Python 和其他语言中，有一种东西叫做串联。当您将一个字符串添加到另一个字符串或将它们连接在一起时，就会发生串联。我们使用加法(+)操作符——或者在字符串上使用时使用连接操作符。这是代码:

print("Wonder" + "Boy")

当您测试这段代码时，您的结果将是:

元宝

如果对两个包含字符串的变量使用+ 运算符，也会发生同样的情况:

firstName = "Wonder"
lastName = "Boy"

print(firstName + lastName)

结果呢？

元宝

一个重要的注意事项:如果你想把两个字符串加在一起，你可以考虑在中间加一个空格。这可以通过在要连接的第一个字符串的末尾添加一个空格来实现:

print("Wonder " + "Boy")

或者在要连接的第二个字符串前添加一个空格:

print("Wonder" + " Boy")

当然，没有什么可以阻止您插入包含空格的第三个字符串:

print("Wonder" + " " + "Boy")

这是可行的，因为在 Python 的眼里，即使是一个空格也被认为是一个字符串或字符。

另一个可以在字符串上使用的数学运算符是乘法()运算符——或者在处理文本时被称为字符串* 复制运算符。尝试在 Python Shell 中键入以下代码:

print("WonderBoy" * 20)

这导致如图 3-2 所示的结果:

图 3-2

字符串复制的结果示例

如果你用这段代码创建一个文件，对一个包含字符串的变量执行字符串重复，你会得到类似的结果，如图 3-3 所示:

图 3-3

对变量执行字符串复制

sidekick="WonderBoy"
print("You ruined the Grill Master's barbeque!")
print("The crowd is chanting your name!")
print(sidekick *20)

更长的字符串

如果字符串只限于一个字符或一个单词，它就不会很强大。如前所述，字符串可以由完整的句子组成，我们在变量中声明它们，就像声明一个单词一样:

joke = "Why did Spiderman get in trouble with Aunt May?"
punchline = "He was spending too much time on the web."

print(joke)
print(punchline)

多行字符串

有时您可能会发现，您希望以特定的方式打印文本，或者像打印诗歌或歌词一样组织文本。在这种情况下，您可以创建一个多行字符串。为此，您只需使用三个双引号(" ")或三个单引号(’ ')。这是一个代码示例。请随意创建一个新文件，并亲自测试它。您应该会看到图 3-4 中展示的相同结果:

图 3-4

创建多行字符串打印语句

print("""My name is Grill Master
and I have an appetite
For destruction
That is well done!""")

使用三个单引号也可以获得相同的结果:

print('''My name is Grill Master
and I have an appetite
For destruction
That is well done!''')

格式化字符串

虽然使用多行字符串可以帮助您格式化文本和字符串，但您也可以使用其他更好的方法。也许你想给一个女孩或男孩留下深刻印象，邀请他们参加一个花哨的邀请或正在努力为你的新主题曲填词。不管怎样，如果没有合适的字符串格式器，你的文本将会是平淡无奇的。

没有灵感是一个英雄最不应该做的事。

之前我们讨论过转义字符 ()。我们学习了如何使用它让 Python 像对待 print()函数的结尾那样对待撇号。事实上，有几种不同的转义字符，每一种都能以特定的方式格式化文本。它们如下:

• \允许您在多行字符串中创建新行

• \用于格式化反斜杠

• \n 创建换行符

• \t 创建制表符或缩进

• \ '或\ "用于单引号或双引号

为了更好地理解我们表中列出的转义字符的用法，让我们看一看“\n”或换行符。这个转义符允许我们在插入文本时创建一个新的行。

创建一个新的 Python 文件，并将其命名为 WonderBoyTheme.py。在该文件中输入以下代码:

print("My name is\nWonder Boy\nAnd it is a wonder\nThat I can fit in these tights!")

乍一看，这段代码非常混乱。然而，当我们运行程序时，我们可以确切地看到\n是如何工作的(图 3-5 )。

图 3-5

在单个 print()函数中格式化字符串

通常，当我们查看这行代码时，我们会期望 print()函数中的所有内容都在一行中打印出来。但是，\n 转义会在 Python 每次遇到它时强制换行，而是格式化我们的文本，使其出现在单独的行上。

\t转义以类似的方式工作，除了它不创建新行；相反，它在文本中进行缩进或制表符。让我们在 WonderBoyTheme.py 文件中添加更多的文本:

print("My name is\nWonder Boy\nAnd it is a wonder\nThat I can fit in these tights!")
print("There trunks are \ttight")
print("tight \ttight \ttight \tso very tight!")

如果运行这段代码，它将返回如图 3-6 所示的结果:

图 3-6

使用转义符的更多示例

蜘蛛侠只希望他有一个主题宋立科！

请注意在示例图中，单词“紧，紧，紧，非常紧”是如何用制表符缩进的？这都要感谢\t。

最后，我们再来重温一下\"和\'转义字符。如前所述，有时你可能想使用引用作为你打印到屏幕上的实际文本的一部分，这导致了一个问题，因为 Python 不能区分你想要什么引用被用于*，除非你告诉它*。

为了让 Python 知道您想在语法意义上而不是编程意义上使用引号，您只需对它们进行转义。让我们在 WonderBoyTheme.py 文件中添加更多的文本。确保你的和我的一致:

print("My name is\nWonder Boy\nAnd it is a wonder\nThat I can fit in these tights!")
print("There trunks are \ttight")
print("tight \ttight \ttight \tso very tight!")
print("\n")
print("And when the people see me they all shout and agree:")
print("\"Boy, those tights are too tight for he!\"")

运行这个程序，看看结果，如图 3-7 所示:

图 3-7

使用 escape \t 创建制表符缩进

请特别注意代码的这一部分:

print("\"Boy, those tights are too tight for he!\"")

第一个双引号(")告诉 Python 它后面的任何内容都要打印到屏幕上。然后，Python 遇到了反斜杠()，并知道将它后面的字符视为常规文本。然后，Python 遇到另一个反斜杠()，并再次将它后面的字符视为简单文本。最后，它遇到了最后一个双引号，因为它前面没有转义字符或反斜杠，所以它知道您打算用它来表示您希望打印的文本的结尾。

注意，如果我们用单引号(')替换所有的双引号，这段代码的工作方式完全相同。

向你的武器库引入一种新武器:列表

让我们面对现实吧——打击犯罪是一项艰巨的任务。一个超级英雄(或者伙伴…让我们慢下来，菜鸟！)有时候需要靠的不仅仅是勇敢，主题曲，还有他们与生俱来的超能力。每个值得穿紧身衣的英雄都有某种超级武器或小玩意，当其他一切都失败时，他们可以依靠它们。为此，我们需要开始为你的无用腰带配备更多的工具(它类似于蝙蝠侠的实用腰带，只是，嗯，你的是在跳蚤市场买的)。

我们的第一个小工具是列表。正如变量是数据结构一样，列表也是数据结构。然而，与变量不同，列表可以包含多条数据。变量可以被认为是一个标签或者一个盒子，而列表更像是一个装满一堆盒子的壁橱。

我们可以用存储在变量中的相同数据类型填充列表，包括字符串、数字、整数、浮点数等等。为了给列表赋值，我们将值放在两个square brackets [ ]之间，并用逗号(,)隔开。

让我们创建一个列表:

superPowers = ['flight', 'cool cape', '20/20 vision', 'Coding Skillz']

在这段代码中，我们创建了一个名为 superPowers 的列表，并为其分配了四条独立的信息——在本例中，是字符串值:flight、cool cape、20/20 vision 和 Coding Skillz。

如果我们想打印这个列表，我们所要做的就是使用我们方便的 print()函数:

print(superPowers)

当我们打印这个列表时，有趣的事情发生了——不是像我们期望的那样只打印列表的内容，而是打印整个结构(见图 3-8 ):

图 3-8

打印列表

请记住，列表是一组单独存储的项目。列表中的每一项都对应一个索引号。所有列表都从索引号 0 开始，并在其后按顺序继续。因此，在我们的列表中，“flight”位于 0，“cool cape”位于 1，“20/20 vision”位于 2，依此类推。

例如，如果我们只想打印位于索引号 3 的项目，我们可以这样做:

superPowers = ['flight', 'cool cape', '20/20 vision', 'Coding Skillz']

print(superPowers[3])

这将导致编码 Skillz 打印到屏幕上，因为它位于我们列表的第三个位置(记住，列表从位置 0 开始)。为了更好地理解，让我们分别打印出列表中的每一项:

superPowers = ['flight', 'cool cape', '20/20 vision', 'Coding Skillz']

print(superPowers[0])
print(superPowers[1])
print(superPowers[2])
print(superPowers[3])

图 3-9 向我们展示了结果:

图 3-9

打印列表中的值

或者，您也可以在一行代码中编写 print()函数，如下所示:

superPowers = ['flight', 'cool cape', '20/20 vision', 'Coding Skillz']

print(superPowers[0], superPowers[1], superPowers[2],superPowers[3])

并获得相同的结果。

让我们创建一个文件，并将其命名为 ListExample.py。向其中添加以下代码，然后运行程序(结果如图 3-10 所示):

图 3-10

打印列表中的值的另一种方法

superPowers = ['flight', 'cool cape', '20/20 vision', 'Coding Skillz']

print(superPowers[0], "is located at Index 0")
print(superPowers[1], "is located at Index 1")
print(superPowers[2], "is located at Index 2")
print(superPowers[3], "is located at Index 3")

在这个例子中，我们在 print()函数的末尾追加或添加了一些文本。注意，我们用逗号分隔第一个打印参数，然后定义 print()函数的第二部分。如果我们想在列表中的值之前打印一些文本，我们也可以使用这种方法:

print("The item located at index 0 is", superPowers[0])

这将给我们:位于索引 0 的项目是航班。

最后，有一种更简单、更有效的方法来打印出我们列表中的所有项目。让我们创建另一个文件，并将其命名为 PowersWeaknesses.py。

superPowers = ['flight', 'cool cape', '20/20 vision', 'Coding Skillz']
superWeaknesses = ['bologna', 'lactose intolerance', 'social settings', 'tight trunks']

print("Behold our fledgling hero/sidekick, \"Wonder Boy!")
print("His super powers include:", *superPowers)
print("And his weaknesses are:", *superWeaknesses)

使用前面带*符号的列表名称告诉 Python 使用整个列表。例如，如果您键入:print(*superPowers)，程序将打印出superPowers列表中的每一项。我们之前代码的结果如图 3-11 所示:

图 3-11

打印列表的全部内容

更改列表

列表和变量一样，可以改变。我们可以给它们添加、删除、重新排列等等。例如，在我们的 PowersandWeaknesses.py 文件中，我们有一个超级弱点列表，其中之一是可怕的“乳糖不耐症”(不能喝乳制品或吃冰淇淋——哦不！).对你来说幸运的是，有一种方法可以消除这种特殊的弱点:他们有药物可以帮助你消化牛奶中的酶。所以现在你又可以用雪糕塞满你的脸了——万岁！

有了这些知识，我们可能想从我们的superWeaknesses列表中删除那个特别的弱点。为了实现这一点，我们将使用del语句。

superWeaknesses = ['bologna', 'lactose intolerance', 'social settings', 'tight trunks']

del superWeaknesses[1]
print(*superWeaknesses)

这将删除位于指数 1 的项目–在我们的案例中为“乳糖不耐受”。当我们把superWeaknesses的内容打印出来的时候，我们现在会看到:博洛尼亚，社交场合，紧身裤。

我们也可以使用 remove 方法从列表中删除一个值。我们没有告诉 Python 该项的位置，而是简单地为它提供了以下值:

superWeaknesses = ['bologna', 'lactose intolerance', 'social settings', 'tight trunks']

superWeaknesses.remove('lactose intolerance')

这将给出与使用del语句相同的结果。

除了从列表中删除项目，我们还可以添加它们。有几种方法可以做到这一点。首先是使用append语句。此方法将项目追加或添加到列表的末尾:

superWeaknesses = ['bologna', 'lactose intolerance', 'social settings', 'tight trunks']

del superWeaknesses[1]

superWeaknesses.append('Taco Meat')

print(*superWeaknesses)

在这个例子中，我们首先创建我们的superWeaknesses列表，然后使用del语句删除位置 1 的项目，就像我们之前做的那样(记住列表从位置或索引 0 开始)。然后我们发现我们有了一个新的敌人——胃绞痛的“玉米卷肉”——所以我们使用append语句将其添加到我们的列表中。当我们打印结果时，我们得到:

博洛尼亚社交设置紧身泳裤玉米卷肉

此外，我们可以将一个项目添加到我们的列表中。insert方法的工作原理与append略有不同。它允许我们在列表中的任何位置添加我们的项目，这里append只是把它放在最后。下面是它在使用中的样子:

superWeaknesses = ['bologna', 'lactose intolerance', 'social settings', 'tight trunks']

del superWeaknesses[1]

superWeaknesses.insert(1,'Taco Meat')

print(*superWeaknesses

insert方法使用两个arguments or 参数。第一个命令告诉 Python 要在列表中添加的项目的位置——也就是说，您希望它在哪个索引位置。第二个参数告诉 Python 您想要向列表中添加什么值。运行前面的代码会打印出:

博洛尼亚 Taco 肉社交设置紧身泳裤

其他列表方法

总共有 11 种方法，数一数，11 种方法。每一个都允许您对存储在列表中的数据执行一些魔法。虽然我们已经回顾了其中的许多，但由于篇幅所限，我们无法在本章中一一介绍。但是，在下面，您可以找到不同列表方法及其用途的表格。作为一项练习，你可以随意尝试。

• list . pop():pop方法允许您从列表中返回(或打印)一个值，然后删除它。这可让您确认您移除的是正确的项目。示例:

  print(superWeaknesses.pop(1))
  print(*superWeaknesses)
  
  

• list.reverse():可以对列表中的项目进行排序。一种方法是使用reverse方法。这将改变您的项目的顺序，将第一个项目移动到末尾，最后一个项目移动到前面，以此类推，本质上是颠倒它们的顺序。示例:

  superWeaknesses.reverse()
  print(*superWeaknesses)
  
  

• list.sort:改变项目顺序的另一种方法是使用 sort 方法。这种方法只是将列表中的项目按字母顺序排序。示例:

  superWeaknesses.sort()
  print(*superWeaknesses)
  
  

• list.count() : This method is used to count the number of times a given value appears in a list. For instance, you may wish to know how many sidekicks have a weakness for “Taco Meat.” We could figure this out using count. Example:

  print(superWeaknesses.count('Taco Meat')
  
  

  这将返回“Taco Meat”在我们的列表中出现的次数。在这种情况下，只有一次。

• list.extend():这个方法的使用非常简单。它用于将一个列表合并到另一个列表中。例如，如果你有一个名为“更多超级弱点”的表格，列出了更多可以击败我们英雄的事情，你可以把它和我们以前的列表“超级弱点”结合起来。这样你就只有一个列表需要处理了。示例:

  superWeaknesses.extend(moreSuperWeaknesses)
  
  

• list.copy() : There are times you may want to copy a list and have a duplicate on hand. Maybe this is for testing purposes, or if you have similarly named data, it would be faster to edit the text than to re-write it. Whatever the case, you can copy a list by using the copy method. Example:

  superWeaknesses2 = superWeaknesses.copy()
  
  

  注意:list.copy 仅在 Python 3.3 及更高版本中可用。使用早期版本的 Python 将导致 AttributeError。

• list.index():我们经常需要知道一个特定的项目在列表中的位置，以便在需要时调用它。您可以使用index方法在列表中查找一个值的位置，而不是回顾您的代码。示例:

  print(superWeaknesses.index('Taco Meat'))
  
  

• 将返回数字 3，因为“Taco Meat”在我们的列表中位于第 3 位。(注意:如果你一直在尝试这些方法——特别是分类方法——“玉米卷肉”可能会对你有不同的定位)。

• list.clear():我们将介绍的最后一个方法是clear方法。我们把这个留到了最后，因为如果你练习使用它，它会做它听起来会做的事情:清除你列表中的任何数据。有时可能需要删除列表中的所有数据——这就是这个方法的用途。示例:

  superWeaknesses.clear()
  
  

在这一集里！

在这激动人心的一集里，我们走了很多路。到目前为止，你的能力正在飞速增长——恕我直言——突飞猛进！很快你就会开着你自己的超级英雄车——也许是神奇的船，或者更好，是神奇的车！

如果你有学习许可证的话。如果没有，那就回到你的神奇循环或神奇溜冰鞋。

让我们回顾一下本章所学的内容，好吗？

• 注释允许我们记录我们的代码以备将来参考——由我们或另一个程序员。

• 我们通过使用散列或#和空格来创建注释。之后的任何文本都会被 Python 忽略。

• 如果我们觉得需要进一步澄清，我们可以在特定的代码行后留下行内注释。请谨慎使用。

• 注释掉代码有助于我们在不删除现有代码的情况下定位错误。一旦我们确定这不是问题所在，我们只需取消对代码的注释。

• 转义字符允许您打印通常不会被视为文本的特殊字符。它们还允许你格式化你的字符串。

• 转义字符包括\t，\n，\ '，\ '和\。

• 字符串是一种数据类型，可以由字母、数字或符号组成。

• 您可以使用+ 符号将一个或多个字符串加在一起，称为串联。

• 您可以使用*符号复制字符串(创建多个副本)。

• 列表是存储单元，就像一个装满盒子的壁橱；您可以在其中存储许多项，而不是只有一项(在变量的情况下)。你这样定义它们:超能力= [‘飞行’，’ 20/20 视野’]等等。

• 列表包含被索引的项目(数据片段)。这些项目从索引 0 开始，按顺序进行。

• 您可以通过多种方式打印列表，包括 print(superPowers[1])(针对单个值)或 print(*superPowers)，如果您希望打印整个列表。

• del语句允许你从列表中删除一个项目。

• 共有 11 种列表方法，包括insert(), append(), pop(), reverse(), sort(), count(), extend(), copy(), index(), clear(), and remove().

四、做决策

当涉及到打击犯罪和处理邪恶(商标待定！)，我们这些超级英雄经常发现自己面临岔路口:我们是应该拯救被扔下大楼的无助少女，还是让她一头扎到地上，以便我们能抓住坏人？我们今天要洗我们的斗篷吗？还是我们可以多洗一天，让它闻起来不那么臭？

归根结底，打击犯罪的大部分工作——以及为此而进行的规划——都归结为一件事:做出决策。

你可能听过这样一句话，“每一个动作都有一个反应。”嗯，在编程中尤其如此。想想看:每一次你与计算机接触，你都在强迫它做出决定。当你移动鼠标时，当你按下一个键时，当你因为你的代码不起作用而用头撞击屏幕一个小时时(好吧，也许不是最后一个)——所有这些都需要计算机解释你想要的，并希望执行一个动作。

这里有一个简单的例子:如果你按下字母“a”或字母“k ”,计算机必须知道在这两种情况下该做什么。如果您正在使用文字处理应用，这个特定的场景很简单——将这两个字母中的一个打印到屏幕上。

然而，当我们讨论与计算机编程相关的决策时，我们更多的是指多答案的突击测验。程序会给用户几个选项——例如，选择 A、B 或 C，然后根据选择的选项做出反应。

为了真正理解所有编程中最强大的功能之一，让我们戴上超级英雄的面具，召唤我们的超级大脑，挖掘我们下一个正在发展的超级能力:决策。

做决定

把你的生活想象成一个计算机程序。午餐时间到了，一个初出茅庐的伙伴/即将成为英雄的人需要午餐来保证他/她的肌肉增长。在你面前是一套物品:两片面包、两罐花生酱和三罐果冻。让我们把它列成一个列表，这样我们可以更好地看到它！

• 面包(两片)

• 松脆的花生酱

• 奶油花生酱

• 苹果果冻

• 葡萄果冻

• 草莓酱

正如你所看到的，在你吃午饭之前必须做出决定。我们已经想好了面包，但是我们要用什么类型的花生酱呢？果冻怎么样？

这种场景被称为决策，或者更好的说法是一个条件语句。也就是说，如果满足某些条件，我们/程序将如何反应？为了以编程的方式来看这个，让我们转向一个叫做的伪代码。

不，伪代码不是你父母在 20 世纪 80 年代用来即兴演奏的菲尔·柯林斯老歌。这是一种使用听起来像代码但不是的语言来规划代码的方法。如果我们对伪代码应用 or 三明治场景，它看起来会像这样:

if making sandwich, get bread
Then choose peanut butter type;
if peanutButterType = "Creamy"
print "That's gross. Don't be gross."
else print "Crunchy is the correct choice! You win deliciousness!"
Next choose jelly type;
If jellyType = "Grape"
print "You really aren't good at this are you?"
else if jellyType = "Strawberry Jam"
print "Sure, if you want to ruin your peanut butter, go ahead."
else print "Apple Jelly is the only Jelly! The golden nectar of the Gods! You are so wise!"
Next put peanut butter and jelly on bread, smash together, leave the crusts on, and eat.

如果你把代码放到 Python 中，你会得到大量的错误，因为记住，它不是工作代码。它是伪的，意思是假的或嘲弄的。有时在真正编码之前，我们使用伪代码来设计我们的程序，这样我们可以设计出重要的部分。这有助于我们的编程逻辑，并允许我们避免编码中的错误。它可以像你的朋友写下的一套详细说明如何去漫画书店的指南。它可能并不漂亮(尽管一些伪代码很漂亮，充满了图表和图形)，但它给了你需要去哪里的想法。

条件语句

用最基本的术语来说，条件语句是决定一段代码是否运行的代码片段——取决于条件是否满足。从编程的角度来看，条件语句可以用在简单的示例中，例如:

如果用户选择成为超级英雄，将他/她输入“英雄”类别；否则，将它们放入反派位置。

• 如果一个超级英雄通过接触有毒废物获得了他们的超能力，把他们归类为“变异的”如果不是，把他们归类为“继承的超能力”

• 如果一个超级英雄有悲惨的背景，让他们的性格类型“黑暗和忧郁”否则，让他们的个性“机智风趣”

这些是条件语句最基本的用法。在现实世界中，要执行(或不执行)程序的某个部分，可能需要满足多个条件。我们很快就会进入更高级的类型，但是现在，让我们看看最基本的条件语句:If语句。

请看——If 语句！

前面的例子都是所谓的if语句的一部分。If语句基本陈述了如果某事发生，做这个。这也意味着，如果某件事情没有发生，程序将会做其他事情——这可能意味着程序什么也不做。

为了让事情更清楚，让我们尝试一点代码。创建一个名为ConditionalStataments.py的新 Python 文件，并输入以下代码:

superHeroType="Dark and Brooding"

print("Let's see what sort of hero we have here...")

if superHeroType=="Dark and Brooding":
    print("Ah, it says here you are 'Dark and Brooding'.")
    print("I bet you had a tragic event in your past!")
    print("Your voice sounds pretty rough by the way...")
    print("Here, have a cough drop. Or two.")

这段代码中有几点需要注意。首先，我们创建了一个名为superHeroType的字符串变量，并用一些文本填充它。这个变量中的文本就是我们将要测试的If语句。

在打印一些文本后，我们用下面一行开始 if 语句:

if superHeroType=="Dark and Brooding":

当解释器看到这一行代码时，就进入条件语句，检查是TRUE还是FALSE。如果条件满足，也就是说，结果为真，程序运行剩余的代码，即缩进的(因此是其中的一部分)—if语句。

在这种情况下，条件得到了满足:superHeroType中的文本等于“黑暗和沉思”，因此程序打印出了print()函数，它们是if语句的一部分。既然是这种情况，程序会产生(见图 4-1 ):

图 4-1。

使用条件语句

另一件需要注意的事情是:==符号被称为比较运算符。在这种情况下，这意味着被比较的值必须完全等于前面引号(" ")中的值。我们在评估文本和数字时使用==符号。

但是如果我们的条件不满足会发生什么呢？如果superHeroType的值不等于“黑暗冥思”怎么办？为了找到答案，我们所要做的就是编辑我们的代码来改变它的值并再次运行程序:

superHeroType="Quick-Witted and Funny"

print("Let's see what sort of hero we have here...")

if superHeroType=="Dark and Brooding":
    print("Ah, it says here you are 'Dark and Brooding'.")
    print("I bet you had a tragic event in your past!")
    print("Your voice sounds pretty rough by the way...")
    print("Here, have a cough drop. Or two.")

现在，当我们运行我们的代码时，返回的只是开始的print()函数(见图 4-2 ):

图 4-2。

未被触发的 if 语句的结果

为什么会这样？因为我们改变了我们的superHeroType变量的值，当 Python 遇到我们的if语句时，它检查条件并发现它没有被满足并返回false。由于不满足条件，Python 跳过了if语句块的剩余部分，并转移到程序的下一部分。

由于没有程序的下一部分，Python 退出，程序结束。

当然，我们可以在程序中创建多个if语句。如果我们这样做了，Python 将评估每一条语句并执行代码块，只要满足条件。让我们打开我们的ConditionalStatements.py文件并修改代码，使其与下面的代码相匹配:

superHeroType="Quick-Witted and Funny"

print("Let's see what sort of hero we have here...")

if superHeroType=="Dark and Brooding":
    print("Ah, it says here you are 'Dark and Brooding'.")
    print("I bet you had a tragic event in your past!")
    print("Your voice sounds pretty rough by the way...")
    print("Here, have a cough drop. Or two.")

if superHeroType=="Too Polite":
    print("It says here that you are 'Too Polite'")
    print("How are you ever going to catch that criminal if you keep holding the door?")
    print("Don't say sorry to him - he's the villain!")

if superHeroType=="Quick-Witted and Funny":
    print("Oh boy. I can tell by all the puns that you are the Quick-Witted and Funny Type.")
    print("I have a joke for you:")
    print("What has 8 fingers, two thumbs, and isn't funny?")
    print("You!")

使用这段修改后的代码，我们在程序中添加了三个条件 if 语句，而不是一个。程序首先打印出一些文本，然后遇到第一个 if 语句，该语句检查superHeroType的值是否等于“黑暗和沉思”。因为它不是，我们的程序忽略该块的缩进代码的其余部分。

每当我们有一个带有缩进文本的代码块时，Python 知道缩进的代码属于那个特定的代码组。一旦它用完了缩进的代码，它就知道特定的代码块结束了，并继续下一个代码块。

不要太纠结于代码缩进——我们很快会更详细地讨论它。现在，只需要知道代码块有一个层次结构——也就是一个结构化的顺序——它依赖于缩进(通常是四个空格或一个 tab 键)来表示代码的哪一部分属于哪一部分。

接下来，Python 运行到我们的第二个if语句，并再次检查标准:superHeroType是否等于“太客气”同样，它没有，所以解释器继续下一个代码块，这恰好是我们的第三个 if 语句。

在第三个 if 语句中，我们检查superHeroType的值是否等于“机智幽默”这一次，结果是true，所以解释器执行缩进的print()函数，这些函数是代码块的一部分。结果如图 4-3 所示:

图 4-3。

评估为 True 的 if 语句示例

布尔逻辑和比较运算符

在我们深入研究条件语句之前，我们需要定义一些有趣的词。这些有趣的话不仅可以一遍又一遍地对你的朋友和家人说，而且也是你无用腰带上的另一个便利工具。

第一个字是Boolean。来吧，大声说出来，让笑声远离你的系统。然后，绕着房子跑几圈，看看你能在对话中使用多少次这个词——布尔。我会在这里等。

布尔是另一种数据类型，正如您可能已经从我们之前对ConditionalStatements.py代码的解释中猜到的，这种特殊的数据类型可以有两个不同的值:true和false。

当我们处理像if这样的条件语句时，我们最终会问某个条件是true还是false。无论我们如何描述这些条件或标准，最终，答案只能是这两个选择中的一个。

当然，我们不能只是和计算机玩一个真心话大冒险的游戏，所以 Python(和其他语言)使用一种被称为比较运算符的东西来帮助我们比较数据，并确定最终结果是true还是false。

我们已经讨论过比较运算符之一——等于运算符==。除此之外，我们还可以使用其他五种比较运算符。它们如下:

• ==用于查看一个值是否等于另一个值

• ！=用于查看一个值是否不等于另一个值

• 用于确定一个值是否大于另一个值

• < =用于小于或等于另一个值

• =用于大于或等于另一个值

到目前为止，我们已经在条件语句示例中使用了字符串。为了更好地理解我们的新工具，比较运算符，让我们转而使用数字。首先，创建一个名为 MathIsHard.py 的新文件。

wonderBoyAllowance = 10
newCape = 20

print("That new cape sure is shiny. I wonder if you can afford it...")

if wonderBoyAllowance > newCape:
    print("Congrats! You have enough to buy that new cape!")

if wonderBoyAllowance < newCape:
    print("Looks like you'll have to keep wearing that towel as a cape...")
    print("Maybe if you ask nicely Wonder Dad will give you a raise...")

让我们更仔细地检查一下这段代码，好吗？我们首先创建两个变量:wonderBoyAllowance 和 newCape。然后，我们打印一些文字说，“新的海角肯定是闪亮的。不知你能否负担得起……”

为了弄清楚神奇小子是否真的买得起那件新斗篷，我们必须比较wonderBoyAllowance(代表你的零花钱)和newCape(代表那件闪亮的新斗篷的价格)。

我们的第一个if语句查看wonderBoyAllowance是否为>(或大于 ) newCape。如果是这样，它将打印出文本，“恭喜！你有足够的钱买那件新斗篷！”然而，由于津贴是而不是大于新 cape 的成本，程序跳到下一个if语句，看看它的值是否为真。

当评估第二个if语句时，程序会注意到您的津贴值小于新 cape 的成本。由于该条件得到满足并返回一个值true，它将执行 if 语句的剩余部分，导致(见图 4-4 ):

图 4-4。

评估多个 if 语句

要了解Boolean逻辑是如何工作的，创建一个新的 Python 文件并将其命名为BooleanExamples.py。输入此代码:

# Creating two variables with different values

a=10
b=20

# Compare values using the different Comparison Operators

print("Is the value of a EQUAL to b?  ", a == b)
print("Is the value of a NOT EQUAL to b?  ", a != b)
print("Is the value of a GREATER than b?  ", a > b)
print("Is the value of a LESS than b?  ", a < b)
print("Is the value of a GREATER THAN or EQUAL to b?  ", a >= b)
print("Is the value of a LESS THAN or EQUAL to b?  ", a <= b)

运行这个程序将显示哪些比较是true哪些是false。值true表示比较正确，而false表示不正确。

Else 语句

现在我们已经理解了if语句和比较操作符，我们可以继续讨论另一种类型的条件语句:else。到目前为止，我们已经使用了条件语句，这些语句仅在满足给定条件时才执行一组代码。然而，如果我们想要一个结果，如果结果为真，而另一个结果为假，会发生什么呢？虽然从技术上讲，我们可以使用多个 if 语句来实现这个结果，但是有一种更好、更有效的方法来编写您的程序。让我们编辑我们的MathIsHard.py文件的代码，并对其进行修改，使其与下面的代码相匹配:

WonderBoyAllowance = 10
NewCape = 20

print("That new cape sure is shiny. I wonder if you can afford it...")

if WonderBoyAllowance > NewCape:
    print("Congrats! You have enough to buy that new cape!")

else:
    print("Looks like you'll have to keep wearing that towel as a cape...")
    print("Maybe if you ask nicely Wonder Dad will give you a raise...")

在这个版本中，我们用一个else语句替换了第二个if语句。else 语句只有在if语句的条件不满足时才会被触发。基本上，你对程序说的是，“如果发生这种情况，做这个，否则，做那个。”

这个程序的结果和之前的一样；然而，现在涉及的代码更少了，由于没有第二个 if 语句，Python 不需要执行另一个比较。这节省了计算能力和处理。虽然这在这里看起来没什么大不了的，但是你可以想象在一个程序中，数万行代码和数百条if语句可以节省多少。

还有一点需要注意:当使用一个else语句时，Python 将总是执行你的 if 块或者你的 else 块；如果不走这两条路中的一条，你的程序将永远不会结束。

但是，如果您需要不止一个if和else选项，会发生什么呢？如果有三个选择呢？还是四个？还是 40 亿？为此，你需要比微不足道的if和else声明更有力的东西。

你准备好再次升级这些能力了吗？如果是这样(明白了——一语双关！)，准备学习——else if！

Else If 语句

我知道你在想什么-else if不是一个真正的短语。事实上，这可能是一个整天挤牛奶、擦擦疲惫额头上汗水的农民的名字——叫他埃尔塞夫叔叔吧！

我不想告诉你这个消息，但是 else if 是一个真实的短语，它是条件语句家族中的一员。它是高度通用的，高效的，并且将会是你作为一个程序员最好的朋友之一。有了它，您可以创建任意数量的条件场景，而不是使用常规 if/else 语句的枯燥混合来创建一个或两个常规场景。

像往常一样，学习这种新力量的最好方法是穿上衣服，尝试一下。因此，记住这一点，创建一个名为UncleElseIf.py的全新文件，并插入以下代码:

# Create our variables representing our allowance and the cost of a new cape

wonderBoyAllowance = 20
newCape = 20

print("That new cape sure is shiny. I wonder if you can afford it...")

if wonderBoyAllowance > newCape:
    print("Congrats! You have enough to buy that new cape!")
    print("And it looks like you have some money left over.")
    print("How about getting a hair cut? You hair is covering your mask!")

elif wonderBoyAllowance == newCape:
    print("You have exactly enough money to purchase the cape!")
    print("No change for you!")
    print("Eh...and no tip for me I see...")

else:
    print("Looks like you'll have to keep wearing that towel as a cape...")
    print("Maybe if you ask nicely Wonder Dad will give you a raise...")

这段代码可能看起来很熟悉，因为它是我们的MathIsHard.py文件的修改版本。首先，我们将wonderBoyAllowance的值改为 20(祝贺加薪！);过一会儿你就会明白为什么了。接下来，我们做介绍性的print()语句，接着是第一个if块。这第一个if检查看如果我们的津贴是大于新斗篷的成本。由于该比较返回一个false，程序跳过 print()函数并继续下一个块。

等一下。下一个块根本不是if或else。事实上，它甚至没有提到else-if——怎么回事？嗯，创造 Python 的大师决定让else-if语句在语言中混合使用 else 和 if，因此是elif。

当解释器看到elif时，它再次评估比较——在这种情况下，它检查我们的津贴是否与新斗篷的成本完全相同。因为它是——两个变量都保存值20——其余的 else-if 执行，缩进的print()函数施展它们的魔法。

因为 else-if 的计算结果为 true，所以程序知道没有必要再进一步查看，并从这个特定的代码块中退出。因为在 if/else/else-if 块之后没有代码，所以程序结束。

这就是事情变得有趣的地方。尽管我们将if、else和else-if称为它们自己的块，但实际上，它们都是同一个块的一部分。想想看:没有else和if就没有else-if，对吗？好吧，你可以，但是那样你的程序可能不会按照你想要的方式运行！

如上所述，else-if语句允许我们创建任意数量的选项。让我们在代码中再添加几个elif并检查结果。修改UncleElseIf.py的文本，使其与以下内容匹配:

# Create our variables representing our allowance and the cost of a new cape

wonderBoyAllowance = 20
newCape = 20

print("That new cape sure is shiny. I wonder if you can afford it...")

# Check to see if allowance is greater than the cost of the new cape
if wonderBoyAllowance > newCape:
    print("Congrats! You have enough to buy that new cape!")
    print("And it looks like you have some money left over.")
    print("How about getting a hair cut? You hair is covering your mask!")

# Check to see if allowance is the same exact price as the new cape
elif wonderBoyAllowance == newCape:
    print("You have exactly enough money to purchase the cape!")
    print("No change for you!")
    print("Eh...and no tip for me I see...")

# Check to see if allowance is zero dollars
elif wonderBoyAllowance == 0:
    print("Oh boy, you are broke!")
    print("Maybe it's time to hang up the cape and grab an apron!")
    print("Time to become...Bag Boy!")

# If all other conditions fail, this else will trigger
else:
    print("Looks like you'll have to keep wearing that towel as a cape...")
    print("Maybe if you ask nicely Wonder Dad will give you a raise...")

在这个版本的代码中，我们在每个部分都添加了注释(#)，以使代码片段更加清晰。我们还向我们的条件块添加了第二个elif；它检查wonderBoyAllowance的值是否为 0，如果是，打印出一些文本，建议您获得一份新工作。

理论上，我们可以向这个条件块添加任意多的elif,只要我们满足需要的条件。例如，我们可以以 1 为增量检查 wonderBoyAllowance 的值，直到达到 20。下面是一个例子:

# Create our variables representing our allowance and the cost of a new cape

wonderBoyAllowance = 20
newCape = 20

print("That new cape sure is shiny. I wonder if you can afford it...")

if wonderBoyAllowance == 0:
        print("Nope. You need 20 more dollars.")

elif wonderBoyAllowance == 1:
    print("Nope. You need 19 more dollars.")

elif wonderBoyAllowance == 2:
    print("Nope. You need 18 more dollars.")
elif wonderBoyAllowance == 3:
    print("Nope. You need 17 more dollars.")
elif wonderBoyAllowance == 4:
    print("Nope. You need 16 more dollars.")
elif wonderBoyAllowance == 5:
    print("Nope. You need 15 more dollars.")

# Keep adding elif until you reach 19
# Then use an else for if the value equals 20 or higher

else:
          print("Looks like you have just enough!")

在这个代码示例中，我们添加了 5 个elseif来覆盖你零花钱的前 5 美元。我本来可以增加总共 19 个elseif，但是那会占据这本书的好几页。相反，你可以自由地自己填充空白并测试这个程序。将wonderBoyAllowance或newCape的值交替几次，这样您就可以看到结果是如何根据我们测试条件的变量的值而变化的。

逻辑运算符

尽管elif语句非常强大，但你还需要学习一种能力，才能真正成为条件语句的大师*…声明…声明…(这里有回音吗？).这种能力被称为逻辑运算符。*

*到目前为止，我们已经讨论了许多不同的操作符类型，包括本章前面的比较操作符。只有三个逻辑操作符，但是它们会给你的程序带来全新的能力。

像比较运算符一样，逻辑运算符只有一个目的:帮助您比较不同的值。也像比较运算符一样，逻辑运算符寻求一个布尔答案:真或假。它们主要用于确定两个或更多的比较是真还是假。与我们的其他操作符不同，逻辑操作符不是由特殊字符或符号组成的，而是由不言自明的实际单词组成的:and、not、or。

其中第一点可能是最容易理解的。它只是查看语句，并尝试确定“这个和那个”是否都为真。如果两者都是，则评估为true；如果不满足一个或多个条件，则评估为false。

让我们在代码中更仔细地检查一下。创建名为 LogicalOperatorsExample.py 的新文件，并输入以下代码片段:

# Create a few variables to evaluate

wonderBoyAllowance = 20
newCape = 20
oldCape = 'smelly'

# Check to see if allowance is equal to the cost of a new cape AND
# that the old cape is "smelly"

if wonderBoyAllowance >= newCape and oldCape == 'smelly':
    print("Wow...you can afford to buy a new cape!")
    print("And your old cape IS really stinky!")
    print("Why not treat yourself to a new cape?")

# If the if fails, this else statement will trigger
else:
    print("Sorry kid, it just isn't time for a new cape yet.")

在神奇小子购买新斗篷之前，必须满足两个条件。首先，他必须有 20 美元来支付这笔费用。第二，他的旧斗篷必须有臭味——这是他能证明花毕生积蓄买一件新斗篷是合理的唯一方法！

在设置好要评估的变量后，我们弹出一个if语句来检查wonderBoyAllowance是否大于或等于newCape的值(>=)。在这种情况下，它等于，所以解释器继续前进，看到and操作符，并且知道下一部分求值必须也是才能使整个if语句求值为true。它检查oldCape的值是否等于“发臭”——事实的确如此！–由于两个条件都是true，它继续打印出if语句的剩余部分。

如果这两个条件中的任何一个不为真，那么就会触发else语句。

下面是结果(图 4-5 ):

图 4-5。

使用 else 语句

逻辑运算符列表中的下一个是 or。当用于条件语句时，or 运算符要求至少有一个条件的计算结果为真，其他条件可以为假，但只要有一个条件为真，整个语句的计算结果为真。

下面是一个 or 运算符的例子:

# Variables to check

wonderBoyAllowance = 20

newCape = 20
newShoes = 50

# Checks if you can afford a new cape OR if you can afford new shoes

if wonderBoyAllowance >= newCape or wonderBoyAllowance >= newShoes:
    print("Looks like you can either afford a new cape or new shoes.")
    print("That's good, because one of them are really stinky!")

# If both of the conditionals fail, the else below triggers
# If even one of the conditionals are true, the else does not trigger

else:
    print("That's a shame, because one of them is really stanky!")

该示例程序旨在检查一个或两个条件是否为true。如果两者都是true，很好——我们的print()功能仍然触发。如果只有一个条件是true——仍然很棒；我们的print()功能将会触发。记住:一个or操作符只需要一个条件为true。

只有当和条件都不满足时，程序才会触发else语句。

敏锐的观察者可能会注意到这些程序的一个小问题——虽然我们知道神奇男孩可以买得起一双鞋或一件新斗篷，但我们不知道他会选择哪一件。更进一步，我们不知道他是否能一起负担得起这两者；我们只是看看他是否能负担得起其中任何一个。

有几种方法可以解决这个问题并扩展我们的计划。我们可以添加一些 if 语句来解决问题。然而，现在可能是讨论所谓的嵌套的好时机。不，这和鸟没有任何关系！

筑巢——不仅仅是为了鸟类

有时，检查给定块中的一个(或两个)条件是否为真是不够的。例如，我们可能希望检查第二个或第三个(或第四个等等。)条件满足如果第一个评估为真。考虑一下我们的代码，它决定了神奇小子是否可以购买新的斗篷和鞋子。我们知道神奇小子可以购买其中任何一个，但我们不知道他是否有足够的钱来购买这两个。我们也不知道他更需要哪一个——斗篷还是鞋子。

我们可以通过编程来回答其中的一些问题——也就是说，我们可以使用我们的程序来解开这些答案。当我们在一个 if 中检查多个语句时，我们称之为嵌套。

到目前为止，您已经注意到当我们使用 if 语句时，代码是如何自动缩进的；在我们插入一种颜色(:)并按 enter 键后，开发环境跳过一行，然后缩进八个空格。作为程序员，这直观地告诉我们，缩进的代码是它上面的 if 语句的一部分。它也告诉解释者同样的事情。这就是所谓的代码层次结构，它表示(1)在该代码之前执行该代码，以及(2)该缩进的代码属于它上面的代码。

为了更好地理解嵌套的工作原理，让我们重新看一下前面的例子:

# Variables to check
wonderBoyAllowance = 20
newCape = 20
newShoes = 50

# Checks if you can afford a new cape

if wonderBoyAllowance >= newCape:
    print("You can afford a new cape.")
    print("But how about new shoes?")

# When the if check to see if you can afford the new cape passes it does this

    if wonderBoyAllowance >= newShoes:

        print("Looks like you can afford new shoes as well.")
        print("That's good, because the old ones are really stinky!")
        print("But can you afford both together?")

#If you cannot afford the shoes, but can afford the cape

, it does this
    else:
        print("You can only afford the new cape, sorry.")

# If both of the conditionals fail, the else below triggers
# If even one of the conditionals are true, this else does not trigger

else:
    print("That's a shame, because one of them is really stanky!")

在更新的示例中，首先要注意的是我们的if语句的缩进。第一个if检查神奇小子是否买得起新斗篷。因为他可以(意味着wonderBoyAllowance大于或等于newCape，所以程序继续执行缩进的或者嵌套的if语句。程序再次检查嵌套的if语句的条件是否为true(是否wonderBoyAllowance等于或大于newShoes)。如果是，它将执行缩进的print()函数。

注意

注意，即使是嵌套的 if 语句下的 print()函数也会缩进。

在这种情况下，我们的嵌套的if语句不等于true，所以嵌套的else语句——缩进的语句——触发。

只有当原始的if语句返回一个false时，底部的else语句才会被触发。这个节目的结果？

     You can afford a new cape.
But how about new shoes?
You can only afford the new cape, sorry.

如果有两个以上的 if 语句会发生什么？出现这种情况时，必须对每个附加的 if 语句使用 elif。让我们用一个简单的数学例子来真正说明嵌套 if 语句的威力。创建一个名为 SuperHeroQuiz.py 的新文件，并键入以下代码:

# Variable representing Wonder Boy's Test Score

wonderBoyScore = 100

# Introduction text

print("Congratulations on finishing your Super-Hero Quiz Intelligence/Reasoning Test.")
print("Or, S.Q.U.I.R.T. for short.")
print("Let's see if you passed or failed your exam!")
print("A passing grade means you are licensed to be a Sidekick!")

# Comparison block to see if Wonder Boy passed his S.Q.U.I.R.T. Exam

if wonderBoyScore > 60:
    print("Here are your results: ")

    if wonderBoyScore > 60 and wonderBoyScore < 70:
        print("Well, you passed by the skin of your teeth!")

    elif wonderBoyScore >= 70 and wonderBoyScore < 80:
        print("You passed...average isn't so bad. I'm sure you'll make up for it with heart.")

    elif wonderBoyScore >= 80 and wonderBoyScore < 90:
            print("Wow, not bad at all! You are a regular B+ Plus player!")

    elif wonderBoyScore >= 90:
            print("Look at you! Top of your class. Yer a regular little S.Q.U.I.R.T. if I ever saw one!")

else:
        print("Nice try fella, but I'm sorry you didn't pass.")
        print("I hear the Burger Blitz needs a security guard - you are a shoo-in!")

在这种情况下，神奇小子还不是一个成熟的伙伴。为了成为其中之一，他/你必须通过 S.Q.U.I.R.T .考试。只有高于 60 分的分数才表明及格。

除了弄清楚神奇小子是否通过了考试，我们还想给他一点关于他考试成绩的反馈。对于每一个 10 分的范围，我们创建了一个if/elif语句，该语句将根据分数显示一些文本。

如果神奇小子没有通过考试(他的分数在 60 分或以下)，所有嵌套的if/elif语句将被跳过，取而代之的是else语句将被触发。

一个重要的注意事项:如果第一个if语句条件不满足，其他条件都不会被计算；相反，程序会自动跳到else语句。当程序运行到第一个if语句时，它检查wonderBoyScore的值，并询问它是否大于 60。如果是而不是，程序将结束并执行else语句。

但是，由于wonderBoyScore 是大于 60 的，程序转到下一个if/elif语句对其求值。它继续这个过程，直到找到一个评估为true的条件。

该方案的结果是:

Congratulations on finishing your Super-Hero Quiz Intelligence/Reasoning Test.
Or, S.Q.U.I.R.T. for short.
Let's see if you passed or failed your exam!
A passing grade means you are licensed to be a Sidekick!
Here are your results:
Look at you! Top of your class. Yer a regular little S.Q.U.I.R.T. if I ever saw one!

随意更改几次wonderBoyScore的值，然后重新运行程序，看看结果如何变化。

在这一集里！

这激动人心的一集充满了动作。在迄今为止的所有章节中，我敢说这一章提升了你的能力最多！有很多东西要塞进一集(有点像你如何把所有的果冻塞进你的 PB&J，并希望它不要溅到你的衬衫上)，但凭借你的超级大脑，敏锐的洞察力，以及阅读陈腐的超级英雄笑话的能力，我敢肯定你会吸收这个坟墓中包含的所有信息。

你会用它行善还是作恶？只有时间会证明一切！

当你的父母询问这本书的迷人之处时，你可以和他们分享一下，这本书是由了不起的作家詹姆斯·佩恩写的，为什么你不能停止阅读它！

• 决策是一个程序必须根据某些定义的标准决定选择一条或另一条道路的过程。

• 伪代码是一种用来描述程序部分的虚构语言；这是一种对程序进行布局的简写，以便更好地理解程序的布局和不同部分。

• 如果满足/不满足某些条件，条件语句允许你的程序沿着程序的一个分支或另一个分支前进。它们包括if、else和elif语句。

• 语句允许你在程序中创建决策。例如，如果发生了“x ”,你可以让程序执行一段代码*。*

  Example:

  if 10 < 20:
      print("Yes, 10 is less than 20")
  
  

• Else 语句通过添加 else 子句来增强 if 语句。例如，如果“x”发生，你可以让一个程序执行一段代码*，或者如果“x”没有发生，你可以让它执行不同的代码块。*

  Example:

  if 10 < 20:
      print("Yes, 10 is less than 20")
  else:
      print("Maths are hard! Numbers bad for brain!")
  
  

• Else if/elif 语句用于向代码中添加额外的 if 条件。

  Example:

  if 10 < 20:
     print("Yes, 10 is less than 20")
  elif 10 == 20:
     print("10 shouldn't be equal to 20, but if you say!")
  else:
      print("In our backwards world, 10 is greater than 20!")
  
  

• 比较运算符允许您比较值。分别是:等于(==)，不等于(！=)、小于()、小于或等于(<=), and greater than or equal to (> =)。

• 逻辑运算符允许您检查多个条件。分别是:and、not、or。*