python（四）元组和集合

元组的定义

'''不可变序列，可变序列'''
'''可变序列 列表，字典''' #可变序列发生改变,id值不变
lst=[10,20,45]
print(id(lst))
lst.append(300)
print(id(lst))
'''不可变序列,字符串，元组''' #不可变序列发生改变,id值发生变化
s='hello'
print(id(s))
s=s+'world'
print(s)
print(id(s))

元组的创建方式

'''元组的创建方式'''
'''第一种创建方式，使用()'''
t=('Python','world',98)
print(t)
print(type(t))

t2='python',11,'hello'  #省略小括号
print(t2)
print(type(t2))

t3=('python',)           #如果元组中只有一个元素，逗号不能省
print(t3)
print(type(t3))

print('--------------------第二种创建方式，使用内置函数tuple()---------------------------')

'''第二种创建方式，使用内置函数tuple()'''
t1=tuple(('Python','world',98))
print(t1)
print(type(t1))

#输出结果
('python', 11, 'hello')
<class 'tuple'>
('python',)
<class 'tuple'>
--------------------第二种创建方式，使用内置函数tuple()---------------------------
('Python', 'world', 98)
<class 'tuple'>

'''空元组的创建方式'''
#空列表的创建方式
lst=[]
lst1=list()
#空字典的创建方式
d={}
d2=dict()
#空元组
t4=()
t5=tuple()
print('空列表',lst,lst1)
print('空字典',d,d2)
print('空元组',t4,t5)

空列表 [] []
空字典 {} {}
空元组 () ()

元组的特性

元组的遍历

'''元组的遍历'''
t=('hello','world',98)
'''第一种获取元组的方式，使用索引'''
print(t[0])
print(t[1])
print(t[2])
#print(t[3]) #IndexError: tuple index out of range

'''遍历元组'''
for item in t:
    print(item)
hello
world
98
hello
world
98

集合的定义

集合的创建方式

'''第一种创建方式使用{}'''
s={2,3,4,5,5,6,7,7} #集合中的元素不允许重复
print(s)

'''第二种创建方式使用set()'''
s1=set(range(6))
print(s1,type(s1))

s2=set([1,2,4,5,5,6,6])
print(s2,type(s2))

s3=set((1,2,4,10,10,5,89))  #集合中的元素是无序的
print(s3,type(s3))

{2, 3, 4, 5, 6, 7}
{0, 1, 2, 3, 4, 5} <class 'set'>
{1, 2, 4, 5, 6} <class 'set'>
{1, 2, 4, 5, 10, 89} <class 'set'>
#########################################################################################
s3=set((1,2,4,10,10,5,89))  #集合中的元素是无序的
print(s3,type(s3))

s4=set('python')
print(s4,type(s4))

s5=set({12,4,34,55,66,44,4})
print(s5,type(s5))

'''定义一个空集合'''
s6={}
print(type(s6)) #dict字典类型

s7=set()
print(type(s7))
#输出结果
{1, 2, 4, 5, 10, 89} <class 'set'>
{'h', 'y', 'p', 'o', 't', 'n'} <class 'set'>
{34, 66, 4, 55, 12, 44} <class 'set'>
<class 'dict'>
<class 'set'>

集合的相关操作

#集合的相关操作
s={10,20,30,405,60}
print(10 in s)
print(100 in s)
print(10 not in s)
print(100 not in s)
True
False
False
True
#########################################################################################
'''集合元素的新增操作'''
s.add(80)
print(s)
s.update({200,400,300}) #一次至少添加一个元素
print(s)
{10, 80, 20, 405, 60, 30}
{200, 10, 300, 80, 400, 20, 405, 60, 30}
#########################################################################################
'''集合元素的删除操作'''
print(s)
s.remove(200)
print(s)
# s.remove(1000)  #没有的元素的将报错KeyError: 1000
s.discard(1000)   #没有元素将不会报错，有就执行删除
print(s)
s.pop()           #删除任意一个元素,不跟元素，跟元素会报错
print(s)
s.clear()         #清空结合
print(s)
{200, 10, 300, 80, 400, 20, 405, 60, 30}
{10, 300, 80, 400, 20, 405, 60, 30}
{10, 300, 80, 400, 20, 405, 60, 30}
{300, 80, 400, 20, 405, 60, 30}
set()

集合间的关系

'''两个集合是否相等'''
s={10,20,30,40}
s2={30,40,20,10}
print(s==s2)
print(s!=s2)

True
False
#########################################################################################
'''一个集合是否是另一个集合的子集'''
s1={10,20,30,40,50,60}
s2={10,20,30,40}
s3={10,20,100}
print(s2.issubset(s1))
print(s3.issubset(s1))

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

True
False
########################################################################################
'''两个集合是否有交集'''
s1={10,20,30,40}
s2={10,20}
s3={100,200}
print(s1.isdisjoint(s2))  #False 有交集
print(s2.isdisjoint(s3))  #True  无交集

False
True

集合的数据操作

#集合的数学操作
##交集
s1={10,20,30,40}
s2={20,30,40,50,60}
print(s1.intersection(s2))
print(s1 & s2)      #intersection()与 & 等价，交集操作

{40, 20, 30}
{40, 20, 30}
#########################################################################################
##并集操作
print(s1.union(s2))
print(s1 | s2)     #union与| 等价，并集操作

{40, 10, 50, 20, 60, 30}
{40, 10, 50, 20, 60, 30}
#交集和并集的操作原数据集合不发生变化
print(s1)
print(s2)
{40, 10, 20, 30}
{40, 50, 20, 60, 30}
#########################################################################################
#差集操作
print(s1.difference(s2))
print(s1-s2)
print(s1)
print(s2)
{10}
{10}
{40, 10, 20, 30}
{40, 50, 20, 60, 30}
#########################################################################################
#对称差集
print(s1.symmetric_difference(s2))
print(s1^s2)

{50, 10, 60}
{50, 10, 60}

集合生成式

#列表生成式
lst=[i*i for i in range(10)]
print(lst)

#集合生成式
s={i*i for i in range(10)}
print(s)

列表、字典、元组、集合之间的比较

小结