吃透Python-第 1 章 开始学习 Python 吧

吃透Python-第 1 章　开始学习 Python 吧

让我们开启 Python 的学习之旅吧！本章，我将讲解 Python 的特点和它的基础内容。

Python 是什么
执行 Python 程序
交互式 shell（基本会话模式）
运算符和操作数
一元运算符和二元运算符
基本算术运算符
运算符的优先级
类型和 type 函数
数值型
整型（int 型）/浮点型（float 型）/复数型（complex 型）
数值字面量
整数字面量（二进制/八进制/十进制/十六进制）和浮点数字面量
字符串
字符串字面量和原始字符串字面量
转义字符
变量
赋值语句
使用\延续代码到下一行
Python 之禅（The Zen of Python）

1-1　Python 是什么

首先介绍一下 Python 的特点和它的历史。

关于 Python
　　程序是驱动计算机的指令的集合，计算机正是通过程序来完成各种处理的。

用于系统描述程序的人工语言叫作编程语言（programming language）。

现在我们要学习的 Python 是由荷兰的吉多·范罗苏姆（Guido van Rossum）开发的编程语言。Python 这个名字来源于英国广播公司（British Broadcasting Corporation，BBC）制作的电视喜剧片《蒙提·派森的飞行马戏团》（Monty Python’s Flying Circus）。

▶ 英语单词 python 是名词，意思是蟒蛇，所以 Python 的商标也使用了蛇的图案（图 1-1）。

图 1-1　Python 的商标

现在，Python 的开发和维护由 Python 软件基金会（Python Software Foundation）负责。我们可以从以下网站获取 Python 的相关信息。

Python 的基本信息：Python 官网

可从该网站下载 Python。

中文信息：Python 中国社区（PyChina）

Python 中国社区的主页，该网站用中文发布相关信息。

在 Python 官网的首页通过 Documentation 和 Python Docs 按钮进入文档列表并选择语言后，即可查看中文版的 Python 入门教程、标准库参考、语言参考和常见问题等文档。

Python 的特点
　　本书在说明 Python 的特点时会用到一些专业术语。在当前阶段，即使大家有不理解的内容也没有关系。

免费的开源软件

Python 可免费使用且其源代码公开（即公开了 Python 自身的开发方法），所以我们不仅能使用 Python 开发程序，还能阅读和学习 Python 的内部机制。

 

多平台运行

Python 可在 Windows、macOS 和 Linux 等平台上运行。

 

文档丰富

互联网上有入门教程等在线文档可供大家学习和参考。

 

适用于众多领域的通用语言

无论是哪种编程语言，都不可能适用于所有领域。编程语言各自有擅长的领域，有的擅长数值计算，有的擅长数据库和事务处理。

从这方面来说，Python 可以说是一个“全能型选手”。

因为 Python 不仅擅长机器学习和深度学习等人工智能领域，还擅长数据分析、科学计算、Web 应用程序和 GUI（Graphical User Interface，图形用户界面）等领域。

不仅如此，Python 还具有胶水语言的特性，能轻易地与用其他编程语言开发的程序组合在一起。因此，针对 Python 不擅长的领域，开发人员也可以利用其他擅长该领域的编程语言编写程序，然后配合 Python 进行开发。

另外，在教学一线也有越来越多的人将 Python 指定为必学编程语言。

 

支持各种编程范式

在开发程序时，我们可以用各种编程范式来表达编程的基本思想、思维方式和开发方法。Python 极具包容性，支持多种编程范式，比如命令式编程、过程式编程、函数式编程和面向对象编程等。

学会 Python 就能精通上述编程范式。开发人员也可以根据自身所长和所开发程序的特点，自由选取编程范式（或调整不同范式之间的比例）。

 

脚本语言

脚本语言是体系较小的编程语言，易于编写程序、运行程序和测试程序。Python 就是一种脚本语言，它具有以下特点。

代码简洁。比其他编程语言少几成代码。
可读性好。程序代码容易阅读。
解释执行。程序能以会话方式逐行运行，易于调试错误。


 

丰富的库

编程语言自身具有一定的局限性，会将图像和网络等处理交给库去执行（库集成了各种处理模块）。

随着 Python 的迅速普及，横跨各领域的 Python 库应运而生。

 

程序运行速度不快

