写在前面
最近这段时间比较充裕,想要系统学习一下python,这个系列算是对自己学习的一个记录吧。同时也想提供一个比较完整详细的python教程供有需要的小伙伴进行学习,大家一起共同进步!!!努力冲冲冲!!!
虽然我也不知道自己能够坚持多久,但我尽量坚持不断更哈哈哈。如果这篇文章对你有帮助的话,请多多点赞支持呀。你们的鼓励和支持就是我坚持的最大动力【比心】。
如果需要查看往期文章的话,可以点击下面的文章链接,全部都已经汇总好了
目录
前言
本文为python学习笔记系列文章。
本文主要介绍了python中的字典和集合,介绍了其基本概念和基本操作。
注:本文主要参考了C语言中文网中的python教程。
字典dict
Python字典(dict)是一种无序的、可变的序列,它的元素以“键值对(key-value)”的形式存储。相对地,列表(list)和元组(tuple)都是有序的序列,它们的元素在底层是挨着存放的。
字典类型是 Python 中唯一的映射类型。“映射”指的是元素之间相互对应的关系,即通过一个元素,可以唯一找到另一个元素。如下图所示。
字典中,将各元素对应的索引称为键(key),各个键对应的元素称为值(value),键及其关联的值称为“键值对”。
字典类型很像学生时代常用的新华字典。通过新华字典中的音节表,可以快速找到想要查找的汉字。其中,字典里的音节表就相当于字典类型中的键,而键对应的汉字则相当于值。
字典类型所具有的主要特征如下表所示。
主要特征 | 解释 |
---|---|
通过键而不是通过索引来读取元素 | 字典类型有时也称为关联数组或者散列表(hash)。它是通过键将一系列的值联系起来的,这样就可以通过键从字典中获取指定项,但不能通过索引来获取。 |
字典是任意数据类型的无序集合 | 和列表、元组不同,通常会将索引值 0 对应的元素称为第一个元素,而字典中的元素是无序的。 |
字典是可变的,并且可以任意嵌套 | 字典可以在原处增长或者缩短(无需生成一个副本),并且它支持任意深度的嵌套,即字典存储的值也可以是列表或其它的字典。 |
字典中的键必须唯一 | 字典中,不支持同一个键出现多次,否则只会保留最后一个键值对。 |
字典中的键必须不可变 | 字典中每个键值对的键是不可变的,只能使用数字、字符串或者元组,不能使用列表。 |
Python 中的字典类型相当于C++中的 Map 对象。
字典的数据类型为 dict,通过 type() 函数即可查看:
# 字典类型举例
a = {'one': 1, 'two': 2, 'three': 3}
print(type(a))
运行结果为:
<class 'dict'>
创建字典
创建字典的方式有很多,下面一一做介绍。
1) 使用 { } 创建字典
由于字典中每个元素都包含两部分,分别是键(key)和值(value),因此在创建字典时,键和值之间使用冒号:
分隔,相邻元素之间使用逗号,
分隔,所有元素放在大括号{ }
中。
语法格式如下:
dictname = {'key':'value1', 'key2':'value2', ..., 'keyn':valuen}
其中 dictname 表示字典变量名,keyn : valuen 表示各个元素的键值对。需要注意的是,同一字典中的各个键必须唯一,不能重复。
举例:
# 创建字典举例--使用{}
#使用字符串作为key
scores = {'数学': 95, '英语': 92, '语文': 84}
print(scores)
#使用元组和数字作为key
dict1 = {(20, 30): 'great', 30: [1,2,3]}
print(dict1)
#创建空元组
dict2 = {}
print(dict2)
运行结果为:
{'数学': 95, '英语': 92, '语文': 84}
{(20, 30): 'great', 30: [1, 2, 3]}
{}
注意:字典的键可以是整数、字符串或者元组,只要符合唯一和不可变的特性就行;字典的值可以是 Python 支持的任意数据类型。
2) 通过 fromkeys() 方法创建字典
可以使用 fromkeys() 方法创建带有默认值的字典。
具体格式为:
dictname = dict.fromkeys(list,value=None)
其中,list 参数表示字典中所有键的列表(list);value 参数表示默认值,如果不写,则为空值 None。
举例:
# 创建字典举例--使用fromkeys()
knowledge = ['语文', '数学', '英语']
scores = dict.fromkeys(knowledge, 60)
print(scores)
运行结果为:
{'语文': 60, '英语': 60, '数学': 60}
这种创建方式通常用于初始化字典,设置 value 的默认值。
3) 通过 dict() 映射函数创建字典
通过 dict() 函数创建字典的写法有多种,下表罗列出了常用的几种方式,它们创建的都是同一个字典 a。
创建格式 | 注意事项 |
---|---|
a = dict(str1=value1, str2=value2, str3=value3) | str 表示字符串类型的键,value 表示键对应的值。使用此方式创建字典时,字符串不能带引号。 |
#方式1 demo = [('two',2), ('one',1), ('three',3)] #方式2 demo = [['two',2], ['one',1], ['three',3]] #方式3 demo = (('two',2), ('one',1), ('three',3)) #方式4 demo = (['two',2], ['one',1], ['three',3]) a = dict(demo) | 向 dict() 函数传入列表或元组,而它们中的元素又各自是包含 2 个元素的列表或元组,其中第一个元素作为键,第二个元素作为值。 |
keys = ['one', 'two', 'three'] #还可以是字符串或元组 values = [1, 2, 3] #还可以是字符串或元组 a = dict( zip(keys, values) ) | 通过应用 dict() 函数和 zip() 函数,可将前两个列表转换为对应的字典。 |
注意,无论采用以上哪种方式创建字典,字典中各元素的键都只能是字符串、元组或数字,不能是列表。列表是可变的,不能作为键。
如果不为 dict() 函数传入任何参数,则代表创建一个空的字典,例如:
# 创建空的字典
d = dict()
print(d)
运行结果为:
{}
访问字典
字典通过键来访问对应的值。因为字典中的元素是无序的,每个元素的位置都不固定,所以字典也不能像列表和元组那样,采用切片的方式一次性访问多个元素。
具体格式为:
dictname[key]
其中,dictname 表示字典变量的名字,key 表示键名。注意,键必须是存在的,否则会抛出异常。
举例:
# 访问字典举例--dictname[key]
tup = (['two',26], ['one',88], ['three',100], ['four',-59])
dic = dict(tup)
print(dic['one']) #键存在
print(dic['five']) #键不存在
运行结果:
88
Traceback (most recent call last):
File "D:\pythonLearning\basic\字典.py", line 27, in <module>
print(dic['five']) #键不存在
KeyError: 'five'
除了上面这种方式外,更推荐使用 dict 类型提供的 get() 方法来获取指定键对应的值。当指定的键不存在时,get() 方法不会抛出异常。
具体语法格式为:
dictname.get(key[,default])
其中,dictname 表示字典变量的名字;key 表示指定的键;default 用于指定要查询的键不存在时,此方法返回的默认值,如果不手动指定,会返回 None。
举例:
# 访问字典举例--get()
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('one') )
运行结果:
88
注意,当键不存在时,get() 返回空值 None,如果想明确地提示用户该键不存在,那么可以手动设置 get() 的第二个参数,例如:
# 访问字典举例--get()
a = dict(two=0.65, one=88, three=100, four=-59)
print( a.get('five', '该键不存在') )
运行结果:
该键不存在
删除字典
手动删除字典可以使用 del 关键字。
举例:
# 删除字典举例
a = dict(two=0.65, one=88, three=100, four=-59)
print(a)
del a
print(a)
运行结果:
{'two': 0.65, 'one': 88, 'three': 100, 'four': -59}
Traceback (most recent call last):
File "D:\pythonLearning\basic\字典.py", line 41, in <module>
print(a)
NameError: name 'a' is not defined
同样,Python 自带垃圾回收功能,会自动销毁不用的字典,所以一般不需要通过 del 来手动删除。
添加字典键值对
为字典添加新的键值对很简单,直接给不存在的 key 赋值即可。
具体语法格式如下:
dictname[key] = value
对各个部分的说明:
- dictname 表示字典名称。
- key 表示新的键。
- value 表示新的值,只要是 Python 支持的数据类型都可以。
举例:
# 添加字典键值对举例
a = {'数学':95}
print(a)
#添加新键值对
a['语文'] = 89
print(a)
#再次添加新键值对
a['英语'] = 90
print(a)
运行结果:
{'数学': 95}
{'数学': 95, '语文': 89}
{'数学': 95, '语文': 89, '英语': 90}
修改字典键值对
Python 字典中键(key)的名字不能被修改,只能修改值(value)。
字典中各元素的键必须是唯一的,因此,如果新添加元素的键与已存在元素的键相同,那么键所对应的值就会被新的值替换掉,以此达到修改元素值的目的。
举例:
# 修改字典键值对举例
a = {'数学': 95, '语文': 89, '英语': 90}
print(a)
a['语文'] = 100
print(a)
运行结果:
{'数学': 95, '语文': 89, '英语': 90}
{'数学': 95, '语文': 100, '英语': 90}
删除字典键值对
可以使用 del 语句对字典键值对进行删除。
举例:
# 删除字典键值对举例--使用del语句删除键值对
a = {'数学': 95, '语文': 89, '英语': 90}
del a['语文']
del a['数学']
print(a)
运行结果为:
{'英语': 90}
判断字典中是否存在指定键值对
如果要判断字典中是否存在指定键值对,首先应判断字典中是否有对应的键。判断字典是否包含指定键值对的键,可以使用 in 或 not in 运算符。
需要指出的是,对于 dict 而言,in 或 not in 运算符都是基于 key 来判断的。
举例:
# 判断字典中是否存在指定键值对举例
a = {'数学': 95, '语文': 89, '英语': 90}
# 判断 a 中是否包含名为'数学'的key
print('数学' in a) # True
# 判断 a 是否包含名为'物理'的key
print('物理' in a) # False
运行结果为:
True
False
通过 in(或 not in)运算符,我们可以很轻易地判断出现有字典中是否包含某个键,如果存在,由于通过键可以很轻易的获取对应的值,因此很容易就能判断出字典中是否有指定的键值对。
keys()、values() 和 items()
这三个方法都用来获取字典中的特定数据:
- keys() 方法用于返回字典中的所有键(key);
- values() 方法用于返回字典中所有键对应的值(value);
- items() 用于返回字典中所有的键值对(key-value)。
举例:
# keys()、values() 和 items()举例
scores = {'数学': 95, '语文': 89, '英语': 90}
print(scores.keys())
print(scores.values())
print(scores.items())
运行结果:
dict_keys(['数学', '语文', '英语'])
dict_values([95, 89, 90])
dict_items([('数学', 95), ('语文', 89), ('英语', 90)])
注意,在 Python 2.x 中,上面三个方法的返回值都是列表(list)类型。但在 Python 3.x 中,它们的返回值并不是我们常见的列表或者元组类型,因为 Python 3.x 不希望用户直接操作这几个方法的返回值。
在 Python 3.x 中如果想使用这三个方法返回的数据,一般有下面两种方案:
1) 使用 list() 函数,将它们返回的数据转换成列表。
举例:
# 使用keys()、values() 和 items()返回的数据方法之--list()
a = {'数学': 95, '语文': 89, '英语': 90}
b = list(a.keys())
print(b)
运行结果为:
['数学', '语文', '英语']
2) 使用 for in 循环遍历它们的返回值。
举例:
# 使用keys()、values() 和 items()返回的数据方法之--for in
a = {'数学': 95, '语文': 89, '英语': 90}
for k in a.keys():
print(k,end=' ')
print("\n---------------")
for v in a.values():
print(v,end=' ')
print("\n---------------")
运行结果为:
数学 语文 英语
---------------
95 89 90
---------------
key: 数学 value: 95
key: 语文 value: 89
key: 英语 value: 90
copy()
copy() 方法返回一个字典的拷贝,也即返回一个具有相同键值对的新字典。
举例:
a = {'one': 1, 'two': 2, 'three': [1,2,3]}
b = a.copy()
print(b)
运行结果为:
{'one': 1, 'two': 2, 'three': [1, 2, 3]}
注意,copy() 方法所遵循的拷贝原理,既有深拷贝,也有浅拷贝。拿拷贝字典 a 为例,copy() 方法只会对最表层的键值对进行深拷贝,也就是说,它会再申请一块内存用来存放 {'one': 1, 'two': 2, 'three': []};而对于某些列表类型的值来说,此方法对其做的是浅拷贝,也就是说,b 中的 [1,2,3] 的值不是自己独有,而是和 a 共有。
举例:
# 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]}
从运行结果不难看出,对 a 增加新键值对,b 不变;而修改 a 某键值对中列表内的元素,b也会相应改变。
update()
update() 方法可以使用一个字典所包含的键值对来更新己有的字典。
在执行 update() 方法时,如果被更新的字典中己包含对应的键值对,那么原 value 会被覆盖;如果被更新的字典中不包含对应的键值对,则该键值对被添加进去。
举例:
# update方法举例
a = {'one': 1, 'two': 2, 'three': 3}
a.update({'one':4.5, 'four': 9.3})
print(a)
运行结果为:
{'one': 4.5, 'two': 2, 'three': 3, 'four': 9.3}
pop() 和 popitem()
pop() 和 popitem() 都用来删除字典中的键值对,不同的是,pop() 用来删除指定的键值对,而 popitem() 用来随机删除一个键值对。
它们的语法格式如下:
dictname.pop(key)
dictname.popitem()
其中,dictname 表示字典名称,key 表示键。
举例:
# pop() popitem()方法举例
a = {'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
print(a)
a.pop('化学')
print(a)
a.popitem()
print(a)
运行结果:
{'数学': 95, '语文': 89, '英语': 90, '化学': 83, '生物': 98, '物理': 89}
{'数学': 95, '语文': 89, '英语': 90, '生物': 98, '物理': 89}
{'数学': 95, '语文': 89, '英语': 90, '生物': 98}
setdefault()
setdefault() 方法用来返回某个 key 对应的 value。
具体语法格式如下:
dictname.setdefault(key, defaultvalue)
说明,dictname 表示字典名称,key 表示键,defaultvalue 表示默认值(可以不写,不写的话是 None)。
当指定的 key 不存在时,setdefault() 会先为这个不存在的 key 设置一个默认的 defaultvalue,然后再返回 defaultvalue。
举例:
# setdefault()方法举例
a = {'数学': 95, '语文': 89, '英语': 90}
print(a)
#key不存在,指定默认值
a.setdefault('物理', 94)
print(a)
#key不存在,不指定默认值
a.setdefault('化学')
print(a)
#key存在,指定默认值
a.setdefault('数学', 100)
print(a)
运行结果为:
{'数学': 95, '语文': 89, '英语': 90}
{'数学': 95, '语文': 89, '英语': 90, '物理': 94}
{'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None}
{'数学': 95, '语文': 89, '英语': 90, '物理': 94, '化学': None}
集合set
python中的集合,和数学中的集合概念一样,用来保存不重复的元素,即集合中的元素都是唯一的,互不相同。
集合会将所有元素放在一对大括号 {} 中,相邻元素之间用“,”分隔
具体语法格式为:
{element1,element2,...,elementn}
其中,elementn 表示集合中的元素,个数没有限制。
同一集合中,只能存储不可变的数据类型,包括整形、浮点型、字符串、元组,无法存储列表、字典、集合这些可变的数据类型,否则 Python 解释器会抛出 TypeError 错误。比如说:
>>> {{'a':1}}
Traceback (most recent call last):
File "<pyshell#8>", line 1, in <module>
{{'a':1}}
TypeError: unhashable type: 'dict'
>>> {[1,2,3]}
Traceback (most recent call last):
File "<pyshell#9>", line 1, in <module>
{[1,2,3]}
TypeError: unhashable type: 'list'
>>> {{1,2,3}}
Traceback (most recent call last):
File "<pyshell#10>", line 1, in <module>
{{1,2,3}}
TypeError: unhashable type: 'set'
并且需要注意的是,数据必须保证是唯一的,因为集合对于每种数据元素,只会保留一份。
>>> {1,2,1,(1,2,3),'c','c'}
{1, 2, 'c', (1, 2, 3)}
由于 Python 中的 set 集合是无序的,所以每次输出时元素的排序顺序可能都不相同。
其实,Python 中有两种集合类型,一种是 set 类型的集合,另一种是 frozenset 类型的集合,它们唯一的区别是,set 类型集合可以做添加、删除元素的操作,而 forzenset 类型集合不行。
创建集合
Python 提供了 2 种创建 set 集合的方法,分别是使用 {} 创建和使用 set() 函数将列表、元组等类型数据转换为集合。
1) 使用 {} 创建
在 Python 中,创建 set 集合可以像列表、元素和字典一样,直接将集合赋值给变量,从而实现创建集合的目的,其语法格式如下:
setname = {element1,element2,...,elementn}
其中,setname 表示集合的名称,起名时既要符合 Python 命名规范,也要避免与 Python 内置函数重名。
举例:
# 创建集合--直接赋值
a = {1,'c',1,(1,2,3),'c'}
print(a)
运行结果为:
{1, 'c', (1, 2, 3)}
2) set()函数创建集合
内置函数set(),其功能是将字符串、列表、元组、range 对象等可迭代对象转换成集合。
具体语法格式如下:
setname = set(iteration)
其中,iteration 就表示字符串、列表、元组、range 对象等数据。
举例:
# 创建集合--set()
set1 = set("c.biancheng.net")
set2 = set([1,2,3,4,5])
set3 = set((1,2,3,4,5))
print("set1:",set1)
print("set2:",set2)
print("set3:",set3)
运行结果为:
set1: {'a', 'g', 'b', 'c', 'n', 'h', '.', 't', 'i', 'e'}
set2: {1, 2, 3, 4, 5}
set3: {1, 2, 3, 4, 5}
注意,如果要创建空集合,只能使用 set() 函数实现。因为直接使用一对 {},Python 解释器会将其视为一个空字典。
访问集合
由于集合中的元素是无序的,因此无法向列表那样使用下标访问元素。Python 中,访问集合元素最常用的方法是使用循环结构,将集合中的数据逐一读取出来。
举例:
# 访问集合举例
a = {1,'c',1,(1,2,3),'c'}
for ele in a:
print(ele,end=' ')
运行结果为:
1 c (1, 2, 3)
删除集合
可以使用 del() 语句删除集合。
举例:
# 删除集合举例
a = {1,'c',1,(1,2,3),'c'}
print(a)
del(a)
print(a)
运行结果为:
{1, (1, 2, 3), 'c'}
Traceback (most recent call last):
File "D:\pythonLearning\basic\集合.py", line 23, in <module>
print(a)
NameError: name 'a' is not defined
添加集合元素
set 集合中添加元素,可以使用 set 类型提供的 add() 方法实现,
具体语法格式为:
setname.add(element)
其中,setname 表示要添加元素的集合,element 表示要添加的元素内容。
需要注意的是,使用 add() 方法添加的元素,只能是数字、字符串、元组或者布尔类型(True 和 False)值,不能添加列表、字典、集合这类可变的数据,否则 Python 解释器会报 TypeError 错误。
举例:
# 添加集合元素举例
a = {1,2,3}
a.add((1,2))
print(a)
a.add([1,2])
print(a)
运行结果为:
{(1, 2), 1, 2, 3}
Traceback (most recent call last):
File "D:\pythonLearning\basic\集合.py", line 30, in <module>
a.add([1,2])
TypeError: unhashable type: 'list'
删除集合元素
删除现有 set 集合中的指定元素,可以使用 remove() 方法。
具体语法格式如下:
setname.remove(element)
注意,如果被删除元素本就不包含在集合中,则此方法会抛出 KeyError 错误
举例:
# 删除集合元素举例
a = {1,2,3}
a.remove(1)
print(a)
a.remove(1)
print(a)
运行结果为:
{2, 3}
Traceback (most recent call last):
File "D:\pythonLearning\basic\集合.py", line 38, in <module>
a.remove(1)
KeyError: 1
如果不想在删除失败时令解释器提示 KeyError 错误,还可以使用 discard() 方法,此方法和 remove() 方法的用法完全相同,唯一的区别就是,当删除集合中元素失败时,此方法不会抛出任何错误。
例如:
# 删除集合元素举例
a = {1,2,3}
a.remove(1)
print(a)
a.discard(1)
print(a)
运行结果为:
{2, 3}
{2, 3}
集合运算
集合最常做的操作就是进行交集、并集、差集以及对称差集运算,先介绍一下各个运算的含义。
图 1 集合示意图
图 1 中,有 2 个集合,分别为 set1={1,2,3} 和 set2={3,4,5},它们既有相同的元素,也有不同的元素。以这两个集合为例,分别做不同运算的结果如下表所示。
运算操作 | Python运算符 | 含义 | 例子 |
---|---|---|---|
交集 | & | 取两集合公共的元素 | >>> set1 & set2 {3} |
并集 | | | 取两集合全部的元素 | >>> set1 | set2 {1,2,3,4,5} |
差集 | - | 取一个集合中另一集合没有的元素 | >>> set1 - set2 {1,2} >>> set2 - set1 {4,5} |
对称差集 | ^ | 取集合 A 和 B 中不属于 A&B 的元素 | >>> set1 ^ set2 {1,2,4,5} |
set的相关方法
通过 dir(set) 命令可以查看它有哪些方法:
>>> dir(set)
['add', 'clear', 'copy', 'difference', 'difference_update', 'discard', 'intersection', 'intersection_update', 'isdisjoint', 'issubset', 'issuperset', 'pop', 'remove', 'symmetric_difference', 'symmetric_difference_update', 'union', 'update']
各个方法的具体语法结构及功能如下表所示。
方法名 | 语法格式 | 功能 | 实例 |
---|---|---|---|
add() | set1.add() | 向 set1 集合中添加数字、字符串、元组或者布尔类型 | >>> set1 = {1,2,3} >>> set1.add((1,2)) >>> set1 {(1, 2), 1, 2, 3} |
clear() | set1.clear() | 清空 set1 集合中所有元素 | >>> set1 = {1,2,3} >>> set1.clear() >>> set1 set() set()才表示空集合,{}表示的是空字典 |
copy() | set2 = set1.copy() | 拷贝 set1 集合给 set2 | >>> set1 = {1,2,3} >>> set2 = set1.copy() >>> set1.add(4) >>> set1 {1, 2, 3, 4} >>> set1 {1, 2, 3} |
difference() | set3 = set1.difference(set2) | 将 set1 中有而 set2 没有的元素给 set3 | >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3 = set1.difference(set2) >>> set3 {1, 2} |
difference_update() | set1.difference_update(set2) | 从 set1 中删除与 set2 相同的元素 | >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.difference_update(set2) >>> set1 {1, 2} |
discard() | set1.discard(elem) | 删除 set1 中的 elem 元素 | >>> set1 = {1,2,3} >>> set1.discard(2) >>> set1 {1, 3} >>> set1.discard(4) {1, 3} |
intersection() | set3 = set1.intersection(set2) | 取 set1 和 set2 的交集给 set3 | >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3 = set1.intersection(set2) >>> set3 {3} |
intersection_update() | set1.intersection_update(set2) | 取 set1和 set2 的交集,并更新给 set1 | >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.intersection_update(set2) >>> set1 {3} |
isdisjoint() | set1.isdisjoint(set2) | 判断 set1 和 set2 是否没有交集,有交集返回 False;没有交集返回 True | >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.isdisjoint(set2) False |
issubset() | set1.issubset(set2) | 判断 set1 是否是 set2 的子集 | >>> set1 = {1,2,3} >>> set2 = {1,2} >>> set1.issubset(set2) False |
issuperset() | set1.issuperset(set2) | 判断 set2 是否是 set1 的子集 | >>> set1 = {1,2,3} >>> set2 = {1,2} >>> set1.issuperset(set2) True |
pop() | a = set1.pop() | 取 set1 中一个元素,并赋值给 a | >>> set1 = {1,2,3} >>> a = set1.pop() >>> set1 {2,3} >>> a 1 |
remove() | set1.remove(elem) | 移除 set1 中的 elem 元素 | >>> set1 = {1,2,3} >>> set1.remove(2) >>> set1 {1, 3} >>> set1.remove(4) Traceback (most recent call last): File "<pyshell#90>", line 1, in <module> set1.remove(4) KeyError: 4 |
symmetric_difference() | set3 = set1.symmetric_difference(set2) | 取 set1 和 set2 中互不相同的元素,给 set3 | >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3 = set1.symmetric_difference(set2) >>> set3 {1, 2, 4} |
symmetric_difference_update() | set1.symmetric_difference_update(set2) | 取 set1 和 set2 中互不相同的元素,并更新给 set1 | >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set1.symmetric_difference_update(set2) >>> set1 {1, 2, 4} |
union() | set3 = set1.union(set2) | 取 set1 和 set2 的并集,赋给 set3 | >>> set1 = {1,2,3} >>> set2 = {3,4} >>> set3=set1.union(set2) >>> set3 {1, 2, 3, 4} |
update() | set1.update(elem) | 添加列表或集合中的元素到 set1 | >>> set1 = {1,2,3} >>> set1.update([3,4]) >>> set1 {1,2,3,4} |
集合frozenset
set 集合是可变序列,程序可以改变序列中的元素;frozenset 集合是不可变序列,程序不能改变序列中的元素。set 集合中所有能改变集合本身的方法,比如 remove()、discard()、add() 等,frozenset 都不支持;set 集合中不改变集合本身的方法,fronzenset 都支持。
>>> dir(frozenset)
['copy', 'difference', 'intersection', 'isdisjoint', 'issubset', 'issuperset', 'symmetric_difference', 'union']
frozenset 集合的这些方法和 set 集合中同名方法的功能是一样的。
两种情况下可以使用 fronzenset:
- 当集合的元素不需要改变时,可以使用 fronzenset 替代 set,这样更加安全。
- 有时候程序要求必须是不可变对象,这个时候也要使用 fronzenset 替代 set。比如,字典(dict)的键(key)就要求是不可变对象
举例:
# frozenset举例
s = {'Python', 'C', 'C++'}
fs = frozenset(['Java', 'Shell'])
s_sub = {'PHP', 'C#'}
#向set集合中添加frozenset
s.add(fs)
print('s =', s)
#向为set集合添加子set集合
s.add(s_sub)
print('s =', s)
运行结果:
Traceback (most recent call last):
File "D:\pythonLearning\basic\集合.py", line 61, in <module>
s.add(s_sub)
TypeError: unhashable type: 'set'
s = {'C', 'C++', 'Python', frozenset({'Shell', 'Java'})}
注意,set 集合本身的元素必须是不可变的, 所以 set 的元素不能是 set,只能是 frozenset。
总结
本文主要介绍了python中的字典和集合,字典部分包括创建字典,访问字典,删除字典,对字典键值对进行增删改查以及字典的相关方法。集合部分包括创建集合,访问集合,删除集合,添加删除集合元素,集合运算以及集合的相关方法。