Skip to content

01.md

Latest commit

 

History

History
1125 lines (721 loc) · 35.5 KB

01.md

File metadata and controls

1125 lines (721 loc) · 35.5 KB

一、开始

在本章中，我们将介绍在 Windows、Ubuntu Linux 和 macOS 系统上获取和安装 Python。我们还将编写第一个基本的 Python 代码，熟悉 Python 编程文化的基本要素，如 Python 的禅宗，同时永远不会忘记语言名称的滑稽起源。

获取和安装 Python3

Python 语言有两个主要版本，Python 2是广泛部署的遗留语言，Python 3是该语言的现在和未来。在 Python2 的最新版本（即Python2.7]（）之间，许多 Python 代码都可以在不进行修改的情况下工作 https://www.python.org/download/releases/2.7/ ）和Python 3的最新版本，如Python 3.5（https://www.python.org/download/releases/3.5.1/ 。但是，主要版本之间存在一些关键差异，从严格意义上讲，这些语言是不兼容的。本书将使用 Python 3.5，但我们将指出与 Python 2 的关键差异。此外，作为一本关于 Python 基础知识的书，我们现在介绍的所有内容都将应用于未来版本的 Python3，所以当它们可用时，不要害怕尝试它们。

在开始用 Python 编程之前，我们需要掌握 Python 环境。Python 是一种高度可移植的语言，可以在所有主要的操作系统上使用。您将能够在 Windows、Mac 或 Linux 上阅读这本书，接下来我们将讨论平台细节的唯一主要部分——安装 Python3。在我们介绍这三个平台时，请随意跳过与您无关的部分。

窗户

以下是针对 Windows 平台执行的步骤：

  1. 对于 Windows，您需要访问Python 官方网站，然后点击左侧的链接进入下载页面。对于 Windows，您应该根据是在 32 位还是 64 位平台上运行，选择 MSI 安装程序之一。

  2. 下载并运行安装程序。

  3. 在安装程序中，决定是只为自己安装 Python，还是为机器的所有用户安装 Python。

  4. 为 Python 发行版选择一个位置。默认设置在C:驱动器根目录下的 C:\Python35中。我们不建议将 Python 安装到程序文件中，因为在 Windows Vista 中，虚拟化文件存储区用于 将应用程序彼此隔离，之后可能会干扰 轻松安装第三方 Python 软件包。

  5. 在向导的定制 Python 页面上，我们建议保留 默认值，它使用的空间小于 40 MB。

  6. 除了安装 Python 运行时和标准库之外，安装程序还将向 Python 解释器注册各种文件类型，例如*.py文件。

  7. 一旦安装了 Python，就需要将 Python 添加到系统PATH环境变量中。为此，从控制面板中选择系统和安全性，然后选择系统。另一种轻松到达这里的方法是按住 Windows 键并按键盘上的中断键。使用左侧的任务窗格，选择“高级系统设置”打开“系统属性”对话框的“高级”选项卡。单击环境变量以打开子对话框。

  8. 如果您具有管理员权限，您应该能够将路径 C:\Python35和C:\Python35\Scripts添加到与PATH系统变量关联的 条目的分号分隔列表中。如果没有，您应该能够 创建或附加一个特定于您的用户 的包含相同值的PATH变量。

  9. 现在打开一个新的控制台窗口——Powershell 或 cmd 都可以正常工作 ——并验证您可以从命令行运行 python：

