Python之组合数据类型（列表、元组、集合、字典）+列表与字典的互相转化

Python之组合数据类型（列表、元组、集合、字典）+列表与字典的互相转化

第1关：列表及 *** 作
任务描述
本关任务：学习列表的定义和表示，了解列表的相关 *** 作。

相关知识
为了完成本关任务，你需要掌握：1.列表是什么，2.如何访问列表元素，3.对列表元素进行 *** 作。

列表是什么
列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可。

简单来说列表是由一系列元素按特定顺序排列组成。你可以创建包含字母表中所有字母/数字0-9或一些字符串的列表；可以将其他数据类型放入列表中，甚至可以将另一个列表放在列表中。

在 Python 中，用方括号[]来表示列表，并用逗号来分隔其中的元素。

例如：

a = [] #创建一个空的列表
b = [1,2,3,4] #创建一个含数字的大小为 4 的列表
c = [1,‘a’,2,‘b’,3,‘c’,4,‘d’] #创建包含多种数据类型的列表
a = [b,c] #创建包含其他列表的列表
print(a)
[[1,2,3,4],[1,‘a’,2,‘b’,3,‘c’,4,‘d’]]
如何访问列表中的元素
先可以考虑前面所学的字符串类型的数据访问，例如有一字符串：
“abcd”
如果我们需要看它的某个特定位置上的字符是什么，则只要知道它的索引位置就行了，索引位置如下图：

字符串 a b c d
索引 -> 0 1 2 3
索引 <- 0 -3 -2 -1
计算机存储数据的位置都是从0号位置开始存储的，习惯使用从左往右进行访问，特殊情况可从右往左访问，即从0号位置开始，到-1号位置在最右边（最后）往左（前）访问。要访问上面那个字符串"abcd"中的字符b的话，我们可以用这样一种形式：

“abcd”[1] #或 “abcd”[-3]
字符b的索引位置在字符串"abcd"中为1(或-3)，所以可以通过加中括号"[]"(中括号内为索引位置)的形式访问。
通常我们习惯将这个字符串赋值给一个变量然后通过变量名进行 *** 作：

a = “abcd”
print(a[1]) #输出变量a储存的字符串索引位置为2的字符
b
与字符串的索引一样，列表索引从0开始。列表可以进行截取、组合等。使用索引位置来访问列表中的值，同样你也可以使用方括号的形式访问索引位置，如下所示：

list = [‘physics’, ‘chemistry’, 1997, 2000]
print(list[0])
physics

print([‘physics’, ‘chemistry’, 1997, 2000][0])
physics
以上两种形式都可以访问列表list索引位置为0的数据physics，第一个通过变量间接访问，第二个是直接访问，形式均为：

列表[索引位置]
可见当一个变量被赋值为某种数据类型时，该变量就相应变为了赋值的数据类型。例如：

a = 10 #此时a的数据类型为整数类型
a = [‘physics’, ‘chemistry’] #此时变为列表
a[1] #对应 列表[索引位置] 的形式来访问特定位置
若要继续访问列表[‘physics’, ‘chemistry’]中元素字符串physics的某个位置上的字符，可继续采用后面加[]的形式，例如：

a = 10 #此时a的数据类型为整数类型
a = [‘physics’, ‘chemistry’] #此时变为列表
print(a[0]) #打印第一个元素（这里为字符串）
physics

print(a[0][1]) #打印第一个元素的第二个位置上的字符
h
注意[]内的索引数字大小必须小于要访问元素长度，例如：
a = [‘physics’, ‘chemistry’] 以a[x]访问列表元素，则x要小于列表元素个数2并且要大于-3，以a[x][y]访问列表元素（这里是字符串，单个数据元素不用此 *** 作）内的元素时，则y要小于列表元素里的元素长度，例如列表0号元素physics长度为7，则y小于7，且大于-8依次类推。
#####列表的相关 *** 作

列表的相关 *** 作有以下几种：

增加元素
通过使用append()函数来在列表末尾处添加列表元素:

list = [] #创建空列表
list.append(‘Google’) #使用append()添加元素
list.append(‘Runoob’)
print(list)
[‘Google’, ‘Runoob’] #结果
添加的元素按append()函数从上到下的先后顺序在列表中从左至右的顺序存放。

