每日一课 | 深度剖析元组、字典、集合与列队

﹏ヽ暗。殇╰゛Y 2023-01-22 07:57 103阅读 0赞

![677b744f52b6549e90024b298826f7ee.png][]

Python大本营每日一课

大家好，我是营长，上期营长分享了数据科学”的知识点：，不清楚的小伙伴可戳这????[每日一课|字符串、列表和栈][Link 1]

本期营长将为大家分享如何快速入门Python开发。

这期分享营长邀请的是应书澜（深耕 Java 技术栈，在 Python、C 语言方面亦有丰富经验，擅长预测算法，分布式中间件）分享Python开发14天快速入门

**元组、字典、集合与列队**

DAY02

###  ###

**元组**

在上一篇文章中我们介绍了列表，本文将介绍与列表类似的一种数据结构：元组。Python 的元组与列表有很多类似的地方，但区别也是很明显的：

*  定义方式不一样：列表采用方括号 `[]`，元组采用圆括号 `()`；
 *  元组中的元素不能改变，元组一旦创建就不能再对其中的元素进行增、删、改，只能访问。

####  ####

**创建元组**

#创建3个元组，和列表类似，同一个元组中可以存放任意数据类型
    tuple1 = ()
    tuple2 = (12,)
    tuple3 = (1, 2, 3, 4, 5)
    tuple4 = (3.14, 5.96, 1897, 2020, "China",3+4j) 
    tuple5 = 4,5,6,7

如上所示，元组和列表类似，同一个元组中可以没有数据，也可以有多种数据，非常灵活。

不过需要注意：

1.  如果元组只有一个元素，那么这个元素后面要加逗号，如 tuple2，否则将被认为是一个基本数据类型，而不是元组；
2.  创建元组，可以没有括号，元素之间用逗号分隔开即可。

####  ####

**访问元组中的元素**

元组和列表都是一种序列，因此，也可以通过索引来访问，方法是一样的，如下例子：

tuple1 = (3.14, 5.96, 1897, 2020, "China",3+4j) 
    print("tuple1[2]:",tuple1[2])
    print("tuple1[1:3]:",tuple1[1:3])

执行结果：

tuple1[2]: 1897
    tuple1[1:3]: (5.96, 1897)

元组相关的常用内建方法

tuple1 = (3.14, 5.96, 1897, 2020, 1949) 
    
    #求元组长度，即元组中元素的个数:len(tuple)
    print("The length of the tuple: ", len(tuple1))
    
    #求元组中元素的最大值：max(tuple)
    print("The largest element in the tuple: ", max(tuple1))
    
    #求元组中元素的最小值：min(tuple)
    print("The smallest element in the tuple: ", min(tuple1))
    
    #统计某个元素在元组中出现的次数：tuple.count(obj)
    print("The number of times 1949 appears: ", tuple1.count(1949))
    
    #从元组中找出某个值第一个匹配项的索引位置：tuple.index(obj)
    print("The index of the first location of 1949: ", tuple1.index(1949))
    执行结果：
    The length of the tuple: 5
    The largest element in the tuple: 2020
    The smallest element in the tuple: 3.14
    The number of times 1949 appears:  1
    The index of the first location of 1949: 4

####  ####

**元组常用的操作**

元组常用的运算操作与列表相同，包括：元组拼接、元组乘法、迭代、嵌套等。简要举例如下：

tuple1 = (1,2,3,4)
    tuple2 = (5,6,"BeiJin",7,8)
    
    #元组拼接
    print("tuple1 + tuple2:",tuple1 + tuple2)
    
    #元组乘法
    print("tuple1*2:",tuple1*2)
    
    #判断元素是否存在于元组中
    print("3 in tuple1?",3 in tuple1)
    print("100 in tuple1?",100 in tuple1)
    
    #迭代
    for element in tuple1:
    print(element)
        
    #元组嵌套
    tuple3 = [tuple1, tuple2]
    print("tuple3:", tuple3)

**执行结果：**