> python
Python 3.5.0 (v3.5.0:374f501f4567, Sep 13 2015, 02:27:37) [MSC v.1900 64 bit (AMD64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>

欢迎来到 Python！

三重箭头提示显示 Python 正在等待您的输入。

此时，您可能希望跳过前面的内容，同时我们将演示如何在 Mac 和 Linux 上安装 Python。

马科斯

  1. 对于 macOS，您需要访问 Python 官方网站http://python.org 。点击左边的链接进入Download页面。在Download页面上，找到与您的 macOS 版本相匹配的 macOS 安装程序，然后单击链接下载。

  2. 下载 DMG 磁盘映像文件，您可以从下载堆栈 或查找器打开该文件。

  3. 在打开的 Finder 窗口中，您将看到文件Python.mpkg 多包安装程序文件。使用“辅助”点击action打开该文件的 上下文菜单。从该菜单中，选择“打开”。

  4. 在某些版本的 macOS 上，您现在会被告知该文件来自一位身份不明的开发人员。按此对话框上的打开按钮继续 安装。

  5. 现在您已进入 Python 安装程序。按照说明，单击向导。

  6. 不需要定制安装，您应该保留标准的 设置。可用时，单击Install按钮安装 Python。 可能会要求您输入密码以授权安装。 安装完成后，单击Close关闭安装程序。

  7. 现在安装了 Python 3，打开一个终端窗口并验证您 可以从命令行运行 Python 3：

> python
Python 3.5.0 (default, Nov 3 2015, 13:17:02) 
[GCC 4.2.1 Compatible Apple LLVM 6.1.0 (clang-602.0.53)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>>

欢迎来到 Python！

三个箭头提示显示 Python 正在等待您的输入。

Linux

  1. 要在 Linux 上安装 Python，您需要使用系统的软件包 管理器。我们将展示如何在最新版本的 Ubuntu 上安装 Python，但在大多数其他现代 Linux 发行版上的过程非常相似。

  2. 在 Ubuntu 上，首先启动 Ubuntu 软件中心。这通常可以通过单击启动器中的图标来运行。或者，您可以通过在 Ubuntu 软件中心上搜索并单击所选内容，从仪表板上运行它。

  3. 进入软件中心后，在右上角的搜索栏中输入搜索词python 3.5，然后按回车键。

  4. 您将得到一个结果，它下面的小字体是Python（v3.5）和Python**解释器（v3.5）。选择此条目并单击出现的Install按钮。

  5. 此时，您可能需要输入密码才能安装软件。

  6. 您现在应该会看到出现一个进度指示器，当安装完成时，该指示器将消失。

  7. 打开一个终端（使用Ctrl+Alt+T）并验证您可以从命令行运行 Python 3.5：

$ python3.5
Python 3.5.0+ (default, Oct 11 2015, 09:05:38)
[GCC 5.2.1 20151010] on linux
Type "help", "copyright", "credits" or "license" for more information.
>>>

欢迎来到 Python！

三重箭头提示显示 Python 正在等待您的输入。

启动 Python 命令行 REPL

现在 Python 已经安装并运行，您可以立即开始使用它了。这是了解该语言的好方法，也是在正常开发过程中进行实验和快速测试的有用工具。

这个 Python 命令行环境是一个读取评估打印循环。Python 将读取我们输入的任何输入，评估评估它，打印结果，然后循环返回开始。你经常会听到它被简单地称为“REPL”。

当启动时，REPL 将打印一些关于您正在运行的 Python 版本的信息，然后它将给您一个三箭头提示。这个提示告诉您 Python 正在等待您键入内容。

在交互式 Python 会话中，您可以输入 Python 程序的片段并查看即时结果。让我们从一些简单的算法开始：

>>> 2 + 2
4
>>> 6 * 7
42

如您所见，Python 读取我们的输入，对其求值，打印结果，然后循环执行同样的操作。

我们可以在 REPL 中为变量赋值：

>>> x = 5

只需键入其名称即可打印其内容：

>>> x
5

在表达式中引用它们：

>>> 3 * x
15

在 REPL 中，可以使用特殊的下划线变量来引用最近打印的值，这是 Python 中为数不多的模糊快捷方式之一：

>>> _
15

也可以在表达式中使用特殊下划线变量：

>>> _ * 2
30

Remember that this useful trick only works at the REPL; the underscore doesn't have any special behavior in Python scripts or programs.

请注意，并非所有语句都有返回值。当我们将5分配给x时，没有返回值，只有引入变量x的副作用。其他声明有更明显的副作用。

请尝试以下命令：

>>> print('Hello, Python')
Hello, Python

您将看到 Python 立即计算并执行该命令，打印字符串Hello, Python并返回另一个提示符。重要的是要理解，这里的响应不是 REPL 评估和显示的表达式的结果，而是print()功能的副作用。

另外，打印是 Python2 和 Python3 之间最大的区别之一。在 Python3 中，括号是必需的，而在 Python2 中则不是。这是因为在 Python 3 中，print()是一个函数调用。稍后将详细介绍函数。

离开 REPL

此时，我们应该向您展示如何退出 REPL 并返回系统 shell 提示符。我们通过向 Python 发送文件结尾控制字符来实现这一点，尽管不幸的是，发送此字符的方式在不同平台上有所不同。

窗户

如果您在 Windows 上，请按Ctrl+Z退出。

Unix

如果您在 Mac 或 Linux 上，请按Ctrl+D退出。

如果您经常在平台之间切换，并且在类 Unix-a 系统上意外按下Ctrl+Z，您将不经意地挂起 Python 解释器并返回操作系统外壳。要通过使 Python 再次成为前台进程来重新激活 Python，只需运行fg命令：

$ fg

现在按回车并多次返回三箭头 Python 提示：

>>>

代码结构和有效缩进

启动 Python 3 解释器：

> python

如果在 Windows 上或：

$ python3

在 Mac 或 Linux 上。

Python 的控制流结构，如for-循环、while-循环和if-语句，都是由以冒号结尾的语句引入的，表示要遵循构造体。例如，for-循环需要一个主体，因此如果您输入：

>>> for i in range(5):
...

Python 将向您提供一个由三个点组成的提示，要求您提供正文。Python 的一个独特（有时也是有争议的）方面是，前导空格在语法上很重要。

这意味着 Python 使用缩进级别，而不是其他语言使用的大括号来划分代码块。按照惯例，当代 Python 代码每一级别缩进四个空格。

因此，当 Python 向我们展示三点提示时，我们将提供这四个空格和一条语句来构成循环体：

...     x = i * 10

我们的循环体将包含第二条语句，因此在下一个三点提示下按 Return 键后，我们将输入另外四个空格，然后调用内置的print()函数：

...     print(x)

要终止我们的区块，我们必须在 REPL 中输入一个空行：

...

块完成后，Python 执行挂起的代码，打印出小于50的10倍数：

0
10
20
30
40

查看整屏 Python 代码，我们可以看到缩进是如何与程序的结构明确匹配的——事实上，必须匹配，如下所示：

Figure 1.1: Whitespaces in the code

即使我们用灰线替换代码，程序的结构也很清楚，如下图所示：

Figure 2.2 : Replaced code with grey lines

每个以冒号结尾的语句都会开始一个新行，并引入一个额外的缩进级别，该级别将一直持续到 dedent 将缩进恢复到以前的级别。缩进的每一级通常是四个空格，尽管稍后我们将更详细地介绍规则。

Python 处理重要空白的方法有三大优势：

  1. 它迫使开发人员在代码块中使用单一级别的缩进。这在任何语言中都被认为是良好的实践，因为它使代码更具可读性。

  2. 带有大量空白的代码不需要被不必要的大括号弄得乱七八糟，也不需要就大括号应该放在哪里进行代码标准的辩论。Python 代码中的所有代码块都很容易识别，每个人都以相同的方式编写它们。

  3. 重要的空白要求作者、Python 运行时系统和未来需要阅读代码的维护人员必须对代码的结构给出一致的解释。因此，从 Python 的角度看，您永远不会有包含块的代码，但从粗略的人类角度看，它看起来不像包含块。

Python 缩进的规则可能看起来很复杂，但实际上它们非常简单：

  • 您使用的空白可以是空格或制表符。普遍的共识是，空格比制表符更可取，四个空格已经成为 Python 社区的标准。

  • 一个基本规则是绝不混合空格和制表符。Python 解释器会抱怨，你的同事会追捕你。

  • 如果您愿意，您可以在不同的时间使用不同数量的缩进。基本规则是相同缩进级别的连续代码行被视为同一代码块的一部分。

  • 这些规则也有一些例外，但它们几乎总是以其他方式与提高代码可读性有关，例如通过在多行上分解必要的长语句。

这种严格的代码格式化方法是按照 Guido 的意图进行编程，或者更恰当地说，是 Guido缩进了编程！高度重视代码质量（如可读性）的理念触及了 Python 文化的核心，我们现在休息一下来探讨这一点。

蟒蛇文化

许多编程语言处于文化运动的中心。他们有自己的社区、价值观、实践和哲学，Python 也不例外。Python 语言本身的开发通过一系列名为Python 增强建议或PEPs的文档进行管理。其中一个名为 PEP8 的 PEP 解释了如何格式化代码，我们在本书中始终遵循其指导原则。例如，PEP8 建议在新的 Python 代码中使用四个空格进行缩进。

另一种被称为 PEP20 的 PEP 被称为“Python 的禅宗”。它引用了 20 条描述 Python 指导原则的格言，其中只有 19 条被写下来。方便的是，Python 的 Zen 永远不会比最近的 Python 解释器更远，因为它总是可以通过键入以下内容从 REPL 访问：

>>> import this
The Zen of Python, by Tim Peters
Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren't special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one-- and preferably only one --obvious way to do it.
Although that way may not be obvious at first unless you're Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it's a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea -- let's do more of those!

在本书中，我们将重点介绍《禅宗时刻》中 Python 禅宗的智慧，以了解它们如何应用于我们所学的内容。正如我们刚刚介绍的，这是我们第一次禅宗时刻的好时机：

Figure 1.1: Moment of zen

随着时间的推移，您将逐渐欣赏 Python 的重要空白，因为它为您的代码带来了优雅，并且您可以轻松阅读他人的。

导入标准库模块

如前所述，Python 附带了一个广泛的标准库，这是 Python 的一个方面，通常被称为电池，包括。标准库的结构为模块，我们将在后面深入讨论这个主题。在此阶段，重要的是要知道您可以通过使用 import 关键字访问标准库模块。

导入模块的基本形式是导入关键字，后跟空格和模块名称。例如，让我们看看如何使用标准库的数学模块来计算平方根。在三个箭头提示下，我们键入以下命令：

>>> import math

由于 import 是一个不返回值的语句，因此如果导入成功，Python 不会打印任何内容，我们会立即返回到提示符。我们可以使用模块的名称，后跟一个点，后跟您需要的模块中属性的名称来访问导入模块的内容。与许多面向对象的语言一样，点运算符用于深入到对象结构中。作为蟒蛇专家，我们知道数学模块包含一个名为sqrt()的函数。让我们尝试使用以下命令：

>>> math.sqrt(81)
9.0

获得帮助

但是，我们如何找出数学模块中还有哪些其他可用的函数呢？

REPL 有一个特殊的功能help()，可以从已提供文档的对象（如标准库模块）检索任何嵌入式文档。

要获得帮助，只需在提示符处键入help：

>>> help
Type help() for interactive help, or help(object) for help about object.

我们将让您在自己的时间探索第一种形式——交互式帮助。这里我们将使用第二个选项，并将数学模块作为需要帮助的对象传递：

>>> help(math)
Help on module math:

NAME
 math

MODULE REFERENCE
 http://docs.python.org/3.3/library/math

 The following documentation is automatically generated from the    
   Python source files. It may be incomplete, incorrect or include 
   features that are considered implementation detail and may vary 
   between Python implementations. When in doubt, consult the module 
   reference at the location listed above.

DESCRIPTION
 This module is always available. It provides access to the
 mathematical functions defined by the C standard.

FUNCTIONS
 acos(...)
 acos(x)

 Return the arc cosine (measured in radians) of x.

您可以使用空格键翻阅帮助，如果您在 Mac 或 Linux 上，请使用箭头键上下滚动。

浏览函数，你会发现有一个数学函数，factorial，用于计算阶乘。按Q退出帮助浏览器，返回 Python REPL。

现在练习使用help()请求有关阶乘函数的特定帮助：

>>> help(math.factorial)
Help on built-in function factorial in module math:

factorial(...)
 factorial(x) -> Integral

 Find x!. Raise a ValueError if x is negative or non-integral.

按Q返回 REPL。

让我们使用factorial()一点。函数接受整数参数并返回整数值：

>>> math.factorial(5)
120
>>> math.factorial(6)
720

注意我们需要如何用模块名称空间限定函数名。这通常是一个很好的实践，因为它非常清楚函数的来源。也就是说，它可能会导致代码过于冗长。

用 math.factorial（）计算水果

让我们使用阶乘来计算有多少种方法可以从一组五个水果中提取三个水果，使用我们在学校学到的一些数学知识：

>>> n = 5
>>> k = 3
>>> math.factorial(n) / (math.factorial(k) * math.factorial(n - k))
10.0

这个简单的表达式对math模块的引用非常冗长。Python import 语句有一种替代形式，允许我们使用 from 关键字将模块中的特定函数引入当前名称空间：

>>> from math import factorial
>>> factorial(n) / (factorial(k) * factorial(n - k))
10.0

这是一个很好的改进，但是对于这样一个简单的表达式来说仍然有点冗长。

import语句的第三种形式允许我们重命名导入的函数。出于可读性或避免名称空间冲突的原因，这可能很有用。尽管该功能很有用，但我们建议不要频繁且明智地使用该功能：

>>> from math import factorial as fac
>>> fac(n) / (fac(k) * fac(n - k))
10.0

不同类型的数字

记住，当我们单独使用factorial()时，它返回一个整数。但是我们上面计算组合的 更复杂的表达式是产生一个浮点数。这是因为我们使用了/，Python 的浮点除法运算符。因为我们知道我们的运算只会返回整数结果，所以我们可以使用 Python 的整数除法运算符//来改进我们的表达式：

>>> from math import factorial as fac
>>> fac(n) // (fac(k) * fac(n - k))
10

值得注意的是，对于n的中等值，许多其他编程语言都会在上述表达式上失败。在大多数编程语言中，常规带符号整数只能存储小于{ParseError: KaTeX parse error: Expected 'EOF', got '}' at position 1: }̲2\times10^{31}}的值：

>>> 2**31 - 1
2147483647

然而，阶乘增长如此之快，以至于 32 位有符号整数中可以容纳的最大阶乘是 12！从 13 岁开始！太大了：

>>> fac(13)
6227020800

在大多数广泛使用的编程语言中，您可能需要更复杂的代码或更复杂的数学来计算从一组 13！中得出 3 个结果的方法有多少！。Python 不会遇到这样的问题，并且可以使用任意大的整数进行计算，这只受计算机内存的限制。为了进一步证明这一点，让我们尝试一个更大的问题，即计算我们可以从100不同的水果中采摘多少对不同的水果（假设我们可以亲手采摘这么多水果！）：

>>> n = 100
>>> k = 2
>>> fac(n) // (fac(k) * fac(n - k))
4950

为了强调该表达式第一项的大小，请计算 100！就其本身而言：

>>> fac(n)
93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000

这个数字甚至比已知宇宙中的原子数量还要大，数字多得可怕。如果像我们一样，您想知道到底有多少位数，我们可以将整数转换为文本字符串，并按如下方式计算其中的字符数：

>>> len(str(fac(n)))
158

那肯定是很多数字。还有很多水果。它还开始展示 Python 的不同数据类型——在本例中是整数、浮点数和文本字符串——如何以自然的方式协同工作。在下一节中，我们将以这一经验为基础，更详细地研究整数、字符串和其他内置类型。

标量数据类型：整数、浮点、无和布尔

Python 附带了许多内置数据类型。这些类型包括原始标量类型（如整数）以及集合类型（如字典）。这些内置类型功能强大，可以单独用于许多编程需求，并且可以用作创建更复杂数据类型的构建块。

我们将介绍的基本内置标量类型有：

  • int-有符号、无限制精度整数
  • float-IEEE 754 浮点数
  • None-一个特殊的、奇异的空值
  • bool-true/false布尔值

现在我们只看它们的基本细节，展示它们的文字形式以及如何创建它们。

int

我们已经看到很多 Python 整数在起作用。Python 整数是有符号的，并且对于所有实际用途来说，其精度是无限的。这意味着它们可以保持的值的大小没有预定义的限制。

Python 中的整数文本通常以十进制形式指定：

>>> 10
10

它们也可以用带有0b前缀的二进制文件指定：

>>> 0b10
2

也可能有一个八进制，前缀为0o：

>>> 0o10
8

如果是十六进制，我们使用0x前缀：

>>> 0x10
16

我们还可以通过调用 int 构造函数来构造整数，int 构造函数可以将其他数值类型（如浮点）转换为整数：

>>> int(3.5)
3

请注意，当使用int构造函数时，舍入总是朝着零：

>>> int(-3.5)
-3
>>> int(3.5)
3

我们还可以将字符串转换为整数，如下所示：

>>> int("496")
496

但是，请注意，如果字符串不表示整数，Python 将抛出异常（稍后将对此进行更多讨论！）。

从字符串转换时，您甚至可以提供可选的基数。例如，要从基 3 转换，只需将 3 作为第二个参数传递给构造函数：

>>> int("10000", 3)
81

浮动

Python 中的浮点数类型支持浮点数。Python 浮点实现为具有 53 位二进制精度的IEEE-754 双精度浮点数字。这相当于十进制中的 15 到 16 位有效数字。

Python 将任何包含小数点的文字数字解释为float：

3.125

可以使用科学记数法，因此对于较大的数字，例如{ParseError: KaTeX\ parse error: Expected 'EOF', got '}' at position 1: }̲3\times10^8{/}，以米/秒为单位的光速，我们可以写：

>>> 3e8
300000000.0

对于像普朗克常数{ParseError: KaTeX parse error:\ Expected 'EOF', got '}' at position 1: }̲1.616\times10^}这样的小数值，我们可以输入：

>>> 1.616e-35
1.616e-35

请注意 Python 如何自动将显示模式切换为可读性最高的形式。

对于整数，我们可以使用float构造函数将其他数字或字符串类型转换为浮点。例如，构造函数可以接受一个int：

>>> float(7)
7.0

float构造函数也可以接受如下字符串：

>>> float("1.618")
1.618

特殊浮点值

通过将某些字符串传递给浮点构造函数，我们可以创建特殊的浮点值NaN（缩写为Nota****N编号）以及正负无穷大：

>>> float("nan")
nan
>>> float("inf")
inf
>>> float("-inf")
-inf

推广浮动

任何涉及int和浮动的计算结果都会提升为浮动：

>>> 3.0 + 1
4.0

您可以在Python文档中阅读有关 Python 数字类型的更多信息。

没有一个

Python 有一个称为None的特殊空值，用大写字母 N 拼写。None常用来表示没有值。Python REPL 从不打印 None 结果，因此在 REPL 中键入None无效：

>>> None
>>>

空值None可以像任何其他对象一样绑定到变量名：

>>> a = None

我们可以使用 Python 的 is 操作符测试对象是否为None：

>>> a is None
True

我们可以在这里看到响应是True，这方便地将我们带到bool类型。

布尔

bool类型表示逻辑状态，在 Python 的几个控制流结构中起着重要作用，我们将很快看到。正如您所料，有两个bool值，True和False，都用大写字母拼写：

>>> True
True
>>> False
False

还有一个bool构造函数，可用于从其他类型转换为bool。让我们看看它是如何工作的。对于ints，零被视为假和所有其他值真：

>>> bool(0)
False
>>> bool(42)
True
>>> bool(-1)
True

我们看到浮点数的相同行为，其中只有零被视为错误：

>>> bool(0.0)
False
>>> bool(0.207)
True
>>> bool(-1.117)
True
>>> bool(float("NaN"))
True

从集合（如字符串或列表）转换时，只有空集合被视为假集合。当从列表转换时（稍后我们将看到），我们看到只有空列表（此处以[]的文字形式显示）计算为False：

>>> bool([])
False
>>> bool([1, 5, 9])
True

类似地，对于字符串，当 传递给bool时，只有空字符串""计算为False：

>>> bool("")
False
>>> bool("Spam")
True

特别是，不能使用 bool 构造函数从True和False的字符串表示形式转换：

>>> bool("False")
True

因为字符串False不是空的，所以它将计算为True。这些到bool的转换非常重要，因为它们在 Python if-语句和while-循环中广泛使用，这些循环在其条件下接受bool值。

关系运算符

布尔值通常由 Python 的关系运算符生成，可用于比较对象。最广泛使用的两个关系运算符是 Python 的相等和不相等测试，它们实际上测试值的等价性或不等价性。也就是说，如果一个对象可以用来代替另一个对象，那么两个对象是等价的。我们将在本书后面了解更多关于对象等价的概念。现在，我们将比较简单的整数。

让我们先给变量g赋值或绑定一个值：

>>> g = 20

我们测试与==是否相等，如下命令所示：

>>> g == 20
True
>>> g == 13
False

对于不平等性，我们使用!=：

>>> g != 20
False
>>> g != 13
True

富比较运算符

我们还可以使用丰富的比较运算符来比较数量的顺序。使用<确定第一个参数是否小于第二个参数：

>>> g < 30
True

同样，使用>确定第一个是否大于第二个：

>>> g > 30
False

您可以使用<=测试小于或等于：

>>> g <= 20
True

我们可以将大于或等于与>=一起使用，如下所示：

>>> g >= 20
True

如果您有使用其他语言的关系运算符的经验，那么 Python 的运算符可能一点也不奇怪。请记住，这些运算符是在比较等价性，而不是恒等性，我们将在接下来的章节中详细介绍这一区别。

控制流：if 语句和 while 循环

现在我们已经检查了一些基本的内置类型，让我们看看两个重要的控制流结构，它们依赖于到bool类型的转换：if-语句和while-循环。

条件控制流：if 语句

条件语句允许我们根据表达式的值来分支执行。语句的形式是if关键字，后跟表达式，以冒号结尾以引入新块。让我们在 REPL 上试试这个：

>>> if True:

记住在块中缩进四个空格，如果条件为True，我们会添加一些要执行的代码，然后是一个空行来终止块：

...     print("It's true!")
...
It's true!

此时将执行块，因为不言而喻，条件为真。相反，如果条件为False，则块中的代码不执行：

>>> if False:
...     print("It's true!")
...
>>>

与if-语句一起使用的表达式将转换为bool，就像使用了bool()构造函数一样，因此：

>>> if bool("eggs"):
...     print("Yes please!")
...
Yes please!

如果该值正好等于某个值，那么我们将使用如下的if命令：

>>> if "eggs":
...     print("Yes please!")
...
Yes please!

由于这种有用的简写，Python 中很少使用使用bool构造函数显式转换为bool。

如果……否则

if-语句支持可选的else子句，该子句位于由else关键字（后跟冒号）引入的块中，该块缩进到与if关键字相同的级别。让我们从创建（但不是完成）一个if块开始：

>>> h = 42
>>> if h > 50:
...     print("Greater than 50")

在这种情况下，为了启动else块，我们只需省略三个点后的缩进：

... else:
...     print("50 or smaller")
...
50 or smaller

如果…以利夫…其他

对于多种情况，您可能会尝试执行以下操作：

>>> if h > 50:
...     print("Greater than 50")
... else:
...     if h < 20:
...         print("Less than 20")
...     else:
...         print("Between 20 and 50")
...
Between 20 and 50

每当你发现你自己有一个包含一个嵌套的 AutoT1^语句的 AutoT0}块时，你就应该考虑使用 Python 的 PosiT2A.关键字，这是一个组合的 Ty3T3。

