【从0到1学Python】第三讲：Python中的各种“量”（二）

乘方符号用两个星号“**”表示。也许你在其他地方使用“^”符号表示乘方——但是请注意，在Python中，符号“^”表示的并非乘方运算。整数型的乘方运算和数学学科中的乘方运算相同。比如说，3 ** 3 = 27，2 ** 4 = 16，4 ** 0.5 = 2.0，4 ** 0=1。但是与数学学科中不同的是，在Python中，0 ** 0=1。

整除

整除符号用两个斜杠“//”表示。两个整数型的乘除运算的结果依旧是整数型。对于整除运算，你可以理解为两个整数型做完除法运算之后，向下取整后的结果。比如说，9 // 4 = 2，3 // 4 = 0，-9 // 4 = -3。

取模

取模符号用百分号“%”表示。取模的表达式形如“a%b”。

所谓取模，若a与b均为正数，其结果就是求除法得到的余数，非常直观；若a、b中存在负数，则可以通过：

求 d = a // b 的结果；
将d与b相乘，求 c = d * b = (a // b) * b；
将a与c相减，得到结果 r = a - c = a - d * b = a - (a // b) * b。

取模运算的结果可正可负。这个方法具有较强的泛用性，因此你可以在为数不多的、有负数出现的场合使用这种方法。比如说：

要求-30 % (-7)，先求d = (-30) // (-7) = 4，再求c = 4 * (-7) = -28，最后得到结果-30 - (-28) = -2，即-30 % (-7) = -2。

取模运算是很常用的运算，各位在初学阶段一定要好好掌握。

2. 浮点型（float）

浮点型的表示

和整数型一样，在Python中表示浮点型和在数学学科中表示“小数”是一样的。比如说，0.2，1.0，-5.5。

浮点型变量也可以用科学计数法来表示。在数学学科的科学计数法表示当中，形如 $a\times 10^b$ 的式子在Python中写为aeb。中间的“e”是不变的，而a和b可以自由变动。比如说，3e-3=0.003，2.5e10=25000000000.0。

浮点型的运算

与整数型相同的运算

浮点型的四则运算和整数型是同理的。计算结果为浮点型。在此不作赘述。

对于乘方、整除和取模运算，对于浮点型依旧成立。计算结果为浮点型。比如说，2.5**2.0=6.25，2.75//1.35=2.0，-10 % 3.0=2.0。

保留小数位数

既然浮点型长得和小数一样，那么在程序输出小数的时候，必然就会有保留小数位数的需求。如何将一个浮点型变量保留指定的小数位数呢？在本讲中，我们先来了解利用round()函数和format()函数进行输出时保留浮点型小数位数的操作。

round()是一个函数，我们使用这个函数的时候需要提供两个参数：待操作的浮点型以及需要保留的小数位数。round()函数在计算完成之后会变为仅保留若干位小数的浮点型量。比如说：

round(3.14159, 2) = 3.14；round(12.9, -1) = 10.0。

美中不足的是，round()函数并不能在输出时提供扩充小数位数的作用。比如说，round(3.14, 5) = 3.14，而并非3.14000。

这时候format()函数上场了。format()函数的应用范围很广，我们将在很多场合使用它。使用format()来保留小数位数，我们需要提供两个参数：待操作的浮点型以及一个格式说明符（字符串）。在这里，格式说明符长这个样子：".xf"，其中x是需要保留的小数位数（大于零），比如说".2f"。但是，format()计算结果是以字符串的形式呈现的。比如说：

format(3.14159, ".2f") = "3.14"。

format()函数可以扩充小数位数。比如说，format(3.14, ".5f") = '3.14000'。这样子，就可以在输出的时候完美输出带多位小数的浮点型了。

3. 字符型（str）

字符型的表示

字符型的量既可以是单个字符，也可以是多个字符。我们在实际编程中遇到的字符绝大多数为ASCII码表中的字符。关于ASCII码表，你既可以在浙教版高中信息技术教材必修一的最后一页看到，也可以上网搜索。这里是一张搜索结果显示的图片：

不难发现，这张表中涵盖了英语中的空格、大小写字母、阿拉伯数字以及许多符号。在初学阶段，你完全可以将“字符串”中所包含的“字符”简单理解为“空格、英语中的大小写字母、阿拉伯数字以及许多符号”。

引号

在字符型中，这些字符用引号包括。这里说的引号，包含单引号、双引号，甚至是三引号！它们在引用字符的时候是基本没有差别的。请注意，输入引号时候需要使用英文输入方式：很多人会错误地将其打成中文的上下引号！

我们通常称多个字符的字符型量为“字符串”。这是一对单引号包括的字符串：

'Hello world!'

这是一对双引号包括的字符串：

"Hello world!"

这是一对三引号包括的字符串。三引号既可以由纯单引号构成，也可以由纯双引号构成。

'''Hello world!'''
"""Hello world!"""

当然，我觉得为求方便，大家在没有特殊需求的情况下，基本上会选择使用单引号与双引号。当然了，引号也可以只包括单个字符。

'a'
"b"
'''c'''
"""d"""

现在，请各位考虑这样一种场合：假设我们需要在字符串中表示一个单引号。如果我们使用单引号包括，那么就会出现：

'Let's go!'

这样的情形。我们会发现前两个单引号中间包括成为一个完整的字符串；但是第二个单引号到最后一个单引号中间被认为是“串外字符”。这会导致引号匹配错误，从而使得程序无法正常运行。这个时候，我们就需要使用双引号去包括单引号：

"Let's go!"

如此，双引号的匹配没有错误，单引号被正确地包括在了字符串中。包括双引号的情形是同理的。

单引号与双引号只能包括单行内的字符。也就是说，面对跨行的段落，单引号与双引号是无法引用的。这个时候就需要请出三引号了。三引号可以跨行包括字符：

'''Hey,
this is me.'''

"""Hey,
this is me."""

转义字符

你也许会考虑这样一个问题：既然三引号引用了跨行字符，那么如何表示行与行之间的“换行”关系呢？转义字符可以解决这样的问题。

转义字符长什么样？转义字符由一个反斜杠“\”（在键盘QWER所在行的最右侧，将输入法调成英文后输入）与一个英文字母（或者数字）组成。虽然长成这个样，但是转义字符仍旧算作一个字符。

转义字符通常表示一些看不见的、不方便输入的字符或者操作，譬如我们刚才提到的换行。初学阶段最常用的转义字符就是表示换行的"\n"（反斜杠+n）。除此之外，还可能会遇到表示制表符的"\t"（反斜杠+t）——也许你可以试着在编辑其他文本的时候按一下键盘上的Tab（制表）按键，看看效果如何。

索引

你可以通过索引来获取目标字符串中的某一个字符或某一段字符串。

在一个字符串中，每一个字符都有相应的索引。索引从0开始编号，从前往后依次递增。

要通过索引获取某一个字符，你需要通过一对方括号（中括号）将索引包括，并在前面加上字符串或其变量名称。比如说：

s = "Hello world!"

于是我们就知道：s[0] = "H"，s[1] = "e"，……，s[11] = "!"。

想要获取某一段字符串，在上面方括号的基础上，你需要给定起始索引与终止索引，必要时给定步长。就像这样：字符串名称[起始索引 : 终止索引 : 步长]。获取到的字符串是一个左闭右开区间（[ 起始索引, 终止索引 )）。比如说：s[1:3] = "el"，取的是s[1]和s[2]，s[3]并不会取到。

关于索引的其他用法，在下文列表 - 列表的运算 - 切片中均有讲到。这玩意儿可以类比过来，在此不做赘述。

字符型的运算

加法（连接）

在字符型中，使用加号进行的运算表示字符型的连接——即使字符型中的字符是阿拉伯数字。比如说，"ab" + "c" = "abc"，"12" + "34" = "1234"，而不是"46"。

乘法（反复）

使用乘号对一个字符型和一个整数型进行的运算表示字符型的反复。比如说，"a" * 3 = "aaa"，"abs" * 2 = "absabs"。

4. 布尔型

布尔型的表示

布尔型，表示真假。这可能是你第一次遇到这个类型的量。你可能疑惑，为什么“真假”不能用整数型的1与0表示——我的回答是，当然可以！但是，布尔型就是Python中专门干这行的，纯粹表示真假，我们为何不使用之呢？

布尔型的量只有两种可能的取值，真与假。无需引号，“真”“假”分别使用首字母大写的True与False表示。注意True不要拼写错了。

布尔型的运算

布尔型之间存在运算。我们通过逻辑运算符——与、或、非进行这类运算。这类运算在后续编程中，是复杂条件判断的重要基础（比如说判断超速、判断闰年等等）。

由于这类运算的情况有限，下面将使用列表的方式来进行情况的穷举，并在最后进行总结。

顺便说一下，这类运算在通用技术科目的学习中也会经常使用。所以，得好好掌握。

与

Python中，与运算的逻辑运算符写作and，左右各带一个空格。

与运算
a	b	a and b
True	True	True
True	False	False
False	True	False
False	False	False

顾名思义，“与”运算就是当a与b都为真时，结果方为真。容易看到，当a与b有一个为假时，a and b的结果就是假。

或

Python中，或运算的逻辑运算符写作or，左右各带一个空格。

或运算
a	b	a or b
True	True	True
True	False	True
False	True	True
False	False	False

顾名思义，“或”运算就是当a与b中有至少一个为真时，结果即为真。容易看到，当a与b都为假时，a or b的结果才是假。

非

Python中，非运算的逻辑运算符写作not，后带一个空格。

非运算
a	not a
True	False
False	True

这个最好理解了，就是真假互换。

逻辑运算符之间的优先级为() > not > and > or。之所以要记住优先级，是为了考试的时候能够应对刁钻题目；自己编程的时候，请使用括号来体现优先级，以使代码清晰明了。

下面，来做几个小练习吧！

逻辑运算小练习

很贴心地将难度设置为了循序渐进的。enjoy! :)

## SECTION 1
1. not True
2. False and True
3. True or False
4. not False
5. True and True
6. True or False
7. False or False

## SECTION 2
1. not True and True
2. not False or False
3. True and not True
4. not True or True
5. True and False and True
6. False or False or True

## SECTION 3
1. True and not False or False
2. False or True and not False
3. not True and False or True and True

参考答案：

## SECTION 1
1. False
2. False
3. True
4. True
5. True
6. True
7. False

## SECTION 2
1. False
2. True
3. False
4. False
5. False
6. True

## SECTION 3
1. True
2. True
3. True

在后续的讲解中，我们将会了解到布尔类型运算的实际含义与应用。

5. 列表（list）

列表的表示

列表是Python中很常用的、有序存放各种量的一种类型。好比是一排带了编号的抽屉，每个抽屉里面都可以存放一个量。这些量甚至可以是不同类型的！

回到代码中，一个列表用一对方括号（中括号）包括，里面的元素之间使用逗号分隔。请注意，不要打成中文的方括号或者逗号！下面是一个长度为3（列表的长度即为元素的个数）、里面装了整数型的列表：

l = [123, 456, 789]

当然，列表内的元素也不一定需要是同一个类型：

l = [123, 456.0, '789']

索引（下标）

我们谈论列表的时候，常常会提到元素的索引。上文提到，这一排抽屉是带了编号的。所谓索引（index），就是这个编号。列表的编号是从0开始依次递增的。假设有一列表l：

l = [12, 34, 56, 78]

我们想要打开抽屉去取其中的元素，就要通过索引来定位。使用索引时，将索引用一对方括号包括，并在索引前写上列表名称。比如说：l[0] = 12，l[1] = 34，l[2] = 56，l[3] = 78。如果引用了大于等于列表长度的索引，那么将会发生“list index out of range”的错误。

我们也可以通过负数来定位到“倒数第几个”的元素。比如说，l[-1] = 78，l[-2] = 56，l[-3] = 34，l[-4] = 12。

有一种情况值得我们单独讨论一下：当列表套列表的情况发生时，如何取出最里面的元素？比如说，我们有列表：

l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

列表l的长度为3，每个元素均为列表。比如说，l[0] = [1, 2, 3]。如果我们想将元素“3”单独取出，我们可以通过再次添加索引的方法取出：l[0][2]。

怎么理解多个索引同时存在的情况呢？从左往右看，我们先分析l[0]，得到l[0] = [1, 2, 3]，于是原式l[0][2]变为[1, 2, 3][2]。对于列表[1, 2, 3]，取索引为2的元素，那便是3了。类似地，我们还可以举出几个例子：l[1][1] = 5，l[0][1] = 2，l[2][0] = 7。

列表的运算

加法（连接）

与字符型类似，列表与列表使用加号进行的运算是将两个列表相连接。比如说：[1, 2, 3] + [4, 5, 6] = [1, 2, 3, 4, 5, 6]，[1, 2] + [3] = [1, 2, 3]。

乘法（反复）

与字符型类似，列表与整数型使用乘号进行的运算是将此列表的元素重复若干遍。比如说：[1, 2, 3] * 3 = [1, 2, 3, 1, 2, 3, 1, 2, 3], ["ab", 3] * 2 = ["ab", 3, "ab", 3]。

切片

如果想在列表中取出多个元素而非单个元素，我们可以使用列表的切片。

想要对列表进行切片，需要给定三个参数：起始索引，终止索引，以及步长。将这三个参数用一对方括号包括，参数之间用引号“:”隔开，并在方括号前加上列表的名字。比如说：l[1: 10: 2]，起始索引为1，终止索引为10，步长为2。

给定参数后，程序将从起始索引开始，取出列表中的元素，并在每取一次之后将索引加上步长，直到当前索引大于等于终止索引。其实，这是一个左闭右开区间。作个图，你一定能搞明白：

理解了这一点后，我们可以进一步玩转切片。我们首先假设有

l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]

