01-Python中的数据类型-04-tuple,dict,set
文章目录
总体 要讲的大纲内容 如下
- 数字类型- int float complex
- 字符串类型 Text Sequence Type- str
- 序列类型 - list range
- tuple dict
- 集合类型 -
setfrozenset - 上下文管理器类型 - 比较复杂暂时 不用掌握
- 二进制序列类型 bytes bytesarray memoryview
- 真值检测
- 比较运算符
- 逻辑运算符
- 如何判断 一个对象 是什么类型- type(xxx)
今天 我们继续讲 python中基础 数据类型 元祖 ，字典 ，集合，不可变集合。 内容 挺多的，要理解每种数据结构 的特点，不一定所有的方法 都要记住，只要常用的方法可以记住即可。内容比较多，多多实践，多多练习。
元祖 tuple
元祖是一种 可以存放元素的一个容器，这点 和list 有点像。元祖 也是支持 索引的 。即也可以通过索引 访问 元素。
元祖最大的特点 就是不可变性。 就是元祖一旦创建完成后，就不能改变。 不能添加元素，不能删除元素，不能修改元素，不能排序元素 等等。
所以元祖 给你的感觉就是一种 ‘只读’ 模式。
元祖 也可以存放不同类型的元素的。
元祖的创建方法
创建一个元祖有3种方式
注意创建只有一个元素的元祖 的写法 最后要加逗号
>>> # 第一种方式
>>> t = 'apple','orange','banana'
>>> t
('apple', 'orange', 'banana')
>>> type(t)
<class 'tuple'>
>>> # 支持索引
>>> t[0]
'apple'
>>> t[1]
'orange'
>>> t[1:3]
('orange', 'banana')
>>> # 第二种方式，创建一个空的元祖
>>> t = tuple()
>>> t
()
>>> type(t)
<class 'tuple'>
>>> ##
>>> t = tuple([1,2,3])
>>> t
(1, 2, 3)
>>> type(t)
<class 'tuple'>
>>> # 第三种方式
>>> t = (1,2,3,4,5)
>>> type(t)
<class 'tuple'>
>>> t
(1, 2, 3, 4, 5)
创建只有一个元素的元祖
>>> t = (1,) # 注意这里
>>> type(t)
<class 'tuple'>
>>> t
(1,)
>>> # 没有 加逗号， 就不能变成 一个元祖，这点要注意
>>> t = (1)
>>> type(t)
<class 'int'>
>>> t
1
元祖的不可变性的理解
来尝试 修改一下元素
>>> t = (1,2,3,4,5)
>>> t
(1, 2, 3, 4, 5)
>>> type(t)
<class 'tuple'>
>>> t[0]
1
>>> t[0] = 'one'
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
当我尝试修改了 这个值的时候，发现 报错 TypeError ， 这是因为 tuple内的元素不允许修改。
注意 不允许修改是指 这个位置的不允许 别的元素替换掉。 上面的例子 0 号位置， ‘one’ 想要替换 0号位置的元素 是不允许的 。
但是如果 0 位置的元素本身是一个可变类型比如 list , 这个时候 list.append 就可以 添加元素。
来看下例子：
t[1] 的元素 是一个 list , 这个时候 我就可以 调用list.append 来添加元素了 。
>>> t = (1,[2,3,4],5,6)
>>> t
(1, [2, 3, 4], 5, 6)
>>> t[1]
[2, 3, 4]
>>> t[1].append('new')
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
元祖是不可变的吗？ 为啥这里就可以变了？
首先你要理解 我说的不可变的含义 。 只在t[1] = xxxxx, 而t[1] 这个元素本身 他是可变类型，所以当然可以添加元素，修改元素的。
看下例子
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
>>> t[1]='frank'
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: 'tuple' object does not support item assignment
好了 我想 你应该 能够理解了吧。
元祖的方法
对 tuple 有哪些可以操作呢？
首先 可以for 去遍历
t = (1, [2, 3, 4, 'new'], 5, 6)
for item in t:
print(item)
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
>>> for item in t:
... print(item)
...
1
[2, 3, 4, 'new']
5
6
元祖解包
解包 : 把元素分到不同变量上面
这样就可以把 元祖的元素 取出来， 当然也可以用索引的方式。
>>> t
(1, 2, 3)
>>> a,b,c = t
>>> a
1
>>> b
2
>>> c
3
解包 有的时候 你只想要 开头，和结尾 这两个元素 .
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
>>> first,*mid,end = t
>>> first
1
>>> end
6
>>> mid
[[2, 3, 4, 'new'], 5]
python 解包小技巧. 如何 获取 开始和末尾的位置的元素。
还可以 获取 元素的长度 len
这里要注意，这里是 一个元素的位置 就是一个长度。 如果一个位置上 有100个元素，也只能算1 。
就像下面的例子 ，长度不是7 ，而是4 ，因为 [2, 3, 4, ‘new’] 这是一个元素，一个整体，作为元祖的一个元素。
>>> t
(1, [2, 3, 4, 'new'], 5, 6)
>>> len(t)
4
好 咱们继续 下一个数据结构 字典
字典 dict
字典 是python中的一个映射类型， 并且也是可变的 。 字典 是由 一对 键值对来组成的 。d = {key:value} 字典里面的元素 一般 用 key:value 这种形式来表示。
为啥会有字典呢？
比如我有一个人的信息 存储了个人的一些 信息 ，
分别是 姓名 身高，爱好，体重等。
如果没有字典 这种结构 ，我们可以使用 list,tuple 来保存这些信息
p = ['frank', 165, 'swimming', 60]
# or
p = ('frank', 165, 'swimming', 60)
如果获取 这个人姓名，我们直接去第一个元素p[0]，获取体重 直接去最后一个元素p[-1]
但这样 也没有问题， 但是如果这个人的信息 越来越多， 我们很难 清晰的知道 第几号位置 代表是什么含义， 只记录位置 信息 获取元素的方式 对我来说 不够友好
我希望 p[‘name’] 获取的就是这个人的姓名， p[‘hobby’] 就是这个人的爱好。
这个时候 字典 就诞生了。
现在 来定义一个字典,通过 key:value 这种形式 既可。
person = {
'name': 'frank',
'height': 165,
'hobby': 'swimming',
'weight': 60
}
在consle 里面看下
>>> person
{'name': 'frank', 'height': 165, 'hobby': 'swimming', 'weight': 60}
>>> person['name']
'frank'
>>> person['weight']
60
>>> person['hobby']
'swimming'
>>> person
{'name': 'frank', 'height': 165, 'hobby': 'swimming', 'weight': 60}
看这样是不是很方便， 我们可以通过过名称(key), 获取我们想要的值。 这样相对来说 是不是更友好点，而不是通过下标 去找 对应的值, 向 list 那样，你需要记住每个属性的位置，就比较麻烦。
字典的创建方法
>>>
>>> a = dict(one=1, two=2, three=3)
... b = {'one': 1, 'two': 2, 'three': 3}
... c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))
... d = dict([('two', 2), ('one', 1), ('three', 3)])
... e = dict({'three': 3, 'one': 1, 'two': 2})
>>>
>>> a
{'one': 1, 'two': 2, 'three': 3}
>>> b
{'one': 1, 'two': 2, 'three': 3}
>>> c
{'one': 1, 'two': 2, 'three': 3}
>>> d
{'two': 2, 'one': 1, 'three': 3}
>>> e
{'three': 3, 'one': 1, 'two': 2}
>>> #创建一个空字典
>>> f = dict()
对于第一，第二种 比较常用的，后面的知道，用的时候看看就行了。
字典的特点
- 字典 是由键值对组成的， 对键 的要求是一个不可变类型也行， 不是所有的 类型都能作为键。
- 字典是可变类型，可以修改字典key 对应的值 。但是key 本身是不可变的。
- 字典 是无序的，永远不要希望 字典 key 按照一定顺序返回，即使你看起来是有序的，也不要依靠这个特性。如果 你真的需要 字典有序，以后会介绍一种数据结构来解决这个问题，这里提一下
OrderedDict这个是 字典的子类 。 你可能对子类 没有的认识，就是和字典很像。
好来说明一下：
来构造一个字典
>>> p ={[1,2,3]:1}
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
这里我想用 list 作为一个 key ， 来创建一个字段， 发现报错了， TypeError 为啥，说 list 是 不可哈希的类型。
这里不可哈希的类型，意思就说list 本身是可以修改的，不能作为key 来使用。
我来改一下,把list 换成 一个tuple 发现可以。 因为 tuple 不可变类型。
>>> p ={(1,2,3):1}
>>> p
{(1, 2, 3): 1}
>>> p[(1,2,3):1]
>>> p[(1,2,3)]
1
好，让我们总结一下，字典中的key 必须是不可变类型，比如 tuple ,str 可以作为key，list 是不可以作为key 的。
你可能 以为你知道了key 的不可变性 ， 真是 tuple 作为一个字典的key 吗？
如果 我的key= (1,2,3,[4,5,6]) 这是一个tuple ，那么这个 可以作为字典的key 吗？ 实践出真知，来看下吧
>>> p ={(1,2,3,[4,5,6]):1}
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
发现并不能 作为key , 我是一个元祖，为啥却不能作为key 呢？
原因其实通过报错信息 已经比较清楚，tuple 有一个元素 是list 这种key 是可以改变的。这样 tuple 整体 就是一个不可哈希的。
>>> key
(1, 2, 3, [4, 5, 6])
>>> type(key)
<class 'tuple'>
>>> hash(key)
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
所以判断一个 元素 可以作为字典的key, 只要 **hash(元素) ** 如果可以 返回值，说明这个元素是可以作为key 的。
好了，关于字典的key 的限制，我希望你可以慢慢理解。
第二个特点 字典 是可以修改的.
>>> person = {
... 'name': 'frank',
... 'height': 165,
... 'hobby': 'swimming',
... 'weight': 60
... }
...
>>>
>>> person['height']
165
>>> # 修改 height
>>> person['height']=166
>>> person
{'name': 'frank', 'height': 166, 'hobby': 'swimming', 'weight': 60}
第三个 字典的无序性
是指 key 的无序性，虽然我定义的key 的时候 是 name,height,hobby weight 这个顺序， 但是这不代表 字典是有序的。
来遍历 一下字典，发现结果
person = {
'name': 'frank',
'height': 165,
'hobby': 'swimming',
'weight': 60
}
for k, v in person.items():
print(k, v)
"""结果如下
name frank
height 165
hobby swimming
weight 60
"""
返回的样子，和我们定义key 的顺序 是一样的， 但是 我坦然告诉你 这只是一个巧合，不能说明 字典是有序的。
字典 的遍历
由于字典是有 key,value 组成了， 想到遍历，可能你已经想到用 for 语句了，对哦，我们是可以用 for 语句遍历字典的。
直接遍历 ，则会 返回字典的key
>>> person
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> for key in person:
... print(key)
...
weight
name
height
hobby
>>> # 这样可以的。
>>> for key in person.keys():
... print(key)
...
weight
name
height
hobby
如果想遍历字典的 value
>>> for key in person.values():
... print(key)
...
60
frank
165
swimming
同时遍历 key ,value 的值
>>> for k,v in person.items():
... print(k,v)
...
weight 60
name frank
height 165
hobby swimming
字典视图对象
Dictionary view objects
其实 只要看下 keys() ,values() ,items() 返回就明白了。
这些返回 都是 dict_keys dict_values , dict_items ,这些类型都是可以迭代的.
>>> person.items()
dict_items([('weight', 60), ('name', 'frank'), ('height', 165), ('hobby', 'swimming')])
>>> person.keys()
dict_keys(['weight', 'name', 'height', 'hobby'])
>>> person.values()
dict_values([60, 'frank', 165, 'swimming'])
字典的常用方法
获取字典长度
即 字典中key 的个数 ,len()
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> len(p)
4
判断一个key ,是否属于字典中的 key
in , not in
>>> p ={'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> 'anme' in p
False
>>> 'name' in p
True
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> 'aaa' not in p
True
>>> 'name ' in p # 这里name 后面有空格，索引这个和name 不一样的
False
>>> 'name' in p
True
获取 字典的keys, values ,k_v
>>> p.keys()
dict_keys(['weight', 'name', 'height', 'hobby'])
>>> p.values()
dict_values([60, 'frank', 165, 'swimming'])
>>> p.items()
dict_items([('weight', 60), ('name', 'frank'), ('height', 165), ('hobby', 'swimming')])
添加一对键值对 ,直接 指定 k,v 赋值 就可以了。
这里要注意 如果你指定的key 已经在 字典中的， 会被覆盖的。 并且不会有任何提示，这样就要注意 你的数据安全问题， 这个一般要检查 有没有key ，在进行 操作。
>>> p['gender']='male'
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming', 'gender': 'male'}
>>> p['name']='xiaoming'
>>> p
{'weight': 60, 'name': 'xiaoming', 'height': 165, 'hobby': 'swimming', 'gender': 'male'}
删除一对键值对 pop ，popitem
popitem() 会随机返回一对键值对，(key,value) 是一个元祖 ，然后从字典中删除 。
如果字典是空的，则会报错 KeyError
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> r = p.popitem()
>>> r
('hobby', 'swimming')
>>> type(r)
<class 'tuple'>
>>> r = p.popitem()
>>> type(r)
<class 'tuple'>
>>> p.popitem()
('name', 'frank')
>>> p.popitem()
('weight', 60)
>>> p.popitem()
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 'popitem(): dictionary is empty'
>>> p
{}
pop(key) 可以指定删除 指定的key ,返回对应的value 值。 如果指定的key 不存在 字典中，会报错 KeyError 的错误。
>>> p
{'weight': 60, 'name': 'frank', 'height': 165, 'hobby': 'swimming'}
>>> p.pop('name')
'frank'
>>> p
{'weight': 60, 'height': 165, 'hobby': 'swimming'}
>>> p.pop('hobby')
'swimming'
>>> p
{'weight': 60, 'height': 165}
浅拷贝 copy
还记得 如何查看 内存地址吗， id(对象) ，这样 就可以看到了，下面的例子 发现两个值不一样的。
>>> p
{'weight': 60, 'height': 165}
>>> p2 = p.copy()
>>> p2
{'weight': 60, 'height': 165}
>>> p
{'weight': 60, 'height': 165}
>>> id(p),id(p2)
(1404177795016, 1404177796776)
合并两个字典
dict.update(other_dict)
>>> p
{'weight': 60, 'height': 165}
>>> nums = {"one":1,"two":2}
>>> p
{'weight': 60, 'height': 165}
>>> p.update(nums)
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2}
向字典中添加元素
直接赋值就可以了，如果没有key 会创建一个新的键值对 。如果有 会覆盖掉原来的键值对。
>>> p
{'weight': 60, 'name': 'frank'}
>>> p['one']=1
>>> p['two'] = 2
>>> p
{'weight': 60, 'name': 'frank', 'one': 1, 'two': 2}
获取 字典的key 对应的值 get vs. []
关于字典获取 值 有两种方式 get [] 操作符来获取。
两种稍微有一点区别
如果是get 如果key 不在字典里面 get(key,default) 会返回 default .不会报错
[] 这种 获取的时候，如果 key 不在字典中 会报错KeyError
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2}
>>> p.get('one')
1
>>> p['one']
1
来获取一个不存在的key 显然会报错的。
>>> p = {'weight': 60, 'height': 165, 'one': 1, 'two': 2}
>>> p['hhh']
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 'hhh'
>>> p.get('hhh')
>>> p.get('hhh',111)
111
setdefault 操作
setdefault(key,default)
有的时候 我们想给字典设置一个默认值 ，如果key 已经存在了，那么使用现在已经有的值. 不会对字典有任何改变 ，同时返回这个字典 key 对应的value
如果没有这个key, 那么把这个值 key=default 放到字典中 ,同时返回这个新设置的值 value .
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2}
>>> p.setdefault('one')
1
>>> p.setdefault('one',10)
1
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2}
>>> p.setdefault('three',3)
3
>>> # 这里 three=3 放入到字典中了
>>> p
{'weight': 60, 'height': 165, 'one': 1, 'two': 2, 'three': 3}
字典这种结构 在python 中会经常使用 需要好好掌握。这种数据结构很方便，也是未来 工作中使用最常用的 数据结构 要好好掌握一下。
集合 set
集合是可以存放 一种 无序 ，不重复的元素的一种数据结构 。 如果理解了 字典的结构，那么集合就很好理解了，
集合结构相当于 字典中只有key ,没有value 的 这种结构。
来创建一个集合
可以使用大括号 { } 或者 set() 函数创建集合.
注意：创建一个空集合必须用set() , 而不是 { }，因为 { } 是用来创建一个空字典。
>>> s = {"one", "two", 'three', 'four', 'five'}
>>> s
{'one', 'four', 'five', 'two', 'three'}
>>> # 第二种创建方式 通过传入一个list 来创建
>>> attrs = set(['name','gender','hobby'])
>>> attrs
{'name', 'hobby', 'gender'}
集合特点
无序性
首先 说明一下无序性 ，集合的所有元素是无序的。就像字典的key 一样 是无序的。
s = {"one", "two", 'three', 'four', 'five'}
for i in range(5):
print(f"第{i}次 打印s ={s}")
"""结果如下：
第0次 打印s ={'three', 'four', 'five', 'one', 'two'}
第1次 打印s ={'three', 'four', 'five', 'one', 'two'}
第2次 打印s ={'three', 'four', 'five', 'one', 'two'}
第3次 打印s ={'three', 'four', 'five', 'one', 'two'}
第4次 打印s ={'three', 'four', 'five', 'one', 'two'}
"""
定义 set 的时候,是按照数字的顺序定义的，但是打印的时候却没有按照数字的顺序打印，如果 是list 肯定是 按照 定义的顺序打印的。
>>> s = {"one", "two", 'three', 'four', 'five'}
... nums = ["one", "two", 'three', 'four', 'five']
>>>
>>> s
{'one', 'four', 'five', 'two', 'three'}
>>> nums
['one', 'two', 'three', 'four', 'five']
不可重复性
我们知道在list 中 元素是可以放任何类型的，并且可以是重复的元素。原因是因为 在list中 每个元素 都会有一个 索引，通过索引 找到这个元素，不论这个元素放在哪里 只要知道 这个元素的索引，我就可以获取到值。
而在集合中 没有 索引这个东西。 它并不能区别对待 相同的元素，
看下面的例子
>>> nums= ['one', 'two', 'three', 'four', 'one']
>>> nums
['one', 'two', 'three', 'four', 'one']
>>> # 存入了 两个 one 元素
>>> s = {'one', 'two', 'three', 'four', 'one'}
>>> s
{'one', 'two', 'three', 'four'}
发现 当我打印的时候 只有一个one，这就是 集合元素的不可重复性。有时候需要对一些数据去重操作 ，这种数据结构 天生 适合做这些事情。
可变性
这个好理解，可以向集合里面 添加元素 ，删除元素 ，修改元素等。
>>> s = {'one'}
>>> s
{'one'}
>>> s.add('two')
>>> s
{'one', 'two'}
元素本身的不可变性
还有一个小问题 要注意，不是所有的元素 都是可以放入 到 集合中的，为啥，因为 集合中的元素 要求 不可变性，即集合中的每一个元素 都是 可以哈希的。
现在向集合中 添加一个 list
>>> s = {"one", "two"}
>>> s
{'one', 'two'}
>>> s.add([3,4,5])
Traceback (most recent call last):
File "<input>", line 1, in <module>
TypeError: unhashable type: 'list'
发现报错了，原因 就是list 是可变的，所以不能放在 集合里面。
集合常用方法
增删改查 ，集合运算
# 创建一个set
s = set([3,5,9,10])
s
{9, 10, 3, 5}
t = set("Hello") #创建一个唯一字符的集合
t
{'H', 'o', 'e', 'l'}
# 也可以这样创建一个集合
# s = {3,5,9,10}
#创建一个空集合
s = set()
# 添加元素
#如果 已经存在的元素,不会重新添加
s = {3,5,9,10}
s.add(5)
s
{9, 10, 3, 5}
s.add(66)
s
{66, 3, 5, 9, 10}
#判断一个元素是否在 集合可以用 in
5 in s
True
6 in s
False
66 in s
True
# 求集合长度
len(s)
5
# 删除元素集合中的一个元素
>>> s.remove(66)
>>> s
{3, 5, 9, 10}
# remove 删除一个不存在的元素 会报错 KeyError
s.remove('frank')
Traceback (most recent call last):
File "<input>", line 1, in <module>
KeyError: 'frank'
# discard 也可以用来删除 元素, 如果不存在不会报错, 不会对集合做任何操作直接返回None.
# Remove an element from a set if it is a member.
# If the element is not a member, do nothing.
>>> s = {3, 5, 9, 10}
>>> s.discard('frank')
>>> s
{3, 5, 9, 10}
# 集合的拷贝 s.copy 这是一个浅拷贝
>>> s = set()
>>> s.add(1)
>>> s.add(10)
>>> s.add(5)
>>> s
{1, 10, 5}
>>> s.add(7)
>>> s
{1, 10, 5, 7}
>>> s.copy()
{1, 10, 5, 7}
>>> s2 = s.copy()
>>> s2
{1, 10, 5, 7}
#集合运算里面 有交 并 补 差集 运算
>>> s={1,2,3,4}
>>> s2 = {3,4,5,6,7}
>>> s,s2
({1, 2, 3, 4}, {3, 4, 5, 6, 7})
>>> s
{1, 2, 3, 4}
>>> s2
{3, 4, 5, 6, 7}
>>> s& s2
{3, 4}
>>> s.intersection(s2) # 交集
{3, 4}
>>> s
{1, 2, 3, 4}
>>> s
{1, 2, 3, 4}
>>> s2
{3, 4, 5, 6, 7}
>>> s.difference(s2) # 差集
{1, 2}
>>> s - s2
{1, 2}
# 集合的并集
>>> s.union(s2)
{1, 2, 3, 4, 5, 6, 7}
>>> s|s2
{1, 2, 3, 4, 5, 6, 7}
**注意 ** 集合删除元素 remove 和discard 的区别
集合的交集 和差集 运算
交集 s & s2 或 s.intersection(s2) 交集运算
差集 s - s2 或 s.difference(s2) 差集运算
并集 s |s2 或 s.union(s2) 并集运算
>>> s
{1, 2, 3, 4}
>>> s2
{3, 4, 5, 6, 7}
>>> s.symmetric_difference(s2)
{1, 2, 5, 6, 7}
>>> s^s2
{1, 2, 5, 6, 7}
删除 两个集合相同的元素,其他的元素构成一个集合返回. 比如上面的例子, 3,4 是公共元素,去掉两个集合的公共元素,其他的元素构成一个新的集合返回. {1,2,5,6,7}
s^s2 或 s.symmetric_difference(s2)
判断集合之间的关系
s.issubset(other) 判断 自己是不是 other 的子集.即判断 s <= other 返回 True or False
s.issuperset(other) 判断 s >= other 返回 True or False
issubset(other)
set <= other
Test whether every element in the set is in other.
# 这个方法是判断 自己是不是 另一个集合的子集
issuperset(other)
Report whether this set contains another set.
# 这个方法 判断 自己 是否包含另一个集合.
>>> s
{1, 2, 3, 4}
>>> s2
{1, 2, 3, 4, 5, 6}
>>>
>>> s.issubset(s2)
True
>>> s2.issuperset(s)
True
xxxx_update 方法
set里面 还有很多 xxxxx_update 方法
这里 的作用 把更新的结果 直接写回到原集合里面.就相当于原地修改集合
s.difference_update(other) # 求差集把结果更新到 s 集合里面
s.intersection_update(other) # 求交集把结果更新到 s 集合里面
s.symmetric_difference_update(other) # 求 这个运算的结果 把结果写到s里面.
下面 举个例子:
# 差集更新
s = {1, 2, 3, 4}
s2 = {3, 4, 5, 6, 7}
s - s2
{1, 2}
s.difference(s2)
{1, 2}
s
{1, 2, 3, 4}
s2
{3, 4, 5, 6, 7}
s.difference_update(s2)
# 交集更新
s = {1, 2, 3, 4}
s2 = {3, 4, 5, 6, 7}
s.intersection(s2)
{3, 4}
s.intersection_update(s2)
s
{3, 4}
# symmetric_difference_update 我也不知道叫什么运算,暂且叫异或运算吧, 把结果更新到 s 里面.
s
{1, 2, 3, 4}
s2
{3, 4, 5, 6, 7}
s.symmetric_difference(s2)
{1, 2, 5, 6, 7}
s.symmetric_difference_update(s2)
s
{1, 2, 5, 6, 7}
# s.update(other)
# update 方法, 将一个其他的集合 更新到自己的集合里面. 相当于批量add 操作
# 如果有相同的元素, 也只会有一个更新的到集合里面. 不会报错. (集合本身是不重复的特性)
>>> s
{1, 2, 7}
>>> s2 = {11,22,33}
>>> s.update(s2)
>>> s
{1, 2, 33, 22, 7, 11}
>>> s2
{33, 11, 22}
方法 pop()
s.pop () 随机 删除 集合中的元素 ,并且返回该元素 , 如果集合是空的,会抛异常KeyError
>>> s = {1,34,56,32,11,35,67,89,56}
>>> s
{32, 1, 34, 35, 67, 11, 56, 89}
>>> s.pop()
32
>>> s.pop()
1
>>> s.pop()
34
>>> s.pop()
35
>>> s.pop()
67
>>> s.pop()
11
>>> s.pop()
56
# 清空集合
# s.clear() 清空集合,使其变成一个空集合.
s = {1,34,56,32,11,35,67,89,56}
s.clear()
s
set()
集合差不多 就说的这里，工作中用到这种结构 大部分 都是用来去重操作，偶尔也会用到集合的运算 。
不可变集合 frozenset
还有一种 结构 frozenset 看到这个名字，可能 你就能猜到，这种结构是一种不可变集合。
就是不允许修改集合本身，不能添加，修改，删除。相当于 set 的 只读模式
创建一个只读集合
>>> read_only_nums = frozenset(["one", "two", 'three', 'four'])
>>> read_only_nums
frozenset({'one', 'two', 'three', 'four'})
>>> read_only_nums.copy()
frozenset({'one', 'two', 'three', 'four'})
>>> s2 = read_only_nums.copy()
frozenset 的常用方法 几乎和set 一样，对于改变集合的方法 都没有 ,其他的方法都有。
比如 判断 是否在元素是否在集合中，获取集合长度，复制一个集合等
常用的方法 如下
[‘copy’, ‘difference’, ‘intersection’, ‘isdisjoint’, ‘issubset’, ‘issuperset’, ‘symmetric_difference’, ‘union’]
拷贝，求差集，交集，判断有没有公共元素，判断是不是子集，判断是不是父集 ，对称差分，并集
总结
今天 我们来学习python 最常用的数据结构，了解常用的方法。 这些都是我们 用来操作数据的武器，所以要好好学习，知道每种数据结构的特性，以及适用场景。这样 遇到一个问题的时候 ，才能想起来去适用这样的数据结构。 加油 ，好好学。