正如 Python 的禅宗提醒我们的那样，扁平比嵌套的好：

>>> if h > 50:
...     print("Greater than 50")
... elif h < 20:
...     print("Less than 20")
... else:
...      print("Between 20 and 50")
...
Between 20 and 50

这个版本更容易阅读。

条件重复：while 循环

Python 有两种类型的循环：for-循环和while-循环。当我们引入重要的空白时，我们已经简要地遇到了for-循环，我们很快就会回到它们，但现在我们将讨论while-循环。

Python 中的While-循环由 while 关键字引入，后跟一个布尔表达式。与if语句的条件一样，表达式被隐式转换为布尔值，就好像它已被传递给bool()构造函数一样。while语句以冒号结尾，因为它引入了一个新块。

让我们在 REPL 处写一个循环，从 5 倒计时到 1。我们将一个名为c的计数器变量初始化为 5，并继续循环直到达到零。这里另一个新的语言特性是使用增广赋值运算符-=，在每次迭代时从计数器的值中减去一。对于其他基本数学运算（如加法和乘法），也存在类似的增广赋值运算符：

>>> c = 5
>>> while c != 0:
...     print(c)
...     c -= 1
...
5
4
3
2
1

因为条件或谓词将隐式转换为bool，就像存在对bool()构造函数的调用一样，我们可以用以下版本替换上述代码：