其实，我们不一定要将参数填满。在没有给定步长的情况下，步长默认为1。此时，在没有给定起始索引的情况下，默认从列表第一个元素开始；在没有给定终止索引的情况下，默认到列表的最后一个元素（包括最后一个元素）为止。没有给定的参数仍旧需要留一个位置给它。比如说：

l[0: 10:] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
l[: 10:] = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0]
l[1::] = [2, 3, 4, 5, 6, 7, 8, 9, 0]

另外，步长可以为负数。此时，在没有给定起始索引的情况下，默认从列表最后一个元素开始；在没有给定终止索引的情况下，默认到列表的第一个元素（包括第一个元素）位置。比如说：

l[8:: -1] = [9, 8, 7, 6, 5, 4, 3, 2, 1]
l[7:: -2] = [8, 6, 4, 2]
l[:: -1] = [0, 9, 8, 7, 6, 5, 4, 3, 2, 1]

其中值得注意的是，l[::-1]是Python中很厉害的翻转列表的方法！灵活运用切片，能够帮助我们有效地处理列表中的数据关系，因此请各位初学者务必熟练掌握。

列表切片小练习

l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12]

##SECTION 1
1. l[1 : 10 : 3]
2. l[2 : 5 : 1]
3. l[2 : 11 : 2]

