元组
什么是元组
Python内置的数据结构之一，是一个不可变序列
不可变序列与可变序列：
- 不可变序列：字符串、元组（没有增删改的操作）
- 可变序列：列表、字典（可以对序列进行增删改的操作，对象地址不发生更改）
'''可变序列 列表 字典'''
lst=[10,20,30]
print(id(lst)) #2408605479104
lst.append(90)
print(id(lst)) #2408605479104 内存地址并没有发生改变
d={'张三':98,'李四':89}
print(id(d)) #2274018401216
d['王五']=88
print(id(d)) #2274018401216
'''不可变序列 元组 字符串'''
s='hello'
print(id(s))
s=s+'world'
print(id(s))
元组的创建方式
- 直接小括号（）
- 使用内置函数tuple()
- 只包含一个元组的元素需要使用逗号和小括号 t=(10,)
'''元组的创建方式'''
#第一种，直接使用()
t=('python','world',98)
print(type(t)) #<class 'tuple'>
t2='python','world',45 #省略了小括号
print(t2)
print(type(t2))
#第二种，使用内置函数tuple()
t1=tuple(('python','world',77)) #注意有两个括号
print(type(t1))
#只包含一个元素,一定要加上逗号和小括号，否则会认为是字符串类型
t3=('python',)
print(type(t3))
'''空元组的创建方式'''
#空列表的创建方式
lst=[]
lst1=list()
#空字典
d={}
d1=dict()
#空元组
t4=()
t5=tuple()
print('空列表',lst,lst1)
print('空字典',d,d1)
print('空元组',t4,t5)
为什么要将元组设计成不可变序列
-
在多任务环境下，同时操作对象时不需要加锁
-
因此，在程序中尽量使用不可变序列
-
注意事项： 元组中存储的是对象的引用
? （a)如果元组中对象本身是不可变对象，则不能再引用其他对象。
? (b)如果元组中的对象是可变对象，则可变对象的引用不允许改变，但数据可以改变。
t=(10,[30,20],9)
print(t)
print(type(t))
print(t[0],type(t[0]),id(t[0]))
print(t[1],type(t[1]),id(t[1]))
print(t[2],type(t[2]),id(t[2]))
'''尝试将t[1]修改为100'''
#t[1]=100 #元组是不允许修改元素的
'''由于[20,30]列表，而列表是可变序列，所以可以向列表中添加元素'''
t[1].append(100) #向列表中添加元素
print(t,id(t[1]))
元组的遍历
元组是可迭代对象，所以可以使用for…in进行遍历
t=('Python','world',98)
'''第一种获取元组元素的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3])
'''遍历元组'''
for item in t:
print(item)
集合
集合的概述与创建
- Python语言提供的内置数据结构
- 与列表、字典一样都是属于可变类型的序列
- 集合是没有value的字典
集合的创建方式
- 直接{}
- 使用内置函数set()
'''第一种创建方式使用{}'''
s={2,3,4,5,5,6,7,7}#集合中的元素不允许重复,
print(s,type(s))
'''第二种创建方式'''
s1=set(range(6))
print(s1)
s2=set([1,2,3,4,5,6,6])
print(s2) #将列表中的元素转成集合并去掉重复元素
s3=set((1,2,4,4,5,65))
print(s3) #{65, 1, 2, 4, 5} 集合中的元素是无序的
s4=set('python')
print(s4,type(s4)) #{'o', 't', 'y', 'h', 'n', 'p'} <class 'set'>
s5=set({23,4,6,8,2,24})
print(s5)
#定义一个空集合
s6=set()
print(s6,type(s6))
集合的相关操作
-
集合元素的判断操作
in or not in
-
集合元素的新增操作
add（）：一次只能添加一个元素
update（）：一次至少添加一个元素
-
集合元素的删除操作
remove（）：一次删除一个指定元素，如果指定的元素不存在抛出KeyError
discard（）：一次删除一个指定元素，如果指定的元素不存在不会抛出异常
pop（）：一次只删除一个任意元素
clear（）：清空集合
s={10,20,30,40,50,60}
'''集合元素的判断操作'''
print(10 in s)
print(100 in s)
print(10 not in s)
print(100 not in s)
'''集合元素的新增操作'''
s.add(80) #添加一个元素
print(s)
s.update([200,400,300]) #一次至少添加一个元素
print(s)
s.update((78,79,67))
s.update({23,25,45})
print(s)
'''集合元素的删除操作'''
s.remove(200)
print(s)
#s.remove(500) #KeyError:500
s.discard(500) #删除集合中没有的元素，不会报错
s.discard(300)
print(s)
s.pop() #随机删除一个元素
print(s)
s.clear() #清空集合
print(s) #set()
集合间的关系
-
两个集合是否相等
- 可以使用运算符==或！=进行判断
-
一个集合是否是另一个集合的子集
- 可以调用方法issubset进行判断
- B是A的子集
-
一个集合是否是另一个集合的超集
- 可以调用方法issuperset进行判断
- A是B的超集
-
两个集合是否没有交集
- 可以调用方法isdisjoint进行判断
s={10,20,30,40}
s2={30,40,20,10}
print(s==s2) #True
print(s!=s2) #False
'''一个集合是否是另一个集合的子集'''
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,90}
print(s2.issubset(s1)) #True
print(s3.issubset(s1))
'''一个集合是否是另一个集合的超集'''
print(s1.issuperset(s2)) #True
print(s1.issuperset(s3))
'''两个集合是否没有交集'''
print(s2.isdisjoint(s3)) #是否没有交集 False
s4={100,200,300}
print(s2.isdisjoint(s4)) #True
集合的数学操作
交集、并集、差集、对称差集
'''集合的数学操作'''
#交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2)) #{40, 20, 30}
print(s1 & s2) #intersection与&等价，交集操作
#并集
print(s1.union(s2)) #{40, 10, 50, 20, 60, 30}
print(s1 | s2) #union与| 等价，并集操作
#差集操作
print(s1.difference(s2)) #{10}
print(s1-s2) #{10}
print(s2-s1) #{50,60}
#对称差集,就是两个集合的并集—交集
print(s1.symmetric_difference(s2)) #{50, 10, 60}
print(s1^ s2) #{50, 10, 60}
集合生成式
-
用于生成集合的公式：{i*i for i in range()}
#列表生成式 lst=[i*i for i in range(6)] print(lst)#[0, 1, 4, 9, 16, 25] #集合生成式 s={i*i for i in range(6)} print(s) #{0, 1, 4, 9, 16, 25}
