Python-项目入门指南-一-

Python 项目入门指南（一）

原文：Python Projects for Beginners

协议：CC BY-NC-SA 4.0

一、入门指南

你好！欢迎迈出成为 Python 开发人员的第一步。令人兴奋不是吗？无论你是刚刚开始学习如何编程，还是已经有了其他语言的经验，本书教授的课程将有助于加速你的目标。作为一名 Python 指导者，我可以向你保证，关键不在于你从哪里开始，而在于你愿意付出多大的努力。

在写这本书的时候，我的日常工作是一名编码训练营教练，在那里我教学生如何在短短十周内从零编程经验到专业开发人员。这本书的设计意图是将基于训练营的方法引入文本。这本书旨在帮助你学习对成为 Python 专业开发者有价值的主题。

接下来的每一章都会有一个概述和对我们那一周所学内容的简要描述。本周我们将涵盖所有必要的基础知识，让我们快速入门。遵循古老的说法，“在你能跑之前，你必须学会走，”在我们开始编码之前，我们必须了解我们的工具是什么以及如何使用它们。

概述

• 理解这本书为什么和如何工作

• 安装 Python 和 Anaconda

• 了解如何使用这些新工具

• 了解如何使用终端

• 编写您的第一个 Python 程序

事不宜迟，我们开始吧，好吗？

星期一:介绍

几乎每个程序员都记得“啊哈！”那一刻，一切都为他们所触动。对我来说，那是我学会 Python 的时候。经过多年的计算机科学教育，我发现最好的学习方法之一是构建应用程序并应用你所学的知识。这就是为什么这本书会让你跟着编码，而不是阅读编程背后的理论。Python 使得理解其他语言中难以理解的概念变得简单。这使得它成为进入开发行业的绝佳语言！

你可能已经注意到这本书的结构与大多数不同。我们用星期或天来分隔每个主题，而不是章节。请注意该部分的当前标题。这是基于训练营的方法的一部分，因此你可以设定每天的目标。这本书有两种解读方式:

1. 在十周的时间里

2. 在十天的过程中

如果你想遵循 10 周的方法，那么就把每一章当作一个周目标。所有章节被进一步分解为周一至周五的每日部分。前四天，周一到周四，将介绍新的概念来理解。周五，或者更广为人知的项目日，我们将根据一周内学到的经验一起创建一个项目。重点是你每天留出 30-60 分钟来完成每天的任务。

如果你非常渴望尝试训练营的方式，在那里你可以在十天内学会所有的内容，那么就把每一章当成一天。当然，你必须知道，为了在十天内完成这本书，你需要每天投入大约 8 个小时，这对于编码训练营的学生来说是典型的一天。在训练营中(就像我教的那个)，我们每天都要复习几个概念，接下来的每一天我们都要重申从之前的课程中学到的主题。这有助于加快学习每个概念的过程。

Python 是什么？

Python 是一种解释的、高级、通用编程语言。为了理解这些描述的含义，让我们做一些比较:

• 低级与高级:指我们是否使用机器级别的指令和数据对象编程，或者我们是否使用语言设计者提供的更抽象的操作编程。低级语言(如 C，C++)需要你分配和管理内存，而 Python 为我们管理内存。

• 通用与针对性:指编程语言的操作是广泛适用还是针对某个领域进行微调。例如，SQL 是一种目标语言，旨在方便从关系数据库中提取信息，但您不会想用它来构建操作系统。

• 解释过的 vs .编译过的:指程序员编写的指令序列，称为源代码，是直接执行(由解释器)还是先转换(由编译器)成机器级原语操作序列。大多数用 Python 设计的应用程序都是通过解释器运行的，所以错误是在运行时发现的。

Python 还强调代码的可读性，并使用空格来分隔代码片段。我们将在课程中更多地了解 Python 中的空格是如何工作的，但是现在我们只知道 Python 是进入计算机科学行业的第一语言。

为什么是 Python？

我可以继续讲述 Python 为何如此神奇，但简单的谷歌搜索就能帮我做到。Python 是最容易学习的语言之一。注意，我说的是“更容易而不是“容易”……这是因为编程仍然很难，但 Python 比大多数其他语言更接近英语。这是学习 Python 的好处之一，因为你从本书中学到的概念仍然适用于其他语言。Python 也是当今技术行业最受欢迎的技能之一，被谷歌、脸书、IBM 等公司使用。它被用于构建 Instagram、Pinterest、Dropbox 等应用程序。

它也是 2019 年增长最快的语言之一，攀升至未来学习的前 3 种语言。然而它的报酬有多高呢？据 Indeed.com 称，2018 年的平均工资约为11.7 万美元！ ² 垄断的钱多着呢！

然而，学习 Python 的最大原因之一肯定是语言本身的使用。它被用于几个不同的行业:前端开发、后端开发、全栈、测试、数据分析、数据科学、网页设计等。，这使它成为一种有用的语言。

为什么是这本书？

先说想看这本书的主要原因。贯穿本书的教材有一个被证实的记录。我个人使用这种精确的组织方法帮助我的学生在各种行业获得高薪职位。多年来，该课程的结构已经过多次改进，以适应当前的行业趋势。

与竞争对手相比，这本书的下一个优势是概念是如何教授的。我不会用细节来烦你；相反，在本书的整个过程中，我们将一起构建小型和大型应用程序。最好的学习方法往往是边做边学！尤其是在编程方面，我经常告诉学生的一个教训是，试着写代码，如果代码坏了，就修复它。如果你不尝试打破东西，你将无法学习！

最后，这本书不仅会教你如何编程，还会教你如何像程序员一样思考。在每周的开始，我会挑战你，到课程结束时，你将能够理解你需要采取的方法。你总是能区分那些只会编程的人和那些久经考验的开发人员。

这本书是给谁的？

在你开始读这本书之前，先了解你要读的内容总是有好处的。想要读一本书，你首先必须意识到这本书本身是否是为你设计的。如果你对以下任何一个问题的答案是肯定的，那么这本书就是为你而写的:

• 你是否有过其他编程语言的经验，却想拿起一门高级语言？

• 你有没有以前没有编程过但是很渴望学习的经历？

• 你以前学过计算机科学课程吗，但是它们没有帮助你学习如何创建应用程序？

• 你想转行吗？

• 你以前有没有试过学语言，但是因为语言的难度而学不下去？

• 你以前用 Python 编程过，但是想提高自己的能力，学习新的工具吗？

这本书是为各种各样的读者设计的，不管你的背景如何。真正的问题在你身上，“你愿意多努力工作”这本书教授的概念可以让任何愿意学习的人受益。即使你以前用 Python 编程过，这本书仍然可以帮助你成为一个更强的开发者。

你会学到什么

这本书是为教学 Python 而设计的训练营课程而创作的。您可以期望涵盖 Python 开发人员工作中所需的必要信息。这些概念将使你有能力继续你的编程教育。在每章的结尾，我们将使用所涵盖的概念来创建各种现实世界的应用程序。毕竟，我们在这里不仅仅关注 Python，我们试图帮助你成为一名更好的开发人员。

明天，我们将了解如何安装本书使用的必要软件。如果您的机器上已经安装了 Anaconda 和 Python，您可以跳到周三的课程。

星期二:设置 Anaconda 和 Python

今天，我们将进行软件设置。在本书中，我们将使用一个名为 Anaconda 的软件平台，一个名为 Jupyter Notebook 的集成开发环境(IDE) ，以及 Python 本身的语言。这本书将严格涵盖 Python 3；然而，有时你可能会看到我提到版本 2 和版本 3 之间的细微差别。让我们先下载并安装这些软件，然后我会详细介绍它们各自的功能。

跨平台开发

Python 可以在所有主流操作系统上运行，这使它成为一种跨平台语言。这意味着你可以在一个操作系统上编写代码，并与使用与你完全不同的机器的人一起工作。如果两台机器都安装了 Python，它们应该都能够运行这个程序。

为 Windows 安装 Anaconda 和 Python

大多数 OS X 和 Linux 操作系统已经安装了 Python 但是，您仍然需要下载 Anaconda。对于 Windows 用户，Python 通常不包括在内，但它与 Anaconda 一起安装。使用以下步骤正确安装 Anaconda:

1. 打开浏览器，输入 www.anaconda.com/distribution/ 。

2. Click the download button in the header (see Figure 1-1).

   

   图 1-1

   Anaconda 下载页面

3. Once you are on the next page, make sure you select the proper operating system on the header at the top. Click that button (see Figure 1-2).

   

   图 1-2

   选择操作系统

4. Next, click the download button for the Python 3.7 (or greater) section (see Figure 1-3).

   

   图 1-3

   下载 Python 3.x 版本

5. This step is strictly for Windows users… Once the installer fully downloads, go ahead and run it. Use all defaults except for one option. When you get to the page in Figure 1-4, make sure you click the “add to path” option. This will let us access Anaconda through our terminal.

   

   图 1-4

   添加到路径

6. 对于所有选项(除了 Windows 用户的步骤 5)，使用默认设置。然后点击“安装”按钮，让 Anaconda 完成安装。

什么是蟒蛇？

Anaconda 是一个 Python 和 R 发行软件。它旨在为 Python " 提供开箱即用的一切。它主要用于数据分析和数据科学；然而，这也是一个极好的学习工具。下载后，它包括

• 核心 Python 语言和库

• Jupyter 笔记型电脑

• Anaconda 自己的包管理器

这些只是 Anaconda 附带的众多特性中的一小部分；然而，这些是我们将在整本书中使用的。这个列表中的第一个特性是 Python 语言和 Python 可以访问的包含包。库是另一个开发人员预先编写的代码，您可以为了自己的利益而使用。下一节将讨论第二个特性。最后，Anaconda 有一种为我们管理环境的方式。这是一个复杂的话题，我们将在接下来的几周深入探讨。

Jupyter 笔记本是什么？

它是一个开源的集成开发环境(IDE)，允许你创建和共享包含实时代码、公式、可视化和叙述性文本的文档。对我们来说，它本质上是我们的笔记本，我们将在那里一起编码。如果你不熟悉 ide，它们只是开发人员编写代码的工具。把它们想象成艺术家的画布。它还允许您编写代码片段，而不需要了解很多关于 Python 的知识。我们将在周四的课程中更多地学习朱庇特笔记本。

在今天的课程中，我们安装了 Anaconda、Python 和 Jupyter Notebook。明天，我们将学习为什么以及如何使用终端。

星期三:如何使用终端

根据你的操作系统，你将会使用命令提示符 ( Windows )或者终端 ( Linux 和)。从现在开始，我将把它称为“终端”，所以如果你使用 Windows，请记住这一点。终端是用户能够通过基本文本向计算机发出命令的工具。对于本书的大部分内容，我们将使用终端来测试我们的 Python 代码或运行 Jupyter Notebook。今天我们将学习基本命令以及如何使用 Python shell。首先，让我们打开终端。由于每个操作系统看起来都不同，终端会话将在代码中由“ $ ”定义。您在该符号后看到的任何文本都将是您需要自己写入终端的内容。