tuple1 + tuple2: (1, 2, 3, 4, 5, 6, 'BeiJin', 7, 8)
    tuple1*2: (1, 2, 3, 4, 1, 2, 3, 4)
    3 in tuple1? True
    100 in tuple1? False
    1
    2
    3
    4
    tuple3: [(1, 2, 3, 4), (5, 6, 'BeiJin', 7, 8)]

###  ###

**字典**

Python 的字典可以理解为一种映射表，存储 key-value（键值对）类型数据的容器。关于字典有三点需要注意：

1.  同一个字典中，键必须是唯一的，不存在两个相同的键，键的值不能改变，数据类型可以是数字，字符串或者元组；
2.  同一个字典中，值不必唯一，值可以是任意数据类型；
3.  字典定义采用花括号 \{\}，键值之间用冒号隔开，键值对之间用逗号隔开；

####  ####

**创建字典**

#创建几个字典
    dict1 = {"ID0012":"ZhangSan", "ID0019":"LiSi", "ID0015":"WangWu"}
    dict2 = {1:"BeiJin",3:"ShangHai",5:"HangZhou"}
    dict3 = {"Excellent":100, "Good":80, "Pass":60, "Fail":50}
    #字典也可以嵌套
    dict4 = {"A":["LiTong","XiaoMing"], "B":["XiaoHong","XiaoHua"]}

####  ####

**访问字典中的元素**

与列表和元组不同，访问字典中的元素不能通过索引，字典中键和值是成对的，而键是唯一的，那么，通过键就可以访问对应的值。

访问有两种方式：

1.  直接通过键来访问；
2.  通过内建 get(key) 方法访问。

**如下例子：**

dict1 = {"Excellent":100, "Good":80, "Pass":60, "Fail":50}
    dict2 = {1:"BeiJin",3:"ShangHai",5:"HangZhou"}
    print("dict1['Good']:", dict1['Good'])
    print("dict2[1]:", dict2[1])
    print("dict1.get('Good'):", dict1.get('Good'))

**执行结果：**

dict1['Good']: 80
    dict2[1]: BeiJin
    dict1.get('Good'): 80

**修改字典中的元素**

dict1 = {"Excellent":100, "Good":80, "Pass":60, "Fail":50}
    dict1['Good'] = 85
    print("dict1['Good']:", dict1.get('Good'))

**执行结果：**

dict1['Good']: 85

####  ####

**删除字典中的元素或字典**

和列表一样，可以通过 del 语句删除字典中的元素或者删除整个字典，可以通过内建方法 clear() 清空字典，还可以通过内建方法 pop(key) 删除指定的元素，如下例子：

dict1 = {"Excellent":100, "Good":80, "Pass":60, "Fail":50}
    
    #删除字典中的一个元素
    del dict1['Good']
    print("dict1:", dict1)
    
    #使用内建方法pop(key)删除指定元素
    dict1.pop('Pass')
    print("dict1:", dict1)
    
    #清空字典
    dict1.clear()
    print("dict1:", dict1)
    
    #删除字典
    del dict1

**执行结果：**

dict1: {'Excellent': 100, 'Pass': 60, 'Fail': 50}
    dict1: {'Excellent': 100, 'Fail': 50}
    dict1: {}

**字典的常用内建方法**

dict1 = {"Excellent":100, "Good":80, "Pass":60, "Fail":50}
    
    #计算字典的长度
    print("The length of the dict1: ", len(dict1))
    
    #获取字典中所有的键
    print("Get all the keys in dict1:\n", dict1.keys())
    
    #获取字典中所有的值
    print("Get all the values in dict1:\n", dict1.values())
    
    #获取字典中所有的键值对
    print("Get all the key-value pairs in dict1:\n", dict1.items())

**执行结果：**

The length of the dict1: 4
    Get all the keys in dict1:
     dict_keys(['Excellent', 'Good', 'Pass', 'Fail'])
    Get all the values in dict1:
     dict_values([100, 80, 60, 50])
    Get all the key-value pairs in dict1:
     dict_items([('Excellent', 100), ('Good', 80), ('Pass', 60), ('Fail', 50)])

