day8 --字典和集合
一、元祖
1.什么是元祖
a.容器，可以同时存储多个数据，不可变的，有序的
不可变--->不能增删改
有序--->可以通过下标获取元素
b.元素，可以是任何类型的数据
注意：如果元祖的元素只有一个的时候，必须在元素的后面加逗号，才能成为元祖
tuple=(100)
print(type(tuple)) #<class 'int'>
#如果多个数据用逗号隔开，表示的也是一个元祖
tuple=10,20,'abc'
print(type(tuple)) #<class 'tuple'>
2.元素的查
元祖的元素不支持增删改
列表获取元素的方式，元祖都支持：元祖[下标]、 元祖[:],元祖[::]
遍历：和列表一样 for in
tuple=('星期一','星期二','星期三','星期四')
index=0
while index < len(tuple):
print(tuple[index])
index+=1
补充：获取部分元素
可以通过相同的变量的个数，来一一获取元祖中的元素
a=10
b=20
a,b=b,a
print(a,b)
c=30
a,b,c=c,b,c
可以通过在变量前加来获取部分的元素 用变量代替有序的元素，先取有序的元素，剩下的元素就是加号的
tuple=('小明',1,2,3,4)
name,*score=tuple
print(name,score)
tuple=('小明',1,2,3,4,'13567891234','年龄')
name,*num,index=tuple
print(name,num,index)
可以通过在列表或者元祖前加*号，来展开列表和元祖中的元素
tuple=(1,2,3,4)
print(*tuple) #1 2 3 4
list=['abc',100,200]
print(*list) #'abc' 100 200
3.元祖的运算
""""
+,*,==,is,in not in -->和列表一样
"""
print((1, 2, 3) + ('a','b')) #(1, 2, 3, 'a', 'b')
print((1, 2) * 3) #(1, 2, 1, 2, 1, 2)
print((1, 2, 3) == (1, 2, 3)) #True
print((1, 2, 3) is (1, 2, 3)) #False
print(1 in (1, 2, 3)) #True
print(1 not in (1, 2, 3)) #False
4.len() ,max(), min()
5.tuple() 所有的序列都可以转换成元祖，注意，字典只能讲key值作为元祖元素
拿出序列的元素作为元祖的元素
print(tuple('abhdnc')) #('a', 'b', 'h', 'd', 'n', 'c')
print(tuple([1, 23, 90])) #(1, 23, 90)
print(tuple(range(5))) #(0, 1, 2, 3, 4)
print(tuple({'a': 100, 'b': 200})) #('a', 'b')
7.sorted()
可以通过sorted()方法，对元祖进行排序，产生一个新的列表
tuple3 = 10, 230, 100, 78, 34
new = sorted(tuple3)
print(new, tuple3)
# [10, 34, 78, 100, 230] (10, 230, 100, 78, 34)
二、认识字典
什么时候用容器类型的数据？ ---> 需要同时保存多个数据的时候
什么时候用列表？ ---> 保存的多个数据是同一类的数据（不需要区分）
什么时候用字典？ ---> 保存的多个数据是不同类的数据 (需要区分)
1.什么是字典（dict）
字典是一个容器类的数据类型，可以用来存储多个数据（以键值对的形式存储）
{key1:value1,key2:value2....}
可变--->可以增删改
无序--->不能通过下标获'取值
键（key):用来定位值的。要求只能是不可变的数据类型（数字，字符串，元祖、、、）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) # {'name': '小花', 'age': 18, 'face': 90, 'score': 100, 'tel': '1547262889'}
print(person2['name']) #小花
dict1 = {}
print(dict1)
三、字典的增删改查
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 x in student:
print(x, student[x])
d.其他遍历方式(了解)
直接遍历拿到值
for value in student.values():
print(value)
直接拿到key和value
print(student.items())
for key, value in 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) #{'color': 'red', 'price': 300000}
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)
#{'study_id': 'py001', 'sex': 'boy'} 小明
四、字典相关操作
1.字典相关运算
==: 判断两个字典的值是否相等
is: 判断两个字典的地址是否相等
in 和 not in: key in 字典 / key not in 字典 ---> 判断key是否存在
dic1 = {'a': 1, 'b': 2}
aa = dic1
print(dic1 is aa) #True
print({'a': 100, 'b': 200} == {'b': 200, 'a': 100}) #True
print({'a': 100, 'b': 200} is {'b': 200, 'a': 100}) # False
print('abc' in {'abc': 100, 'a': 200}) # True
print('abc' in {'100': 'abc', 'a': 200}) # False
2.字典相关的函数和方法
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, dict1 is dict2)
4.dict.fromkeys(序列, 值) --> 创建一个字典，将序列中的每个元素作为key，值作为value
dict3 = dict.fromkeys('xyz', 100)
print(dict3) #{'x': 100, 'y': 100, 'z': 100}
dict3 = dict.fromkeys(['aa', 'bb', 'cc'], (1, 2))
print(dict3) #{'aa': (1, 2), 'bb': (1, 2), 'cc': (1, 2)}
5.
字典.get(key) --> key不存在取None
字典.get(key,默认值) --> key不存在取默认值
有（key）时，取key对应的value
student = {}
print(student.get('name')) #None
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))
#[('a', 1), ('b', 2), ('c', 3), ('d', 4)] <class 'list'>
print(dict1.items(), type(dict1.items()))
#dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)]) <class 'dict_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)
#{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'aa': None}
8.
字典1.update(字典2) --> 使用字典2中键值对去更新字典1。 (已经存在的key就更新，不存在就添加)
dict1 = {'a': 1, 'b': 2}
dict2 = {'b': 200, 'c': 100}
dict1.update(dict2)
print(dict1)
# {'a': 1, 'b': 200, 'c': 100}
五、集合
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,2,3,4}
集合1.update(序列) --> 将序列中的元素添加到集合1中
set1.update({'a', 'b'})
print(set1) #{'b', 1, 2, 3, 4, 'a'}
set1.update('0987')
print(set1) #{1, 2, 3, 4, '0', '9', '8', '7', 'b', 'a'}
set1.update(['abc', 'aaa'])
print(set1) #{1, 2, 3, 4, '0', '9', 'aaa', '8', '7', 'abc', 'b', 'a'}
set1.update({'name': 1, 'age': 18}) # 字典只添加key
print(set1)
#{1, 2, 3, 4, '0', '9', 'aaa', '8', '7', 'name', 'abc', 'b', 'age', 'a'
3.删(删除元素)
集合.remove(元素) --> 删除指定的元素
set1.remove(1) #删除元素1
print(set1)
#{2, 3, 4, '0', '9', 'aaa', '8', '7', 'name', 'abc', 'b', 'age', 'a'}
4.改(集合不能改)
六、集合相关的数学运算
集合相关的运算: 是否包含，交集、并集、差集、补集
1.包含
集合1 >= 集合2 ---> 判断集合1之中是否包含集合2
集合2 <= 集合2 ---> 判断集合2之中是否包含集合1
set1 = {1, 2, 3, 4, 5, 10}
set2 = {3, 4, 1}
print(set1 >= set2) #True
2.交集 -> &
& --> 求两个集合公共的部分
set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3, 10, 20}
print(set1 & set2) #{1, 2, 3}
3.求并集
| --> 求两个集合的和
print(set1 | set2) #{1, 2, 3, 4, 5, 10, 20}
4.求差集
集合1-集合2 --> 求集合1中除了集合2以外的部分
print(set1 - set2) #{4, 5}
5.求补集
^ --> 求两个集合除了公共部分以外的部分
print(set1 ^ set2) #{20, 4, 5, 10}
七、类型转换
1.整型
int()
浮点数、布尔、部分字符串可以转换成整型。
只有去掉引号后本身就是一个整数的字符串才能转换成整型
print(int('34'))
print(int('+45'))
print(int('-90'))
# print(int('34.5')) # ValueError
2.浮点数
整数，布尔，部分字符串可以转换成浮点数
去掉的引号，本身就是一个数字的字符串才能转换成浮点数
print(float(100)) # 100.0
print(float(True))
print(float('34.90'))
print(float('100'))
3.布尔
所有的数据都可以抓换成布尔值
为空为0的值转换成False, 其他的数据都转换成True
print(bool('abchd')) # True
print(bool('False')) # True
print(bool('')) # False
print(bool([1, 2, 3])) # True
print(bool([])) # False
print(bool({'a': 1})) # True
print(bool({})) # False
print(bool(()))
print(bool(0.00))
print(bool(None))
num = 100
if num == 0:
print('是0')
if not num:
print('是0')
names = [23]
if names:
print('不是空')
else:
print('是空')
num = 230
if num % 2:
print('是奇数')
else:
print('是偶数')
4.字符串
str()
所有的数据都可以转换成字符串
数据转换成字符串，就是在数据的最外面加引号
print([str(100)])
print([str(True)])
print([str([1, 2, 3])])
print([str({'a': 1, 'b': 2})])
print([str(lambda x: x*2)])
list_str = str([1, 2, 3])
print(len(list_str)) #9 字符串每个元素之间都有个空格
5.列表
list()
序列才能转换成列表。
将序列中的元素作为列表的元素。字典转换成列表，将字典的key作为列表的元素
print(list('styui')) #['s', 't', 'y', 'u', 'i']
print(list((23, 45, 'ac'))) #[23, 45, 'ac']
print(list({'a': 100, 'b': 89})) #['a', 'b']
print(list({'a': 100, 'b': 89}.items()))
#[('a', 100), ('b', 89)]
6.元祖(和列表一样)
tuple()
只能将序列转换成元祖
print(tuple('ancbd')) #('a', 'n', 'c', 'b', 'd')
print(tuple({'a': 100, 'b': 89})) #('a', 'b')
7.字典
dict()
序列的每个元素下面有两个元素的数据才能转换成字典
list1 = [(1, 2)]
print(dict(list1)) #{1: 2}
tuple1 = ((1, 8), {'a', 'b'})
print(dict(tuple1)) #{1: 8, 'a': 'b'}
8.集合
set()
序列可以转换成集合，有去重的功能
print(set([1, 1, 90, 3, 10, 10]))
# {10, 1, 90, 3}
