python学习之元组和集合

5.元组

5.1 元组的概念

• python内置的数据结构之一，是一个不可变序列
• 不可变序列与可变序列
  不可变序:字符串、元组；没有增、删，改的操作
  可变序列:列表、字典；可以对序列执行增、删、改操作，对象地址不发生更改
• 元组：t = (‘python’,‘hello’,90)

s = 'hello'
print(id(s))#1969706295024
s = s+' world'
print(id(s))#1969706319664
print(s)#hello world

5.2 元组的创建

• 直接小括号 t = (‘python’,‘hello’,90)
• 使用内置函数tuple() t = tuple( (‘python’,‘hello’,90))
• 只包含一个元组的元素需要使用逗号和小括号 t = (10,)

#小括号
t1 = ('python','world',98)
print(t1) #('python', 'world', 98)
print(type(t1)) #<class 'tuple'>

#省略小括号
t2 = 'python','world',98
print(t2) #('python', 'world', 98)
print(type(t2)) #<class 'tuple'>

#没有用逗号和小括号，就是不元组，只是字符串
t3 = ('python')
print(t3)
print(type(t3))#<class 'str'>

#元组只有一个元素，要用逗号和小括号
t4 = ('python',)
print(t4)
print(type(t4))#<class 'tuple'>

#使用内置函数tuple()
t5 = tuple(('python','world',98))
print(t5)#('python', 'world', 98)
print(type(t5))#<class 'tuple'>

#空元组
t6 = ()
t7 = tuple()
print(t6) #()
print(t7) #()
#复习
#空字典
t8 = {}
t9 = dict()
print(t8)
print(t9) #{}

#空列表
t10 = []
t11 = list()
print(t10)
print(t11)#[]

5.3 为什么要将元组设计成不可变序列

• 在多任务环境下，同时操作对象时不需要加锁；因此,在程序中尽量使用不可变序列
• 注意事项:元组中存储的是对象的引用
  a)如果元组中对象本身是不可变对象，则不能再引用其它对象
  b)如果元组中的对象是可变对象，则可变对象的引用不允许
  改变，但数据可以改变
  如 t = (‘python’,‘world’,[98,99])，t[2}不能改变，但t[2].append(100)是允许的

5.4 元组的遍历

t = ('python','world',98)

#索引
print(t[0])
print(t[1])
print(t[2])

#循环遍历
for i in t:
    print(i)

6.集合

6.1 集合的概念

• python语言提供的内置数据结构
• 与列表、字典一样都属于可变类型的序列
• 集合是没有value的字典
• 通过hash函数计算位置

6.2 集合的创建

#直接使用{}
s = {1,2,3,4,5,6,7,6} #不允许重复
print(s) #{1, 2, 3, 4, 5, 6, 7}

#使用内置函数set()
s1 = set(range(6))
print(s1,type(s1))#{0, 1, 2, 3, 4, 5} <class 'set'>

s2 = set([1,2,3,4,3])
print(s2,type(s2)) #{1, 2, 3, 4} <class 'set'>

s3 = set((1,3,5,3,23,3,4))
print(s3,type(s3))#{1, 3, 4, 5, 23} <class 'set'>

s4 = set('python')
print(s4,type(s4))#{'t', 'o', 'y', 'h', 'n', 'p'} <class 'set'>

s5 = set({12,32,4,3,52,5,2,3})
print(s5,type(s5)) #{32, 2, 3, 4, 5, 52, 12} <class 'set'>
#！！
s6 = {}
print(type(s6)) #<class 'dict'>

s7 = set()
print(s7,type(s7)) #set() <class 'set'>

6.3 集合的相关操作

• 集合元素的判断操作：in或not in
• 集合元素的新增操作：
  1.add()方法，一次添加一个元素
  2.update()方法，一次至少添加一个元素
• 集合元素的删除操作：
  1.remove()方法，一次删除一个指定元素，如果指定的元素不存在则抛出KeyError
  2.调用discard()方法，一次删除一个指定元素，如果指定的元素 不存在不抛异常
  3.调用pop()方法，一次只随机删除一个任意元素
  4.调用clear()方法，清空集合

**#集合的判断**
s = {1,2,3,4,5,6,7,6}
print(1 in s) #True
print(6 not in s) #False

**#集合的新增**
#一次添加一个元素
s.add(10)
print(s) #{1, 2, 3, 4, 5, 6, 7, 10}

#一次至少添加一个元素
s.update([100,99,0])
s.update({9,8,7})
s.update((11,22,33))
print(s) #{0, 1, 2, 3, 4, 5, 6, 7, 100, 99, 10, 8, 9, 11, 33, 22}


**#集合的删除**
s.remove(100)
#s.remove(999)  #报错:KeyError: 999
print(s) #{0, 1, 2, 3, 4, 5, 6, 7, 99, 10, 8, 9, 11, 33, 22}

s.discard(99)
s.discard(999) #没有也不报错
print(s) #{0, 1, 2, 3, 4, 5, 6, 7, 10, 8, 9, 11, 33, 22}

s.pop()
#s.pop(2) #b报错:TypeError: pop() takes no arguments (1 given)
print(s) #{1, 2, 3, 4, 5, 6, 7, 10, 8, 9, 11, 33, 22} 删除了0

s.clear()
print(s) #set()

6.4 集合之间的关系

• 两个集合是否相等：可以使用运算符==或!=进行判断.——个集合是否是另一个集合的子集；可以调用方法issubset进行判断
• B是A的子集：—个集合是否是另一个集合的超集；可以调用方法issuperset进行判断
• A是B的超集
• 两个集合是否没有交集：可以调用方法isdisjoint进行判断

#两个集合是否相等
s1 = {1,2,3,4,5,6,7}
s2 = {1,2,3,4,7,6,5}
print(s1==s2)# True
print(s1!=s2)# False

#一个集合是否是另一个集合的子集
s3 = {1,2,3,4}
print(s3.issubset(s1)) #True

#一个集合是否是另一个集合的超集
print(s1.issuperset(s3)) #True

#两个集合是否有交集
s4 = {11,22,33}
print(s1.isdisjoint(s3)) #False 有交集为False
print(s1.isdisjoint(s4)) #True 没有交集为True

6.5 集合的数学操作

交集，并集，差集，对称差集

#集合的数学操作
#集合的交集操作
s1 = {1,2,3,4,5,6,7}
s2 = {1,2,3,4,9}

print(s1.intersection(s2)) #{1, 2, 3, 4}
print(s1 & s2) #{1, 2, 3, 4}

#集合的并集操作
print(s1.union(s2)) #{1, 2, 3, 4, 5, 6, 7, 9}
print(s1 | s2) #{1, 2, 3, 4, 5, 6, 7, 9}

#集合的差集操作
print(s1.difference(s2)) #{5, 6, 7}
print(s1-s2) #{5, 6, 7}

#对称差集
print(s1.symmetric_difference(s2)) #{5, 6, 7, 9}
print(s1^s2) #{5, 6, 7, 9}

6.6 集合生成式

• 公式： { ii for i in range(1,10)}。其中，i1表示集合元素的表达式。将{}修改为[]就是列表生成式；元组不可变，所以没有元组生成式