python基础彻底学会列表和元组（Python序列的元组字典）

python基础彻底学会列表和元组（Python序列的元组字典）通过下面的代码，我们可以看出元组和列表的区别：如果希望修改元组的元素，只能通过创建一个新的元组的方式来实现。所以，可以把元组理解为只读版的列表。o=(3 'abc' [1 2 3]) print(o[1]) o[1]=999 print(o) 运行结果： abc Traceback (most recent call last): File "F:\Python程序\元组，字典，集合示例.py" line 9 in <module> o[1]=999 TypeError: 'tuple' object does not support item assignment元组创建的方法一：#创建元组，如果只有一个元素，需要加上逗号 p=(3 ) q=(3) o=(3 'abc' [1 2 3]) pri

带你走进 @ 机器人时代

Discover 点击上面蓝色文字，关注我们

Python序列除了列表外，还有元组、字典、集合等序列结构，他们各有不同的功能和应用，今天我们来看看。

元组相当于是不可变的列表，一旦创建就不能修改。

o=(3 'abc' [1 2 3]) print(o[1]) o[1]=999 print(o) 运行结果： abc Traceback (most recent call last): File "F:\Python程序\元组，字典，集合示例.py" line 9 in <module> o[1]=999 TypeError: 'tuple' object does not support item assignment

元组创建的方法一：

#创建元组，如果只有一个元素，需要加上逗号 p=(3 ) q=(3) o=(3 'abc' [1 2 3]) print(type(p)) print(type(q)) print(type(o)) 运行结果： <class 'tuple'> <class 'int'> <class 'tuple'>

元组创建的方法二：
使用tuple()函数创建或转换为元组：

#使用tuple()函数创建元组 p=tuple('ABC') print(type(p)) q=tuple([1 2 3 4 '5']) print(type(q) '\n' q) o=tuple(range(1 5)) print(type(q) '\n' o) 运行结果： <class 'tuple'> <class 'tuple'> (1 2 3 4 '5') <class 'tuple'> (1 2 3 4)

访问元组的方法和访问列表的方法大同小异，可以通过索引号、切片的方式访问。

如果希望修改元组的元素，只能通过创建一个新的元组的方式来实现。所以，可以把元组理解为只读版的列表。

通过下面的代码，我们可以看出元组和列表的区别：

#元组和列表的区别 #测试内存占用 p=[] print('列表的存储空间：' p.__sizeof__()) q=() print('元组的存储空间：' q.__sizeof__()) 运行结果： 列表的存储空间：40 元组的存储空间：24

字典：是一种无序的、可变的序列，它的元素以“键值对（key-value）”的形式存储。如：{1:'abc' 2:'efg'}这种形式，1是键 abc是键值。

它主要有这些特征：键是唯一的，不能重复；键不可变，只能使用数字、字符串或者元组，不能使用列表；字典是可变的，可以任意嵌套；字典是任意数据的无序集合；通过键来读取数据，而不是通过索引。

我们来看看下面几种创建字典的方式：

#字典的创建 p={1:'abc' 2:'efg'} print(p type(p)) m=dict.fromkeys(['张三' '李世' '王五'] 60) print(m type(m)) n=dict(a='手机' b='电脑') print(n type(n)) d = (['two' 2] ['one' 1] ['three' 3]) a = dict(d) print(a type(a)) 运行结果： {1: 'abc' 2: 'efg'} <class 'dict'> {'张三': 60 '李世': 60 '王五': 60} <class 'dict'> {'a': '手机' 'b': '电脑'} <class 'dict'> {'two': 2 'one': 1 'three': 3} <class 'dict'>

访问字典的方式有两种：

#访问字典 p={'two': 99999 'one': 88888 'three': 3} print(p['one']) print(p.get('one')) 运行结果： 88888 88888

通过以下代码，我们看看对字典的增删改查的操作：

#访问字典 p={'two': 99999 'one': 88888 'three': 3} #增加一堆键及键值 p['three']=77777 print(p) #修改键及键值 p['three']=66666 print(p) #删除键及键值 del p['three'] print(p) #判断键是否存在 print('two' in p) print('four' in p) 运行结果： {'two': 99999 'one': 88888 'three': 77777} {'two': 99999 'one': 88888 'three': 66666} {'two': 99999 'one': 88888} True False