删除元素
通过使用pop()函数来删除列表末尾处的列表元素：

list = [‘Google’, ‘Runoob’]
list.pop()
print(list)
[‘Google’]
这里需要注意的是pop()函数也可以通过指定索引位置来删除列表特定位置的数据，例如：

list = [‘Google’, ‘Runoob’]
list.pop(0)
print(list)
[‘Runoob’]
还可以使用remove()函数来删除指定的内容：

list = [‘Google’, ‘Runoob’]
list.remove(‘Google’)
print(list)
[‘Runoob’]
两种方式都可以将列表中的元素删除，可在不同情形下使用。
######替换元素
如果想要改变一个有数据的列表某个特定位置上的数据，我们可以通过类似赋值的方式进行：

list = [‘Google’, ‘Runoob’]
list[0] = “Baidu”
print(list)
[‘Baidu’, ‘Runoob’]
列表运算符
与字符串一样，列表之间可以使用 + 号和 * 号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的列表。

Python 表达式 结果 描述
len([1, 2, 3]) 3 计算元素个数
[1, 2, 3] + [4, 5, 6] [1, 2, 3, 4, 5, 6] 连接
[‘Hi!’,] * 4 [‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’] 复制
3 in [1, 2, 3] True 元素是否存在
列表内置函数
Python列表包含了以下内置函数

函数名 描述
len(list) 计算列表元素个数。
max(list) 返回列表中元素最大值。
min(list) 返回列表中元素最小值。
list(str) 将字符串转换为列表。
#使用逗号运算符给多个变量赋值
t1,t2 = [10,30,50],[20,30,50]
print(len(t1))
print(min(t2))
print(max(t1))
#创建一个字符串a
a = “abcd”
print(list(a))
以上实例输出结果：

3
20
50
[‘a’,‘b’,‘c’,‘d’]
编程要求
请仔细阅读右侧代码，结合相关知识，在 Begin-End 区域内进行代码补充，完成列表的相关 *** 作。

测试说明
本关的测试文件是src/step0/list.py，测试过程如下：

平台自动编译并运行list.py，并获取相应的输出。
平台将程序输出与预期输出对比。如果一致则测试通过，否则测试失败。

#coding = utf-8
#********* Begin *********#
#第一步 请在列表fruit中找出不属于水果一类元素，赋值给变量 a
fruit = ["苹果","梨子","菠萝","黄瓜","香蕉"]
a = "黄瓜"
 
#第二步 将变量 a 的值添加到列表vegetable 的末尾
vegetable = ["土豆","萝卜","茄子","白菜"]
vegetable.append(a)

#第三步 删去列表fruit中不属于水果的元素
fruit.remove("黄瓜")
#第四步 将列表fruit和列表vegetable作为元素按顺序加入到列表food中
food =[ ["苹果","梨子","菠萝","香蕉"] , ["土豆","萝卜","茄子","白菜","黄瓜"]]

#最后打印输出列表food，打印输出列表food中第1个元素的第3个元素
print(food)
print(food[0][2])
#********* End *********#

第2关：元组及 *** 作
任务描述
本关任务：熟悉元组的相关知识，了解元组的使用。

相关知识
为了完成本关任务，你需要掌握：1.如何创建元组，2.如何使用元组。

创建元组
Python 的元组与列表类似，不同之处在于元组的元素不能修改。
元组使用小括号，列表使用方括号。

元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可。

创建空元组：

tup1 = ()
元组中只包含一个元素时，需要在元素后面添加逗号，避免与括号运算符混淆。

tup1 = (50,)
与列表一样，元组的创建也可以嵌套进行。

tup = (1,2,3,“abc”,(1,2,3,“abc”),[1,2,3,“abc”])
元组的使用
访问元组
与列表一样元组可以使用索引位置来访问元组中的值，如下实例:

tup1 = (‘physics’, ‘chemistry’, 1997, 2000)
tup2 = (1, 2, 3, 4, 5, 6, 7 )
print("tup1[0]: ", tup1[0])
print("tup2[-1]: ",tup2[-1])
以上实例输出结果：