##SECTION 2
1. l[:: -1]
2. l[: 0 : -1]
3. l[8 : 0 : -2]

参考答案：

##SECTION 1
1. [2, 5, 8]
2. [3, 4, 5]
3. [3, 5, 7, 9, 11]

##SECTION 2
1. [12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1]
2. [12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2]
3. [9, 7, 5, 3]

6. 字典（dict）

字典的表示

字典是Python中通过“键值对”的方式、无序储存数据的一种类型。想象一本字典——我们通过找到某一个字，然后查看这个字的释义。那个“字”，就是“键”（key）；那个“释义”，就是“值”（value）。

字典使用一对花括号（大括号）包括，键值对之间用逗号隔开，某个键值对中使用冒号“:”隔开。注意不要打成中文的冒号！下面是一个拥有三个键值对的字典：

d = {"apple": 1, "banana": 2, "cherry": 3}

"apple"和1、"banana"和2、"cherry"和3，分别是三对键值对。因为我们找“值”的时候，是通过“键”唯一确定的，因此，这三对键值对的前后位置不影响字典的内容。

d1 = {"banana": 2, "apple": 1, "cherry": 3}
d2 = {"apple": 1, "cherry": 3, "banana": 2}

## d1和d2是一样的

字典的键和值也不一定分别是字符串和整数型。键可以是整数型、浮点型、字符型；值可以是整数型、浮点型、布尔型、字符型、列表，甚至是另一个字典。

