Python学习笔记04-基础篇—元组、集合与字典

可以叫我才哥

发布于 2021-08-05 11:16:33

7920

发布于 2021-08-05 11:16:33

文章被收录于专栏：可以叫我才哥

1、元组 tuple

上一节我们介绍了列表List，在对列表进行使用的时候是可以修改其内部元素值的。有时候我们需要创建一系列不可修改的元素，便会用到元组。

1）创建空元组

元组用圆括号来标识，创建空元组可以使用()或者内建函数tuple

>>> Atuple = ()
>>> Atuple
()
>>> type(Atuple)
<class 'tuple'>
>>> Btuple = tuple()
>>> Btuple
()
>>> type(Btuple)
<class 'tuple'>

2）创建元组

语法上，元组是用逗号隔开一系列值元组在输出时总是被圆括号包围的，以便正确表示嵌套元组。输入时圆括号可有可无，不过经常会是必须的（如果这个元组是一个更大的表达式的一部分）例如：

>>> t = 1,2,3,4,5,'hello'
>>> t
(1, 2, 3, 4, 5, 'hello')

当使用内建函数tuple且实参是一个序列(字符串、列表或元组)，返回的将是一个包含序列内元素的元组

>>> t = tuple('123')
>>> t
('1', '2', '3')

使用单一元素同圆括号创建元组时，需要在结尾处添加一个逗号

>>> t = (1)
>>> t
1
>>> t = (1,)
>>> t
(1,)

3）元组元素的访问

元组和列表一样是一种序列类型，可以通过索引和切片进行元素的访问

>>> t = 1,'a',2,3,5,'8'
>>> t[1]
'a'
>>> t[-1]
'8'
>>> t[2:4]
(2, 3)

4）元组的不可改变

列表是可变的（mutable），元组是不可变的（immutable ）

>>> t
(1, 'a', 2, 3, 5, '8')
>>> t[1]
'a'
>>> t[1] = 'b'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment

5）序列解包

语句 t = 12345, 54321, 'hello!' 是元组打包的一个例子：值 12345, 54321 和 'hello!' 被打包进元组。其逆操作也是允许的（函数返回多个值可以采用元组）

>>> t = 12345, 54321, 'hello!'
>>> x,y,z = t
>>> x
12345
>>> y
54321
>>> z
'hello!'

2、集合 set

集合是由不重复元素组成的无序的集。它的基本用法包括成员检测和消除重复元素。集合对象也支持像联合，交集，差集，对称差分等数学运算。花括号或 set() 函数可以用来创建集合。注意：要创建一个空集合你只能用 set() 而不能用 {}，因为后者是创建一个空字典。

1）创建空集合

>>> a = set()
>>> a
set()
>>> type(a)
<class 'set'>
>>> a = {}  #这种方式是创建空字典
>>> type(a)
<class 'dict'>

2）创建集合

集合里的元素是不重复的，当我们创建一个含有重复元素的集合后，返回的集合结果会自动保留元素唯一性

>>> a = {'a','a','b','c','d'}
>>> a
{'c', 'd', 'a', 'b'}
>>> b = set('aabbccde')
>>> b
{'c', 'a', 'd', 'b', 'e'}

3）集合的数学运算

集合的数学运算也就是我们中学就学过的，并集交集差集等，可以通过运算符或者方法实现 ①并集 一组集合的并集就是他们所有元素组成的集合，可以使用运算符 | 或者 union方法实现

>>> a = {'a','b','c','d'}
>>> b = set('bcdef')
>>> b
{'c', 'd', 'b', 'f', 'e'}
>>> a | b
{'c', 'a', 'd', 'b', 'f', 'e'}
>>> a.union(b)
{'c', 'a', 'd', 'b', 'f', 'e'}

②交集 一组集合的交集就是他们各自均包含的元素组成的集合，可以使用运算符 & 或者intersection方法实现

>>> a
{'c', 'd', 'a', 'b'}
>>> b
{'c', 'd', 'b', 'f', 'e'}
>>> a & b
{'c', 'd', 'b'}
>>> a.intersection(b)
{'c', 'd', 'b'}

③差集 两个集合的差集就是你有我没有的元素组成的集合，可以使用运算符 - 或者 difference方法实现

>>> a
{'c', 'd', 'a', 'b'}
>>> b
{'c', 'd', 'b', 'f', 'e'}
>>> a - b
{'a'}
>>> a.difference(b)
{'a'}

④子集 若某个集合的元素均属于另外一个集合，则该集合为另外一个集合的子集，可以用运算符< 或者 issubset方法进行判断（返回布尔型结果）

>>> a
{'c', 'd', 'a', 'b'}
>>> b
{'c', 'd', 'b', 'f', 'e'}
>>> c = set('bcd')
>>> b < a
False
>>> c < a
True
>>> c.issubset(a)
True

⑤对称集

两个集合的对称差是只属于其中一个集合，而不属于另一个集合的元素组成的集合，可以使用 ^ 或者 symmetric_difference方法实现（可以理解为先并集-交集）

>>> a
{'c', 'd', 'a', 'b'}
>>> b
{'c', 'd', 'b', 'f', 'e'}
>>> a^b
{'a', 'f', 'e'}
>>> A = a|b
>>> B = a&b
>>> A-B
{'a', 'f', 'e'}

4）集合的一些操作方法

和序列类型列表的常见操作方法其实是差不多的