tup1[0]: physics
tup2[-1]: 7
嵌套的元组访问元素与列表一样，通过再后面添加中括号的形式。

tup = (1,2,3,“abc”,(10,20,30))
print("tup[3][1]: ",tup[3][1])
print("tup[4][0]: ",tup[4][0])
以上实例输出结果：

tup[3][1]: b
tup[4][0]: 10
修改元组
元组中的元素值是不允许修改的，但我们可以对元组进行连接组合，如下实例:

-- coding: UTF-8 --

tup1 = (12, 34.56)
tup2 = (‘abc’, ‘xyz’)

以下修改元组元素 *** 作是非法的。 tup1[0] = 100 创建一个新的元组

tup3 = tup1 + tup2
print(tup3)
以上实例输出结果：

(12, 34.56, ‘abc’, ‘xyz’)

删除元组
元组中的元素值是不允许删除的。

元组运算符
与列表一样，元组之间可以使用+号和*号进行运算。这就意味着他们可以组合和复制，运算后会生成一个新的元组。

Python 表达式 结果 描述
len((1, 2, 3)) 3 计算元素个数
(1, 2, 3) + (4, 5, 6) (1, 2, 3, 4, 5, 6) 连接
(‘Hi!’,) * 4 (‘Hi!’, ‘Hi!’, ‘Hi!’, ‘Hi!’) 复制
3 in (1, 2, 3) True 元素是否存在
元组内置函数
Python 元组包含了以下内置函数

函数名 描述
len(tuple) 计算元组元素个数。
max(tuple) 返回元组中元素最大值。
min(tuple) 返回元组中元素最小值。
tuple(list) 将列表转换为元组。
#使用逗号运算符给多个变量赋值
t1,t2 = (10,30,50),(20,30,50)
print(len(t1))
print(min(t2))
print(max(t1))
#创建一个列表a
a = [1,2,3]
print(tuple(a))
以上实例输出结果：

3
20
50
(1,2,3)
编程要求
请仔细阅读右侧代码，结合相关知识，在 Begin-End 区域内进行代码补充，完成元组的相关 *** 作。

测试说明
本关的测试文件是src/step1/tuple.py，测试过程如下：

平台自动编译并运行tuple.py，并获取相应的输出。
平台将程序输出与预期输出对比。如果一致则测试通过，否则测试失败。

#coding = utf-8
#********* Begin *********#
#第一题  列表和元组相互转换，修改元组中的数据
#第一步  将元组 fruit 转换为一个名为 fruit 的列表并打印输出
fruit = ("苹果","梨子","菠萝","黄瓜","香蕉")
fruit = list(fruit)
print(fruit)

#第二步  在上一步得到的列表 fruit 通过索引位置将"黄瓜"去掉并打印输出
fruit.pop(3)
print(fruit)

#第三步  将上一步的到的列表 fruit 转换为元组并打印输出

fruit = tuple(fruit)
print(fruit)

#第二题  通过元组的嵌套修改元组中的数据

#第一步  创建元组 food 将列表 fruit 和 vegetable 放入其中并打印输出元组food

fruit = ["苹果","梨子","菠萝","黄瓜","香蕉"]
vegetable = ["土豆","萝卜","茄子","白菜"]
food = (fruit,vegetable)
print(food)

#第二步  打印输出上一步得到的元组 food 的第一个元素（列表fruit）
print(food[0])

#第三步  通过索引位置去掉元组 food 的第一个元素（列表fruit）的"黄瓜"
fruit.remove("黄瓜")
print(food[0])          #打印输出列表 food 的第一个元素

#第四步  打印输出元组 food 
print(food)
#********* End *********#

第3关：集合及 *** 作
任务描述
本关任务：熟悉集合的相关知识，了解集合的使用。

相关知识
为了完成本关任务，你需要掌握：1.集合的创建，2.集合的相关 *** 作。

集合的创建
集合（set）与数学意义相同，是一个无序的元素不重复的序列。

我们可以使用大括号 { } 或者set()函数创建集合，注意：创建一个空集合必须用set()而不是 { }，因为 { } 是用来创建一个空字典。

