目录
1.调用remove()方法,一次删除一个指定元素,如指定元素不存在,则KeyError
2.调用discard()方法,一次删除一个指定元素,如指定元素不存在,则异常
2.一个集合是否是另一个集合的子集,可以调用.issubset()进行判断.
3.一个集合是否是另一个集合的超集,可以调用.issuperset()进行判断
4.两个集合是否没有交集,可以用.isdisjoint()进行判断
1.什么是元组
元组是python内置的数据结构之一,是一个不可变序列。
不可变序列:字符串,元组,没有增删改操作
可变序列:列表,字典,可以对序列执行增删改操作,对象地址不发生更改
"----不可变序列与可变序列-------"
# 可变序列(可执行增删改操作):如列表,字典等
lst = [10, 20, 30, 40, 50, 60, 70]
print(id(lst))
lst.append(80)
print(lst, id(lst))
scores = {'张三': 18, "李四": 20, "王五": 25}
print(id(scores))
scores['陈七'] = 26
print(scores, id(scores))
"""
##########运行结果#######
2980365770048
[10, 20, 30, 40, 50, 60, 70, 80] 2980365770048
2980365797888
{'张三': 18, '李四': 20, '王五': 25, '陈七': 26} 2980365797888
"""
# 不可变序列:如字符串,元组等
s = 'hello!'
print(id(s)) # 2897780738736
s = s * 3
print(s, id(s)) # hello!hello!hello! 2897781065408
可以看出列表,字典,列表经过增加元素之后id并没有发生改变 ,而字符串经过增加之后,id发生了改变。
2.元组的创建
1.直接用小括号()创建
2.使用内置函数tuple()
3.只包含一个元组的元素需要使用逗号和小括号
'------元组的创建方式---------'
## 1.使用()来创建元组
t = ('python', 'hello', 98.5, 55)
print('t的值以及数据类型', t, type(t))
#######################这里用()创建元组的时候,()是可以省略的
t3 = 'python', 'hello', 98.5, 55
print('t3的值以及数据类型', t3, type(t3))
## 2.使用内置函数tuple()
t1 = tuple(('字符串', 9955, 63.21651,))
print('t1的值以及数据类型', t1, type(t1))
## 3只包含一个元组的元素需要使用逗号和小括号
t4 = ('元组',)
print('t4的值以及数据类型', t4, type(t4))
t5 = ('元组')
print('t5的值以及数据类型', t5, type(t5)) # 这里省略了”,“,导致t5变为了str类型
## 4.空元组的创建
t6 = ()
t7 = tuple()
print('t6以及t7的数据类型', type(t6), type(t7))
为什么要将元组设计成为不可变序列?
在多任务环境下,同时操作对象时不需要加锁,在程序中尽量使用不可变序列。
注意:元组中存储的是对象的引用,如果元组中对象本身不可对象,则不能再引用其它对象,如果元组中的对象是可变对象,则可变对象的引用不允许改变,但数据可以改变。
t = (10, [20, 30], 40)
print(t, type(t), id(t)) # (10, [20, 30], 40) <class 'tuple'> 2128380789184
print(t[0], type(t[0]), id(t[0])) # 10 <class 'int'> 2128372105744
print(t[1], type(t[1]), id(t[1])) # [20, 30] <class 'list'> 2128376995136
print(t[2], type(t[2]), id(t[2])) # 40 <class 'int'> 2128372106704
### 尝试将t[1]修改为100
# t[1] = 100 #######元组是不允许修改元素的,原先是list类型,100是int型,所以这里会报错
"""
但是由于这里的[20,30]是列表,元组是不可变序列,而列表是可变序列,所以可以向表列中添加元素,而列表的内存地址不变
"""
t[1].append(100) # 向列表中添加元素
print(t, type(t), id(t)) # (10, [20, 30, 100], 40) <class 'tuple'> 2128380789184
print(t[1], type(t[1]), id(t[1])) # [20, 30, 100] <class 'list'> 1858501451072
3.元组的遍历
元组是可迭代对象,所以可以使用 for ...in进行遍历
t = (95, 'python', 98.015)
'# 第一种获取元组中元素的方法是根据索引'
print(t[0], t[1], t[2])
"# 第二种获取元组中元素的方法 遍历元组"
for item in t:
print(item)
4.什么是集合
集合: python语言提供的内置数据结构,与字典,列表一样,都是可变类型的序列。根据上图我们可以看到,集合是没有value值的字典。
5.集合的创建
1.直接用{}
{’python‘,"hello", "world",98}
2.直接使用内置函数set{}
'--------集合的创建方式------------'
# 集合同字典一样,字典是键不允许重复,集合同样的里面的元素不允许重复
#######第一种创建方式,使用{}
s = {1, 2, 3, 5, 5, 6, 7, 7}
print(s)
# {1, 2, 3, 5, 6, 7}
#######第二种创建方式,使用内置函数set()
s1 = set(range(6))
print(s1, type(s1))
# {0, 1, 2, 3, 4, 5} <class 'set'>
print(set([3, 4, 5, 6, 7])) # 使用set()函数,将列表中的元素转为集合中的元素
# {3, 4, 5, 6, 7}
print(set((1, 1, 2, 3, 4, 4, 5, 65))) # 使用内置函数set(),将元组中的数据转为集合中的元素
# {1, 2, 3, 4, 5, 65}
print(set('hello world')) # 将字符串转为集合
# {'d', 'w', 'h', ' ', 'o', 'l', 'e', 'r'} ## 这里可以证明集合是无序的
print(set({1, 2, 3, 5, 5, 6, 7, 7})) # 将集合元素进行转换,这里不使用set()函数,其本身也为set类型
# {1, 2, 3, 5, 6, 7}
# 空集合
# {}是字典类型,即dict类型
set() # 空集合
print(type(set()))
6.集合的增删改查方式
1.集合元素的判断操作
in 或 not in
s1 = {10, 20, 30, "python", '36', 36.29}
print(10 in s1) # True
print('python' not in s1) # False
2.集合元素的新增操作
(1). 调用add(),一次添加一个元素
s1 = {10, 20, 30, "python", '36', 36.29}
s1.add(5020)
print(s1)
### {'python', 36.29, 20, '36', 10, 5020, 30}
2. 调用update()至少添加一个元素
s1 = {10, 20, 30, 40, 50, 36.29}
s1.update({60, 70, 80, 90}) # 加入集合
print(s1)
### {36.29, 70, 40, 10, 80, 50, 20, 90, 60, 30}
s1.update((100, 200, 300)) # 加入元组
print(s1)
### {36.29, 100, 70, 40, 200, 10, 300, 80, 50, 20, 90, 60, 30}
s1.update([400, 500, 600]) # 加入列表
print(s1)
### {36.29, 100, 70, 40, 200, 10, 300, 80, 400, 50, 20, 500, 600, 90, 60, 30}
3. 集合元素的删除操作
1.调用remove()方法,一次删除一个指定元素,如指定元素不存在,则KeyError
s1 = {36.29, 100, 70, 40, 200, 10, 300, 80, 400, 50, 20, 500, 600, 90, 60, 30}
s1.remove(100)
print(s1)
## {70, 200, 10, 80, 400, 20, 600, 90, 30, 36.29, 40, 300, 50, 500, 60}
2.调用discard()方法,一次删除一个指定元素,如指定元素不存在,则异常
s1.discard(1) # 要删除元素不在集合内不会报错
print(s1)
3.调用pop()方法,一次删除任意一个元素
s1.pop() # 任意删除一种元素,不能指定参数
print(s1)
## {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29, 40, 300, 50, 60}
4.调用clear(),清空集合
s1.clear() # 清空集合
print(s1)
## set()
7.集合间的关系
1.两个集合是否相等可以使用==或者!=进行判断
s1 = {70, 200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29}
s2 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29, 40, 300, 50, 60}
print(s1 == s2) # False
print(s1 != s2) # True
2.一个集合是否是另一个集合的子集,可以调用.issubset()进行判断.
s1 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29}
s2 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29, 500}
s3 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29, 40, 300, 50, 60}
print(s1.issubset(s3)) # True
print(s2.issubset(s3)) # False
3.一个集合是否是另一个集合的超集,可以调用.issuperset()进行判断
"-----一个集合是否是另一个集合的超集"
# 超级就是a是b的真子集,b是a的超集
s1 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29}
s2 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29, 500}
s3 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29, 40, 300, 50, 60}
print(s3.issuperset(s1)) # True
print(s3.issuperset(s2)) # False
4.两个集合是否没有交集,可以用.isdisjoint()进行判断
"-----两个集合是否有交集---------"
s1 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29}
s2 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29, 500}
s3 = {200, 10, 80, 400, 20, 600, 90, 30, 100, 36.29, 40, 300, 50, 60}
s4 = {1, 2, 3, 4, 5}
print(s1.isdisjoint(s3)) # False
print(s1.isdisjoint(s4)) # True ##说明s1与s4没交集
5.求两个集合之间的交集.intersection(), 并集.union(), A对B的差集(就是A减去AB的交集).difference(), 对称差集.symmetric_difference()
s1 = {10, 20, 30, 40, 50}
s2 = {20, 30, 40, 50, 60}
print(s1.intersection(s2)) # 两个集合的交集
print(s1 & s2) # intersection与&等价,都是求两个集合的交集
### {40, 50, 20, 30}
print(s1.union(s2)) # 两个集合的并集
print(s1 | s2) # union 与 | 等价,并集操作
### {40, 10, 50, 20, 60, 30}
print(s1.difference(s2)) # 计算s1与s2的差集,就是s1集合减去s1,s2的交集
print(s1 - s2)
### {10}
print(s1.symmetric_difference(s2)) # 对称差集就是s1与s2的并集减去s1与s2的交集
print(s1 ^ s2)
### {10, 60}
8.集合生成式
用于生成集合的公式。元组没有生成式,因为元组是不可变序列
{表达集合元素的表达式 for i in range(1,10) }
将{}改为[ ]就是列表生成式
lst = [i ** 2 for i in range(1, 6)] # 列表生成式
print(lst)
### [1, 4, 9, 16, 25]
set1 = {i ** 2 for i in range(1, 6)} # 集合生成式(集合是无序的)
print(set1)
### {16, 1, 4, 9, 25}
lst1 = [10, 20, 30, 40, 50, 60]
lst2 = [1, 1515, 2120, 1.0151, 151, 165165]
print(list(zip(lst1, lst2)))
### [(10, 1), (20, 1515), (30, 2120), (40, 1.0151), (50, 151), (60, 165165)]
print(dict(zip(lst1, lst2)))
### {10: 1, 20: 1515, 30: 2120, 40: 1.0151, 50: 151, 60: 165165}
9.总结