获取字典中特定的数据，我们还可以使用下列方法：
keys() 方法用于返回字典中的所有键（key）；
values() 方法用于返回字典中所有键对应的值（value）；
items() 用于返回字典中所有的键值对（key-value）；

p={'two': 99999 'one': 88888 'three': 3} print(p.keys()) #取得键 print(p.values()) #取得键值 print(p.items()) #取得键值对 运行结果： dict_keys(['two' 'one' 'three']) dict_values([99999 88888 3]) dict_items([('two' 99999) ('one' 88888) ('three' 3)]) #注意返回值的类型

如果要操作这些返回值，需要转换为列表：

p={'two': 99999 'one': 88888 'three': 3} print(p.keys()) #取得键 #注意返回值的类型 s=list(p.keys()) print(s type(s)) 运行结果: dict_keys(['two' 'one' 'three']) ['two' 'one' 'three'] <class 'list'>

我们也可以使用循环来遍历字典：

p={'two': 99999 'one': 88888 'three': 3} for i j in p.items(): print(i j) 运行结果： two 99999 one 88888 three 3

copy()方法：

#copy()方法 a = {'one': 1 'two': 2 'three': [1 2 3]} b = a.copy() #向 a 中添加新键值对，由于b已经提前将 a 所有键值对都深拷贝过来 # 因此 a 添加新键值对，不会影响 b。 a['four']=100 print(a) print(b) #由于 b 和 a 共享[1 2 3]（浅拷贝） # 因此移除 a 中列表中的元素，也会影响 b。 a['three'].remove(1) print(a) print(b) 运行结果： {'one': 1 'two': 2 'three': [1 2 3] 'four': 100} {'one': 1 'two': 2 'three': [1 2 3]} {'one': 1 'two': 2 'three': [2 3] 'four': 100} {'one': 1 'two': 2 'three': [2 3]}

update()方法：

#update方法 a = {'one': 1 'two': 2 'three': 3} a.update({'one':9 'four': 12}) print(a) 运行结果： {'one': 9 'two': 2 'three': 3 'four': 12}

pop() 和 popitem() 方法：删除键值对

#pop() 和 popitem() 方法删除键值对 a = {'数学': 100 '语文': 99 '英语': 80} print(a) a.pop('语文') print(a) a.popitem() print(a) 运行结果： {'数学': 100 '语文': 99 '英语': 80} {'数学': 100 '英语': 80} {'数学': 100}

popitem() 总是弹出底层中的最后一个 key-value，这和列表的 pop() 方法类似。

setdefault() 方法用来返回某个 key 对应的 value；如果该 key 存在，那么直接返回该 key 对应的 value；
如果该 key 不存在，那么先为该 key 设置默认值，然后再返回该 key 对应的 默认值。

字典可以用来格式化字符串，我们来看看它的应用：

#使用字典格式化字符串 # 字符串模板中使用key t = '我们国家%(a1)s 有%(a2).0f年的历史，拥有人口：%(a3)s' c = {'a1':'自古以来' 'a2': 5000 'a3': '14亿'} # 使用字典为字符串模板中的key传入值 print(t % c) 运行结果： 我们国家自古以来 有5000年的历史，拥有人口：14亿

集合：与数学中的集合概念一样，用来保存不重复的元素，所有的元素都是唯一的。

同一集合中，只能存储不可变的数据类型，包括整形、浮点型、字符串、元组，无法存储列表、字典、集合这些可变的数据类型。

可以用{}和set()方法来创建集合，它最实用的特点就是用来过滤重复的数据。一般来说，由于集合是无序的，所有我们在访问集合的时候采用循环的方式来读取数据。

通过代码，我们可以看到集合操作的一些方法：

#集合的操作 p={1 2 3 4 6 7 7 8 9 9 0} #集合会自动删除重复的元素 print(p type(p)) #向集合中添加元素 p.add('ABC') print(p type(p)) #从集合中删除元素 p.remove(9) print(p type(p)) #使用discard()删除元素，失败不会报错 p.discard('ABD') print(p type(p)) q={3 4 5 999 'ABC' 'CD'} #集合的交集运算 print(p&q) #集合的并集运算 print(p|q) #集合的差集运算 # 取一个集合中另一集合没有的元素 print(p-q) #取集合 A 和 B 中不属于 A&B 的元素 print(p^q) 运行结果： {0 1 2 3 4 6 7 8 9} <class 'set'> {0 1 2 3 4 'ABC' 6 7 8 9} <class 'set'> {0 1 2 3 4 'ABC' 6 7 8} <class 'set'> {0 1 2 3 4 'ABC' 6 7 8} <class 'set'> {'ABC' 3 4} {0 1 2 3 4 'ABC' 6 7 8 5 999 'CD'} {0 1 2 6 7 8} {0 1 5 2 6 7 8 'CD' 999}

