数据类型----元组、集合的内置方法
目录
一、元组tuple
元组与列表类似，也是可以存多个任意类型的元素，不同之处在于元组的元素不能修改，即元组相当于不可变的列表，用于记录多个固定不允许修改的值，单纯用于取
1.1 定义
"""
小括号括起来，内部存放多个元素，元组之间逗号隔开，元素不可改变，元素类型不能是任意的，
"""
定义：t1 = (11, 22, 33, 44)
# 强调：如果元组内只有一个值，则必须加一个逗号，否则()就只是包含的意思而非定义元组
countries = ('kevin'，)
print(countries) # 本质:countries = tuple('kevin')
1.2 数据类型转变
# 但凡能被for循环的遍历的数据类型都可以传给tuple()转换成元组类型
# print(tuple(123))错误
# print(tuple(123.11))错误
print(tuple('hello')) # ('h', 'e', 'l', 'l', 'o')
print(tuple([11, 22, 33, 44])) # (11, 22, 33, 44)
print(tuple((1,2,3,4))) # (1, 2, 3, 4)
print(tuple({'username':'kevin', 'age':19})) # ('username', 'age')
print(tuple({111,222,33,444})) # (33, 444, 222, 111)
1.3 使用
1.3.1 按索引取值(正向取+反向取)：只能取，不能改否则报错！
tuple1 = (1, 'hhaha', 15000.00, 11, 22, 33)
# 1. 按索引取值(正向取+反向取)：只能取，不能改否则报错！
print(tuple1[0]) # 1
print(tuple1[2]) # 15000.0
print(tuple1[-1]) # 33
print(tuple1[-2]) # 22
print(tuple1[-3]) # 11
'''不能修改值'''
# tuple1[0] = 666 # 报错：TypeError
1.3.2 切片(顾头不顾尾，步长)
# 2.切片(顾头不顾尾，步长)
print(tuple1[0:3]) # (1, 'hhaha', 15000.0)
print(tuple1[0:5:2]) # (1, 15000.0, 22)
1.3.3 长度len
# 3.长度len()
print(len(tuple1)) # 6
1.3.4.成员运算 in 和 not in
# 4.成员运算 in 和 not in
print('hhaha' in tuple1) # True
print('hhaha' not in tuple1) # False
1.3.5.循环
for line in tuple1:
print(line)
1.3.6. 元组笔试题
'''元组笔试题'''
# 当元组内部哪怕是一个元素，也要加一个逗号隔开，否则就不是元组类型
t = (111)
t1 = (111.11)
t2 = ('hello')
t3 = ('hello', )
l = ['hello', ] # list
print(type(t)) # <class 'int'>
print(type(t1)) # <class 'float'>
print(type(t2)) # <class 'str'>
print(type(t3)) # <class 'tuple'>
print(type(l)) # <class 'list'>
'''
容器类型：可以存放多个元素的数据类型都是容器类型
推荐：如果是容器类型，内部就算有一个元素，也最后都加上一个逗号隔开
'''
二、集合set
2.1 定义
集合、list、tuple、dict一样都可以存放多个值，但是集合主要用于：去重、关系运算
"""
大括号括起来，内部存放多个元素，元素之间逗号隔开，
1.数据类型只能是不可变的类型
2.集合内没有重复的元素
3.集合内元素无序
4.不能直接取值
"""
# 定义：
s = {11,22,33,44}
# 如何定义一个空集合
s = {11,22,33,44}
print(type(s)) # set
# 定义空集合
print(type({})) # dict
s1 = set()
print(type(s1)) # set
2.2 数据类型转换
# 但凡能被for循环的遍历的数据类型（强调：遍历出的每一个值都必须为不可变类型）都可以传给set()转换成集合类型
s = set([1,2,3,4])
print(s) # {1, 2, 3, 4}
print(set((1,2,3,4))) # {1, 2, 3, 4}
print(set({'name':'jason','age':20})) # {'name', 'age'}
print(set('hello')) # {'e', 'o', 'l', 'h'}
2.3 使用
2.3.1 关系运算
我们定义两个集合friends与friends2来分别存放两个人的好友名字，然后以这两个集合为例讲解集合的关系运算
friends1 = {"zero", "kevin", "jason", "egon"} # 用户1的好友们
friends2 = {"Jy", "ricky", "jason", "egon"} # 用户2的好友们
两个集合的关系如下图所示
# 1.并集（|）：求两个用户所有的好友（重复好友只留一个)
print(friends1 | friends2)
# 返回：{'egon', 'Jy', 'jason', 'kevin', 'ricky', 'zero'}
# 2.交集(&)：求两个用户的共同好友
print(friends1 & friends2)
# 返回：{'egon', 'jason'}
# 3.差集(-)：
# 求用户1独有的好友
print(friends1 - friends2)
# 返回：{'zero', 'kevin'}
# 求用户2独有的好友
print(friends2 - friends1)
# 返回：{'Jy', 'ricky'}
# 4.对称差集(^) # 求两个用户独有的好友们（即去掉共有的好友）
print(friends1 ^ friends2)
# 返回：{'zero', 'kevin', 'Jy', 'ricky'}
# 5.值是否相等(==)
print(friends1 == friends2) # False
# 6.父集：一个集合是否包含另外一个集合
# 6.1 包含则返回True
print({1, 2, 3} > {1, 2}) # True
print({1, 2, 3} >= {1, 2}) # True
print({1, 2, 3} >= {1, 2, 3}) # True
# 6.2 不存在包含关系，则返回False
print({1, 2, 3} > {1, 3, 4, 5}) # False
print({1, 2, 3} >= {1, 3, 4, 5}) # False
# 7.子集
print({1, 2} < {1, 2, 3}) # True
print({1, 2} <= {1, 2, 3}) # True
print({1, 2, 3} <= {1, 2, 3}) # True
print({1, 2, 3, 4} <= {1, 2, 3}) # False
2.3.2 去重
集合去重复有局限性：
- 只能针对不可变类型
- 集合本身是无序的，去重之后无法保留原来的顺序
# 例1：
ll = [11, 22, 33, 44, 22, 33, 88, 55, 33, 999, 22, 11]
# 将列表转成了集合
s = set(ll)
# 集合没有重复值
print(s) # {33, 999, 11, 44, 22, 55, 88}
# 再将集合转回列表
print(list(s)) # [33, 999, 11, 44, 22, 55, 88]
# 例2：
l1 = ['kevin', 'tony', 'jack', 'jack', 'jack', 'jack']
print(set(l1)) # {'tony', 'kevin', 'jack'}
print(list(set(l1))) # ['tony', 'kevin', 'jack']
针对不可变类型，并且保证顺序则需要我们自己写代码实现
例如
l=[
{'name':'lili','age':18,'sex':'male'},
{'name':'jack','age':73,'sex':'male'},
{'name':'tom','age':20,'sex':'female'},
{'name':'lili','age':18,'sex':'male'},
{'name':'lili','age':18,'sex':'male'},
]
new_l=[]
for dic in l:
if dic not in new_l:
new_l.append(dic)
print(new_l)
# 结果：既去除了重复，又保证了顺序，而且是针对不可变类型的去重
[
{'age': 18, 'sex': 'male', 'name': 'lili'},
{'age': 73, 'sex': 'male', 'name': 'jack'},
{'age': 20, 'sex': 'female', 'name': 'tom'}
]
2.3.3 其他操作
1.长度
# 长度
s = {'a', 'b', 'c'}
print(len(s)) # 3
2.成员运算
# 成员运算
print('c' in s) # True
print('x' in s) # False
3.循环
# 循环
s = {1, 2, 3, 4, 5, 6, 7, 8}
for i in s:
print(i)
2.3.4 练习
0221自己写的：
"""
一.关系运算
有如下两个集合，pythons是报名python课程的学员名字集合，linuxs是报名linux课程的学员名字集合
pythons={'ly','qq','kevin','ricky','gangdan','biubiu'}
linuxs={'kermit','tony','gangdan'}
1. 求出即报名python又报名linux课程的学员名字集合
2. 求出所有报名的学生名字集合
3. 求出只报名python课程的学员名字
4. 求出没有同时这两门课程的学员名字集合
"""
pythons = {'ly', 'qq', 'kevin', 'ricky', 'gangdan', 'biubiu'}
linuxs = {'kermit', 'tony', 'gangdan'}
# 1. 求出即报名python又报名linux课程的学员名字集合
print(pythons & linuxs) # {'gangdan'}
# 2. 求出所有报名的学生名字集合
print(pythons | linuxs)
# 返回：{'biubiu', 'kermit', 'qq', 'gangdan', 'kevin', 'tony', 'ly', 'ricky'}
# 3. 求出只报名python课程的学员名字
print(pythons - linuxs)
# 返回：{'kevin', 'ly', 'biubiu', 'ricky', 'qq'}
# 4. 求出没有同时这两门课程的学员名字集合
print(pythons ^ linuxs)
# 返回：{'kevin', 'biubiu', 'ricky', 'qq', 'tony', 'kermit', 'ly'}