更改目录

在终端中，您可能经常想要在文件夹之间移动。这给了你在电脑上导航的能力。了解如何做到这一点很重要，因为这一直是我们启动 Jupyter Notebook 时要做的事情。为了改变目录，你需要输入“ cd ”，然后输入你想去的文件夹名。

$ cd desktop

如果你需要从一个文件夹中返回，那么你需要使用两个点(“..”:

$ cd ..

通常，在本书中，您需要遍历几个目录才能进入一个项目文件夹。当您使用“cd”命令时，您可以选择向前或向后移动多远，您只需要指定您要去的文件夹的正确路径。以下面的代码为例…

$ cd desktop/../desktop

我们将进入桌面目录，但随后返回，只是为了回到它里面。这没什么不好；然而，这只是一个例子，计算机将遵循您指定的路径。通常情况下，我们只需将光盘放入桌面就可以了。

正在检查目录

要检查您当前所在的目录，只需查看您可以书写这些文本行的左侧。对于 Windows 用户，您当前所在的目录将是您所在的结束 URL，以粗体标记如下:

C:\Users\name\desktop>

最后一个文件夹名是“桌面”，这意味着我当前在我的桌面的目录中。如果我要创建任何文件或文件夹，它们会直接在那里创建。要检查您所在的 Linux 目录，它将是“ $ ”左侧的名称:

user@user:~/Desktop$

对于 OS X 用户，它将位于您的用户名(您登录时的用户名)的左侧:

User-Macbook-Pro:Desktop Name$

制作目录

虽然进入您的文件浏览器当然没问题，但是右键单击并选择“创建新文件夹”，了解如何通过终端会话本身创建新文件夹是很好的。确保你在“桌面”目录中，即我们“ cd 之前进入的目录。然后写下下面一行:

$ mkdir python_bootcamp

这将在您的桌面上创建一个名为“ python_bootcamp ”的新文件夹。从现在开始，我们将使用这个文件夹来存储我们的课程，以便保持有序。

创建文件

同样，进入文件资源管理器可以更容易地创建文件。但是，有时我们需要根据文件类型在终端中创建文件。然而，在我们创建新文件之前，让我们将" cd "放到我们创建的" python_bootcamp "文件夹中:

$ cd python_bootcamp

现在，对于 Windows 用户，我们需要键入以下内容:

$ echo.>example.txt

或者如果你使用的是 Linux/OSX :

$ touch example.txt

现在，您应该能够在文件资源管理器中看到 sample.txt 文件。

注意

如果没有看到“”。txt "扩展名，这是因为您没有在文件资源管理器的首选项中选中“扩展名”。

检查版本号

终端总是检查我们下载的某些软件版本号的好方法。因为我们已经下载并安装了 Python，所以让我们运行以下代码:

$ python --version

清除终端输出

有时终端会得到大量无用的输出，或者变得难以阅读。当你想清除输出时，你需要写下面一行(对于 Windows ):

$ cls

对于 Linux/OSX 用户，您需要键入以下内容:

$ clear

使用 Python Shell

Python 是一种需要所谓的“解释器来读取和运行我们创建的代码的语言。当 Python shell 被激活时，它在打开的终端会话中充当本地解释器。当它开放时，我们可以写任何我们想执行的 Python。这通常对于练习小代码片段非常有用，这样您就不必打开 IDE 并运行整个文件。要启动 Python shell，当我们在“ python_bootcamp 目录中时，只需键入“ python ”并点击 enter。将出现以下内容:

$ python
Python 3.7.0 (v3)
Type "help", "copyright", "credits" or "license" for more information
>>>

输出将显示您当前运行的 Python 版本。你会注意到三个箭头( > > > )，这意味着你现在正在 Python 解释器内工作。在 Python shell 中，您编写的所有内容都被解释为 Python 语言。如果出于某种原因，您收到以下响应:

$ python
'python' is not recongized as an internal or external command, operable program or batch file.

这意味着 Anaconda 和 Python 没有正确安装。我建议您回到昨天的课程，按照给出的逐步说明重新安装 Anaconda。您可能还需要重新启动计算机。

编写您的第一行 Python 代码

到目前为止，我们还没有进行任何编程。一般来说，我反对自己不去编码；然而，这些基本的设置说明对于开发人员的入门至关重要。虽然我们还没有学习任何 Python，但是当解释器还在运行的时候，在箭头旁边写下下面的代码并按下回车键:

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

这就对了。您刚刚编写了第一行 Python 代码，应该会看到以下输出:

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

退出 Python Shell

现在，我将在后面的课程中解释您刚刚编写的内容，但现在让我们离开 Python shell，通过编写以下行并按 enter 键来结束今天的课程:

>>> exit( )

今天的课程是关于操作和理解终端的。对于一些开发人员来说，这是一项重要的技能，尤其是那些使用 Linux 操作系统的开发人员。明天我们将讨论如何操作 Jupyter 笔记本！

星期四:使用 Jupyter 笔记本

朱庇特笔记本将会是我们在本书中花费大部分时间的地方。这是数据科学社区中使用的一个强大工具，它使我们更容易学习 Python，因为我们可以专注于编写代码。今天的课程是关于如何使用这个工具，细胞，以及如何打开它。

注意

每节课都会要求你打开 Jupyter 笔记本，所以把这一页放在手边，以防你需要回头再看。

打开 Jupyter 笔记本

Jupyter 笔记本可以通过 Anaconda 程序打开；但是，我希望您开始习惯终端以及如何操作它，所以我们不打算通过 Anaconda 打开它。相反，我们将通过终端来执行此操作。这样做的两个好处是

• Jupyter 笔记本将在我们的终端所在的目录中打开

• 作为开发人员，知道如何使用终端将对您有所帮助

如果昨天的终端会话仍然打开，请跳过第一步。

步骤 1:打开终端

我们需要打开终端，将“ cd 放入我们的“ python_bootcamp 目录:

$ cd desktop/python_bootcamp

步骤 2:编写 Jupyter 笔记本命令

通过终端打开 Jupyter Notebook 就像输入工具名称一样简单:

$ jupyter notebook

在键入代码之前，请确保您位于正确的目录中；否则，它将在您的终端目录当前所在的位置打开。通常，这将在用户文件夹中打开 Jupyter Notebook。Jupyter 笔记本将在您的浏览器中打开。

创建 Python 文件

每当我们开始新的一周，我们最终都会创建一个新的工作文件。这样做很简单；Jupyter 笔记本第一次打开时，只需点击屏幕右侧的“新建按钮即可。然后选择“ Python 3 ”(见图 1-5 )。

图 1-5

创建 Python 3 笔记本

一旦你点击了" Python 3 "选项，一个新的标签将作为这个文件打开。点击顶部的名称进行重命名，我们把这个文件命名为“W eek_01 ”(见图 1-6 )。

图 1-6

更改文件名

Jupyter 笔记本电池

现在我们已经打开了 Jupyter Notebook 并创建了一个可以使用的文件，让我们来谈谈细胞。我说的不是生物学；相反，在本笔记本中，您会注意到工具下方的空白白色矩形部分(参见图 1-7 )。这些被称为细胞

图 1-7

以红色突出显示的笔记本单元格

每个单元格都是我们可以写代码的地方，甚至可以使用标记语言。让我们先写一些标记。

1. 在第一个单元格中单击，周围区域会发出蓝光。

2. 在工具栏中，您会注意到一个写着“代码”的下拉菜单点击下拉菜单，选择“降价”。

3. 在单元格内写下以下内容:

# Week 01

注意

编写标记时，一行中 hashtags 的数量与标题的大小有关。比如 HTML 标题标签。

1. 现在让我们运行单元来执行代码。为此，按住 shift 并按 enter 键(单元格必须被选中)。

2. 当您使用 shift + enter 时，一个新的单元格将出现在当前单元格的下方。

在这个新创建的单元格中，让我们继续编写一行简单的 Python 代码，看看输出是如何工作的。让我们继续编写以下内容:

# this is python
print("Hello, buddy!")

去查查手机。它将运行单元格内的所有代码并输出结果。同样，不要担心实际的 Python，这一课是关于 Jupyter 笔记本单元如何运行的。

对于本书的其余部分，我们将在 Jupyter 笔记本文件中编写代码。我将使用 markdown 来指定某些部分，所以在继续之前，请确保您已经熟悉了运行单元格、编写 markdown 和创建新的 Jupyter 笔记本文件。

今天我们学习了如何使用 Jupyter 笔记本，以及我们可以用细胞做什么。在明天的课程中，我们将构建我们的第一个 Python 应用程序！

星期五:创建你的第一个程序

每周五将被称为“项目日”，在那里我们将一起构建一个小的应用程序或游戏，它使用了一周中所学的概念。然而，本周我将让您在一个单元格中编写一些代码，这样您就可以看到 Python 的强大功能。因为我们还没有学习任何 Python，所以我希望你们能够体验我们将在接下来的几周里学到的东西。您将要编写的代码将使用第 2、3 和 4 周的概念。在这几周结束时，你将能够完全理解以下代码的每一行，并做出自己的调整，使程序更具挑战性。

我们将从昨天课的 Jupyter 笔记本文件开始学习。如果你在回到这本书后已经关闭了程序，请继续并重新打开文件。

注意

如果您忘记了如何打开 Jupyter 笔记本，请回到昨天的课程，重做这些步骤，除了创建一个文件。

引入的行号

对于较大的项目，有时很难跟着书走。对于这个项目，以及以后的所有课程，我将实现行号。这将使您更容易跟踪并检查您是否正确地编写了代码:

1| ←

行号现在将出现在所有单元格的左侧，因为我们将需要在一个单元格中编写所有这些代码。请务必注意这些数字，因为您可能会看到它们跳过了几行:

1| # this is the first line in the cell
5| # this is the fifth line in the cell

这意味着你应该在第五行上写下所示的第二行。

注意

点按单元格的边后按下“L”来打开线条。

创建程序

我们需要做的第一件事是在文件中的当前单元格下创建一个新的单元格。为此，只需遵循以下步骤:

1. 单击文件中的最后一个单元格。

2. 高亮显示时，进入菜单栏中的“插入选项卡，点击下方的“插入单元格”

我们的项目现在有了一个细胞。如果你想创建一个标题为“猜谜游戏的 markdown 单元格，请随意回顾上一课以及我们之前是如何做的。在这个新单元格中，让我们继续编写以下代码:

 1| # guessing game
 2| from random import randint
 3| from IPython.display import clear_output
 5| guessed = False
 6| number = randint(0, 100)
 7| guesses = 0
 9| while not guessed:
10|   ans = input("Try to guess the number I am thinking of!")      # use tab to indent
12|   guesses += 1
14|   clear_output( )
16|   if int(ans) == number:
17|           print("Congrats! You guessed it correctly.")              # use tab twice to indent twice
18|           print( "It took you { } guesses!".format(guesses) )
19|           break
20|   elif int(ans) > number:
21|           print("The number is lower than what you guessed.")
22|   elif int(ans) < number:
23|           print("The number is greater than what you guessed.")

这个程序无论如何都不是完美的，但是尝试猜测计算机正在思考的数字肯定很有趣。我知道现在对你来说这看起来像是一门外语，但是在接下来的几个星期里，每一行都会变得有意义。最终你甚至可以对游戏做出自己的改变和改进！我要你现在做的是运行细胞和玩游戏。开始像开发人员一样思考，并在玩的时候问自己这些问题:

• 我可以做哪些改进？

• 是什么让程序崩溃？

• 我能做得更好吗？

如果出现错误，不要害怕，这是成为开发人员成长的一部分！测试你写的代码的有趣的部分是你试图破坏它。随着我们的深入，我将用一些问题来挑战你，为什么代码中的一行是这样工作的。当这种情况发生时，试着思考几分钟，甚至试着用谷歌搜索答案。作为一名开发者，你会发现你做的很多事情都是在谷歌搜索一个问题。这就是优秀的开发人员与伟大的开发人员之间的区别……独立解决问题的能力。有了这本书的其余课程，没有我的帮助，你也能很好地解决问题。

最终输出

每周的所有源代码都将位于本书的 Github 资源库中。你可以在书的前面找到那个知识库的链接。要找到本周的具体代码，只需从 Github 存储库中打开或下载“ Week_01.ipynb ”文件。如果您在这个过程中遇到了错误，一定要参考您用这个文件中的代码编写的内容，看看哪里出错了。

今天，我们能够看到我们的第一个 Python 程序在运行。虽然你可能不明白发生了什么，但我相信让你见识一下 Python 的威力是至关重要的。随着我们的深入，您可以随时回到该计划，并对其进行自己的改进。毕竟，让你变得更好的唯一方法就是去做！！！

每周总结

我知道这一周有点慢，但这是这个过程中至关重要的一周。我们讲述了如何下载必要的工具，如何使用它们，以及如何使用终端本身。这些主题对于理解接下来的内容非常重要，有助于你走向成功。

在这个周末，我们一起编写了一个有趣的猜谜游戏，我希望你能试着打破这个游戏。作为一名开发人员，想要打破一个程序是很重要的，这样你就可以改进它。在接下来的一周，真正的乐趣开始了。我们将开始学习 Python 的基础知识，并最终一起编写一个小程序。

每周挑战

每周结束时都会有自己的挑战，你一定要试试。完成它们将有助于提高你的编程技能。因为本周主要是关于设置，所以接下来的挑战与编程无关。然而，其他的几周会给你很好的例子来检验你的能力。

1. 新文件:创建一个名为“第一周-挑战”的新 Jupyter 笔记本文件现在，主工作文件夹中应该有两个文件。

2. 编写降价:在练习 1 的文件中，创建一个带有降价的单元格，上面写着“挑战 1”尝试几种不同的页眉尺寸。挑一个你最喜欢的。

3. 探索 Python :你应该习惯于谷歌搜索你感兴趣的问题或话题。尝试搜索您感兴趣的 Python 主题，并在开始学习该语言时记住它们。

4. 激励自己:每个程序员都是白手起家。每个人都通过推动自己学习他们感兴趣的语言而成为伟大的程序员。找出是什么促使你想成为一名开发人员，并把它写下来。当你开始奋斗时，请记住这一点。

Footnotes 1

www.tiobe.com/tiobe-index/

  2

www.indeed.com/salaries/Python-Developer-Salaries

 

二、Python 基础

无论你想到哪个著名的程序员，像比尔·盖茨或吉多·范·罗苏姆，他们在人生的某个阶段也是从基础做起的。这些基本概念是构建学习任何编程语言的基础所必需的。毕竟，你不会从屋顶开始盖房子，你需要有一个基础来工作。这就是本周发挥作用的地方。

本周的重点将是数据类型和变量的**。这些几乎是任何编程语言的核心概念。学习一门语言的美妙之处在于，它让你可以很容易地学会其他语言。这部分是因为所有语言都遵循相同的核心概念。到本周末，你将能够理解如何自己编写简单的程序。一个程序，比如我们将一起构建的程序，我们将在一个格式良好的收据中向用户打印信息。**

本周我还将介绍您的第一个挑战问题。这些问题是为了确保你开始“像开发人员一样思考。”有些问题可能没有明确的答案，但它们会促使你创造解决方案并解决问题。重要的是，你花一些时间思考每个问题，这样你就可以开始训练你解决问题的技巧。毕竟，这是每个开发行业最受欢迎的技能。

概述

• 了解数据类型

• 如何使用变量

• 看看你能用绳子做什么

• 如何操作字符串

• 编写打印收据的程序

挑战问题

在编程中，我们有一个概念叫做“算法”一个算法仅仅是一组步骤。不管你知不知道，你一生都在使用算法。一个常见的算法是一个食谱，你按照它来制作食物。

要像开发人员一样思考，您必须开始理解计算机如何读取代码。一台计算机只和它应该执行的程序一样聪明。这意味着如果步骤不正确，即使最聪明的计算机也可能失败。例如，让我们用一个食谱来烤一个蛋糕。如果我们错过了一个步骤，或者把蛋糕放在烤箱里太久，那么我们就失败了，就像电脑错过了一个关键步骤一样。

现在，我希望你们思考一下制作花生酱和果冻三明治的步骤。在一张纸上写下你的步骤。当你把它们写出来的时候，试着像电脑一样思考，并且明白你需要尽可能的精确。答案会在本章末尾。

星期一:注释和基本数据类型

今天是你学习 Python 语言的第一课！今天教授的两个概念将有助于建立我们正在努力的基础。为了继续今天的内容，让我们从“ python_bootcamp ”文件夹中打开 Jupyter 笔记本。如果需要，请回到上周关于如何打开 Jupyter 笔记本的课程。打开后，创建一个新文件，并将其重命名为“ Week_02 接下来，用下面的代码进行第一个单元格的降价:

# Comments & Basic Data Types

什么是注释，为什么要使用注释？

评论就像你留下的笔记，可以给自己看，也可以给别人看。它们不被解释器读入，意味着你可以写任何你想写的东西，计算机会忽略它。一个好的评论应该简短、易读、切中要点。在每一行放一个注释是很乏味的，但是不放任何注释是不好的做法。当你编程时，你会开始理解快乐的媒介是什么样子的。

当你开始写更大的程序时，你会想给自己留些笔记。我经常创建一个程序，停止工作三个星期，当我回来时，我忘记了我在做什么。留下评论不仅对你自己有好处，对其他阅读你代码的人也有好处。把评论想象成面包屑，帮助你理解正在发生的事情。

写评论

在 Python 中，我们可以使用散列 (#)符号来编写注释。此符号后面的任何文本都将被注释掉。在减价标题下方的单元格中，让我们写下第一条评论:

# this is a comment

让我们继续运行单元。请注意，什么也没有发生。这是因为计算机完全忽略任何评论。在大多数情况下，我们将在他们自己的行上写评论；但是，在某些情况下，您可能会看到与代码一致的注释。在与上一条注释相同的单元格中，我们添加下面一行:

print("Hello")       # this is also a comment

这一行的第一部分将运行并输出**【Hello】****，但是第二部分将被忽略，因为有散列符号。**

**### 注意

Markdown 使用散列字符作为头，就像 Python 注释一样。确保您知道您的单元格设置为*“降价/单元格”的类型*

要编写多行注释，以便为更大部分的代码编写更具描述性的段落，我们需要使用三个左右双引号:

" " "
       This is a multi-Line comment
" " "
print("Hello")       # this is also a comment

去查查手机。请注意，多行注释中的文本会被忽略。这些类型的注释对于添加关于代码的描述性段落非常有用。但是，一定不要过度使用它们，因为使用太多它们肯定会把程序搞得一团糟。

什么是数据类型？

几乎所有的语言都使用数据类型，它们对每个程序都是必不可少的。数据类型是我们定义值的方式，比如单词或数字。如果我问你一个句子是由什么组成的，你可能会用*“单词或字符*”来回答在编程中，我们称之为字符串。就像我们把数字称为它们自己的数据类型一样。数据类型定义了我们可以做什么，以及这些值如何存储在计算机的内存中。在表 2-1 中，你会发现每一行都显示了一个数据类型、一个样本值以及对每一个的描述。阅读每一部分，了解每种类型的详细解释。您可以在表格中找到我们本周讨论的四种基本类型。

表 2-1

数据类型示例

|

数据类型

|

样本值

|

描述

| | --- | --- | --- | | 整数 | five | 整数 | | 浮动 | Five point seven | 十进制数字 | | 布尔代数学体系的 | 真实的 | 真值或假值 | | 线 | “你好” | 引号中的字符 |

打印声明

在我们进一步讨论之前，我只想简单介绍一下打印声明。几乎在每一种语言中，你都需要向用户输出信息的能力；在 Python 中，我们可以通过 print 语句做到这一点。现在我不想太深入，但是打印语句是我们在 Python 中称之为的函数。我们将在整个第五周讨论各种功能。但是现在，我们只需要知道 print 语句允许我们向用户输出信息。它的工作方式是通过写下关键字“打印”，然后加上括号。括号内的内容将输出给用户查看。

整数

这些数据类型通常被称为整数或整数。它们是正数或负数整数，没有小数点。整数的使用有各种各样的原因，在数学计算和索引(，我们将在后面进入)；它们是任何语言中的主要数据类型。让我们在文件的下一个单元格中打印几个例子:

# the following are all integers
print(2)
print(10)

去查查手机。结果输出应该是一系列数字 2 和 10 。

漂浮物

每当一个数字上有小数点时，它们就被称为浮点数据类型。不管它是 1 位数还是 20 位数，它仍然是一个浮点数。浮点数的主要用途是在数学计算中，尽管它们也有其他用途。让我们来看一个例子:

# the following are all floats
print(10.953)
print(8.0)       # even this number is a float

去查查手机。输出应该是一系列数字 10.953 和 8.0 。

注意

数字“8.0”被认为是一个浮点数，因为它包含一个小数点。

布尔运算

布尔数据类型为真或假值。你可以把它想象成一个开关，要么关闭，要么打开。除了 True 或 False，它不能被赋予任何其他值。布尔是一种关键的数据类型，因为它们提供了多种用途。其中最常见的是跟踪是否发生了什么。例如，如果你玩一个视频游戏，想知道玩家是否还活着，当玩家开始繁殖时，你可以设置一个布尔值“真”。当玩家失去了他们所有的生命，你会设置布尔为“假”。这样你可以简单地检查布尔值，看看玩家是否还活着。这使得程序更快，而不是每次都计算生命。让我们继续运行以下代码:

# the following are booleans
print(True)
print(False)

去查查那个手机。输出应该分别是字真和假。

用线串

也被称为"字符串文字 ，"这些数据类型是我们今天要讨论的四种数据类型中最复杂的。字符串的实际定义是

Python 中的字符串是代表 unicode 字符的字节数组。

对于大多数初学者来说，这听起来就像一堆废话，所以让我们把它分解成一些我们可以理解的简单的东西。字符串无非是一组 字符、符号、数字、空格，甚至是两组 引号之间的空格。在 Python 中，我们可以使用单引号或双引号来创建字符串。大多数时候这是个人偏好，除非你想在一个字符串中包含引号(见下一个块中的第 3 行)。引号内的内容将被视为字符串，即使它是一个数字。让我们在下一个单元格中为字符串编写一些示例:

# the following are strings
print(" ")
print("There's a snake in my boot!")
print('True')

输出将在顶部包含一个空行，因为我们在第一条语句中不打印任何内容。

周一练习

1. 输出:打印出你的名字。

2. 类型检查:尝试使用 Type()方法检查值的类型。这将始终打印出您正在检查的数据类型。当您不确定时，这对于检查数据类型很有用。举个例子:

   >>> type(int) # will output <class 'int'>

今天，我们关注 Python 中的四种基本数据类型。理解两者之间的差异是我们前进的关键。在明天的课程中，我们将开始了解如何保存这些数据类型，以便在程序的后面使用。

星期二:变数

变量是编程中最重要的初级概念之一。它们允许我们使用指定的名称将值保存到内存中。这让我们可以在程序的后面使用这些值。昨天的课程讲述了不同的数据类型，但是如果您想保存其中一种数据类型以备后用，该怎么办呢？这就像我们如何在大脑中存储信息一样，变量存储在计算机内存中，我们可以在以后通过引用我们使用的名称来访问它们。我不会深入 Python 如何存储信息背后的理论，因为我们更关注编程的应用，但值得注意的是 Python 自动为我们处理内存存储和垃圾收集。

为了跟上这一课，让我们从之前的笔记本文件“ Week_02 ”继续，简单地在底部添加一个标有“变量”的 markdown 单元格。

它们是如何工作的

我们在等于运算符(“=”)的左边声明了一个名称，在右边，我们为想要保存以备后用的值赋值。举个例子(不用写这个):

>>> first_name = "John"

当你创建一个变量时，你赋值的那一行是一个叫做声明的步骤。我们刚刚声明了一个名为“ first_name 的变量，并为它分配了字符串数据类型“ John 的值。这个字符串现在存储在内存中，我们可以通过调用变量名“ first_name ”来访问它。

注意

变量名只能包含字母、下划线和数字。但是，它们不能以数字开头。

处理命名错误

所有的程序员都会犯错，所以如果你遇到错误也不成问题。这是工作带来的。让我们来看看变量(不需要写这个)的一个常见错误:

>>> Sport = 'baseball'    # capital 'S'
>>> print(sport)          # lowercase 'S'

如果我们尝试运行这段代码，我们将得到以下错误/输出:

NameError: name 'sport' is not defined

这是因为名字完全不同。我们引用了一个带有小写字母“s”的变量，但是声明了一个带有大写字母“s”的变量。

整数和浮点变量

为了在变量中存储一个整数或浮点数，我们在操作符的左边给一个名字，在右边写一个数字。在下一个单元格中，让我们继续编写以下代码:

num1 = 5           # storing an integer into a variable
num2 = 8.4         # storing a float into a variable
print(num1, num2)  # you can print multiple items using commas

去查查那个手机。注意输出是 5 和 8.4 ，即使我们打印出了“ num1 和“ num2”。“我们打印出存储在这些变量中的值。

布尔变量

请记住，布尔值是真或假值，因此存储它们就像键入这两个单词中的一个一样简单。让我们写以下内容:

# storing a boolean into a variable
switch = True
print(switch)

去查查那个手机。结果输出为“真”。注意，在 Jupyter Notebook 中，True 或 False 的值会发绿光。如果我们写得正确，这是一个很好的指示。

字符串变量

字符串和前面三种数据类型一样容易存储。请记住，使用单引号或双引号很重要。让我们继续在新的单元格中编写以下代码:

# storing strings into a variable
name = 'John Smith'
fav_number = '9'
print(name, fav_number)            # will print 9 next to the name

继续运行它。记住字符串“ 9 ”和整数 9 是不一样的。这两种数据类型表现不同，即使输出看起来相似。

使用多个变量

几乎在你编写的任何程序中，你都需要对变量进行一些计算或操作。在下面的代码中，我们从先前声明的变量中访问值，并将它们相加以创建一个和。在运行此单元之前，请确保已经运行了之前的单元。让我们将它放入一个新的单元格中:

# using two variables to create another variable
result = num1 + num2
print(result)

运行这个单元后，你会注意到它将 5 和 8.4 加在一起输出 13.4 。

注意

如果您得到一个错误消息，说某个变量不存在，请尝试运行首先声明该变量的单元格。

对数值变量使用运算符

把 Python 想象成一个计算器，我们可以随意改变任何变量。在下面的代码中，我们改变了先前定义的"结果"变量:

# adding, deleting, multiplying, dividing from a variable
result += 1   # same as saying result = result + 1
print(result)
result *= num1   # same as saying result = result * num1
print(result)

去查查手机。在第一行中，我们给结果加 1，然后我们把它乘以" num1，"的值，也就是 5。与此同时，计算机保存了结果变量，所以我们可以继续编辑它。然后我们打印结果，结果显示为 72.0 。

覆盖以前创建的变量

Python 让我们很容易改变一个变量的值，只需要简单地重新声明它。在某些语言中，您必须定义数据类型，但是 Python 为我们处理了所有这些。我们已经在前面的结果变量中看到了这种情况，但是在它自己的单元格中值得注意:

# defining a variable and overwriting it's value
name = 'John'
print(name)
name = 'Sam'
print(name)

继续在新的单元格中运行。您会注意到输出显示了**“约翰”和“山姆”**。访问或重新声明变量的位置很重要；记住这一点。

空白

空白仅仅意味着用于间隔的字符，并且有一个"空的"表示。在 python 的上下文中，它意味着制表符和空格。例如:

>>> name = 'John Smith'

等号运算符的左右两边都有空格。这不是必需的，但它使阅读代码更容易。计算机在编译代码时会忽略空白。然而，在字符串中，空格是而不是空格，这只是一个“空格”字符。

星期二练习

1. 变量输出:将值 3 存储在一个名为“x”的变量中，将值 10 存储在一个名为“y”的变量中。将 x * y 的结果保存到一个名为“结果”的单独变量中。最后，输出信息，如下所示:

   >>> 3 + 10 = 13
   
   

2. 面积计算:计算一个 245.54”x 13.66”的长方形的面积。打印出结果。提示:面积是宽度乘以高度。

变量无处不在，Python 让我们很容易将它们合并。能够存储信息是任何程序的关键部分。明天我们将看看如何操作字符串。

星期三:使用字符串

理解可以对字符串数据类型做什么很重要。接下来的两天包括与和一起操作字符串，这样我们可以在周末建立一个收据打印程序。我们不会担心接受用户输入，而是担心如何格式化字符串，什么是字符串索引，等等。

为了继续学习这一课，让我们从之前的笔记本文件“ Week_02 ”继续，并在底部简单地添加一个 markdown 单元格，上面写着“使用字符串”。

串并置

当我们谈论连接字符串时，我的意思是我们希望将一个字符串添加到另一个字符串的末尾。这个概念只是将字符串变量加在一起以完成一个更大的字符串的许多方法之一。对于第一个示例，让我们将三个单独的字符串加在一起:

# using the addition operator without variables
name = "John" + " " + "Smith"
print(name)

继续运行 markdown 单元格下面的单元格。我们得到的输出是“约翰·史密斯”。我们最后添加了两个字符串，这两个字符串是名称，并使用一个内部带有空格的字符串来分隔它们。让我们先尝试将这两个名字存储到变量中:

# using the addition operator with variables
first_name = "John"
last_name = "Smith"
full_name = first_name + " " + last_name
print(full_name)

去查查那个手机。我们得到与前一个细胞完全相同的输出；然而，这次我们使用了变量来存储信息。

格式化字符串

之前，我们通过将多个字符串相加来创建一个更大的字符串，从而创建了一个全名。虽然这完全可以使用，但对于较大的字符串来说，就很难阅读了。想象一下，你必须创造一个使用 10 个变量的句子。将所有十个变量添加到一个句子中很难跟踪，更不用说读取了。我们需要使用一个叫做字符串格式的概念。这将允许我们编写一个完整的字符串，并在适当的位置注入我们想要使用的变量。

。格式( )

format 方法的工作原理是直接在结束字符串引号后加一个句点，后跟关键字“ format ”。关键字后的括号内是将注入字符串的变量。不管是什么数据类型，它都会把它插入到字符串中合适的位置，这就带来了一个问题，它怎么知道把它放在哪里？这就是花括号发挥作用的地方。花括号的顺序与格式括号中变量的顺序相同。要在一个格式字符串中包含多个变量，只需用逗号分隔每个变量。让我们来看看一些例子:

# injecting variables using the format method
name = "John"
print( "Hello { }".format(name) )
print( "Hello { }, you are { } years old!".format(name, 28) )

去查查那个手机。我们会看到第一行的输出是“你好约翰”，第二行是“你好约翰，你 28 岁了”。请记住，format 函数会注入变量，甚至是数据类型本身。在这个例子中，我们注入了整数值 28。

f 字符串(Python 3.6 中的新特性)

在 Python 中将变量注入字符串的新方法是使用我们称之为 f strings 的方法。通过将字母" f "放在一个字符串的前面，你可以直接在行中将一个变量注入到一个字符串中。这一点很重要，因为当字符串变长时，它使字符串更容易阅读，这是格式化字符串的首选方法。只要记住你需要 Python 3.6 来使用它；否则你会收到一个错误。要在一个字符串中注入一个变量，只需在变量名周围加上花括号。让我们看一个例子:

# using the new f strings
name = "John"
print( f"Hello {name}" )

去查查手机。我们得到了与相同的输出。format() 方法；但是，这次读代码就容易多了。

注意

在本书中，我们将使用。format()方法。

Python 2 中的格式

Python 2 不包括。format()方法；取而代之的是，你可以使用百分比运算符来标记被注入变量的位置。下面是将变量“ name 注入“ %s ”位置的例子。百分比运算符后的字母表示数据类型。对于整数，你可以用“ %d ”来表示数字。在字符串结束后，您可以放置一个百分比运算符，后跟您想要使用的变量。让我们看一个例子:

# one major difference between versions 2 & 3
name = 'John'
print('Hello, %s' % name)

去查查那个手机。您会注意到，我们得到了与前面方法相同的输出。如果您想在 Python 2 中用多个变量格式化一个字符串，那么您需要编写以下代码:

# python 2 multiple variable formatting
first_name = "John"
last_name = "Smith"
print( "Hello, %s %s" % (first_name, last_name) )        # surround the variables in parenthesis

去查查手机。我们将得到输出“你好，约翰·史密斯”。当传递多个变量时，需要用括号将变量名括起来，并用逗号分隔。注意，字符串中还有两个符号，从左到右依次表示每个变量的位置。

字符串索引

关于字符串，我们需要理解的另一个关键概念是它们是如何存储的。当计算机将一个字符串保存到内存中时，字符串中的每个字符都被赋予一个我们称之为“索引 的符号。“索引本质上是内存中的一个位置。把索引想象成你在商场排队等候时的位置。如果你在队伍的最前面，你的索引号将会是零。你后面的人将被赋予索引位置 1。他们后面的人将被给予索引位置 2，以此类推。

注意

包括 Python 在内的大多数语言的索引都是从 0 开始，而不是从 1 开始。

Python 字符串也是如此。如果我们取一个类似*“Hello”*的字符串，分解它们的索引(见图 2-1 ，我们可以看到字母“ H ”位于索引零处。让我们试一个例子:

# using indexes to print each element
word = "Hello"
print( word[ 0 ] )            # will output 'H'
print( word[ 1 ] )            # will output 'e'
print( word[ -1 ] )           # will output 'o'

为了索引一个特定的元素，您可以在变量名的右边使用方括号。在那些方括号中，您放入您希望访问的索引位置。在前面的例子中，我们正在访问存储在变量**“单词”中的字符串“你好”**中的前两个元素。最后一行访问最后一个位置的元素。使用负索引号将导致试图从后面访问信息，例如-4 将导致字母“e”的输出。

图 2-1

字符串的索引位置

使用索引时要非常小心。索引是内存中的一个特定位置。如果你试图访问一个超出范围的位置，你会使你的程序崩溃，因为它试图访问一个不存在的内存位置。例如，如果我们试图访问*“Hello*”上的索引 5。

字符串切片

我想简单介绍一下切片这个话题。切片主要用于 Python 列表；但是，您也可以在字符串上使用它。切片本质上是当你只想要变量的一部分时，这样，如果我只想要单词“hello”中的“He ”,我们将编写如下:

print( word[ 0 : 2 ] )            # will output 'He'

括号中的第一个数字是起始索引；第二个是停止指数。我们将在下一周触及这个概念；然而，你可以随意摆弄切片。不过，在今天结束之前，我想快速介绍一下切片时的开始、停止和步进参数。切片的语法总是

>>> variable_name[ start : stop : step ]

在上一个单元格中，我们只包括开始和停止，因为步骤是可选的，默认情况下每次递增 1。然而，如果我们想打印每隔一个字母:

print( word[ 0 : 5 : 2 ] )         # will output 'Hlo'

去查查手机。通过将步骤作为数字 2 传递，它每次将索引增加 2，而不是 1。我们将在后面的章节中更深入地讨论这个问题；现在，让这成为对所有三个参数的切片的介绍。

周三练习

1. 变量注入:创建一个打印语句，将整数、浮点、布尔和字符串全部注入一行。输出应该看起来像“ 23 4.5 假约翰”。

2. 填空:使用 format 方法，通过将你的名字和喜欢的活动赋值到变量中来填写以下空格:

   "{ }'s favorite sports is { }."

   "{ } is working on { } programming!"

我们今天讨论了使用字符串、格式化和索引时的一些关键概念。明天我们将使用其他方法来帮助我们操作字符串。

周四:字符串操作

在您将要构建的许多程序中，您会希望以某种方式改变字符串。字符串操作仅仅意味着我们想要改变当前的字符串。幸运的是，Python 有大量的方法，我们可以用它们来改变字符串数据类型。

接下来，让我们从之前的笔记本文件“ Week_02 ”继续，简单地在底部添加一个 markdown 单元格，上面写着:“操纵字符串。

。标题( )

通常，你会遇到不大写的单词，这些单词通常应该是名字。title 方法将字符串中每个单词的首字母全部大写。尝试以下方法:

# using the title method to capitalize a string
name = "john smith"
print( name.title( ) )

去查查那个手机。我们得到的输出是一个" John Smith "，每个单词都有大写字母。这个方法对于正确格式化名字非常有用。

注意

尝试使用 name.lower()和 name.upper()看看会发生什么。

。替换( )

replace 方法的工作方式类似于查找和替换工具。它在括号中接受两个值，一个是它要搜索的值，另一个是它用以下内容替换搜索到的值:

# replacing an exclamation point with a period
words = "Hello there!"
print( words.replace( "!", "." ) )

去查查那个手机。这将导致“ Hello there ”的输出。

注意

为了在以后正确存储替换，我们必须重新声明我们的 words 变量: words = words.replace('！', '.').

。查找( )

find 方法将搜索我们要求它搜索的任何字符串。在本例中，我们尝试搜索整个单词，但我们可以搜索包括字符或完整句子在内的任何内容:

# finding the starting index of our searched term
s = "Look over that way"
print( s.find("over") )

去查查那个手机。你会注意到我们得到了 5 的输出。Find 返回匹配的起始索引位置。如果你计算单词“ over 开始的位置，那么“ o 在索引位置 5。当您想要访问搜索中的特定索引时，这一点非常重要。

。条状( )

如果你想去掉字符串左右两边的某个字符，你可以使用 strip 方法。默认情况下，它会删除空格。让我们尝试运行以下代码:

# removing white space with strip
name = "   john   "
print( name.strip( ) )

输出将产生“ john ”，因为我们已经移除了左侧和右侧的所有空格。

注意

试试看。lstrip()和。rstrip()看看会发生什么。

。拆分( )

我不会对 split 进行过多的描述，因为它返回的是一个列表，我们还没有涉及到这些；然而，我想让你看看如何使用这种方法。它的作用是将句子中的单词分成一组单词，存储在一个列表中。现在先不要担心列表，我们会有的。现在，让我们看看这个方法是如何工作的:

# converting a string into a list of words
s = "These words are separated by spaces"
print( s.split(" ") )

去查查手机。输出结果是单词列表“ ['这些'，'单词'，'是'，'分隔'，'分隔'，'空格'] ”。我们将回到这个方法以及它为什么重要。

周四练习

1. 大写:尝试操作字符串“uppercase ”,使它打印出来的都是大写字母。你需要寻找一种新方法。

2. 剥去符号:剥去这个字符串“$$John Smith”左边的所有美元符号。试试看。lstrip()和。剥离()。要查看有关如何进一步使用 strip 方法的描述，请尝试使用 Python 中的帮助功能，方法是键入以下内容:

   >>> help(" ".strip)
   
   

今天你学了一些操作方法，但还有更多。试着用你在网上找到的其他人做实验。

星期五:创建收据打印程序

欢迎来到你的第一个项目！我们将创建一个非常基本的收据打印程序。本周，我们已经学习了变量、操作符和字符串操作，我们将使用这些技能来创建这个程序。

接下来，让我们从我们的“ Week_02 ”笔记本继续，简单地在底部添加一个减价单元格，上面写着:“星期五项目:打印收据。

完工图纸

描绘出你想要建造的东西的设计总是好的。对于较大的项目，你会想要创建一个流程图或某种设计文档，这将使你走上正轨。这样你就不会偏离预期的结果。对我们来说，我们将用我们所学的概念构建一个小的收据打印程序，其中的输出将如图 2-2 所示。

图 2-2

星期五项目的最终结果

我们开始吧，好吗！

启发过程

无论何时开始一个项目，你都必须知道从哪里开始。无论项目大小，都有一定的依赖性。就像盖房子一样，你必须先有地基，然后才能盖屋顶。现在，这个程序大约有 50 行，几乎没有依赖关系，所以我们将从顶部边框开始，一路向下到底部。

定义我们的变量

在减价标题下方的单元格中，让我们开始定义我们将在整个计划中使用的变量:

1| # create a product and price for three items
2| p1_name, p1_price = "Books", 49.95
3| p2_name, p2_price = "Computer", 579.99
4| p3_name, p3_price = "Monitor", 124.89

我总是喜欢在构建这些周五项目时引入新概念，因为实现好的编码技术是有好处的。该块中引入的技术是在同一行声明多个变量的能力。为此，我们只需用逗号分隔变量名及其相关值。看前面声明的两个变量，“ Books 的值会保存到变量名“ p1_name ”，值“ 49.95 ”会保存到变量名“ p1_price ”。我们已经把程序减少了一半，而不是写六行。我们用的线越少越好(多数时候)。像 x 和 y 这样的变量，或者在我们的例子中，一个名字和价格，是在一行中声明相关变量的好例子。

接下来，让我们在收据的顶部定义公司将使用的变量。这个项目的所有代码可以在单个单元格中完成，或者您可以将单元格分开。这取决于你。我提供了行号，以防您跟踪单个单元格:

6| # create a company name and information
7| company_name = "coding temple, inc."
8| company_address = "283 Franklin St."
9| company_city = "Boston, MA"

例如，我们将公司名称全部小写，这样我们可以使用字符串操作方法来解决这个问题。

最后，让我们在收据的底部声明我们将输出给用户的消息:

11| # declare ending message
12| message = "Thanks for shopping with us today!"

去查查手机。现在我们已经定义了所有的变量，我们可以继续了。

创建顶部边框

正如我们可以从这个项目开始时的设计中看到的，我们需要在顶部和底部打印出一个边框。让我们从顶部边框开始:

14| # create a top border
15| print( "*" * 50 )

去查查手机。这里应用了一个新概念，我们写 "*" * 50 。我们所要做的就是打印出 50 个星星作为上边框，而不是打印 50 条语句，我们可以简单地将字符串乘以我们想要的数字。这样我们得到了顶部边框，同时保持代码简洁易读。代码的可读性始终是关键。

显示公司信息

我们已经在前面几行中为公司定义了变量，所以让我们显示它们:

17| # print company information first, using format
18| print( "\t\t{ }".format( company_name.title( ) )
19| print( "\t\t{ }".format(company_address) )
20| print( "\t\t{ }".format(company_city) )

去查查手机。起初，这些打印语句可能看起来有点难以理解；不过，我给你介绍一个逃兵角色。转义字符由定义反斜杠 "" 字符读入。反斜杠后面的内容是计算机将解释的内容。在三个打印语句中，我们使用 "\t" 作为制表符缩进。你可能会看到的另一个流行的转义字符是 "\n" ，它的意思是换行，就像你按下回车键一样。我们在一行中使用两个转义字符，使其在输出中居中。让我们创建一个分割线:

22| # print a line between sections
23| print( "=" * 50 )

去查查手机。就像我们打印上边框一样，我们将等号乘以 50 来创建相同宽度的线条。这将给出单独部分的外观。

显示产品信息

查看我们的原始设计，我们希望在列出每个产品的名称和价格之前创建一个标题。这可以通过使用我们的转义字符进行缩进来实现:

25| # print out header for section of items
26| print("\tProduct Name\tProduct Price")

去查查手机。由于标题名称的大小，我们只需要在每个标题前使用一个制表符。现在，我们可以为每个产品的信息输出一行:

28| # create a print statement for each product
29| print( "\t{ }\t\t${ }".format(p1_name.title( ), p1_price) )
30| print( "\t{ }\t\t${ }".format(p2_name.title( ), p2_price) )
31| print( "\t{ }\t\t${ }".format(p3_name.title( ), p3_price) )

去查查手机。我们使用与之前的打印声明相似的样式，以便将每个产品的标题和价格放在各自标题的中心。尽量不要被打印字符串中的所有符号搞糊涂；您可以简单地将它们分解成一个制表符，然后是格式化为字符串的第一个变量，接着是两个制表符，接着是美元符号(以使价格看起来像货币)，然后是格式化为字符串的第二个变量。这就完成了我们产品的部分，所以让我们放入另一个部分分隔线:

33| # print a line between sections
34| print('=' * 50)

去查查手机。这将为我们的下一部分设置显示总数。

显示总数

像 products 部分一样，我们希望为我们的合计创建一个标题，但是我们还希望它位于 products 部分的 price 列的中心。为此，我们将使用三个选项卡:

36| # print out header for section of total
37| print("\t\t\tTotal")

去查查手机。现在我们已经将合计标题与 products 中的 price 列对齐，我们可以在下一行输出合计。然而，在我们可以打印出总数之前，我们必须首先计算总数，它是我们所有产品的总和。让我们定义一个名为 total 的变量，然后将其打印出来:

39| # calculate total price and print out
40| total = p1_price + p2_price + p3_price
41| print( "\t\t\t${ }".format(total) )

去查查手机。同样，我们已经添加了三个选项卡，加上一个美元符号，使总值显示为货币。现在让我们添加一个部分边界:

43| # print a line between sections
44| print( "=" * 50)

继续运行单元格，以确保它看起来像目前为止期望的输出。

显示结束消息

为了显示最后的感谢信息，我们的设计使它的间距比任何其他部分都稍大，所以我们需要添加几个换行符来给它一些额外的间距:

46| # output thank you message
47| print( "\n\t{ }\n".format(message) )

去查查手机。我们的信息现在集中了，我们准备继续前进。

显示底部边框

为了完成这个简单的打印程序，为了美观，我们需要添加一个底部边框:

49| # create a bottom border
50| print( "*" * 50 )

继续最后一次检查手机。

恭喜你！尽管可能很简单，但这是一个巨大的里程碑。在学习了更多的材料之后，试着回到这里来改进它。

每周总结

本周，我们复习了变量编程和字符串处理中一些非常重要的基础概念。您必须始终记住，变量需要在使用之前声明，并且相关的名称与等号运算符右侧的值一起保存在内存中。Python 中的字符串很容易处理，因为这种语言有各种各样的方法，我们可以调用这些方法来完成这项工作。在周末，我们能够构建一个简单的收据打印程序。试试破解程序！我总是鼓励学生尝试破坏程序，因为这将教会你如何修复它。

挑战问题解决方案

做 PB&J 三明治没有一个确定的解决方案，但是我希望你回去看看你是否还不够具体。计算机的智能取决于我们对它们的编程，所以如果你说把花生酱放在面包上，它可能会理解为把整个罐子放在面包上。作为一名开发人员，你需要对你的描述进行具体化。甚至尝试用改进的步骤重写一个新算法。

每周挑战

要测试你的技能，请尝试以下挑战:

1. 侧边框:在周五的项目中，我们最终在打印出来的信息的上方和下方创建了边框。现在试着在边上加一个星形边框。

2. 研究方法:我们已经讨论了一些广泛使用的字符串操作方法；然而，还有很多；试着查找一些并实现它们。

3. 反转:声明一个等于“Hello”的变量。使用切片反转字符串。纠结的话试着查一下。

小费

切片时，可以定义开始、停止和步进。**

三、用户输入和条件

欢迎来到第 3 周！本周我们将介绍如何在我们的程序中处理用户输入和做出决策。这些决定被称为分支语句或条件。如果你每天都在思考你的生活，你在不知道的情况下根据具体情况做出决定，比如早上什么时候起床，午餐吃什么，什么时候吃饭等等。这些被称为分支语句。这同样适用于编程，我们需要让计算机做决定。

概述

• 使用用户输入

• 如何使用“如果”语句来做决策

• 如何使用“elif”语句做出多个决策

• 无论如何，如何使用“else”语句来做决定

• 构建具有决策和用户输入的计算器

挑战问题

本周的挑战是测试你阅读代码的能力。我希望你阅读代码块，并考虑它是否会工作。如果你认为它不起作用，我希望你记下它为什么不起作用。既能读又能写很重要:

>>> print('{} is my favorite sport'.format(element))
>>> element = 'Football'

写下答案后，继续在单元格内运行代码。如果你的答案是不正确的，试着分析你为什么。答案会在本章末尾。

星期一:用户输入和类型转换

在今天的课程中，我们将介绍与用户交互的能力和一个叫做类型转换的概念。这些对于理解如何在周末构建计算器是必要的。

为了继续今天的内容，让我们从“ python_bootcamp ”文件夹中打开 Jupyter 笔记本。打开后，创建一个新文件，并将其重命名为“ Week_03。“接下来，对第一个标题为:“用户输入&类型转换”的单元格进行降价。“我们将开始在那个牢房下面工作。

接受用户输入

在我们将要创建的许多程序中，你需要接受用户输入。为此，我们需要使用 input() 函数。像 print 函数一样，input 将打印括号内的字符串，但它也会创建一个框供用户输入信息。让我们看一个例子:

# accepting and outputting user input
print( input("What is your name? ") )

去查查那个手机。您会注意到，无论您在框中写什么，单元格都会输出。当解释器遇到输入功能时，它会暂停，直到按下 enter 键。

注意

输入的信息以字符串形式输入程序。

存储用户输入

在前一个单元格中，我们只是打印出用户输入的内容。但是，为了处理他们输入的数据，我们需要将其存储到一个变量中:

# saving what the user inputs
ans = input("What is your name? ")
print("Hello { }!".format(ans) )

去查查那个手机。存储用户在程序中输入的信息就像存储到变量中一样简单。这样我们就可以随时处理他们输入的数据。

什么是类型转换？

Python 定义了类型转换函数，直接将一种数据类型转换成另一种数据类型，这在日常和竞争性编程中非常有用。在某些情况下，您正在处理的数据可能不是正确的类型。最明显的例子是用户输入，因为无论用户输入什么，输入都被当作字符串。如果您希望输入一个数字，您需要将输入转换为整数数据类型，以便能够处理它。

检查类型

在我们讨论如何进行类型转换之前，我想先介绍一下 Python 的一个重要函数，它允许我们检查任何给定变量的类型:

# how to check the data type of a variable
num = 5
print( type(num) )

去查查那个手机。这里的输出将是“ <类‘int’>”。不要担心这里的课程，我们会在下一周上课。重点放在第二部分，它将类型输出为整数。这允许我们检查使用什么数据类型。

转换数据类型

Python 让我们能够通过简单地将类型包装在变量周围，轻松地将类型从一种类型转换为另一种类型。让我们来看一个将字符串转换成整数的例子:

# converting a variable from one data type to another
num = "9"
num = int(num)     # re-declaring num to store an integer
print( type(num) )   # checking type to make sure conversion worked

去查查那个手机。我们刚刚将字符串 "9" 转换为一个整数。现在我们可以在任何计算中使用变量 num。为了正确地进行转换，我们使用了 int() 类型转换。放在括号内的任何数据类型都被转换为 int。查看表 3-1 了解如何从一种数据类型转换到另一种数据类型。

表 3-1

转换数据类型

|

当前类型

|

数据值

|

转换为

|

适当的代码

|

输出

| | --- | --- | --- | --- | --- | | 整数 | nine | 线 | 字符串(9) | '9' | | 整数 | five | 浮动 | 浮子(5) | Five | | 浮动 | Five point six | 整数 | int(5.6) | five | | 线 | ‘9’ | 整数 | int('9 ') | nine | | 线 | “真的” | 布尔代数学体系的 | 布尔（"真"） | 真实的 | | 布尔代数学体系的 | 真实的 | 整数 | int(True) | one |

正如你所看到的，有几种方法可以将类型转换为；您只需要为每个定义的数据类型使用关键字。布尔类型 True 转换为整数 1，因为 True 和 False 值分别表示 1 和 0。此外，将浮点数转换为整数只会截断小数，以及小数右边的任何数字。

注意

并非所有数据类型都可以正确转换。这是有限度的。

转换用户输入

让我们尝试处理用户的输入，以便向他们键入的任何内容添加 100:

# working with user input to perform calculations
ans = input("Type a number to add: ")
print( type(ans) )    # default type is string, must convert
result = 100 + int(ans)
print( "100 + { } = { }".format(ans, result) )

去查查那个手机。输入数字“ 9 ”会给我们一个合适的结果；然而，这种转换不能很好地与单词**“九”**一起工作，因为输入的默认返回类型是一个字符串，如该单元格中的第一个 print 语句所示。

处理错误

在最后一个单元格中，我们将用户输入转换为整数；然而，如果他们用一个词来代替呢？程序会马上中断。作为一名开发人员，我们必须假设用户不会提供我们期望他们提供的正确信息。为了解决这个问题，我们将引入 try 和 except 块。Try 和 except 用于捕捉错误。它的工作原理是尝试运行 try 块中的内容；如果它没有产生错误，那么它会继续运行，不会碰到 except 块；但是，如果发生错误，except 块中的代码将运行。这是为了确保当出现错误时，你的程序不会停止运行。这是处理错误的通用方法；还有许多其他方法，比如使用函数 isalpha() 和 isalnum() 。让我们看一个使用 try 和 except 块的例子:

# using the try and except blocks, use tab to indent where necessary
try:
      ans = float( input("Type a number to add: ") )
      print( "100 + { } = { }".format(ans, 100 + ans) )
except:
      print("You did not put in a valid number!")
# without try/except print statement would not get hit if error occurs
print("The program did not break!")

去查查那个手机。尝试输入不同的答案，包括非数字。您会注意到，如果您不输入数字，我们的无效打印语句将会输出。如果我们没有 try 和 except，程序就会中断，最后一个 print 语句也不会出现。

代码块和缩进

在大多数其他编程语言中，缩进只是用来帮助代码看起来漂亮。但是对于 Python 来说，它是指示代码块所必需的。让我们从“处理错误一节中取出之前的代码。try 语句后的两行是缩进的，称为代码块**。这些行属于 try 语句，因为它们直接在语句后缩进。except 块中的另一个 print 语句也是如此。这就是为什么我们的无效打印语句只在 except 块运行时才运行。所有代码块都需要连接到一个语句；不能随意缩进一节。**

注意

缩进必须一致。它并不总是需要四个空格；然而，一个制表符有四个空格，所以用制表符缩进通常更容易。

周一练习

1. 转换:试着将一串“ True 转换成一个布尔值，然后输出它的类型以确保正确转换。

2. 输入总和:创建两条输入语句，要求用户输入两个数字。把这些数字的总和打印出来。

3. 汽车信息:要求用户输入汽车的年份、品牌、型号和颜色，并打印一份格式良好的声明，如“2018 蓝色雪佛兰 Silverado”

今天是涵盖用户输入、如何从一种数据类型转换到另一种数据类型以及如何处理错误的重要一步。

周二:If 声明

今天我们将学习如何在代码中做决定。这将使我们能够让我们的程序根据用户的输入、计算等来决定运行哪一行代码。这是本周最重要的一课。一定要花大量的时间来学习今天的课程。

为了跟上这一课，让我们从之前的笔记本文件“ Week_03 ”继续，并在底部添加一个标有“ If 语句”的单元格。

它们是如何工作的

每天你都要做上百个决定。这些决定决定了你一天要做什么。在编程中，这些被称为分支语句或**“if 语句”**if 语句的工作方式与做出决策的方式相同。您检查一个条件，如果该条件为真，则执行该任务，如果不为真，则不执行该任务继续前进:

“我饿了吗？”

是的，所以我应该做些食物

继续烹饪食物

使用 if 语句可以在编程中实现相同的决策过程。

编写第一条 If 语句

所有分支语句都以同样的方式开始，用关键字“ if ”。关键字后面是所谓的条件。最后，在语句的末尾总会有一个结束冒号。 if 语句检查给定条件是真还是假。如果条件为真，则代码块运行。如果为 False，则程序继续运行，不运行任何直接缩进在 If 语句后面的代码。让我们试一试:

# using an if statement to only run code if the condition is met
x, y = 5, 10
if x < y:
      print("x is less than y")

去查查那个手机。注意这里的输出是**“x 小于 y”。这是因为我们最初声明 x 等于 5，y 等于 10，然后使用 if 语句来检查 x 是否小于 y，它确实小于 y。如果 x 等于 15，那么缩进在“if”**之后的打印语句将永远不会运行，因为条件将为假。

比较运算符

在我们继续分支语句之前，我们需要回顾一下比较运算符。到目前为止，我们已经使用了算术运算符来加减值，使用赋值运算符来声明变量，随着*“if 语句”*的引入，我们现在已经看到了比较运算符。你可以做几个比较。然而，您将使用的大多数比较运算符如表 3-2 所示。

表 3-2

比较运算符

|

操作员

|

情况

|

功能

|

例子

| | --- | --- | --- | --- | | == | 平等 | 如果 x == y: | 如果 x 等于 y … | | ！= | 不平等 | 如果 x！= y: | 如果 x 不等于 y… | | > | 大于 | 如果 x > y: | 如果 x 大于 y… | | < | 不到 | 如果 x < y: | 如果 x 小于 y… | | >= | 大于或等于 | 如果 x >= y: | 如果 x 大于或等于 y… | | <= | 小于或等于 | 如果 x <= y: | 如果 x 小于或等于 y… |

注意

w3 Schools ¹ 提供了大量的参考资料，可以了解许多不同类型的运营商的更多信息。

检查用户输入

我们新学到的条件语句的一个很大的用途是检查用户输入。让我们试试:

# checking user input
ans = int( input("What is 5 + 5? ") )
if ans == 10:
      print("You got it right!")

去查查那个手机。我们的条件语句检查用户的输入是否等于整数 10。如果是，那么缩进的 print 语句将运行。注意第二行，我们要求用户输入，并立即将他们的答案转换成整数。由于除了之外，我们没有使用 try 和**，输入非数字会导致错误。**

逻辑运算符

逻辑运算符用于组合条件语句。您可以在一个“if 语句”中写尽可能多的条件。根据所使用的逻辑运算符，if 语句可能会运行，也可能不会运行。让我们看看我们可以使用的三个逻辑运算符。

逻辑运算符“与”

、逻辑运算符是为了确保当你检查多个条件时，条件的两边都为真。这意味着如果和左边或右边的条件为假，那么代码将不会运行该代码块。让我们试一个例子:

# using the keyword 'and' in an 'if statement'
x, y, z = 5, 10, 5
if x < y and x == z:
      print("Both statements were true")

去查查那个手机。输出将导致**“两个语句都为真”**，因为 x 小于 y，并且与 z 的值相同。

注意

您可以在一行中包含任意多的条件。

逻辑运算符“或”

或逻辑运算符用于检查的一个或两个条件是否为真。使得如果左边的条件为假，而右边的条件为真，则代码块仍将运行，因为至少有一个条件为真。只有当两个条件都为假时，“if 块”才不会使用或运算符运行。让我们来看一个例子:

# using the keyword 'or' in an 'if statement'
x, y, z = 5, 10, 5
if x < y or x != z:
      print("One or both statements were true")

去查查那个手机。请注意，我们得到了输出**“一个或两个陈述为真”**。即使我们的第二个条件为假，这仍然有效，因为 x 等于 z，我们检查它是否不等于它；但是，由于左边的条件为真，所以它运行。

逻辑运算符“非”

在某些情况下，您可能希望检查值的反义词。**“not”**操作符就是为此而使用的。它本质上返回与当前值相反的值。让我们试一试:

# using the keyword 'not' within an 'if statement'
flag = False
if not flag:                  # same as saying if not true
      print("Flag is False")

去查查那个手机。您会注意到结果输出是**“Flag is False”**。这是由于*“非”*操作符，它取 False 的相反值，并使条件返回 True。

注意

如果我们写“ if flag == False: ”，我们会得到相同的结果。

成员运算符

成员运算符用于测试序列是否出现在对象中。有两个关键字可以用来检查一个值是否存在于一个对象中。我们去看看。

成员运算符“in”

当你想检查一个给定的对象是否有一个值出现在其中，你可以使用操作符中的**。最好的用例是检查字符串中的某个值。让我们来看一个例子:**

# using the keyword 'in' within an 'if statement'
word = "Baseball"
if "b" in word:
      print( "{ } contains the character b".format(word) )

去查查那个手机。结果输出是**“棒球包含字符 b”**。这是区分大小写的，但幸运的是，单词 Baseball 有一个小写字母和一个大写字母 b。

成员运算符“不在”

同样，如果你想检查一个对象是否不包含一个特定的值，你可以使用 "not in" 操作符。本质上，这只是检查与“操作符中的“??”相反的操作。让我们看看:

# using the keyword 'not in' within an 'if statement'
word = "Baseball"
if "x" not in word:
      print( "{ } does not contain the character x".format(word) )

去查查那个手机。得到的输出是**“棒球不包含字符 x”**。它只是检查字符 x 是否不包含在我们的 word 变量的字符串值中。

星期二练习

1. **检查包含性-第一部分:**要求用户输入，并检查他们所写的内容是否包含“ es ”。

2. 检查包含性-第二部分:要求用户输入，并检查他们所写的内容是否在结尾有一个“ ing ”。提示:使用切片。

3. 检查相等:让用户输入两个单词，写一个条件语句检查两个单词是否相同。不区分大小写，这样大写字母就不重要了。

4. 返回指数:要求用户输入一个数，如果小于 10，返回该数的平方。提示:研究指数的算术表达式。

今天是关于条件语句的重要一课。对任何程序来说，让计算机做出决定并根据决定采取行动的能力都是非常重要的。

星期三:Elif 声明

条件语句给了我们在程序中做决定的权力，但是到目前为止，我们只看到了它们的一瞥。今天，我们将学习所有关于 elif 语句的知识。它们让我们能够根据情况运行单独的代码块。它们也被称为 else if 语句。

为了继续本课，让我们从之前的笔记本文件“ Week_03 ”继续，并在底部添加一个标有“ Elif 语句”的降价单元格。

它们是如何工作的

正如我们在上一课中看到的，条件语句赋予我们在程序中做决定的能力；然而，你如何处理多重决策？在 Python 中，我们使用 elif 语句来声明基于给定条件的另一个决策。 Elif 语句必须与一个 if 语句相关联，这意味着没有 if 就不能创建一个 elif 。Python 按照从上到下的顺序工作，所以它检查第一个 if 语句；如果该语句为假，则继续第一个 elif 语句并检查该条件。如果该条件也返回 False，它将继续执行下一个条件语句，直到不再需要检查。但是，一旦单个条件语句返回 True，所有其他条件都会被跳过，即使它们为 True。它的工作原理是，第一个返回 True 的条件是唯一运行的代码块。

撰写您的第一份 Elif 陈述

创建一个 elif 语句与一个 if 语句是相同的，除了一点不同，您使用了 elif 关键字。你也可以为每个 elif 设置多个条件。让我们来试试:

# using the elif conditional statement
x, y = 5, 10
if x > y:
      print("x is greater")
elif x < y:
      print("x is less")

去查查那个手机。注意，输出是**“x 较小”**。它检查了初始的 if 语句，但是由于返回 False，它继续执行 elif 条件语句。该语句返回 True，其中的代码块运行。

检查多个 Elif 条件

基于单个变量编写多个决策的能力是必要的，这也是构建 elif 语句的原因。以下面的代码为例:

# checking more than one elif conditional statement
x, y = 5, 10
if x > y:
      print("x is greater")
elif (x + 10) < y:                    # checking if 15 is less than 10
      print("x is less")
elif (x + 5) == y:                    # checking if 10 is equal to 10
      print("equal")

去查查那个手机。得到的输出是**“等于”。第一个 if 和 elif 语句都返回 False，但是第二个 elif 语句返回 True，这就是该代码块运行的原因。您可以拥有任意多的elif**，但是它们必须与一个 if 语句相关联。

注意

在条件中，我们执行加法，但是我们把它放在括号中，这样它首先执行数学运算。

条件句中的条件句

我们已经了解了 Python 如何使用缩进来分隔代码块。到目前为止，我们只看到了一个缩进层次，但是如果我们在一个 if 语句中添加一个 if 语句会怎么样呢？

# writing multiple conditionals within each other - multiple block levels
x, y, z = 5, 10, 5
if x > y:
      print("greater")
elif x <= y:
      if x == z:
              print("x is equal to z")       # resulting output
      elif x != z:
              print("x is not equal to z")   # won't get hit

去查查那个手机。输出结果在**“x 等于 z”**。分解一下，最初的 if 语句返回 False，下一个 elif 语句返回 True，所以它运行那个块。现在，该块内部是另一个条件语句，所以它检查返回 True 的第一个 if 语句，并运行其中的代码块。

If 语句与 Elif 语句

您需要理解的一个主要区别是使用 elif 语句而不是使用多个 if 语句。所有的 elif 语句都连接到一个原始的 if 语句，这样一旦一个条件为真，其余的就不会运行。让我们看一个例子:

# testing output of two if statements in a row that are both true
x, y, z = 5, 10, 5
if x < y:
      print("x is less")
if x == z:
      print("x is equal")

去查查那个手机。注意，这里产生的输出都是打印语句。这部分是因为有两个 if 语句。这些 if 语句互不相关；它们是独立的条件语句，而一个 elif 总是连接到一个 if 。

# testing output of an if and elif statement that are both true
x, y, z = 5, 10, 5
if x < y:
      print("x is less")
elif x == z:
      print("x is equal to z")

去查查那个手机。注意，这里的输出只有**“x 小于”**，不包括第二个打印语句。那是因为一个 elif 附加在一个 if 语句上，一旦其中一个条件返回 True，那么其他所有条件即使本身为 True 也不会被检查。

周三练习

1. 升高/降低:要求用户输入一个数字。键入 convert 这个数字，并使用 if/elif 语句打印它是大于还是小于 100。

2. 寻找解决方案:给定下面的代码，修复任何/所有错误，使其输出“更低”:

x, y = 5, 10
if x > y:
      print("greater")
try x < y:
      print("lower")

今天是创建一个为我们做决定的程序的第二步，不是一个决定，而是多个决定。

星期四:Else 语句

任何好的决策的第三也是最后一部分是默认情况下做什么。在 Python 中，我们知道它们是 else 语句。今天的课很短，但对进一步理解条件语句是必要的。

为了继续本课，让我们从之前的笔记本文件“ Week_03 ”继续，并在底部添加一个标有“ Else 语句”的降价单元格。

它们是如何工作的

Else 条件语句是end all beif 语句的 all 。有时你无法为你想做的每个决定创造条件，所以这就是 else 语句有用的地方。 else 语句将涵盖所有未涵盖的其他可能性，并且如果程序到达该处，将始终运行该代码。这意味着如果一个 elif 或 if 语句返回 True，那么它将永远不会运行else；然而，如果它们都返回 False，那么无论什么时候，else 子句都会运行。同样，在代码中更容易看到它；我们试试吧！

编写第一条 Else 语句

像一个 elif 语句一样， else 子句需要总是与一个原始的 if 语句相关联。 else 子句涵盖了所有其他可能性，所以根本不需要写条件；您只需要提供关键字**“else”**，后跟一个结束冒号。请记住，如果程序到达语句，else 子句将运行其中的代码。尝试以下方法:

# using an else statement
name = "John"
if name == "Jacob":
      print("Hello Jacob!")
else:
      print("Hello { }!".format(name) )

去查查那个手机。注意这里的输出是**“你好 John”**。第一个 if 语句返回 False，所以一旦它到达 *else 子句，*就会运行其中的打印语句。

完整的条件语句

现在我们已经讨论了条件语句的所有三个部分，让我们继续尝试在一个语句中同时使用这三个部分:

# writing a full conditional statement with if, elif, else
name = "John"
if name[0] == "A":
      print("Name starts with an A")
elif name[0] == "B":
      print("Name starts with a B")
elif name[0] == "J":
      print("Name starts with a J")
else:                                 # covers all other possibilities
      print( "Name starts with a { }".format( name[0] ) )

去查查那个手机。得到的输出是 "Name 以 J" 开头，由第二个 elif 语句输出。第一个 if 和 elif 语句返回 False，所以它们的代码块没有运行。一旦第二个 elif 语句返回 True 并运行它自己的代码，那么 else 语句将被跳过而不运行。记住索引从 0 开始，所以通过在名称变量后使用括号符号访问字符串内的第一个元素。

注意

如果您在理解括号符号方面有困难，请务必回头查看关于字符串索引的部分。

周四练习

1. 修复错误:给定以下代码，修复任何/所有错误，使其正确输出*“你好约翰”*:

   >>> name = "John"
   >>> if name == "Jack":
   >>>           print("Hello Jack")
   >>> elif:
   >>>>          print("Hello John")
   
   

2. 用户输入:要求用户输入不带冒号的军用时间(1100 =上午 11:00)。编写一个条件语句，使其输出以下内容:

   1. 早上好如果不到 1200

   2. "下午好"如果在 1200 和 1700 之间

   3. "晚上好"如果等于或高于 1700

今天我们学习了所有关于 else 语句的内容。现在，您可以构建能够在给定条件下生成代码的程序。

星期五:创建计算器

上周我们一起开发了一个收据打印程序。根据本周的经验，我们将构建一个简单的计算器，它接受用户输入并输出正确的结果。

为了跟上这一课，让我们从之前的笔记本文件“ Week_03 ”继续，并在底部添加一个减价单元格，内容为“星期五项目:创建一个计算器”。

完工图纸

每个星期，我们总是想设计出最终的设计。由于本周的主题是逻辑而非外观，我们将列出构建计算器的必要步骤:

1. 询问用户他们想要执行的计算。

2. 向用户询问他们想要运行操作的号码。

3. 为数学运算设置 try/except 子句。

   1. 将数字输入转换成浮点数。

   2. 执行操作并打印结果。

   3. 如果遇到异常，打印错误。

步骤#1:要求用户进行计算

对于其中的每一步，让我们将代码放在单独的单元格中。这将允许我们对项目的具体步骤进行分段，使得测试每个步骤变得更加容易。第一步是要求用户输入要执行的数学运算(加、减等。):

# step 1: ask user for calculation to be performed
operation = input("Would you like to add/subtract/multiply/divide? ").lower( )
print( "You chose { }.".format(operation) )   # for testing purposes

去查查那个手机。根据用户输入的内容，您的输出将打印他们选择的内容。您会注意到，在我们接受输入的那一行，我们也立即将其转换为小写。这是为了避免以后出现区分大小写的问题。我们的打印声明仅用于对该单元进行测试，稍后将被删除。

第二步:询问数字，提醒订单问题

在步骤#1 下面的单元格中，我们需要创建逻辑的下一步。这里，我们要求用户输入几个数字，并输出这些数字以供测试之用:

# step 2: ask for numbers, alert order matters for subtracting and dividing
if operation == "subtract" or operation == "divide":
      print( "You chose { }.".format(operation) )
      print("Please keep in mind that the order of your numbers matter.")
num1 = input("What is the first number? ")
num2 = input("What is the second number? ")
print( "First Number: { }".format(num1) )   # for testing purposes
print( "Second Number: { }".format(num2) )   # for testing purposes

去查查那个手机。请注意，我们在 print 语句中警告用户，如果他们选择减法或除法，数字的顺序很重要。这很重要，因为 num1 总是在操作符的左边(在我们的程序中是 ??)，这有很大的不同。

注意

如果出现未定义的错误，请重新运行上一个单元格。

步骤 3:设置数学运算的 Try/Except

第三步，也是最后一步，是尝试执行操作。这里设置 try/except 块的原因是因为我们必须将用户的输入转换成浮点数据类型。我们必须假设他们可能没有输入正确的输入。让我们看看这个细胞是如何工作的:

# step 3: setup try/except for mathematical operation
try:
       # step 3a: immediately try to convert numbers input to floats
       num1, num2 = float(num1), float(num2)
       # step 3b: perform operation and print result
       if operation == "add":
               result = num1 + num2
               print( "{ } + { } = { }".format(num1, num2, result) )
       elif operation == "subtract":
               result = num1 - num2
               print( "{ } - { } = { }".format(num1, num2, result) )
       elif operation == "multiply":
               result = num1 * num2
               print( "{ } * { } = { }".format(num1, num2, result) )
       elif operation == "divide":
               result = num1 / num2

               print( "{ } / { } = { }".format(num1, num2, result) )
       else:
               # else will be hit if they didn't chose an option correctly
               print("Sorry, but '{ }' is not an option.".format(operation) )
except:
       # steb 3c: print error
       print("Error: Improper numbers used. Please try again.")

去查查那个手机。这里发生了很多事情，所以让我们从头开始。我们设置了一个 try 块，并立即将用户的输入转换成浮点数。如果这导致一个错误，那么 except 子句将被命中并输出一个错误发生而不是程序中断。如果输入可以转换，那么我们设置一个 if/elif/else 语句来执行计算并输出正确的结果。如果他们没有输入正确的操作，我们会让他们知道。此单元格依赖于前两个。如果出现错误，请重新运行以前的单元格。

最终输出

既然我们已经在三个独立的单元中为我们的程序创建了逻辑，现在我们可以把它们放在一个单元中。让我们删除所有的测试打印语句。实际上，您可以将三个单元格中的所有代码粘贴到一个单元格中，结果如下:

# step 1: ask user for calculation to be performed
operation = input("Would you like to add/subtract/multiply/divide? ").lower( )
# step 2: ask for numbers, alert order matters for subtracting and dividing
if operation == "subtract" or operation == "divide":
      print( "You chose { }.".format(operation) )
      print("Please keep in mind that the order of your numbers matter.")
num1 = input("What is the first number? ")
num2 = input("What is the second number? ")
# step 3: setup try/except for mathematical operation
try:
      # step 3a: immediately try to convert numbers input to floats
      num1, num2 = float(num1), float(num2)
      # step 3b: perform operation and print result
      if operation == "add":
            result = num1 + num2
            print( "{ } + { } = { }".format(num1, num2, result) )
      elif operation == "subtract":
            result = num1 - num2
            print( "{ } - { } = { }".format(num1, num2, result) )
      elif operation == "multiply":
            result = num1 * num2

            print( "{ } * { } = { }".format(num1, num2, result) )
      elif operation == "divide":
            result = num1 / num2
            print( "{ } / { } = { }".format(num1, num2, result) )
      else:
            # else will be hit if they didn't chose an option correctly
            print("Sorry, but '{ }' is not an option.".format(operation) )
except:
      # steb 3c: print error
      print("Error: Improper numbers used. Please try again.")

去查查那个手机。现在，您可以运行单个单元来让我们的程序从头到尾正常工作。它并不完美，但它给了你进行简单计算的能力。一如既往的尝试打破程序，改一句绕一句，变成自己的。

祝贺你完成了另一个项目！尽管这个计算器可能很简单，但我们已经展示了使用逻辑、接受用户输入并转换它以及检查错误的能力。

每周总结

多好的一周啊！我们刚刚看到了如何与用户进行交互，以及如何执行分支语句。这将允许我们用逻辑构建项目，它将根据程序使用的信息执行特定的代码。这里要记住的最重要的概念是我们的条件语句和 try/except 块。了解捕捉错误和导致程序崩溃的错误之间的区别很重要。我们总是想尽可能地捕捉错误，以确保我们的程序。下周我们将学习循环，以及如何一遍又一遍地连续运行代码块，直到我们不想再运行为止。

挑战问题解决方案

如果您要运行质询问题的代码块，您会发现它会产生一个错误。这是因为我们试图在声明“元素”变量之前访问它。如果你要颠倒这两条线，程序将按预期工作。

每周挑战

要测试你的技能，请尝试以下挑战:

1. 反转数字:改变计算器项目，使数字的顺序无关紧要。有几种方法可以得到相同的结果；一种方法是询问用户是否愿意颠倒数字的位置。

2. 年龄组:要求用户输入自己的年龄。根据他们的输入，输出以下组之一:

   1. 介于 0 和 12 之间= "Kid "

   2. 13 至 19 岁之间=“青少年”

   3. 20 至 30 岁之间=“年轻人”

   4. 31 至 64 岁之间=“成人”

   5. 65 岁或以上=“高级”

3. 基于文本的 RPG :这是一个开放式的练习。创建一个基于文本的 RPG，并有一个故事线。你接受用户的输入，给他们几个选择，根据他们的选择，他们可以选择不同的道路。根据故事的长度，你将使用几个分支语句。

Footnotes 1

www . w3schools . com/python/python _ operators . ASP