10、元组和集合类型（赋值补充）

前面学了列表和字典，今天我们看一个和列表相似的类型元组。再总结一个集合类型。

预习：

1、简单购物车
　　实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，如果输入为空或其他非法输入则要求用户重新输入　　
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
2、有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
    pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
    linuxs={'wupeiqi','oldboy','gangdan'}
    1. 求出即报名python又报名linux课程的学员名字集合
    2. 求出所有报名的学生名字集合
    3. 求出只报名python课程的学员名字
    4. 求出没有同时这两门课程的学员名字集合
3、
    1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
    2.在上题的基础上，保存列表原来的顺序
    3.去除文件中重复的行，肯定要保持文件内容的顺序不变
    4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]

 

本篇导航：

• 元组（tuple）
• 集合（set）
• 赋值

 

一、元组（tuple）

为何要有元组？===>存多个值，对比列表来说，元组不可变，主要是用来读

定义：与列表类型相似，只不过[]换成()，元组是不可变类型所以可以当做字典的key

t=(1,[1,3],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2)))
print(type(t))

元组所以可以当做字典的key

#元组可以作为字典的key
d={(1,2,3):'egon'}
 print(d,type(d),d[(1,2,3)])

常用方法：

#为何要有元组，存放多个值，元组不可变，更多的是用来做查询
t=(1,[1,3],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2)))
print(type(t))

#元组可以作为字典的key
d={(1,2,3):'egon'}
print(d,type(d),d[(1,2,3)])

# 索引
goods=('iphone','lenovo','sanxing','suoyi')
print(goods.index('iphone'))
print(goods.count('iphone')) #统计
 
#切片
goods=('iphone','lenovo','sanxing','suoyi')
print(goods[1:3])

# 长度
print(len(goods))

#in:
goods=('iphone','lenovo','sanxing','suoyi')
print('iphone' in goods)

 #补充：元组本身是不可变的，但是内部的元素可以是可变类型
t=(1,['a','b'],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2)))
t[1][0]='A'
print(t)
# t[1]='aaaaaaaaaaaa' #报错

补充：元组本身是不可变的，但是内部的元素可以是可变类型

t=(1,['a','b'],'sss',(1,2)) #t=tuple((1,[1,3],'sss',(1,2)))
t[1][0]='A'
print(t)
# t[1]='aaaaaaaaaaaa' #报错

---

 

二、集合（set）

集合：可以包含多个元素，用逗号分割

作用：去重，关系运算

集合的元素遵循三个原则：

1、集合是可变类型但每个元素必须是不可变类型

2、没有重复的元素

3、无序

注意：集合的目的是将不同的值存放到一起，不同的集合间用来做关系运算，无需纠结于集合中单个值

s={1,2,2,'eaaa',(1,2,3)} #s=set({1, 2, (1, 2, 3), 'eaaa'})
print(s,type(s))

重点及方法：

# in 和 not in
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
print('egon'  in pythons)

pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
#  | 并集:所有报名的学生名字集合
s=pythons | linuxs
print(s)
print(pythons.union(linuxs))

# & 交集:求二者共同的部分：求即报名python又报名linux的学生
s=pythons & linuxs
print(s)
print(pythons.intersection(linuxs))

# - 差集:求只报名python，没有报名linux的学生
print(pythons - linuxs)
print(pythons.difference(linuxs))

#  ^ 对称差集: 没有同时报名python和linux课程的学生名字集合
print(pythons ^ linuxs)
print(pythons.symmetric_difference(linuxs))

# ==
set1={1,2,3}
set2={1,2,3}
print(set1 == set2)

# >，>= ，<,<= 父集，子集

set1={1,2,3,4,5}
set2={1,2,3,4}
print(set1 >= set2)
print(set1.issuperset(set2))

print(set2 <= set1)
print(set2.issubset(set1))
#以上的运算中符号和方法的作用相同可以根据自己的理解记忆一种即可