因为用 Python 编写的程序是解释执行的（还有 Python 是动态类型语言等原因），所以这类程序无法快速运行。

不过，把 Python 程序的主要部分交给运行速度很快的库来处理，能提高程序的运行速度。

 

难以掌握

虽然外界宣传 Python 很容易学，但事实并非如此。可读性强意味着简短的 Python 代码中潜藏着许多深层的含义。另外，Python 表面上几乎没有指针（普遍认为学起来比较困难），但其实它的内部充满了指针（引用）。因此大家在学习 Python 时要正确理解 Python 程序的每一个表达式和语句的含义。

关于 Python 的版本
　　Python 在持续更新，它的版本号用 A.B 或 A.B.C 这种形式表示。其中，A 是主版本号，B 是次版本号。末尾的数字 C 会在有小的变动或修补漏洞时添加到版本号中。

Python 在 1991 年、1994 年、2000 年和 2008 年依次发布了 0.9 版、1.0 版、2.0 版和 3.0 版。

Python 从 2.x 开始受到广泛关注，随后许多库被开发出来。之后，Python 在 3.x 中发生较大变化，导致 Python 2.x 和 Python 3.x 不兼容。大部分用 Python 2.x 编写的程序无法直接使用 Python 3.x 运行。官方对 Python 2.x 的支持只持续到 2020 年，所以除非有特殊情况，比如只能使用支持 Python 2.x 的库等，否则应尽量使用 Python 3.x。

本书使用的是 Python 3.7。

执行 Python 程序
　　在用 Python 编写程序之前，首先要安装 Python。大家可以通过附录来学习安装方法。

另外，如附录所述，Python 程序的执行方式主要有 3 种（图 1-2）。

图 1-2　执行 Python 程序

交互式 shell（基本会话模式）
　　逐行执行 Python 程序（图 1-2 中的 ），这也是本章唯一使用的方式。

在集成开发环境内执行
　　使用集成开发环境 IDLE（图 1-2 中的 ）执行程序。

使用 python 命令执行
　　使用 python 命令执行以后缀名“.py”保存的程序。

此外，还有一些可以快速运行 Python 程序的方法，比如使用第三方提供的集成开发环境、执行编译操作等。

1-2　Python 的基础知识

本节通过讲解交互式 shell（基本会话模式）的使用方法，让大家逐渐熟悉 Python 并掌握其基础内容。

交互式 shell（基本会话模式）
　　我们已经知道了有很多执行 Python 程序的方法，接下来就尝试一下交互式 shell1 吧。交互式 shell 也叫作基本会话模式。

1俗称壳，指为使用者提供操作界面的软件。

交互式 shell（基本会话模式）的启动和退出
　　首先使用 python 命令启动交互式 shell。

▶ 启动方式与操作系统的版本和 Python 的版本有关。以下方式仅供参考。

使用 Windows 时，要在 PowerShell 或命令提示符中输入 python，也可以在“开始菜单”中用以下方式查找并启动 Python。

“开始菜单”-“所有程序”-“Python3.7”-“Python3.7（64bit）”

 

使用 Linux 时，要在 shell 提示符中输入 python。

使用 macOS 时，要在终端输入 python3。

启动后会出现主提示符（primary prompt），也就是 3 个并排的右向箭头 >>>。

▶ >>> 后面有 1 个空格。

提示符之后可以输入各种命令。

首先，我们试着输入 copyright。输入后，版权信息就会显示出来（例 1-1）。

▶ 红字处是输入命令的地方，蓝字处是 Python 的 shell 显示信息的地方。另外，不同版本的 Python 显示的内容不同。

在正式使用交互式 shell 之前，我们先来学习以下内容。

退出方式

Python 有多种退出方式。

使用 quit 函数或 exit 函数退出

退出时可以输入 quit() 或 exit()。下面请先输入 quit()（例 1-2）。

这样就退出交互式 shell 了。再次启动 Python，并输入 exit()（例 1-3）。

这里出现了函数（function）一词，我将在之后的章节中逐一讲解函数、“()”等的概念。

使用组合键强制退出

我们可以通过以下组合键强制退出交互式 shell。

Windows：按住 Ctrl 键的同时按 Z 键，然后按 Enter 键。
macOS 和 Linux：按住 Ctrl 键的同时按 D 键，然后按 Enter 键。
该退出方法是在程序无法退出时使用的最终手段。