方法	描述
add()	为集合添加元素
clear()	移除集合中的所有元素
copy()	拷贝一个集合
difference()	返回多个集合的差集
difference_update()	移除集合中的元素，该元素在指定的集合也存在。
discard()	删除集合中指定的元素
intersection()	返回集合的交集
intersection_update()	返回集合的交集。
isdisjoint()	判断两个集合是否包含相同的元素，如果没有返回 True，否则返回 False。
issubset()	判断指定集合是否为该方法参数集合的子集。
issuperset()	判断该方法的参数集合是否为指定集合的子集
pop()	随机移除元素
remove()	移除指定元素
symmetric_difference()	返回两个集合中不重复的元素集合。
symmetric_difference_update()	移除当前集合中在另外一个指定集合相同的元素，并将另外一个指定集合中不同的元素插入到当前集合中。
union()	返回两个集合的并集
update()	给集合添加元素

3、字典 dict

字典在其他语言里可能会被叫做联合内存或联合数组。与以连续整数为索引的序列不同，字典是以关键字为索引的，关键字可以是任意不可变类型，通常是字符串或数字。如果一个元组只包含字符串、数字或元组，那么这个元组也可以用作关键字。但如果元组直接或间接地包含了可变对象，那么它就不能用作关键字。列表不能用作关键字，因为列表可以通过索引、切片或 append() 和 extend() 之类的方法来改变。

理解字典的最好方式，就是将它看做是一个键: 值对的集合，键必须是唯一的（在一个字典中）。一对花括号可以创建一个空字典：{} 。另一种初始化字典的方式是在一对花括号里放置一些以逗号分隔的键值对，而这也是字典输出的方式。

字典主要的操作是使用关键字存储和解析值。也可以用 del 来删除一个键值对。如果你使用了一个已经存在的关键字来存储值，那么之前与这个关键字关联的值就会被遗忘。用一个不存在的键来取值则会报错。对一个字典执行 list(d) 将返回包含该字典中所有键的列表，按插入次序排列 (如需其他排序，则要使用 sorted(d))。要检查字典中是否存在一个特定键，可使用in 关键字。

1）创建字典

使用{}或者内建函数dic()可以生成一个不含任何项的空字典 ①空字典

>>> d = {}
>>> d
{}
>>> type(d)
<class 'dict'>
>>> d = dict()
>>> d
{}
>>> type(d)
<class 'dict'>

②字典赋值 直接使用方括号向字典中新增项

>>> d
{}
>>> d['name'] = '才哥'
>>> d
{'name': '才哥'}

'name'为键（key）,'才哥'为其映射的值（value）

③创建含有元素项的字典

>>> name = {'上单':'吕布','中单':'貂蝉','刺客':'赵云'}
>>> name
{'上单': '吕布', '中单': '貂蝉', '刺客': '赵云'}
>>> name['刺客']
'赵云'
>>> name =dict(上单='吕布',中单='貂蝉',刺客='赵云')
>>> name
{'上单': '吕布', '中单': '貂蝉', '刺客': '赵云'}

在使用 dict() 函数创建字典时，可以传入多个列表或元组参数作为 key-value 对，每个列表或元组将被当成一个 key-value 对，因此这些列表或元组都只能包含两个元素。

>>> alist = ['上单', '吕布']
>>> dic = dict(alist)
>>> dic
{'上': '单', '吕': '布'}
>>> blist = [['上单', '吕布']]
>>> dic = dict(blist)
>>> dic
{'上单': '吕布'}
>>> ctuple = (('上单', '吕布'),( '中单', '貂蝉'),( '刺客', '赵云'))
>>> dic = dict(ctuple)
>>> dic
{'上单': '吕布', '中单': '貂蝉', '刺客': '赵云'}

2）访问字典中的值

直接用方括号[]即可得到关键字对应的值

>>> dic
{'上单': '吕布', '中单': '貂蝉', '刺客': '赵云'}
>>> dic['中单']
'貂蝉'

3）获取键或值

keys()方法可以获取字典的全部关键字，values()方法可以获取全部值

>>> dic
{'上单': '吕布', '中单': '貂蝉', '刺客': '赵云'}
>>> dic.keys()
dict_keys(['上单', '中单', '刺客'])
>>> dic.values()
dict_values(['吕布', '貂蝉', '赵云'])

4）获取键值对

items()方法可以获取字典全部键值对

>>> dic
{'上单': '吕布', '中单': '貂蝉', '刺客': '赵云'}
>>> dic.items()
dict_items([('上单', '吕布'), ('中单', '貂蝉'), ('刺客', '赵云')])

使用for循环可以遍历键值对、所有键、所有值字典可以存储列表和字典，一般来说字典的keys可以是元组（不可变类型），values可以是列表和字典

5）字典的操作方法

序号	函数及描述
clear()	删除字典内所有元素
copy()	返回一个字典的浅复制
fromkeys()	创建一个新字典，以序列seq中元素做字典的键，val为字典所有键对应的初始值
get(key, default=None)	返回指定键的值，如果值不在字典中返回default值
key in dict	如果键在字典dict里返回true，否则返回false
items()	以列表返回可遍历的(键, 值) 元组数组
keys()	返回一个迭代器，可以使用 list() 来转换为列表
setdefault(key, default=None)	和get()类似, 但如果键不存在于字典中，将会添加键并将值设为default
update(dict2)	把字典dict2的键/值对更新到dict里
values()	返回一个迭代器，可以使用 list() 来转换为列表
pop(key,default])	删除字典给定键 key 所对应的值，返回值为被删除的值。key值必须给出。否则，返回default值。
popitem()	随机返回并删除字典中的最后一对键和值。