###  ###

**集合**

集合（set）是一个数学概念，是由一个或多个确定的元素所构成的整体。

集合具有三个特点：

1.  确定性，集合中的元素必须是确定的；
2.  互异性，集合中的元素互不相同；
3.  无序性，集合中的元素没有先后之分。

根据集合的特点，Python 中集合的基本功能包括关系测试和消除重复元素。

#### **创建集合** ####

可以用大括号（\{\}）创建集合。但需要注意，如果要创建一个空集合，必须用 set() 而不是 \{\} ；后者创建一个空的字典。

country1 = {'China', 'America', 'German'}
    country2 = set('China')
    country3 = set()
    
    print("country1:",country1)
    print("country2:",country2)
    print("country3:",country3)

**执行结果：**

('country1:', set(['German', 'America', 'China']))
    ('country2:', set(['i', 'h', 'C', 'a', 'n']))
    ('country3:', set([]))

#### 操作集合中的元素 ####

我们可以访问集合中的元素，也可增加，移除元素。

setA = {'A', 'B', 'C'}
    
    print("setA:",setA)
    setA.add('D')
    print("setA.add('D'):",setA)
    setA.add('A')
    print("setA.add('A'):",setA)
    setA.remove('A')
    print("setA.remove('A'):",setA)

**执行结果：**

('setA:', set(['A', 'C', 'B']))
    ("setA.add('D'):", set(['A', 'C', 'B', 'D']))
    ("setA.add('A'):", set(['A', 'C', 'B', 'D']))
    ("setA.remove('A'):", set(['C', 'B', 'D']))

####  ####

**集合运算**

对于集合，我们可以计算交集、并集、补集。

setA = {'A', 'B', 'C'}
    setB = {'D', 'C', 'E'}
    
    #交集
    print("setA & setB:",setA&setB)
    
    #并集
    print("setA | setB:",setA|setB)
    
    #差集
    print("setA - setB:",setA-setB)

**执行结果：**

('setA & setB:', set(['C']))
    ('setA | setB:', set(['A', 'C', 'B', 'E', 'D']))
    ('setA - setB:', set(['A', 'B']))

###  ###

**队列**

前面已经介绍过列表，结合其内建函数 append(obj) 和 pop()，可以直接将列表作为栈使用。本节将介绍另一种数据结构——队列，即“先进先出”，就像排队打饭，队头的人先打到饭，队尾的人最后。Python 中有专门的队列模块 Queue，本节介绍一种用列表实现的队列，如下例子：

from collections import deque
    
    #基于列表初始化一个队列
    queue = deque(['A','B','C'])
    #队尾添加元素
    queue.append('D')
    print('queue',queue)
    #队头出列
    queue.popleft()
    print('queue',queue)
    #队头出列
    queue.popleft()
    print('queue',queue)

**执行结果：**

('queue', deque(['A', 'B', 'C', 'D']))
    ('queue', deque(['B', 'C', 'D']))
    ('queue', deque(['C', 'D']))

**下期预告****：****元组、字典、集合与队列**

以上内容均来自CSDN GitChat《Python开发14天快速入门》，作者应书澜，，识别二维码查看专栏更多详情。

**仅限5月14日-5月20日**

**仅需29元**

**识别二维码查看详情**

**????????**

![711dbbb54b22a6fd9a7255a924eb491d.png][]

**点击原文，查看更多**

[677b744f52b6549e90024b298826f7ee.png]: /images/20221020/3074817dcfb44e85ad5518b0d9e22b2c.png
[Link 1]: http://mp.weixin.qq.com/s?__biz=MzU5MjEwMTE2OQ%3D%3D&chksm=fe266c5cc951e54af952d5d79c607b4e217ff595ca1967eb18bc3c1c3c190f20d95426cea698&idx=2&mid=2247501314&scene=21&sn=1ccc99fab88d1cc0ca2889da03dd24f5#wechat_redirect
[711dbbb54b22a6fd9a7255a924eb491d.png]: /images/20221020/9397fe146198460390cb8adaa93e396b.png