1.什么是元祖
a.
是容器，可以存储多个数据，不可变，有序的
不可变：不能增删改
有序：可以通过下标获取
b.
元素，可以是任何类型的数据
注意：如果元祖的元素只有一个，则必须在后面加逗号表示一个元祖
tuple1 = (100,)
print(tuple1)
tuple1 = 10, 20, 'abc' # 也是元祖(多个数据用逗号隔开表示的也是元祖)
print(tuple1)
2.元祖：不支持增删改，但可以查
列表获取元素的方式，元祖都支持
元祖[下标] 或 元祖[ : : ]
tuple2 = '星期一', '星期二', '星期三', '星期四'
print(tuple2[0])
print(tuple2[2:])
print(tuple2[ : : -1])
#### 3.遍历元祖
for item in tuple2:
print(item)
index = 0
while index < len(tuple2):
print(tuple2[index])
index += 1
4.补充：获取部分元素：可以通过相同的变量个数，来一一获取元祖中的元素
x, y = (10, 20)
print(x, y)
x, y, z = 10, 20, 30
print(x, y, z)
应用：交换两个数的值
a = 10
b = 20
方法1：
t = a
a = b
b = t
方法2：
a, b = b, a
print(a, b)
5.可以通过在变量前加*来获取部分元素(适用列表)
tuple2 = ( 90, 80, 70, '小明')
name, *score = tuple2
print(name, score)
*score, name = tuple2
print(name, score)
6.可以在列表或元祖前加*，来展开列表中的元素
tuple3 = ( 90, 80, 70, '小明')
print(*tuple3)
list1 = ['abc', '100', '200']
print(*list1)
7.元祖运算
>, +, *, ==, is, in, not in
print((1, 2, 3) + ('z', 'c', 'b'))
print((1,2) * 2)
print((1,2,3) == (1, 2, 3))
print((1,2,3) is (1,2,3))
print((1,2) in (1,2,3))
print((1,2,3) not in (1,2,3))
8.元祖支持的函数方法
- len()
- max()
- min()
9.tuple()
所有的序列都可以转换成元祖，注意：字典只能将key值作为元祖元素
print(tuple('abcd'))
10.sorted()
排序后产生一个新的列表
tuple4 = (1,2,3,8,0,4)
tuple5 = sorted(tuple4)
print(tuple4)
print(tuple5)
11.需要存储多个数据时就用容器
什么时候用列表：保存同一类数据时用列表
什么时候用字典：需要区分数据意义时就要字典
什么时候用元祖: 保存同一类数据时用列表，并且不可变时
12.什么是字典
字典是一个容器类的数据类型，可以用来存储多个数据（键值对的形式存储数据）
{key1:value1, key2:value2, .....}
字典是可变的（可以增删改），无序的（不能用下标获取值）
key:用来定位值的。要求：唯一性，只能是不可变的数据类型（数字，字符串，元祖....）
值：存放数据，可以是任何类型的数据
student = {'name':'xiaoming', 'age':'18', 'math':80, 'english':90,'chinese':90}
print(student['name'])
13.查（获取value）
获取字典的值必须通过key来获取
每次只能获取单个值
a.
语法：字典[key] 获取key对应的值
key必须存在，否则报错
b.
字典.get(key) :获取key对应的值
key不存在时不会报错，返回一个none
注意：key一定存在时用字典[key]，当key可能存在可能不存在时用字典.get（）方法
student = {'name':'xiaoming', 'age':'18', 'math':80, 'english':90,'chinese':90}
print(student['math'])
print(student.get('math'))
print(student.get('kkkk')) # 返回None
14.直接遍历字典(拿到key推荐使用)
student = {'name':'xiaoming', 'age':'18', 'math':80, 'english':90,'chinese':90}
for x in student:
print(x, student[x])
15.其他方式遍历（占cpu）
a.直接遍历获取值
for value in student.values():
print(value)
b.直接遍历获取key-value
for key, value in student.items():
print(key, value)
17.添加键值对
- 语法：dict[key] = value(key不存在)
car = {}
car['color'] = 'red'
print(car)
18.修改
- 语法：dict[key] = value(key存在)
car = {}
car['color'] = 'red'
car['color'] = 'black'
print(car)
19.删除键值对
a.
语法：del dict[key] 通过key删除键值对b.
语法：dict.pop(key) 取出key对应的值，但相对来说就是删除键值对
student = {'name':'xiaoming', 'age':'18', 'math':80, 'english':90,'chinese':90}
del student['age']
print(student)
name = student.pop('name')
print(student, name)
20.字典相关运算
字典不支持+，* 运算
但只支持 == 运算，但字典长度要相同，字典是无序的
字典也支持 is，in，not in
注意：key in dict 或者 key not in dict
print({'a': 100, 'b':200} == {'b': 200, 'a': 100})
print({'a': 100, 'b':200} is {'b': 200, 'a': 100})
print('a' in {'a': 100, 'b':200})
print('a' not in {'a': 100, 'b':200})
21.字典相关函数和方法
len(dict)
获取键值对的个数dict.clear()
清空字典所有的键值对dict.copy()
复制一份所有的键值对，产生一个新的字典
dict1 = {1,5,8,9}
dict2 = dict1.copy()
print(dict2)
- dict.fromkeys(序列，值)
将序列中的每个元素作为key，后面的值作为value
dict3 = dict.fromkeys('xyz', 100)
print(dict3) #{'x': 100, 'y': 100, 'z': 100}
- dict.get(key) # key不存在时返回none
- dict.get(key, 默认值) # key不存在时取默认值
student = {}
print(student.get('name'))
print(student.get('name', '无名'))
dict.values()
直接获取所有的value序列dict.keys()
直接获取所有key的序列dict.items()
将键值对转换成元祖，作为一个序列的元素
注意：返回的都不是列表，是其他类型的序列dict.setdefault(key)
dict.setdefault(key, 值)
key存在时对字典没有任何效果，key不存在时会添加一个新的键值对（key为空时默认为none）
student = {}
student.setdefault('aa', 100)
print(student)
student.setdefault('aa')
print(student)
- dict1.update(dict2)
使用2中的键值对去更新字典2(已经存在的key就更新，不存在的就添加)
dict1 = {'a': 1, 'b': 2}
dict2 = {'a': 100, 'c': 500}
dict1.update(dict2)
print(dict1)
print(dict2)
22.什么是集合（set）
集合也是容器，集合是可变的，无序的
可变：能增删改
无序：不能通过下标获取元素
形式：{元素1，元素2....}
元素：必须是不可变的数据，并且元素具有唯一性，则集合自带去重的功能
set1 = {1, 'asd', 45, (10, 200)}
print(set1)
注意：set2 = {}表示字典，而不是集合
23.集合的查（获取）
- a.
集合不能单独获取一个元素，不能切片，只能通过for-in来遍历
set1 = {1, 'asd', 45, (10, 200)}
for x in set1:
print(x)
24.增加元素
a.
set.add(元素) ：集合中添加一个元素
set1 = {1, 'asd', 45, (10, 200)}
set1.add(5)
print(set1)b.
set1.update(set2) :将集合2中的元素添加到集合1中,相当于数学求并集
set2 = {'zzz', 'aaa'}
set1.update(set2)
print(set1)
set2.update('789')
print(set2) #{'aaa', 'zzz', '9', '7', '8'}
set2.update(['abc', 'uuu'])
print(set2) # 列表元素必须是不可变的
set2.update({'name': 520})
print(set2) # 字典只能把key添加到集合中
25.删除
集合就一种删除方法
语法：集合.remove(元素)
注意：集合不能改
26.集合相关运算
包含，交集，并集，补集，差集
27.包含
运算符： >= 和 =<
集合1 >= 集合2 : 判断集合1是否包含集合2
集合1 <= 集合2 : 判断集合2是否包含集合1
set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3,}
print(set1 >= set2)
print(set2 <= set1)
28.交集
求两个集合公共部分
运算符：&
set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3,}
print(set1 & set2) #{1, 2, 3}
29.并集
求两个集合的和
运算符：|
set1 = {1, 2, 8, 4, 10}
set2 = {1, 20, 9,}
print(set1 | set2) # {1, 2, 4, 20, 8, 9, 10}
30.差集
运算符: -
集合1 - 集合2 ：求集合1中除了集合2以外的部分
set1 = {1, 2, 8, 4, 10}
set2 = {1, 20, 9,}
print(set1 - set2) # {8, 2, 10, 4}
31.补集
运算符： ^
求两个集合除了公共部分以外的部分
set1 = {1, 2, 8, 4, 10}
set2 = {1, 20, 9,}
print(set1 ^ set2) # {2, 4, 8, 9, 10, 20}
1.整型
语法：int()
浮点数、布尔、部分字符串
去掉引号后就本身就是整数，才能转换成整型
print(int('+4'), int('-5'))
2.浮点数
语法：float()
整数、布尔、部分字符串
去掉引号本身就是一个数字的字符串才能转换成浮点数
print(float('23.5'),float(+25), float(-5))
3.bool
语法：bool()
所有的数据都能转换成bool类型
所有容器为空时转换都是False，整数0才能转换成False
print(bool(-5))
print(bool(None))
简化条件语句
num = 11
if num:
print('不为0')
4.字符串
语法：str()
所的数据都可以转换成字符串,也就是在数据外面加引号
print(str([1, 2, 5]),str({'name': 555, 'age': 18}))
5.列表
语法：list()
序列才能转换成列表
将序列元素作为列表的元素
字典转化成列表只是将字典的key做作为列表的元素
print(list({'a':10, 'b':20}))
print(list({'a':10, 'b':20}.items()))
# [('a', 10), ('b', 20)]
6.元祖
tuple()
将序列转换成元祖
print(tuple({'a':10, 'b':20})) #('a', 'b')
print(tuple({'a':10, 'b':20}.items())) #(('a', 10), ('b', 20))
7.字典
语法：dict()
只有序列才能转换成字典，要求序列的每个元素有且只有两个元素
print(dict([('name', 'xiaoming'), ('age', 20)]))
8.集合set
语法：set()
序列可以转换成集合，有去重的功能
字典转换成集合，也只能将key作为集合的元素
print(set({'naem' : 'xiaoming', 'age': 18}))
