Python序列的元组、字典、集合一次说清楚，绝不拖泥带水

带你走进 @ 机器人时代

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 
    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))

运行结果：

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

#使用tuple()函数创建元组
p=tuple('ABC')
print(type(p))
q=tuple([1,2,3,4,'5'])
print(type(q),'
',q)
o=tuple(range(1,5))
print(type(q),'
',o)

运行结果：

 
 (1, 2, 3, 4, '5')
 
 (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'} 
{'张三': 60, '李世': 60, '王五': 60} 
{'a': '手机', 'b': '电脑'} 
{'two': 2, 'one': 1, 'three': 3} 

访问字典的方式有两种：

#访问字典
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'] 

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

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} 
{0, 1, 2, 3, 4, 'ABC', 6, 7, 8, 9} 
{0, 1, 2, 3, 4, 'ABC', 6, 7, 8} 
{0, 1, 2, 3, 4, 'ABC', 6, 7, 8} 
{'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}

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

在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 -

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