创建格式：

parame = {value01,value02,…}

或者：

set(value)

a = {‘apple’, ‘orange’, ‘pear’}
a
{‘apple’, ‘orange’, ‘pear’}

s = set() #使用set()创建一个空的集合
集合的 *** 作
集合去重
重复元素在set中自动被过滤,即去重功能：

fruit = {‘apple’, ‘orange’, ‘apple’, ‘pear’}
print(basket)
{‘orange’, ‘pear’, ‘apple’} #集合是无序的

s = set([1, 1, 2, 2, 3, 3]) #对列表去重
s
{1, 2, 3}
添加元素
通过add(key)方法可以添加元素到set中，可以重复添加，但不会有效果：

s = {1,2,3,4}
s
{1, 2, 3, 4}

s.add(4) #添加重复元素 4
s
{1, 2, 3, 4}
删除元素
通过remove(key)方法可以删除元素：

s.remove(4) #删除元素 4而不是索引位置 4
s
{1, 2, 3}
集合运算
两个set可以做数学意义上的交集、并集等运算：

a = {1,2,3,4}
b = {4,5,6,7}
a - b # 只在集合a中包含元素
{1,2,3}

a | b # 集合a或b中包含的所有元素
{1,2,3,4,5,6,7}

a & b # 集合a和b中都包含了的元素
{4}

a ^ b # 不同时包含于a和b的元素
{1,2,3,5,6,7}
常用 *** 作
计算集合的大小可使用函数len()

thisset = {“Google”, “Runoob”, “Taobao”}
len(thisset)
3
使用in判断元素是否在集合中：

thisset = {“Google”, “Runoob”, “Taobao”}
“Runoob” in thisset
True

“Facebook” in thisset
False
编程要求
请仔细阅读右侧代码，结合相关知识，在 Begin-End 区域内进行代码补充，完成集合的相关 *** 作。

测试说明
本关的测试文件是src/step2/set.py，测试过程如下：

平台自动编译并运行set.py，并获取相应的输出。
平台将程序输出与预期输出对比。如果一致则测试通过，否则测试失败。

# -*- coding: utf-8 -*-
#********* Begin *********#
#第一步 请将列表fruit转换为一个集合
fruit = ["苹果","梨子","菠萝","黄瓜","香蕉"]
fruit = set(fruit)
#第二步 将集合fruit中的“黄瓜”去掉
fruit.remove("黄瓜")

#第三步 使用"in"判断"黄瓜"是否在fruit中，将判断结果打印输出
print("黄瓜" in fruit)
#第四步 创建空集合food，输出集合food的长度
food = set()

print(len(food))

#第五步 将fruit和vegetable合并到food并输出此时food的长度
vegetable = {"土豆","萝卜","茄子","白菜"}
food = fruit | vegetable
print(len(food))
#********* End *********#

第4关：字典及 *** 作
任务描述
本关任务：熟悉字典的相关知识，了解字典的使用。

相关知识
为了完成本关任务，你需要掌握：1.字典的定义，2.字典的相关 *** 作。

字典的定义
字典是 Python 最强大的数据类型之一，通过键-值(key-value)对的方式建立数据对象之间的映射关系。

字典的每个键-值对用冒号:分割，每个键-值对间用逗号,分隔开，字典是包含在{}中。

每个键都与一个值相关联，我们可以使用键来访问与之相关联的值。与键相关联的值可以是数字、字符串、列表乃至字典。

事实上，可将任何 Python 对象用作字典中的值。

字典的相关 *** 作
字典的创建
字典的创建格式如下所示：

d = {key1 : value1, key2 : value2 }

键必须是唯一的，但值则不必。

值可以取任何数据类型，但键必须是不可变的，如字符串，数字或元组。

一个简单的字典实例：

dict = {‘Alice’: ‘2341’, ‘Beth’: ‘9102’}
print(dict)
{‘Alice’: ‘2341’, ‘Beth’: ‘9102’}
访问字典中的值
要获取与键相关联的值，可依次指定字典名和放在方括号内的键。我们访问列表等其他类型是通过方括号[]内添加索引位置的形式，这里字典我们把索引位置用字典中的键(key)来代替。

