什么时候用容器类型的数据？ ---> 需要同时保存多个数据的时候 什么时候用列表？ ---> 保存的多个数据是同一类的数据（不需要区分） 什么时候用字典？ ---> 保存的多个数据是不同类的数据 (需要区分)
一、tuple
1.什么是元祖
使用()将多个元素括起来，多个元素之间用逗号隔开
a.
容器，可以同时存储多个数据,不可变的，有序的
不可变 ---> 不能增删改
有序 ---> 可以通过下标获取元素
b.
元素，可以是任何类型的数据
tuple1= (1,'yue',True, [1,2],lambda s:s*2)
print(tuple1)
注意
1.
如果元祖的元素只有一个的时候，必须在元素的后面加逗号
tuple2= (100,)
print(type(tuple2))
2.
多个数据直接用逗号隔开，表示的也是一个元祖
tuple2= 10,20,'abc'
print(tuple2,type(tuple2))
2、元素的查
元祖的元素不支持增删改
列表获取元素的方式，元祖都支持：元祖[下标], 元祖[:], 元祖[::]
遍历：和列表一样
tuple2= ('星期一','星期二','星期三','星期四')
print(tuple2[1])
print(tuple2[2:])
print(tuple2[::-1])
# 遍历
for item in tuple2:
print(item)
index= 0
while index< len(tuple2):
print(tuple2[index])
index+= 1
补充：获取部分元素
可以通过相同的变量个数，来获取元祖中的元素
x, y= (10,20)
print(x, y)
x, y, z= (10,20,30)
x, y= 10,20
# 1.应用：交换两个数的值
a= 10
b= 20
# 错误写法
# a = b # a = 20
# b = a # b = 20
# 方法1：
# t = a # t = 10
# a = b # a = 20
# b = t # b = 10
# 方法2：
a, b= b, a # a,b = (b,a) = (20, 10)
可以通过在变量前加*来获取部分的元素(适用于列表)
tuple2= ('小明',90,89,67,100)
name,*score= tuple2
print(name, score)
tuple2= (90,89,67,100,'小明')
*score, name= tuple2
print(score, name)
tuple2= ['boy',15300022673,90,89,67,100,'小明']
sex, tel,*score, name= tuple2
print(sex, name, score)
"""
(了解)
可以通过在列表或者元祖前加*,来展开列表中的元素
"""
tuple3= (1,2,3,4)
print(*tuple3)
list1= ['abc',100,200]
print(*list1)
3.元祖的运算
+, *, ==, is, in, not in ---> 和列表一样
print((1,2,3)+ ('a','b'))
print((1,2)* 3)
print((1,2,3)== (1,2,3))
print((1,2,3)is (1,2,3))
print(1 in (1,2,3))
print(1 not in (1,2,3))
4.len(), max(), min()
tuple3= 10,230,100,78,34
print(len(tuple3))
print(max(tuple3))
print(min(tuple3))
5.tuple()
所有的序列都可以转换成元祖，注意，字典只能将key值作为元祖元素
print(tuple('abhdnc'))
print(tuple([1,23,90]))
print(tuple(range(5)))
print(tuple({'a': 100,'b': 200}))
6.sorted()
可以通过sorted()方法，对元祖进行排序，产生一个新的列表
tuple3= 10,230,100,78,34
new= sorted(tuple3)
print(new, tuple3)
二、dict
1.什么是字典（dict）
"""
字典是一个容器类的数据类型，可以用来存储多个数据(以键值对的形式存储)。可变的，无序的
{key1:value1, key2:value2...}
可变 ---> 可以增删改
无序 ---> 不能通过下标获取值
键(key): 用来定位值的。要求只能是不可变的数据类型(数字，字符串，元祖...)。是唯一的
值(value): 存储的数据。可以是任何类型的数据
"""
# person1 = ['yuting', 18, 90, 100, '1547262889']
person2= {'name': 'yuting','age': 18,'face': 90,'score': 100,'tel': '1547262889','name':'小花'}
dict1= {10: 893,'abc': 100, (1,23): 'abc'}
print(person2)
dict1= {}
print(dict1)
2、字典的增删改查
1.查(获取键值对的value)
"""
获取字典的值，必须通过key来获取
a.字典[key] ---> 获取key对应的值
注意：key值必须是存在的，否则会报KeyError
"""
student= {'name': '小明','age': 30,'study_id': 'py001','sex': 'boy'}
print(student['name'])
print(student['sex'])
# print(student['score']) # KeyError: 'score'
"""
b.字典.get(key) ---> 通过key获取值
注意：key值不存在的时候不会报错，结果是None
"""
print(student.get('age'), student.get('study_id'))
print(student.get('score'))
"""
确定key一定存在就是使用[]语法，key可能不存在的时候使用get语法
"""
c.直接遍历字典（推荐使用）
通过for-in遍历字典拿到的是key值
"""
for xin student:
print(x, student[x])
d.其他遍历方式(了解)
# 直接遍历拿到值
for valuein student.values():
print(value)
# 直接拿到key和value
print(student.items())
for key, valuein student.items():
print(key, value)
2.增(添加键值对)
"""
字典[key] = 值（key不存在）
"""
car= {}
car['color']= 'yellow'
print(car)
car['price']= 300000
print(car)
3.修改（修改值）
"""
字典[key] = 新值 (key存在)
"""
car['color']= 'red'
print(car)
4.删 (删除键值对)
a.
del 字典[key] ---> 通过key删除键值对
student= {'name': '小明','age': 30,'study_id': 'py001','sex': 'boy'}
del student['age']
print(student)
b.
字典.pop(key) ---> 取出key对应的值(实质还是删除key对应的键值对)
name= student.pop('name')
print(student, name)
3.字典相关运算
==: 判断两个字典的值是否相等
is: 判断两个字典的地址是否相等
in 和 not in: key in 字典 / key not in 字典 ---> 判断key是否存在
"""
dic1= {'a': 1,'b': 2}
aa= dic1
print(dic1is aa)
print({'a': 100,'b': 200}== {'b': 200,'a': 100})
print({'a': 100,'b': 200}is {'b': 200,'a': 100})
print('abc' in {'abc': 100,'a': 200})# True
print('abc' in {'100': 'abc','a': 200})# False
4.字典相关的函数和方法
1.
len(字典) --> 获取键值对的个数
dict1= {'a': 1,'b': 2,'c': 3,'d': 4}
print(len(dict1))
2.
字典.clear() --> 清空字典
dict1.clear()
print(dict1)
3.
字典.copy() --> 将字典中的键值对复制一份产生一个新的字典
dict1= {'a': 1,'b': 2,'c': 3,'d': 4}
dict2= dict1.copy()
print(dict2, dict1is dict2)
4.
dict.fromkeys(序列, 值) --> 创建一个字典，将序列中的每个元素作为key，值作为value
dict3= dict.fromkeys('xyz',100)
print(dict3)
dict3= dict.fromkeys(['aa','bb','cc'], (1,2))
print(dict3)
5.
字典.get(key) --> key不存在取None
字典.get(key,默认值) --> key不存在取默认值
student= {}
print(student.get('name'))
print(student.get('name','无名'))
6.
字典.values() --> 返回所有值对应的序列
字典.keys() --> 返回所有键对应的序列
字典.items() --> 将键值对转换成元祖，作为一个序列的元素
注意：返回的都不是列表，是其他类型的序列
dict1= {'a': 1,'b': 2,'c': 3,'d': 4}
items= list(dict1.items())
print(items,type(items))
print(dict1.items(),type(dict1.items()))
7.
字典.setdefault(key) --> 添加键值对，键是key，值是None
字典.setdefault(key,value) --> 添加键值对，键是key，值是value
注意：key存在的时候，对字典不会有任何操作(不会修改key对应的值)
dict1= {'a': 1,'b': 2,'c': 3,'d': 4}
dict1.setdefault('aa')
print(dict1)
8.
字典1.update(字典2) --> 使用字典2中键值对去更新字典1。(已经存在的key就更新，不存在就添加)
"""
dict1= {'a': 1,'b': 2}
dict2= {'b': 200,'c': 100}
dict1.update(dict2)
print(dict1)
三、set
1.什么是集合(set)
容器，可以同时存储多个数据,可变的，无序的,元素是唯一的
可变 --> 增删改
无序 --> 不能通过下标获取元素
唯一 --> 自带去重的功能
{元素1, 元素2...}
元素：只能是不可变的数据
"""
set1= {10,20,'abc', (10,200),10}
print(set1)# {(10, 200), 10, 20, 'abc'}
# set2 = {} # 这个是空的字典
2.集合的增删改查
a.
查(获取元素)
集合不能单独的获取一个元素，也不能切片，只能通过for-in来遍历
for x in set1:
print(x)
b.
增(添加元素)
集合.add(元素) --> 在集合中添加一个元素
set1= {1,2,3}
set1.add(4)
print(set1)
集合1.update(序列) --> 将序列中的元素添加到集合1中
set1.update({'a','b'})
print(set1)
set1.update('0987')
print(set1)
set1.update(['abc','aaa'])
print(set1)
set1.update({'name': 1,'age': 18})# 字典只添加key
print(set1)
3.删(删除元素)
集合.remove(元素) --> 删除指定的元素
set1.remove(1)
print(set1)
4.改(集合不能改)
2、集合相关的运算
包含，交集、并集、差集、补集
1.包含
集合1 >= 集合2 ---> 判断集合1之中是否包含集合2
集合2 <= 集合2 ---> 判断集合2之中是否包含集合1
set1= {1,2,3,4,5,10}
set2= {3,4,1}
print(set1>= set2)
2.交集 -> &
& --> 求两个集合公共的部分
set1= {1,2,3,4,5}
set2= {1,2,3,10,20}
print(set1& set2)
3.求并集
| --> 求两个集合的和
print(set1| set2)
4.求差集
集合1-集合2 --> 求集合1中除了集合2以外的部分
print(set1- set2)
5.求补集
^ --> 求两个集合除了公共部分以外的部分
print(set1^ set2)