▶ Ctrl＋Z 和 Ctrl＋D 称为文件终止符。

调出命令历史

想要输入已经输入过的命令（语句和表达式等）时，没有必要从头输入。

使用↑、↓、Home、End、Page Up、Page Down 这些键可以按顺序调出输入过的命令。

如果想输入和之前完全相同的命令，可以直接按 Enter 键；如果想稍微修改一下命令，可以使用←键和→键把光标移动到合适的位置，修改后按 Enter 键。

要点　想要输入相同或类似的命令时，可调出命令历史进行修改。

运算符和操作数
　　我们使用交互式 shell 模拟计算器的功能，以此来熟悉 Python。

先进行四则运算（例 1-4）。输入计算表达式后，运算结果就显示出来了。

▶ 箭头后的绿色文字为补充说明部分，并不是输入或输出的内容。

　我们将在第 17 页和第 18 页学习为什么输入表达式后运算结果会自动显示出来等内容。

提示符后（字符“7”之前）不能直接输入空格，但是“7”和“+”之间、“+”和“3”之间，以及“3”和回车符之间有无空格均可。

▶ 3-3 节会介绍具体原因。另外，第 5 章会介绍 7/3 的运算结果的最后一位是 5 而不是 3 的原因。

运算符和操作数
　　用来进行运算的 + 和 - 等符号称为运算符（operator），7 和 3 等运算的对象称为操作数（operand）（图 1-3）。

图 1-3　运算符和操作数

加减法运算符 + 和 - 与我们平时计算使用的符号相同，乘除法运算符则不同。乘法使用 * 而不是 ×，除法使用 / 而不是 ÷，舍去运算结果小数部分的除法使用运算符 //，求余运算使用运算符 %（表 1-1）。

另外，求幂运算符为 **。

▶ 7 ** 3 表示计算 7 * 7 * 7 的值。另外，两个 * 之间不能有空格。

在最后计算的表达式 7 * (3 + 2) * 4 中，如果缺少括号，表达式将计算 7 * 3 和 2 * 4 的和，运算结果就会变成 29。也就是说，下页这几点与四则运算的规则相同。

从左至右进行运算。
乘除法比加减法优先级更高，即乘除法的运算符拥有更高的优先级。
优先运算括号内的表达式。

括号可以迭代，如表达式 7 * ((3 + 5) % 2)。另外，进行迭代操作的行为称为嵌套。

▶ 从左至右依次进行运算的运算符是左结合的（求幂运算符 ** 是右结合的）。运算符的结合规则将在 3.3 节介绍。

运算符的优先级
　　有两个操作数的运算符称为二元运算符（binary operator）。除了二元运算符，还有存在 3 个操作数的运算符—— 三元运算符（trinary operator），以及只有 1 个操作数的一元运算符（unary operator）。

试着使用我们平时计算常用的一元运算符 + 和 -（例 1-5）。

通过此例，我们可以得知以下内容。

一元运算符 + 和 - 的优先级比乘除法运算符的优先级高。

接下来，我们让交互式 shell 模拟计算器的功能，以此来学习 9 个运算符。

这些运算符根据优先级可分为 4 类。表 1-1 是按优先级从高到低的顺序进行排列的运算符一览表。不同颜色表示不同优先级的运算符。

表 1-1　基本算术运算符

数值型和数值字面量
　　例 1-4 演示了整数间的四则运算。只有使用运算符 / 的运算结果是实数，其结果中包含了小数部分，其他运算结果均为整数。

数值型
　　不同编程语言表示数值的方法也各有不同。

我们用类型（type）来表示数值、字符等的种类和方法。Python 有 3 种表示数值的类型。

int 型　表示整数的整数型（integer type）。
float 型　表示实数的浮点型（floating type）。
complex 型　表示复数的复数型（complex type）。

▶ 许多编程语言的 int 型只能表示有限的数值，比如数值范围被限制为 -2 147483648~2147483647，而 Python 在表示数值方面没有这样的限制。

　另外，Python 的 float 型相当于 C 语言和 Java 的 double 型（而非 float 型）。Python 没有 double 型。

我们尝试一下整数型和浮点型的混合运算（例 1-6）。

