下载掌阅APP，畅读海量书库
立即打开
一种编程语言所支持的数据类型决定了该编程语言所能保存的数据。Python语言常用的内置数据类型包括数值（number）、字符串（string）、列表（list）、元组（tuple）、集合（set）和字典（dictionary），下面分别介绍。
Python中有3种不同的数值类型，分别是整型（int）、浮点型（float）和复数类型（complex）。
1.整型
整型数值包括正整数、0和负整数，不带小数点，无大小限制。整数可以使用不同的进制来表示：不加任何前缀表示十进制整数；加前缀0o表示八进制整数；加前缀0x则表示十六进制整数。
例如，下面的代码
执行完毕后，a、b、c的值分别是10、8和16。其中，0o10为八进制数，输出时转为十进制数8；0x10为十六进制数，输出时转为十进制数16。
提示 Python语言中提供了布尔（Boolean）类型，用于表示逻辑值True（逻辑真）和False（逻辑假）。Boolean类型是整型的子类型，在作为数值参与运算时，False自动转为0，True自动转为1。使用bool函数可以将其他类型的数据转为Boolean类型，当向bool函数传入下列参数时其将返回False：定义为假的常量，包括None或False；任意值为0的数值，如0、0.0、0j等；空的序列或集合，如"（空字符串）、()（空元组）、[]（空列表）等。
2.浮点型
浮点型数值使用C语言中的double类型实现，可以用来表示实数，如3.14159、-10.5、3.25e3等。
提示 3.25e3是科学记数法的表示方式，其中e表示10，因此，3.25e3实际上表示的浮点数是3.25×10 3 =3250.0。
当前环境中浮点数的取值范围和精度可以通过以下代码查看：
执行上面的代码后，可以看到如下格式的信息：
其中，min和max是浮点数的最小值和最大值，dig是浮点数所能精确表示的十进制数字的最大位数。
3.复数类型
复数由实部和虚部组成，每一部分都是一个浮点数，其书写方法如下：
其中，a和b是两个数值，j或J是虚部的后缀，即a是实部，b是虚部。
在生成复数时，也可以使用complex函数，其语法格式如下：
其中，real为实部值，imag为虚部值，返回值为real+imag*1j。如果省略虚部imag的值，则返回的复数为real+0j；如果实部real和虚部imag的值都省略，则返回的复数为0j。
例如，下面的代码
执行完毕后，c1、c2、c3、c4和c5的值分别是（3+5.5j）、3250j、（5-3.5j）、（5+0j）和0j。
【思考题2-4】 执行print(0o20)，则在屏幕上会输出（ ）。
A.20
B.0o20
C.16
D.32
【思考题2-5】 执行print(0x20)，则在屏幕上会输出（ ）。
A.20
B.0x20
C.16
D.32
【思考题2-6】 1.25e3是否是浮点数1250.0的科学记数法表示方式？
字符串是由多个字符组成的序列，每个字符是字符串中的一个元素。例如，"Python"即是一个由6个字符元素按顺序排列所形成的字符串。之所以说字符串是一个序列，是因为字符串所包含的信息不仅依赖于该字符串是由哪些字符组成的，而且依赖于这些字符的排列顺序。例如，两个字符串"could"和"cloud"虽然包含了相同的字符元素，但由于字符元素的排列顺序不同，所以这两个字符串所表达的信息是完全不同的。
1.字符串的表示方法
Python语言中只有用于保存字符串的数据类型，而没有用于保存单个字符的数据类型。Python中的字符串可以写在一对单引号中，也可以写在一对双引号或一对三双引号中，3种写法的区别将在后面的章节中介绍，目前我们使用一对单引号或一对双引号的写法。
例如，下面的代码
执行完毕后，s1和s2的值分别是字符串'Hello World!'和"你好，世界！"。
提示 Python中提供了int和float函数，可以根据传入的字符串分别创建整数或浮点数。
int函数有两个参数：第一个参数是用于创建整数的字符串（要求必须是一个整数字符串，否则会报错），第二个参数是字符串中整数的数制（不指定则默认为10，即十进制）。例如，int（'35'）返回整数35，int（'35', 8）返回整数29（即八进制数35对应的十进制数），int（'35+1'）则会报错。
float函数只有一个参数，即用于创建浮点数的字符串（要求必须是一个整数或浮点数字符串，否则会报错）。例如，float（'35'）返回浮点数35.0，float（'35.5'）返回浮点数35.5，float（'35.5+3'）则会因无法转换而报错。
这里需要特别注意int和float函数与第1章中所学习的eval函数的区别，int和float函数仅根据字符串中的数值直接创建整数或浮点数，不会做任何运算。若传入的字符串是一个包含运算的表达式，如前述的int（'35+1'）和float（'35.5+3'），则执行时都会报错。
不包含任何字符的字符串，如"（一对单引号）或""（一对双引号），称为空字符串（或简称为空串）。
2.转义符
在字符串中，可以使用转义符，常用的转义符如表2-1所示。
表1-2 Python部分版本的信息
例如，下面的代码
执行完毕后，使用print函数依次输出成功创建的各变量的值，则可以得到如图2-2所示的结果。
图2-2 字符串的创建及输出示例
提示 为了减少转义符的使用，如果一个字符串中包含单引号，则通常使用一对双引号作为字符串的定界符，如"It's a book."；如果一个字符串中包含双引号，则通常使用一对单引号作为字符串的定界符，如'He said, "This is my book."'。
3.字符串的索引
通过字符串的索引操作，可以得到由字符串中0个或多个字符元素组成的一个新字符串。Python为字符串提供了两种索引方式：从前向后索引（正向索引）和从后向前索引（反向索引）。如图2-3所示，正向索引方式中，第1个字符的索引值为0，其他字符的索引值是前一字符的索引值加1；反向索引方式中，最后一个字符的索引值为-1，其他字符的索引值是后一字符的索引值减1。在访问字符串中的元素时，既可以只使用某一种索引方式，也可以同时使用两种索引方式。
图2-3 字符串索引方式示例
字符串的索引操作需要使用一对方括号[]（即下标运算）。
一方面 ，可以指定索引范围，其语法格式为
各符号的含义如下。
• s：待做索引操作的字符串。
• beg：新生成字符串的起始字符在字符串s中的索引值。
• end：新生成字符串的结束字符在字符串s中的索引值加1。
beg和end均可省略。
• 省略beg：即写作s[:end]，表示新生成字符串的起始字符在字符串s中的索引值为0，等价于s[0:end]。
• 省略end：即写作s[beg:]，表示新生成字符串的结束字符是字符串s中的最后一个字符，等价于s[beg:len（s）]（len（s）表示字符串s中包含的字符元素的数量，即字符串的长度，也可理解为字符串s中最后一个字符的索引值加1）。
• 同时省略beg和end：即写作s[:]，表示新生成的字符串包含s中的所有字符元素。
注意 s[beg:end]返回的字符串中，所包含的字符在字符串s中的索引值是beg～end-1，不包括end。
例如，代码清单2-2给出了指定索引范围的字符串索引操作示例。
表1-2 Python部分版本的信息
代码清单2-2执行完毕后，第2～7行代码可以按每行代码对应注释中的描述输出结果，如图2-4所示。
图2-4 代码清单2-2的运行结果
提示 在进行字符串的索引操作时，还可以指定步长，即写作s[beg:end:step]。此时，在新创建的字符串中，所包含的字符在s中的索引依次为beg、beg+step、beg+2×step、…、beg+ k ×step（beg+ k ×step<end且beg+( k +1)×step≥end）。例如，对于s='HelloWorld!'，执行print(s[0:6:2])，输出结果为Hlo，即s[0:6:2]返回的新字符串所包含的字符在字符串s中的索引值分别是0、2、4（不包括6）。
另一方面 ，可以指定索引值，返回由指定索引值的单个字符元素组成的字符串，其语法格式为
其中，idx是返回的字符串所包含的字符在字符串s中的索引值。如代码清单2-3所示。
表1-2 Python部分版本的信息
代码清单2-3执行完毕后，第2行和第3行代码分别按每行代码对应注释中的描述输出结果，如图2-5所示。
图2-5 代码清单2-3的运行结果
注意 通过索引操作可以访问字符串中的字符元素，但不能修改。例如，如果执行s[2]='复'，则会报TypeError错误，如图2-6所示。
图2-6 修改字符串字符元素的报错信息
【思考题2-7】 下列选项中，执行时会报错的语句是（ ）。
A.int('23')
B.int('23+1')
C.int('23', 8)
D.int('2a', 16)
【思考题2-8】 下列选项中，执行时不会报错的语句是（ ）。
A.int('23.5')
B.float('23.5+1')
C.float('23.5')
D.int('2a', 8)
【思考题2-9】 已知s="学习"，执行s[0]='复'，s中存储的字符串是否会被修改为字符串"复习"？
列表（list）是Python中一种非常重要的数据类型，一个列表中可以包含多个元素。与字符串相同，列表也是一个序列，即列表所表示的信息不仅与包含哪些元素有关，而且与元素的排列顺序有关。与字符串不同的是，字符串中只能包含字符元素；而列表中可以包含数值、字符串、列表及后面要介绍的元组、集合、字典等任意类型的元素，且同一个列表中各元素的类型可以相同，也可以不相同。所有元素都写在一对方括号[]中，每两个元素之间用逗号分隔。不包含任何元素的列表，即[]，称为空列表。
列表中元素的索引方式与字符串中元素的索引方式完全相同，也支持从前向后索引（正向索引）和从后向前索引（反向索引）两种方式。例如，对于ls=[1, 2.5, 'test', 3+4j, True, [3, 1.63], 5.3]这个列表，其各元素的索引值如图2-7所示。
图2-7 列表索引方式示例
与字符串相同，利用一对方括号[]可以指定索引范围，从已有列表中取出其中部分元素形成一个新列表，其语法格式为
各符号的含义如下。
• ls：待做索引操作的列表。
• beg：新生成列表的起始元素在ls中的索引值。
• end：新生成列表的结束元素在ls中的索引值加1。
与字符串的索引操作相同，beg和end均可省略。
• 省略beg：即写作ls[:end]，表示新生成列表的起始元素在原列表ls中的索引值为0，等价于ls[0:end]。
• 省略end：即写作ls[beg:]，表示新生成列表的结束元素是原列表ls中的最后一个元素，等价于ls[beg:len（ls）]（len（ls）表示列表ls中包含的元素的数量，即列表的长度，也可理解为列表ls中最后一个元素的索引值加1）。
• 同时省略beg和end：即写作ls[:]，表示新生成的列表包含原列表ls中的所有元素。
例如，代码清单2-4给出了指定索引范围的列表索引操作示例。
表1-2 Python部分版本的信息
代码清单2-4执行完毕后，第2～7行代码分别按每行代码对应注释中的描述输出结果，如图2-8所示。
图2-8 代码清单2-4的运行结果
如果只访问列表ls中的某一个元素，则可以使用下面的写法：
其中，idx是要访问的元素的索引值。例如，代码清单2-5给出了指定索引值的列表索引操作示例。
表1-2 Python部分版本的信息
代码清单2-5执行完毕后，第2行和第3行代码分别按每行代码对应注释中的描述输出结果，如图2-9所示。
图2-9 代码清单2-5的运行结果
注意 ls[beg:end]返回的仍然是一个列表，而ls[idx]返回的是列表中的一个元素。例如，如图2-10所示，对于ls=[1, 2.5, 'test', 3+4j, True, [3, 1.63], 5.3]，执行print(ls[2:3])，会输出['test']，而执行print(ls[2])，则会输出test。可见，ls[2:3]返回的是只有一个字符串元素'test'的列表，而ls[2]返回的则是ls中索引值为2的元素（即字符串'test'）。
图2-10 指定索引范围和指定索引值两种列表索引操作返回结果的区别
另外，通过一对方括号[]不仅可以访问列表中的某个元素，还可以对元素进行修改。例如，代码清单2-6给出了修改列表元素的示例。
表1-2 Python部分版本的信息
代码清单2-6执行完毕后，第2、4、6、8、10行代码分别按每行代码对应注释中的描述输出结果，如图2-11所示。
图2-11 代码清单2-6的运行结果
注意 在对列表中的元素赋值时，既可以通过执行ls[idx]=a，修改单个元素的值，也可以通过执行ls[beg:end]=b，修改一个元素的值或同时修改连续多个元素的值。但需要注意，在通过“ls[beg:end]=b”这种方式赋值时，b是另一个列表，其功能是用b中各元素替换ls中beg～end-1这些位置上的元素，赋值前后列表元素数量允许发生变化。
例如，代码清单2-6中，第3行和第7行都是修改列表ls中某一个元素的值，在为单个元素赋值时，可以使用任意类型的数据（包括列表，如第7行）；第5行是将列表ls中第2～4个元素修改为另一个列表['python', 20]中的两个元素；第9行是将列表ls中前两个元素修改为另一个空列表[]中的元素，相当于将ls中前两个元素删除。
【思考题2-10】 下列选项中，描述错误的选项是（ ）。
A.列表中的元素类型必须相同
B.列表中的元素之间用逗号分隔
C.列表中的元素可以是列表类型
D.列表中可以包含数值类型的元素
【思考题2-11】 已知ls=[12, 34.5, True, 'test', 3+5j]，则下列选项中，输出结果为“['test']”的选项是（ ）。
A.ls[3]
B.ls[4]
C.ls[3:4]
D.ls[4:5]
【思考题2-12】 通过一对方括号[]不仅可以访问列表中的某个元素，还可以对元素进行修改，是否正确？
与列表相同，元组可以包含多个元素，且同一个元组中各元素的类型可以不相同，书写时每两个元素之间也是用逗号分隔。与列表的不同之处在于，元组的所有元素都写在一对圆括号（ ）中，且元组中的元素不能修改。不包含任何元素的元组，即（ ），称为空元组。
元组中元素的索引方式与列表中元素的索引方式完全相同。例如，对于t=（1, 2.5, 'test', 3+4j, True, [3, 1.63], 5.3）这个元组，其各元素的索引值如图2-12所示。
图2-12 元组索引方式示例
与列表相同，利用一对方括号[]可以从已有元组中取出其中部分元素形成一个新元组，其语法格式为
各符号的含义如下。
• t：待做索引操作的元组。
• beg：新生成元组的起始元素在t中的索引值。
• end：新生成元组的结束元素在t中的索引值加1。
与字符串和列表的索引操作相同，beg和end均可省略。
• 省略beg：即写作t[:end]，表示新生成元组的起始元素在原元组t中的索引值为0，等价于t[0:end]。
• 省略end：即写作t[beg:]，表示新生成元组的结束元素是原元组t中的最后一个元素，等价于t[beg:len（t）]（len（t）表示元组t中包含的元素的数量，即元组的长度，也可理解为元组t中最后一个元素的索引值加1）。
• 同时省略beg和end：即写作t[:]，表示新生成的元组包含原元组t中的所有元素。
例如，代码清单2-7给出了指定索引范围的元组索引操作示例。
表1-2 Python部分版本的信息
代码清单2-7执行完毕后，第2～7行代码可以按每行代码对应注释中的描述输出结果，如图2-13所示。
如果只访问元组t中的某一个元素，则可以使用下面的写法：
其中，idx是要访问的元素的索引值。例如，代码清单2-8给出了指定索引值的元组索引操作示例。
图2-13 代码清单2-7的运行结果
表1-2 Python部分版本的信息
代码清单2-8执行完毕后，第2行和第3行代码分别按每行代码对应注释中的描述输出结果，如图2-14所示。
图2-14 代码清单2-8的运行结果
注意 通过索引操作可以访问元组中的元素，但不能修改。例如，如果执行t[2]='Test'，则会报TypeError错误，如图2-15所示。
图2-15 修改元组元素的报错信息
提示 从前面的介绍中可以看到，字符串、列表和元组的使用方法非常相近，它们的元素都是按一定顺序排列，可通过一对方括号直接访问，这样的数据类型统称为序列。其中，字符串和元组中的元素不能修改，而列表中的元素可以修改。
【思考题2-13】 已知t=(12, 34.5, True, 'test', 3+5j)，则下列选项中，输出结果为“('test',)”的选项是（ ）。
A.t[3]
B.t[4]
C.t[3:4]
D.t[4:5]
【思考题2-14】 已知t=(12, 1.5, [True, 3+5j])，则下列选项中，执行时不会报错的语句包括（ ）。（多选）
A.t[2]=1
B.t[2:]=1
C.t[2][1]='test'
D.print(t[2])
【思考题2-15】 通过一对方括号[]不仅可以访问元组中的某个元素，还可以对元素进行修改，是否正确？
与元组和列表类似，集合中同样可以包含多个不同类型的元素，但集合中的各元素是无序的，且不允许有相同元素。不包含任何元素的集合称为空集合。
集合中的所有元素都写在一对花括号{}中，各元素之间用逗号分隔。创建集合时，既可以使用{}，也可以使用set函数。set函数的使用方法如下：
其中，iterable是一个可选参数，表示一个可迭代对象。set会将可迭代对象iterable中的每个元素逐一取出，作为新创建的集合对象中的元素。
注意 可迭代（iterable）对象是指可以逐一访问每一个元素的数据，如前面学习的字符串、列表、元组类型的数据都是可迭代对象。
例如，代码清单2-9给出了集合创建示例。
表1-2 Python部分版本的信息
代码清单2-9执行完毕后，第2、4、6、8行代码分别按对应注释中的描述输出结果，如图2-16所示。
图2-16 代码清单2-9的运行结果
代码清单2-9中各行代码的描述如下。
• 第1行代码中，直接使用一对花括号{}创建了一个集合。虽然在花括号中包含了两个值为2.5的元素，但集合中不能包含重复的元素，因此会自动过滤重复元素，只保留一个。从第2行代码的输出结果中可以看到，集合中只出现了一次值为2.5的元素。
• 从第2行代码的输出结果中还可以看到，输出的各元素的顺序与第1行创建集合时给出的各元素的顺序不一致，这是因为集合中的元素本来就是无序的，系统会自动将这些元素调整为能够快速检索的存储方式。
• 第3、5、7行代码都使用set创建集合，传入的参数分别是字符串、列表和元组。同样，从第4、6、8行代码的输出结果中可以看到，对于具有重复值的元素，所创建的集合也会进行自动过滤，只保留一个；输出的集合中各元素的顺序也与创建集合时所传入的元素顺序不一致。
• 第3行代码中，传给set的参数是一个字符串'hello'。在创建集合时，会将字符串'hello'的每一个字符元素取出，即'h'、'e'、'l'、'l'、'o'，并将其作为集合中的元素。集合会自动过滤重复的元素'l'，因此所创建的集合包含'h'、'e'、'l'、'o'共4个元素，且这4个元素是无序的。
• 第5行代码中，传给set的参数是一个列表[10, 2.5, 'test', 3+4j, True, 5.3, 2.5]。在创建集合时，会将列表的每一个元素取出，即10、2.5、'test'、3+4j、True、5.3、2.5，并将其作为集合中的元素。集合会自动过滤重复的元素2.5，因此所创建的集合包含10、2.5、'test'、3+4j、True、5.3共6个元素，且这6个元素是无序的。
• 第7行代码中，传给set的参数是一个元组（10, 2.5, 'test', 3+4j, True, 5.3, 2.5）。在创建集合时，会将元组的每一个元素取出，即10、2.5、'test'、3+4j、True、5.3、2.5，并将其作为集合中的元素。集合会自动过滤重复的元素2.5，因此所创建的集合包含10、2.5、'test'、3+4j、True、5.3共6个元素，且这6个元素是无序的。
• 第7行代码中，set后面有两对圆括号，其中外层的圆括号表示用于接收传入的参数，而内层的圆括号是元组的定界符。
注意
1.与字符串、列表、元组等序列类型不同，集合中的元素是无序的，因此不能使用数值索引方式进行访问。例如，如图2-17所示，当使用数值索引访问集合中元素时，会给出报错信息“TypeError: 'set'object does not support item assignment”，即“类型错误：set对象不支持元素赋值操作”。
2.集合的主要应用可以概括为3个方面：①用于做并、交、差等集合运算；②基于集合快速检索元素；③使用集合过滤重复元素。关于集合的更多使用方法将在后面章节给出。
3.一对花括号{}用于创建后面将要介绍的空字典，而不能用于创建空集合；如果要创建一个空集合，则只能使用set()。
图2-17 使用数值索引访问集合中元素时所给出的报错信息
提示
1.集合中的元素必须是可哈希（hashable）的对象。读者只需要知道列表、集合和字典类型的数据不是可哈希对象，所以它们不能作为集合中的元素。如图2-18所示，当将列表[3+4j, 20]作为集合中的元素时，会给出报错信息“TypeError: unhashable type: 'list'”，即“类型错误：不可哈希的类型——列表”。
2.代码清单2-9的第5行代码中，set（[10, 2.5, 'test', 3+4j, True, 5.3, 2.5]）表示给set传入的参数是一个列表，执行时会将该列表中的元素取出作为新创建集合中的元素。因此，只要传入的列表中没有不可哈希的元素即可。例如，如果将第5行代码改为c=set（[10, 2.5, 'test', [3+4j, 20], True, 5.3, 2.5]），即传入的列表参数中索引值为3的元素[3+4j, 20]是一个列表，则如图2-19所示，会给出与图2-18相同的报错信息。再例如，如果将第5行代码改为c={[10, 2.5, 'test', 3+4j, True, 5.3, 2.5]}，表示所创建的集合中只包含一个元素，即列表[10, 2.5, 'test', 3+4j, True, 5.3, 2.5]，则如图2-20所示，也会给出与图2-18相同的报错信息。
图2-18 将列表作为集合元素时所给出的报错信息示例1
图2-19 将列表作为集合元素时所给出的报错信息示例2
图2-20 将列表作为集合元素时所给出的报错信息示例3
【思考题2-16】 下列选项中，执行时会报错的语句是（ ）。
A.set('Python')
B.set(35.2, True)
C.set([35.2, True])
D.set((35.2, True))
【思考题2-17】 下列选项中，执行时不会报错的语句是（ ）。
A.{['Python', True]}
B.{3.5, [1.2, True]}
C.{3.5, {1.2, True}}
D.{3.5, 1.2, True}
【思考题2-18】 通过一对花括号{}是否可以创建一个空集合？
字典是另一种无序元素的集合。但与集合不同，字典是一种映射类型，每一个元素是一个键（key）:值（value）对。在一个字典对象中，键必须是唯一的，即不同元素的键不能相同；另外，键必须是可哈希数据，即键不能是列表、集合、字典等数据类型，而值则没有任何限制，可以是任意数据类型。不包含任何元素的字典，即{}，称为空字典。
创建字典时，既可以使用{}，也可以使用dict函数。如果要创建一个空字典，可以使用{}或dict()，如下面的代码所示：
这两条语句的作用相同，执行完毕后，a和b是两个不包含任何元素的空字典。
如果在创建字典的同时，需要给出字典中的元素，则可以使用下面的方法：
提示 创建字典的第3种方法中用到了zip函数。zip函数的参数是多个可迭代的对象（如列表、元组等），其功能是将不同可迭代对象中对应位置（即具有相同索引值）的元素分别打包成元组，然后返回由这些元组组成的可迭代对象。例如，对于zip（['one', 'two', 'three'], [1, 2, 3]），传入了两个列表作为zip函数的参数，zip函数会将这两个列表中每组具有相同索引值的元素封装成一个元组，因此会形成3个元组，即（'one', 1）、（'two', 2）、（'three', 3），最后这3个元组被封装成一个可迭代对象作为zip函数的返回数据。再例如，对于zip（['one', 'two', 'three'], [1, 2, 3], ['一', '二', '三']），传入了3个列表作为zip函数的参数，zip函数会将这3个列表中每组具有相同索引值的元素封装成一个元组，因此会形成3个元组，即（'one', 1, '一'）、（'two', 2, '二'）、（'three', 3, '三'），最后这3个元组被封装成一个可迭代对象作为zip函数的返回数据。类似地，对于zip（['one', 'two', 'three'], [1, 2, 3], ['一', '二', '三'], ['I', 'II', 'III']），zip函数会返回由（'one', 1, '一', 'I'）、（'two', 2, '二', 'II'）、（'three', 3, '三', 'III'）这3个元组组成的可迭代对象。为了方便查看zip函数返回的可迭代对象中的元素，可通过list将zip函数返回的可迭代对象转换为列表，如图2-21所示。
图2-21 zip函数使用示例
代码清单2-10给出了字典创建示例。
表1-2 Python部分版本的信息
执行代码清单2-10，运行结果如图2-22所示。
图2-22 代码清单2-10的运行结果
代码清单2-10中前5行代码的描述如下。
• 从图2-22显示的运行结果中可以看到，前5行代码创建了5个相同的具有3个元素的字典对象，即{'one': 1, 'two': 2, 'three': 3}。第一个元素的键是字符串'one'，值是整数1；第二个元素的键是字符串'two'，值是整数2；第三个元素的键是字符串'three'，值是整数3。
• 第1行代码直接使用一对花括号{}创建字典对象。在花括号{}中，每两个元素用逗号分隔，键和值之间用冒号分隔。
• 第2行代码使用dict创建字典对象，传入了3个用逗号分隔的参数，分别是one=1、two=2和three=3，这3个参数会被自动封装成一个字典对象{'one':1, 'two': 2, 'three': 3}。下一章我们学习关键字参数和不定长参数后，读者会对这种写法有进一步的理解。
• 第3行代码使用dict创建字典对象，将zip（['one', 'two', 'three'], [1, 2, 3]）的返回结果作为传入的参数。根据前面的描述，该zip函数执行后会返回由（'one', 1）、（'two', 2）、（'three', 3）这3个元组组成的可迭代对象。每个元组对应所创建字典中的一个元素，元组中索引值为0的元素作为字典中元素的键，而元组中索引值为1的元素作为字典中元素的值。
• 第4行代码使用dict创建字典对象，传入了一个列表[('one', 1), ('two', 2), ('three', 3)]作为参数，该列表由3个元组组成。与第3行代码相同，每个元组对应所创建字典中的一个元素，元组中索引值为0的元素作为字典中元素的键，而元组中索引值为1的元素作为字典中元素的值。
• 第5行代码使用dict创建字典对象，传入了一个字典{'one':1, 'two':2, 'three':3}作为参数。dict会根据传入的字典对象创建一个新的字典对象，新的字典对象与传入的字典对象具有完全相同的元素，即实现了字典的复制。
与字符串、列表、元组这些序列数据不同，在访问字典中的元素时不能使用整数索引的方式，而是要以键作为元素的索引。例如，先执行a={'one':1, 'two':2, 'three':3}，再执行print(a[0])，则会产生报错信息“KeyError: 0”，即“键错误：0”（表示未找到键为0的元素），如图2-23所示。
图2-23 使用整数索引访问字典元素时所产生的报错信息
代码清单2-11给出了以键作为索引访问字典元素的示例。
表1-2 Python部分版本的信息
代码清单2-11执行完毕后，第2～6行代码分别按对应注释中的描述输出结果，如图2-24所示。
图2-24 代码清单2-11的运行结果
代码清单2-11中各行代码的描述如下。
• 第1行代码创建了一个包含3个元素的字典对象。第一个元素的键是字符串'name'，值是字符串'张三'；第二个元素的键是字符串'age'，值是整数19；第三个元素的键是字符串'score'，值是字典{'python': 95, 'math':92}。
• 第2行代码中，info['name']的作用是访问键为字符串'name'的元素的值，因此返回结果是字符串'张三'。
• 第3行代码中，info['age']的作用是访问键为字符串'age'的元素的值，因此返回结果是整数19。
• 第4行代码中，info['score']的作用是访问键为字符串'score'的元素的值，因此返回结果是字典{'python':95, 'math':92}。
• info['score']访问的元素的值是字典{'python':95, 'math':92}，因此在第5行和第6行代码中可以分别通过info['score']['python']和info['score']['math']访问字典{'python':95, 'math':92}中键为字符串'python'的元素的值和键为字符串'math'的元素的值，返回值分别为整数95和整数92。
【思考题2-19】 下列选项中，错误的描述是（ ）。
A.字典中的每一个元素是一个键：值对
B.字典中不同元素的键不能相同
C.字典中不同元素的值不能相同
D.通过“{}”可以创建一个空字典
【思考题2-20】 下列选项中，不能创建字典对象的语句是（ ）。
A.{'one':1, 'two':2, 'three':3}
B.dict('one':1, 'two':2, 'three':3)
C.dict([('one', 1), ('two', 2), ('three', 3)])
D.dict(zip(['one', 'two', 'three'], [1, 2, 3]))