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}