int 型数值之间的加法运算结果是 int 型，除此以外的加法运算结果都是 float 型。像这样，操作数的类型不同，运算结果的类型也不同。我将在第 5 章讲解详细规则。

数值字面量（整数字面量和浮点数字面量）
　　7 和 3.0 等数值的表示法称为数值字面量（numeric literal）。7 是整数字面量（integer literal），3.0 是浮点数字面量（floating point literal）。

▶ literal 的本意是“字面上的”“字面意义的”。

整数字面量不仅可以表示十进制数，还可以表示二进制数、八进制数和十六进制数。

▶ 一般来说，n 进制数是以 n 为基数的数（第 24 页的专栏 1-2）。

各基数的字面量表示方法如下所示。十进制数以外的进制数需要加前缀。

二进制字面量　… 前缀是 0b。　使用 0 和 1 这两个数字。
八进制字面量　… 前缀是 0o。　使用 0~7 这 8 个数字。
十进制字面量　… 　 　　　　　　使用 0~9 这 10 个数字。
十六进制字面量　… 前缀是 0x。使用 0~9 和 a~f（或 A ～ F）这 16 个数字和字母。

▶ 二进制字面量、八进制字面量、十六进制字面量的开头也可以写成 0B、0o、0X。不过，八进制数字面量的 0o 不容易辨认。

0b 和 0x 中的 0 只是数值字面量的前缀字符。在十进制数中，除 0 以外的数字的开头不能为 0。因此，03 和 010 等是错误的表示法。

我们来输入整数字面量看看效果吧（例 1-7）。

最后的 010 产生了错误。

▶ 此处产生的是语法错误。具体内容我会在第 3 章讲解。

通过此例，我们可以得知以下内容。

仅仅输入数值字面量，不进行运算，值也会显示出来。
整数值用十进制数表示。

Python 从版本 3.6 起可以在数值字面量字符间的任意位置插入下划线“_”（实际上 Python 程序会忽略下划线）（例 1-8）。这样可以让位数较多的数值更易于阅读。

浮点数字面量可以省略整数部分或小数部分。另外，我们也可以在浮点数字面量的末尾添加 10 的指数表示形式。请看以下示例。

6.52   10.   .001   1e5   3.14e-7   3.141_592_653_5

▶ e5表示 105，e-7表示 10-7。

字符串字面量和转义字符
　　前面学习的都是数值，现在我们来看一看字符。首先试着输入字符（例 1-9）。

很遗憾，这里产生了错误。原因是程序将此处输入的 Fukuoka 2 当成名称而非排列在一起的字符进行了识别。

2Fukuoka 是福冈的日语读法。

▶ 错误消息的最后一行可直译为如下内容。

　命名错误：未定义 'Fukuoka' 这一名称。

我会在后面讲解此处的名称指的是什么，现在我们继续学习字符。

字符串字面量
　　字符串（string）由一系列字符组成，其字符序列称为字符串字面量（string literal）。

字符串字面量使用单引号“'”包围想要表示的字符，例如 ’ A ’ 和 ’ Fukuoka '。我们来看例 1-10。

从示例的后半部分我们可以得知以下内容。

使用“字符串 + 字符串”的形式运算，可以得到从左至右拼接的字符串。
字符串和整数使用运算符 * 相乘，可以得到重复该整数次数的字符串。

※注意：字符串之间不能使用运算符 * 相乘。

可以使用 0 个字符构成字符串（空字符串）。

字符串的特性和数值的特性完全不同。字符串字面量的类型不是 int 型或 float 型，而是表示字符串的 str 型。

我们通过例 1-11 来看一下字符串和数值的不同点。

由此我们得知，不能对“字符串 + 数值”进行运算。

转义字符
　　单引号 ’ 是表示字符串字面量的开始位置和结束位置的特殊字符。因此，‘This isn’ t a pen.’ 之类的表示方式是错误的。

字符 ’ 用 ’ 这 2 个字符来表示（虽然使用了 2 个字符，但实际上表示的是 1 个字符）。所以，‘This isn’t a pen.’ 才是正确的表示方式。

像这样，把反斜杠 \ 放在开头，配合 2 个或多个字符来表示某一字符（该字符用普通字符难以表示）的方法称为转义字符（escape sequence）。

表 1-2 是转义字符一览表。

表 1-2　转义字符