把相应的键放入到方括号中（name[key]）:

dict = {‘Name’: ‘Runoob’, ‘Age’: 7}
print ("dict[‘Name’]: ", dict[‘Name’])
dict[‘Name’]: Runoob

print ("dict[‘Age’]: ", dict[‘Age’])
dict[‘Age’]: 7
添加元素（键-值对）
字典是一种动态数据结构，可随时在字典中添加键—值对。要添加键—值对时，可依次指定字典名、键和键对应的值。

下面在字典menu中添加两道菜的菜名和价格：

#coding=utf-8
#创建并初始化menu字典

menu = {‘鱼’:40, ‘猪肉’:30, ‘番茄’:15, ‘拉面’:10}
#向menu字典中添加菜名和价格

menu[‘果汁’] = 12
menu[‘煎蛋’] = 2
######输出新的menu

print(menu)
{‘鱼’: 40,‘猪肉’: 30,‘番茄’: 15,‘拉面’: 10, ‘果汁’: 12,‘煎蛋’: 2}
新的menu字典包含6个键-值对，新增加的两个键-值对（菜名和对应价格）添加在了原有键-值对的后面，注意字典中键-值对的排列顺序和添加顺序没有必然联系，Python 不关心字典中键-值对的排列顺序，而只关心键与值得对应关系。

同理，字典和列表一样，可以先创建一个空字典，然后可以不断向里面添加新的键-值对。

修改字典中的值
字典和列表一样，里面的值都是可以修改的。要修改字典中的值，可直接指定字典中的键所对应的新值。例如，将menu中的fish价格改为50。

#coding = utf-8
#创建并初始化menu字典

menu = {‘鱼’:40, ‘猪肉’:30, ‘番茄’:15, ‘拉面’:10}

修改menu字典中菜fish的价格

menu[‘鱼’] = 50

打印输出新的menu

print(menu)
{‘鱼’: 50, ‘猪肉’: 30, ‘番茄’: 15, ‘拉面’: 10}
删除键-值对
我们可以通过del方法删除字典中不需要的键-值对，使用del方法时，要指定字典名和要删除的键。

例如，在menu菜单中删除键noodles和它的值。

创建并初始化menu字典

menu = {‘鱼’:40, ‘猪肉’:30, ‘番茄’:15, ‘拉面’:10}

删除noodles键值对

del menu[‘拉面’]

打印输出新的menu

print(menu)
{‘鱼’:40, ‘猪肉’:30, ‘番茄’:15}
编程要求
请仔细阅读右侧代码，结合相关知识，在 Begin-End 区域内进行代码补充，完成字典的相关 *** 作。

测试说明
本关的测试文件是src/step3/dict.py，测试过程如下：

平台自动编译并运行dict.py，并获取相应的输出。
平台将程序输出与预期输出对比。如果一致则测试通过，否则测试失败。

# -*- coding: utf-8 -*-
#********* Begin *********#
#第一步 创建一个空字典 menu
#第二步 将列表fruit中水果与prices中的价格对应给menu赋值并输出
fruit = ["苹果","梨子","菠萝","黄瓜","香蕉"]
prices = [2,3,10,2,1]
f1=zip(fruit,prices)
menu = dict(f1)
print(menu)

#第三步 将20块钱的"哈密瓜"添加到字典menu中并输出
menu['哈密瓜'] = 20
print(menu)

#第四步 将"黄瓜"从menu中去掉并输出
del menu['黄瓜']
print(menu)

#第五步 将菠萝的价格修改为9.9，打印输出menu
menu['菠萝'] = 9.9
print(menu)
#********* End *********#

列表与字典的互相转化

字典转列表

d = {'a':1,'b':2 }
a = list(d.keys())
b = list(d.values())
print(a)        # 本行的输出为： ['a','b']
print(b)        # 本行的输出为：[1,2]

列表转字典
两个列表转为字典(使用zip函数)

l = ['a','b','c']
t = [1,2,3]
zip(l,t)
c = dict(zip(l,t))
print(c)    # 本行的输出为： {'a':1,'b':2,'c':3}