>>> c = 5
>>> while c:
...     print(c)
...     c -= 1
...
5
4
3
2
1

这是因为将整数值c转换为bool会导致True，直到我们达到零，这将转换为False。这就是说，在本例中使用这个简短的形式可能被描述为非 Pythonic，因为回顾 Python 的禅，显式比隐式好。我们认为第一种形式的可读性高于第二种形式的简洁性。

While-循环通常在 Python 中使用，其中需要无限循环。我们只需将True作为谓词表达式传递给 while 构造即可实现这一点：

>>> while True:
...     print("Looping!")
...
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!
Looping!

现在，您可能想知道我们如何摆脱这个循环，重新获得对 REPL 的控制！只需按Ctrl+C:

Looping!
Looping!
Looping!
Looping!
Looping!
Looping!^C
Traceback (most recent call last):
File "<stdin>", line 2, in <module>
KeyboardInterrupt
>>>

Python 截取键笔划并引发一个特殊异常，该异常终止循环。我们将在后面的第 6 章、异常中更多地讨论什么是异常以及如何使用它们。

带中断的退出循环

许多编程语言都支持循环构造，它将谓词测试放在循环的末尾而不是开头。例如，C、C++、C 和 java 支持了 TyrT0p 构造。其他语言也有 repeat-till 循环。Python 中的情况并非如此，习惯用法是使用while True和提前退出，这是由 break 语句促成的。