linuxs={'wupeiqi','oldboy','gangdan'}
linuxs.add('asb') #set类型的集合是可变类型
# linuxs.add([1,2,3]) #报错，只能添加不可变类型
print(linuxs)

res=linuxs.pop() #不用指定参数,随机删除,并且会有返回值
print(res)

res=linuxs.remove('oldboy') #指定元素删除，元素不存在则报错，单纯的删除，没有返回值，
# # print(linuxs)
# print(res)
#
# res= linuxs.discard('oldboy1111111') #指定元素删除，元素不存在不报错，单纯的删除，没有返回值，
print(linuxs)
print(res)

#以下方法可做了解
#update() 更新
linuxs={'wupeiqi','oldboy','gangdan'}
new_set={'wupeiqi','alex_SB'}
# linuxs.update(new_set)
# print(linuxs)

# new_set.update(linuxs)
# print(new_set)

#清除
# linuxs.clear()
#复制
# linuxs.copy()

---

 

三、赋值

x=10

#链式赋值
# a=b=c=d=e=f=10
# print(a,b,c,d,e,f)

#增量赋值
x=10
y='a'
# temp=x
# x=y
# y=temp
# print(x,y)

# x,y=y,x
# print(x,y)

#值的解压
msg='hello'
l=[1,2,3]

# a,b,c,d,e=msg
# print(a,b,c,d,e)

# a,_,_,_,e=msg
# a,*_,e=msg
# print(a)
# print(e)

# dic={'a':1,'b':2,'c':3}
# x,y,z=dic
# print(x,y,z)

---

 

预习解答：

'''
实现打印商品详细信息，用户输入商品名和购买个数，则将商品名，价格，购买个数加入购物列表，
如果输入为空或其他非法输入则要求用户重新输入
msg_dic={
'apple':10,
'tesla':100000,
'mac':3000,
'lenovo':30000,
'chicken':10,
}
'''

msg_dic = {'apple':10,'tesla':100000,'mac':3000,'lenovo':30000,'chicken':10,}
shop_card = []
while True:
    for k in msg_dic:
        print('name:{}  price:{}'.format(k,msg_dic[k]))

    goods=input('商品名: ').strip()
    if len(goods) == 0 :
        print("没有输入商品名称！")
        continue
    if not goods in msg_dic :  #等同goods not in msg_dis
        print("本商城没有此商品！")
        continue

    while True :
        num = input('购买个数: ').strip()
        if len(num) == 0 :
            print("没有输入商品数量！")
            continue
        if not num.isdigit() :
            print("商品数量格式输入有误！")
            continue
        break

    shop_card.append((goods,msg_dic[goods],int(num)))
    print(shop_card)


# 有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
# pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
# linuxs={'wupeiqi','oldboy','gangdan'}
pythons={'alex','egon','yuanhao','wupeiqi','gangdan','biubiu'}
linuxs={'wupeiqi','oldboy','gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs)
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)


# 1. 有列表l=['a','b',1,'a','a']，列表元素均为可hash类型，去重，得到新列表,且新列表无需保持列表原来的顺序
l=['a','b',1,'a','a']
print(set(l))
# 2.在上题的基础上，保存列表原来的顺序
l1=[]
for i in l:
    if i not in l1:
        l1.append(i)
print(l1)

# 4.有如下列表，列表元素为不可hash类型，去重，得到新列表，且新列表一定要保持列表原来的顺序
l=[
    {'name':'egon','age':18,'sex':'male'},
    {'name':'alex','age':73,'sex':'male'},
    {'name':'egon','age':20,'sex':'female'},
    {'name':'egon','age':18,'sex':'male'},
    {'name':'egon','age':18,'sex':'male'},
]
l1=[]
for item in l:
    if item not in l1:
        l1.append(item)
print(l1)

---

 

小知识点：

in：字符串，列表，元组，字典，集合

for：字符串，列表，元组，字典，集合

解压:字符串，列表，元组，字典，集合