元组、集合

元组

什么是元组

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}