字典和集合
1.元祖
a.
使用()将多个元素括起来，多个元素之间用逗号隔开
不可变 --->不能增删改
有序 ---->可以通过下标获取元素
tuple1 = (1, 'yue', True, [1, 2], lambda s: s*2)
print(tuple1) #(1, 'yue', True, [1, 2], at 0x0000019766BA5378>)
如果元祖的元素就只有一个的时候，必须在元素的后面加逗号
tuple2 = (100,)
print(type(tuple2)) #
b.
如果多个数据直接用逗号隔开，表示的也是一个元祖
tuple2 = 10, 20
print(tuple2, type(tuple2)) #(10, 20)
c.
元祖的元素不支持增删改
列表获取元素的方式，元祖都支持：元祖[下标]、元祖[：]、元祖[：：]
tuple2 = ('星期一', '星期二', '星期三', '星期四')
print(tuple2[1]) # 星期二
print(tuple2[2:]) # ('星期三', '星期四')
print(tuple2[::-1]) #('星期四', '星期三', '星期二', '星期一')
d.获取部分元素
1.可以用过相同的变量个数，来一一获取元祖中的元素
x, y = (10, 20)
print(x, y) # 10 20
2.可以通过在变量前加*来获取部分元素（也适用于列表）
tuple2 = ('小明', 90, 89, 67, 100)
name, *score = tuple2
print(name, score) #小明 [90, 89, 67, 100]
tuple2 = ['boy', 15320001547, 90, 89, 67, 100, '小明']
sex, tel, *score, name = tuple2
print(sex, name, score) # boy 小明 [90, 89, 67, 100]
3.可以通过在列表或则元祖前加*，来展开列表中的元素
tuple3 = (1, 2, 3, 4)
print(*tuple3) # 1 2 3 4
e.
元祖的运算
可以通过sorted()方法，对元祖进行排序，产生一个新的列表
tuple3 = 10, 230, 100, 78, 34
new = sorted(tuple3)
print(new, tuple3) # [10, 34, 78, 100, 230] (10, 230, 100, 78, 34)
2.字典
1.查
保存多个数据代表不同类的数据（需要区分）用字典
可变 ----> 可以进行增删改
无序 ----> 不能通过下标获取值（不能切片）
键(key):要求只能是不可变的数据类型(数字，字符串，元祖...)
a.相同的key时，保留最后一个
值（value):存储的数据。可以是任何类型的数据
a. 字典[key] -->获取key对应的值
key值必须存在，否则会报错KeyError
student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'sex': 'boy'}
print(student['name']) # 小明
print(student['sex']) # boy
b.字典.get(key) --->通过key获取值
注意：key值不存在的时候不会报错，结果为None
student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'sex': 'boy'}
print(student.get('age'), student.get('study_id')) #30 py001
print(student.get('score')) # None
确定key一定存在就使用[]语法，key可能不存在的时候用get语法
c.遍历字典
通过for-in遍历字典拿到的是key值
student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'sex': 'boy'}
for x in student:
print(x, student[x])
2.增
字典[key] = 值 (key不存在)
car = {}
car['color'] = 'yellow'
car['prince'] = '300000'
print(car) # {'color': 'yellow', 'price': 300000}
3.修改(修改值)
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'], student['sex']
print(student) # {'name': '小明', 'study_id': 'py001'}
b.字典.pop(key) --->取出key对应的值(实质还是删除key对应的键值对
name = student.pop('name')
print(student, name) # {'study_id': 'py001'} 小明
5.字典的相关运算
== 、is、 in 和 not In
a.
len() --> 获取键值对的个数
dict1 = {'abc': 1, 'a': 200}
print(len(dict1)) # 2
b.
字典.clear() -- > 清空字典
dict1.clear()
print(dict1) # {}
c.
字典.copy()-->将字典中的键值对复制一份产生一个新的字典
dict1 = {'abc': 1, 'a': 200}
dict2 = dict1.copy()
print(dict2) # {'abc': 1, 'a': 200}
d.
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)}
e.
字典.get(key) ---> key不存在取None
字典.get(key,默认值) ---> key不存在取默认值
student = {}
print(student.get('age')) # None
print(student.get('age', 18)) # 18
f.
字典.values() --->返回所有值对应的序列
字典.keys() ---->返回所有键对应的序列
字典.items() -->将键值对转换成元祖，作为一个序列的元素
dict1 = {'abc': 1, 'a': 200}
items = list(dict1.items())
print(items) # [('abc', 1), ('a', 200)]
print(dict1.items()) # dict_items([('abc', 1), ('a', 200)])
g.
字典.setdefault(key) --->添加键值对，键是key，值是None
字典.setdefault(key, 值）--->添加键值对，键是key，值是value
注意：key存在的时候，对字典不会有任何操作（不会修改key对应的值）
dict1 = {'abc': 1, 'a': 200}
dict1.setdefault('a', 500)
print(dict1) # {'abc': 1, 'a': 200}
dict1.setdefault('ab', 500)
print(dict1) # {'abc': 1, 'a': 200, 'ab': 500}
h.
字典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}
3.集合
set2 = {} # 这个是空的字典
集合不能改
可变 ---> 增删改
无序 ---> 不能通过下标去获取元素
唯一 --- > 自带去重的功能
{元素1， 元素2， ....}
元素：只能是不可变的数据
set1 = {10, 20, 'abc', (10, 200), 10}
print(set1) # (10, 200), 10, 20, 'abc'}
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) # {1, 2, 3, 4, 'a', 'b'}
set1.update('0987')
print(set1) # {1, 2, 3, 4, 'a', '0', '8', '7', '9', 'b'}
set1.update(['abc', 'aa'])
print(set1) # {1, 2, 3, 4, 'a', '0', '8', '7', 'abc', '9', 'b', 'aa'}
set1.update({'name': 1, 'age': 18}) # 字典只添加key
print(set1) # {1, 2, 3, 4, 'a', '0', '8', 'name', '7', 'age', 'abc', '9', 'b', 'aa'}
c.删
集合.remove(元素) ---> 删除指定的元素
set1.remove('aa')
print(set1) # {1, 2, 3, 4, 'a', '0', '8', 'name', '7', 'age', 'abc', '9', 'b'}
2.集合的相关运算
a.包含
集合1 >= 集合2 --->判断集合1中是否包含集合2
集合1 <= 集合2 --->判断集合2中是否包含集合1
set1 = {1, 2, 3, 4, 5}
set2 = {3, 4, 2}
print(set1 >= set2) # True
b.交集 - >&
set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3, 10, 20}
print(set1 & set2) # {1, 2, 3}
c.并集
| ---> 求两个集合的和
print(set1 | set2) # {1, 2, 3, 4, 5, 10, 20}
d.求差集
集合1 - 集合2 ---> 求集合1中除了集合2以外的部分
print(set1 - set2) # {4, 5}
e.补集
^ --->求两个集合除了公共部分以外的部分
print(set1 ^ set2) # {20, 4, 5, 10}
3.数据类型的转换
1.整型
int()
浮点数、布尔、部分字符串可以转换成整型
部分字符串:只有去掉引号后本身就是一个整数的字符串才能转换成整型
2.浮点数
float()
整数，布尔，部分字符串可以转换成浮点数
部分字符串：去掉字符串的引号，本身就是一个数字的字符串才能转换成浮点数
3.布尔
bool()
所有的数据都可以转换成布尔值
为空为0的值 转换成False，其他的数据都转换成True.
print(bool(''))
print(bool([]))
print(bool(0))
print(bool(None))
# False
4.字符串
str()
所有的数据都可以转换成字符串
数据转换成字符串，就是在数据的最外面加引号
5.列表
list()
序列才能转换成列表
将序列中的元素作为列表的元素
字典转换成列表，将字典的key作为列表的元素
print(list('student')) # ['s', 't', 'u', 'd', 'e', 'n', 't']
print(list((23, 45, 'ac'))) # [23, 45, 'ac']
6.元祖（和列表一样）
只能将序列转换成元祖
tuple()
7.字典
dict()
序列的每个元素有两个元素的数据才能转换成字
list1 = [(1, 3), (2, 4)]
print(dict(list1)) # {1: 3, 2: 4}
8.集合
set()
序列可以转换成集合，有去重的功能
print(set([1, 1, 90, 3, 10, 10])) # {10, 1, 90, 3}