字符串字面量的表示方法
　　由 1 个单引号 ’ 构成的字符串字面量需要用 4 个字符来表示，包括表示开始位置的 '、表示单引号的 ’ 和表示结束位置的 '。请看例 1-12。

显示结果与以往稍有不同。包围字符串的符号是双引号 " 而不是单引号 '。

实际上，字符串字面量的表示方法有 4 种。

用单引号 ' 包围字符串

此时，可以直接用 " 表示双引号。单引号用 \' 表示。

 

用双引号 " 包围字符串

此时，可以直接用 ' 表示单引号。双引号用 \" 表示。

 

用 3 个单引号 ''' 包围字符串

此时，可以直接用 " 表示双引号，字符串中间也可以包含换行符。

 

用 3 个双引号 """ 包围字符串

此时，可以直接用 ' 表示单引号，字符串中间也可以包含换行符。

如果不包含引号和换行符，以上表示方法的显示结果相同。我们来看例 1-13。

交互式 shell 显示的结果均用单引号 ’ 包围，各种情形都以 ‘String’ 的形式显示。

下面我们试着在字符串字面量中插入引号和换行符（例 1-14）。

通过以上结果，在交互式 shell 中，关于字符串字面量的显示我们可以得知以下几点。

一般使用 '' 包围字符串。
字符串内如果含有单引号，就使用双引号包围字符串。
换行符和单引号使用转义字符 \n 和 \' 表示。

可用多种表示方法是为了方便输入代码，但我们在编写程序的时候要尽量使用统一的表示方法。

▶ 本专栏基本上使用 '' 来包围字符串，当字符串包含单引号时使用 "" 包围。

大家可能觉得 ‘’’ 和 “”" 除表示包含换行符的字符串字面量之外没有别的用途，其实并非如此。

‘’’ 和 “”" 能以程序代码中的字符串为基础，生成类似于用户手册的程序文档。Python 使用 “”" 形式的字符串字面量来生成这种程序文档。

▶ 我们将在第 9 章学习 """ 形式的字符串字面量。

拼接相邻的字符串字面量
　　在相邻的字符串字面量之间插入空格、制表符、换行符等空白字符，字符串字面量仍会被识别为连续的字符串。

例如，‘ABC’ ‘DEF’ 会被识别为 ‘ABCDEF’。我们来看例 1-15。

结果为不带空白字符的字符串 ‘ABCDEF’（也就是说，‘ABCDEF’ 并不是通过 ‘ABC’ + ‘DEF’ 这种运算拼接在一起的）。

原始字符串字面量
　　以 r 或 R 开头的字符串字面量叫作原始字符串字面量（raw string literal）。原始字符串字面量中的转义字符按照原本含义解释。

下面的示例展示了字符串字面量和原始字符串字面量在表示方法上的不同。

连续 4 个反斜杠字符 \ 构成的字符串字面量

字符串字面量　　　　　'\\\\\\\\'　　　　　※4 个转义字符 \\。

原始字符串字面量　　　r'\\\\'　　　　 　 　※4 个反斜杠字符 \。

这种原始字符串字面量的表示方法一般用在频繁出现反斜杠的路径中。

▶ raw 表示原生的、未加工过的。原始字符串字面量又称原生字符串字面量。

变量和类型
　　未使用引号包围的 Fukuoka 不是字符串而是名称（第 12 页）。

这里的名称是变量（variable）的名称。我会在后面的章节中详细讲解变量，这里我们可以先按照下面的内容理解什么是变量。

要点　变量就像一个箱子，用来存储整数、浮点数和字符串等值。把相应的值放入变量后，可以随时取出。

▶ 这种解释不完全正确，我会在第 5 章具体讲解并加以纠正。

请看例 1-16 中的代码。

 = 是用于赋值运算的符号，与数学上的“x 等于 17”的含义不同。这里指的是赋值给 x、y 和 z。

　　 在交互式 shell 中仅输入变量名会显示出变量的值。

　　 输入算术运算的表达式后，运算结果会显示出来。

　　 输入多个表达式，各表达式间以逗号隔开，这样一来，相应的结果会以逗号隔开显示在括号内。这种方法非常便捷。

在例 1-9 中，输入名称 Fukuoka 后产生了名字未定义的错误。如果像例 1-16 这样用“x = 17”这样的表达式赋值，就不会产生错误。理由如下。

要点　初次使用的变量名在赋值时，程序会自动声明该变量。

因为变量 x、y 和 z 被赋予了整数值，所以程序会声明这些变量为 int 型。

但是，变量的类型并不是固定的。试着输入例 1-17 中的代码确认一下结果。

变量 x 先后“变身”为整数 int 型、浮点数 float 型和字符串 str 型。

使用 type 函数确认类型
　　实际上，有专门的方法可以确认变量的类型——输入 type( 表达式 ) 即可得到括号内的表达式的类型。我们来看例 1-18。

可以看到，变量 x 的类型在不断变化。

另外，type() 也可以用于字面量（例 1-19）。

前面讲的变量名都只有 1 个字符。关于变量名，其实并不是任意名称都可以使用。命名规则大致如下。

可使用的字符包括字母、数字和下划线。
字母区分大小写。
数字不能放在变量名开头。

比如，我们可以使用以下名称。

a   abc   point   point_3d   a1   x2

▶ 变量名可以使用汉字，但我并不推荐使用。详细规则我们将在 3-3 节中学习。

表达式和语句
　　我们来比较一下赋值和加法。请输入例 1-20 中的内容。

最开始的“x = 17”没有显示任何内容，后面的“x + 17”显示了运算结果。之所以会出现这种情况，是因为二者存在以下根本性的差异。

x = 17 是语句（statement）　　　　　 　※ 是语句，不是表达式。
x + 17 是表达式（expression）　　　　　※ 是表达式，也可以是语句（第 52 页）。

输入表达式后，程序会输出表达式的值；输入语句后，程序仅会执行相应的处理（本例中是赋值）。

▶ 当然，如果执行输出命令的语句，相应的内容就会显示出来。我们将在下一章学习相关内容。

要确认“x + 17”是表达式而“x = 17”不是表达式并不难（例 1-21）。

后者不是表达式，没有可供程序查看的类型，所以产生错误。表达式和语句有丰富的内涵，我们会在后面慢慢学习它们的相关内容。

赋值语句
　　正如前文讲解的那样，+ 是加法运算符，而 = 不是运算符。

要点　用于赋值的符号 = 不是运算符。

▶ 表 3-5 中展示的完整运算符一览不包含 =。虽然 = 不是运算符，但人们仍习惯称它为赋值运算符，本书也遵循了该习惯。

使用符号 = 进行赋值的语句称为赋值语句（assignment statement）。赋值语句功能的丰富程度要远超大家的想象。

▶ 前面讲过在给初次使用的变量名赋值时，程序会自动声明该变量的功能。

我们会逐步学习赋值语句的相关内容，这里先学习两个方便的功能。

给多个变量同时赋相同的值
　　第一个功能是给多个变量同时赋相同的值。请看例 1-22。

x 和 y 这两个变量在被自动声明的同时赋值为 1。

给多个变量同时赋不同的值
　　第二个功能是给多个变量同时赋不同的值。请看例 1-23。

值 1、2、3 分别赋给了变量 x、y、z。

下面来实践一下（例 1-24）。

此处执行了 x 和 y 的赋值操作。这些赋值操作如果按先后顺序执行，应该会得到如下结果。

① 执行 x = y + 2 后，x 的值更新为 4。

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　×

② 执行 y = x + 3 后，y 的值更新为 7，即更新后的 x 的值 4 与 3 的和。

但实际上并非如此。两个赋值操作理论上是同时进行的，也就是下面这样。

执行 x = y + 2 后，x 的值变为 4。 　　　　　　　　　　　　　　　　　　　　　　　　　　　　　○
执行 y = x + 3 后，y 的值变为 9。

要点　理论上可以给多个变量同时赋值。

▶ 在用逗号对多个变量进行赋值时使用了第 8 章中介绍的元组。

符号的叫法
　　表 1-3 展示了 Python 中使用的符号以及它们的叫法。

表 1-3　符号的叫法

使用 \ 延续代码到下一行
　　如果在某一行代码的最后（换行符前）插入 \，该行代码将直接延续到下一行。也就是说，连续输入 \ 和换行符所形成的转义字符（第 13 页的表 1-2）表示

延续该行到下一行。

我们来看例 1-25。

像最后一行代码那样，\ 和换行符之间如果有空格，就会产生错误。

使用 \ 延续代码到下一行并不是交互式 shell 的特性，后面介绍的脚本程序也使用 \ 使代码延续到下一行。

要点　如果想将当前行的代码延续到下一行继续输入，需要在该行末尾输入 \。

　　　※当行末的字符为 \ 时，该行代码将延续到下一行。

▶ 此外，我们还可以使用括号来延续代码到下一行（具体内容会在第 3 章中介绍）。

专栏 1-1　交互式 shell 最后显示的值

　　交互式 shell 最后显示的值可以用变量“_”来表示。该变量在运算结果需要用于下次运算时非常有用。

　　请看下面的应用实例。

Python 之禅
　　我们试着在交互式 shell 中输入例 1-26 的内容。

输入命令后，画面上显示出许多英语句子。这是由蒂姆•彼得斯（Tim Peters）总结的《Python 之禅》。

▶ Python 官网中发布了相同内容。

我们来粗略浏览一下《Python 之禅》的内容（现在理解不了也没关系）。

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.

这可能不容易，除非你是 Python 之父。

▶ Python 之父指的是 Python 的开发者吉多·范罗苏姆。

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!

命名空间是一种绝妙的理念，我们应当多加利用。

专栏 1-2　关于基数

　　我们在日常计算中使用的十进制数以 10 为基数。

　　同样，二进制数以 2 为基数，八进制数以 8 为基数，十六进制数以 16 为基数。

　　下面我们来简单学习一下各个基数。

十进制数

十进制数可以用以下 10 个数表示。

0 1 2 3 4 5 6 7 8 9
使用完这些数，位数上升为 2 位。2 位数从 10 开始一直到 99。之后位数上升为 3 位，从 100 开始。也就是说，十进制数的表示方法如下所示。

1 位　　…表示 0 到 9 共 10 个数。

1 ～ 2 位…表示 0 到 99 共 100 个数。

1 ～ 3 位…表示 0 到 999 共 1000 个数。

十进制数的位数按从低到高的顺序依次表示为 100, 101, 102 ,…。因此，我们可以把 1234 理解成下面这样。

1234   =   1×103  ＋  2×102  ＋  3×01  ＋  4×00
           ※100 等于 1（20 和 80 都等于 1，总之任何数的 0 次方都等于 1）。
 

二进制数

二进制数可以用以下 2 个数表示。

0 1
使用完这些数，位数上升为 2 位。2 位数从 10 开始一直到 11。之后位数上升为 3 位，从 100 开始。也就是说，二进制数的表示方法如下所示。

1 位　　…表示 0 和 1 共 2 个数。

1 ～ 2 位…表示 0 到 11 共 4 个数。

1 ～ 3 位…表示 0 到 111 共 8 个数。

二进制数的位数按从低到高的顺序依次表示为 20, 21, 22 ,…。因此，我们可以把 1011 理解成下面这样。

1011   =   1×23  ＋  0×22  ＋  1×21  ＋  1×10
用十进制数表示就是 11。

※Python 的二进制整数字面量的表示方法是 0b1011。

 

八进制数

八进制数可以用以下 8 个数表示。

0 1 2 3 4 5 6 7
使用完这些数，位数上升为 2 位，下一个数变成 10。2 位数从 10 开始一直到 77。2 位数使用完毕后，位数上升为 3 位。也就是说，八进制数的表示方法如下所示。

1 位　　…表示从 0 到 7 共 8 个数。

1 ～ 2 位…表示 0 到 77 共 64 个数。

1 ～ 3 位…表示 0 到 777 共 512 个数。

八进制数的位数按从低到高的顺序依次表示为 80, 81, 82, …。因此，我们可以把 5316 理解为下面这样。

5316   =   5×83  ＋  3×82  ＋  1×81  ＋  6×80
用十进制数表示就是 2766。

※Python 的八进制整数字面量的表示方法是 0o5316。

 

十六进制数

十六进制数可以用以下 16 个数和字母表示。

0 1 2 3 4 5 6 7 8 9 A B C D E F
从前往后依次对应十进制数的 0～15（A ～ F 可以用小写字母 a ～ f 替代）。

使用完这些数，位数上升为 2 位。2 位数从 10 开始一直到 FF。之后位数上升为 3 位，从 100 开始。

十六进制数的位数按从低到高的顺序依次表示为 160, 161, 162, …。因此，我们可以把 12A3 理解为下面这样。

12A3   =   1×163  ＋  2×162  ＋  10×161  ＋  3×160
用十进制数表示就是 4771。

※Python 的十六进制整数字面量的表示方法是 0x12a3。

 

二进制数和十六进制数相互转换

表 1C-1 展示了 4 位二进制数与 1 位十六进制数之间的对应关系。4 位二进制数表示的 0000 ～ 1111 就是 1 位十六进制数表示的 0～F。

表 1C-1　二进制数和十六进制数的对应关系

二进制数	十六进制数
0000	0
0001	1
0010	2
0011	3
0100	4
0101	5
0110	6
0111	7
1000	8
1001	9
1010	A
1011	B
1100	C
1101	D
1110	E
1111	F
利用这种对应关系能轻易地将二进制数转换为十六进制数，或者将十六进制数转换为二进制数。

比如，二进制数 0111101010011100 在转换为十六进制数时只要按 4 位一组的方式进行分组，每组替换为相应的 1 位十六进制数即可。



另外，在将十六进制数转换为二进制数时，只要反向操作即可，也就是把十六进制数的每一位都替换为相应的 4 位二进制数。

当然，八进制数的 1 位对应二进制数的 3 位，即 3 位二进制数表示的 000~111 对应 1 位八进制数的 0~7。

利用这种对应关系同样可以进行进制转换。

总结
作为一种迅速普及的脚本语言，Python 支持多种编程范式，包括命令式编程、过程式编程、函数式编程和面向对象编程。
Python 的版本在不断更新，当前已更新至 Python 3。如果没有什么特殊的理由，应当使用 Python 3，而不是 Python 2。
Python 程序能以多种方式执行，包括交互式 shell（基本会话模式）、python 命令和集成开发环境。
基本会话模式会显示主提示符 >>>，该提示符后需要输入命令和语句。输入 quit() 或 exit() 将退出基本会话模式。

• 和 + 等符号称为运算符，用来进行各种运算。
  另外，如果表达式表示的是运算的对象，该表达式就称为操作数。

根据操作数的数量，运算符可分为一元运算符、二元运算符和三元运算符。

基本的算术运算符包括用于求幂的 **、一元运算符 + 和 -，以及二元运算符 *、/、//、%、+ 和 -。
运算符有优先级的概念，例如除法运算符 / 的优先级比加法运算符 + 的优先级高。但是，不论优先级如何，() 内的运算都会优先执行。

类型表示数值和字符的性质。

数值型包括整型（int 型）、浮点型（float 型）和复数型（complex 型）。
用数字或排列在一起的字符表示数值的方式称为数值字面量。
整数字面量可以用二进制字面量、八进制字面量、十进制字面量和十六进制字面量表示。
浮点数字面量的末尾可以附加使用 10 的指数形式 en。
反斜杠符号 \ 和不同字符组合在一起可以表示不同的转义字符，包括换行符 \n 和回车符 \r 等。
在一行代码的最后（换行符之前）输入 \，可以将本行代码延续到下一行。
表示字符串的类型是字符串型（str 型）。字符串字面量是字符的拼写方式，使用单引号 ‘、双引号 "、3 个单引号 ‘’’ 或 3 个双引号 “”" 包围需要表示的字符串。
多个字符串字面量之间如果有空白字符，字符串字面量将进行拼接。
原始字符串字面量如果包含转义字符，就会以字符原本的形式进行解释。
可以使用运算符 + 进行数值的加法运算和拼接字符串，但字符串和数值不能相加。
变量可以存储整数、浮点数和字符串等值，这些值可以随时取出来使用。
x + 17 是表达式，而 x = 17 是语句，不是表达式。赋值符号 = 有很多功能，但 = 不是运算符。
第一次使用的变量名在赋值时，程序会自动声明该变量。
可以把与当前变量值类型不同的值赋给变量。
用逗号分隔多个变量并把分隔好的变量放在 = 左侧，我们就可以同时为它们赋予不同的值。赋值操作理论上是同时进行的。
可以使用 type( 表达式 ) 查看变量和字面量的类型。
由蒂姆·彼得斯总结的《Python 之禅》作为 Python 编程指南受到了全世界 Python 程序员的欢迎。