break语句跳出循环—如果嵌套了几个循环，则只跳出最里面的循环—在循环体之后立即继续执行。

让我们看一下break的一个示例，在此过程中介绍了一些其他 Python 特性，并逐行检查：

>>> while True:
...     response = input()
...     if int(response) % 7 == 0:
...         break
...

我们从一段时间True开始：无限循环。在 while 块的第一条语句中，我们使用内置的input()函数向用户请求字符串。我们将该字符串赋给一个名为 response 的变量。

我们现在使用一个if-语句来测试提供的值是否可以被 7 整除。我们使用int()构造函数将响应字符串转换为整数，然后使用模运算符（%）除以 7 并给出余数。如果余数等于零，则响应可被 7 整除，我们进入if块体。

在if块中，现在有两级缩进深度，我们从八个空格开始，并使用 break 关键字。break 终止最内部的循环（在本例中为while-loop），并导致执行跳转到循环后的第一条语句。

在这里，语句是程序的结束。我们在三点提示下输入一个空行，以关闭if块和while块。我们的循环将开始执行，并在调用input()时暂停，等待我们输入一个数字。让我们试一下：

12
67
34
28
>>>

一旦我们输入一个可被 7 整除的数字，谓词变为真，我们就输入if-块，然后我们从循环中直接break到程序结束，返回 REPL 提示符。

总结

  • 从 Python 开始

    • 获取和安装 Python3

    • 启动读取评估打印循环或 REPL

    • 简单算法

    • 通过将对象绑定到名称来创建变量

    • 内置print()功能打印

    • 使用Ctrl+Z（Windows）或Ctrl+D（Unix）退出 REPL

  • 肾盂

    • 显著压痕

    • PEP 8-Python 代码的样式指南

    • PEP 20-Python 的禅宗

  • 以各种形式导入带有导入语句的模块

  • 查找和浏览help()

  • 基本类型和控制流程

    • ints、floats、None和bool，加上它们之间的转换

    • 等式和顺序测试的关系运算符

    • 带 else 和elif块的if-语句

    • while循环隐式转换为 bool

    • 使用Ctrl+C中断无限循环

    • 用 break 打破循环

  • 使用input()向用户请求文本

  • 增广赋值算子