下面总结集合的一些方法：

方法名	语法格式	功能
add()	set1.add()	向 set1 集合中添加数字、字符串、元组或者布尔类型
clear()	set1.clear()	清空 set1 集合中所有元素
copy()	set2 = set1.copy()	拷贝 set1 集合给 set2
difference()	set3= set1.difference(set2)	将 set1 中有而 set2 没有的元素给 set3
difference_update()	set1.difference_update(set2)	从 set1 中删除与 set2 相同的元素
discard()	set1.discard(elem)	删除 set1 中的 elem 元素
intersection()	set3= set1.intersection(set2)	取 set1 和 set2 的交集给 set3
intersection_update()	set1.intersection_update(set2)	取 set1和 set2 的交集，并更新给 set1
isdisjoint()	set1.isdisjoint(set2)	判断 set1 和 set2 是否没有交集，有交集返回 False；没有交集返回 True
issubset()	set1.issubset(set2)	判断 set1 是否是 set2 的子集
issuperset()	set1.issuperset(set2)	判断 set2 是否是 set1 的子集
pop()	a = set1.pop()	取 set1 中一个元素，并赋值给 a
remove()	set1.remove(elem)	移除 set1 中的 elem 元素
symmetric_difference()	set3= set1.symmetric_difference(set2)	取 set1 和 set2 中互不相同的元素，给 set3
symmetric_difference_update()	set1.symmetric_difference_update(set2)	取 set1 和 set2 中互不相同的元素，并更新给 set1
union()	set3 = set1.union(set2)	取 set1 和 set2 的并集，赋给 set3
update()	set1.update(elem)	添加列表或集合中的元素到 set1

在Python中还有一种frozenset 集合是不可变序列，程序不能改变序列中的元素。

# frozenset 集合 t = {'张三' '李四' '王五'} f = frozenset(['男' '女']) b = {'1班' '2班'} #向set集合中添加 t.add(f) print('t =' t) 运行结果： t = {frozenset({'男' '女'}) '李四' '王五' '张三'}

字典和集合是进行过性能高度优化的数据结构，特别是对于查找、添加和删除操作。

我们通过以下例子可以发现集合与列表在实际应用中的效率对比：

#初始化1万个产品的名称和价格 #分别用集合和列表来统计产品的价格数量 #计算耗时 #统计时间需要用到 time 模块中的函数 import time def find_11(pd): p_list = [] for _ price in pd: # A if price not in p_list: #B p_list.append(price) return len(p_list) id = [x for x in range(0 10000)] price = [x for x in range(20000 30000)] pd = list(zip(id price)) # 计算列表版本的时间 开始时间 = time.perf_counter() find_11(pd) 结束时间 = time.perf_counter() print("列表总共用时: {}".format(结束时间 - 开始时间)) #使用集合完成同样的工作 def find_s(pd): u_set = set() for _ price in pd: u_set.add(price) return len(u_set) # 计算集合版本的时间 开始时间1 = time.perf_counter() find_s(pd) 结束时间1 = time.perf_counter() print("集合总共用时: {}".format(结束时间1 - 开始时间1)) 运行结果： 列表总共用时: 0.47609080000074755 集合总共用时: 0.0010524000008445

可见，Python序列的类型，各有各的用处

坚持学习，每天都能进步一点点！！

往期回顾：

• 来来来，送你一个金牌销售机器人，7X24小时不休，不要工资免费用！
• RPA技术在旅行社销售业务中如何凤凰涅槃？？
• 【工资翻三倍】系列：一招搞定九宫图片切割机器人，让你的朋友圈更加炫酷！

本文引用和摘录相关内容，请联系侵删。

- END -

最后，文章有帮助到你的话【点赞在看】
激励我们分享更多的干货！