和列表类似，想要获取某一个键对应的值，我们需要使用一对方括号将其包括，并在前面加上字典的名称。比如说：d["apple"] = 1，d["banana"] = 2，d["cherry"] = 3。

字典的运算

添加（更新）键值对

如果希望在字典中添加一个键值对，那么只需要通过赋值就可以实现了。比如说，对于上文的字典d，进行赋值：

d["dude"] = True

如此，d就变成了：d = {"apple": 1, "banana": 2, "cherry": 3, "dude": True}，添加了一个键值对。如果赋值对象的键已经存在，那么字典的内容就会更新。比如说：

d["apple"] = -1

如此，d就变成了：d = {"apple": -1, "banana": 2, "cherry": 3, "dude": True}，键"apple"对应的值被更新为了-1。

7. 小结

恭喜！本讲的内容到此结束了。在本章中，我们基本了解到了6种Python中不同类型的量的表示（长什么样），以及相关的基本运算。

笔者对于“基本运算”的概念之划分并不准确，因此有一些其他“关于量的基本操作”——比方说，在列表中查找某个元素的索引、合并两个字典等操作——并没有在本讲中被划分为“运算”，而是被划分为了“方法”。

对于不同类型的量的其他基本操作（“方法”），以及各个类型的量之间的关系，我们将在后续提到。

【从0到1学Python】第三讲：Python中的各种“量”（二）

0. 变量的赋值

1. 整数型（int）

整数型的表示

整数型的运算

加、减法

乘法

除法

乘方

整除

取模

2. 浮点型（float）

浮点型的表示

浮点型的运算

与整数型相同的运算

保留小数位数

3. 字符型（str）

字符型的表示

引号

转义字符

索引

字符型的运算

加法（连接）

乘法（反复）

4. 布尔型

布尔型的表示

布尔型的运算

与

或

非

*逻辑运算小练习*

5. 列表（list）

列表的表示

索引（下标）

列表的运算

加法（连接）

乘法（反复）

切片

*列表切片小练习*

6. 字典（dict）

字典的表示

字典的运算

添加（更新）键值对

7. 小结

相关推荐

逻辑运算小练习

列表切片小练习