###一、元组

####1、什么是元组
元组：使用()将多个元素括起来，多个元素之间用逗号隔开
a.
容器,可以同时存储多个数据，不可变，有序的
不可变 –> 不能增删改
有序 —>可以通过下标获取元素
b.
元素,可以是任何类型的数据

######注意：如果元组的元素只有一个的时候，必须在元素后面加逗号

1
2
3

tuple2 = 10, 20, 'bc'
print(tuple2, type(tuple2))
结果为：(10, 20, 'bc') <class 'tuple'>

####2、元组的查
元组的元素不支持增删改
列表获取元素的方式，元组都支持：元组[下标]，元组[:],元组[::]
补充：获取部分元素，可以通过相同的变量个数，来一一获取元组中的元素

1
2
3

tuple2 = ('星期一', '星期二', '星期三', '星期四')
print(tuple2[2:])
输出的结果为：('星期三', '星期四')

#####a.应用：交换两个值

1
2
3
4
5

a = 10
b = 20
a, b = b, a
print(a, b)
输出的结果 ：20 10

#####b.可以通过在变量前加*来获取部分元素(适用于列表)

1
2
3
4

tuple2 = ('小明', 90, 89, 67, 100)
name, *score = tuple2
print(name, score)
输出的结果：小明 [90, 89, 67, 100]

#####c.可以通过在列表或者元组前加*，来展开列表中的元素

1
2
3

tuple3 = (1, 2, 3, 4, 5)
print(*tuple3)
输出的结果为：1 2 3 4 5

####3.元组的运算
+,*,==,is,in ,not in,—>和列表一样

####4.tuple()
所有的序列都可以转换为元组，注意。字典只能讲key值作为元组元素

####5.sorted()
可以通过sorted()方法，对元组进行排序，产生一个新的列表

###二、认识字典

####1.什么是字典
字典是一个容器类的数据类型，可以用来存储多个数据(以键值对的形式存储)，可变的，无序的
{key1:value1,key2:value2,key3:value3,…..}
可变 —>可以增删改
无序–>不能通过下标获取值
键(值)：用来定位值的，要求只能是不可变的数据类型(数字，字符串，元组…)，是唯一的
值(value):存储的数据，可以是任何类型的数据

####2.

1
2
3

什么时候用容器类型的数据？ -->需要同时保存多个数据的时候
什么时候用列表？ -->保存的多个数据是同一类的数据(不需要区分)
什么时候用字典？ -->保存的多个数据是不同类的数据（需要区分）

###三、字典的增删改

1.查(获取键值对的value)

获取字典的值，必须通过key来获取
语法：

#####a.字典[key] –>获取key对应的值
注意：key值必须是存在的，否则会包keyerror错

1
2

student = {'name': '小明', 'age': '18', 'study_id': 'py001', 'sex': 'boy'}
print(student['name'])

#####b.字典.get(key) –>通过key获取值
注意;key值不存在的时候不会报错，结果是None

1

print(student.get('age'), student.get('study_id'))

确定key一定存在就使用[]语法，key可能不存在1的时候用get()语法

#####c.遍历字典
通过for-in遍历字典拿到的是可以值

1
2

for x in student:
    print(x, student[x])

#####d.其他遍历方式(不推荐使用)

直接遍历拿到值

1
2

for value in student.values():
    print(value)

直接拿到key和value

1
2
3

print(student.items())
for key, value in student.items():
    print(key, value)

#####增(增加键值对)

字典[key]=值(不存在) —>

1
2
3

car ={}
car['color'] = 'red'
print(car)

#####3.修改（修改值）
字典[key] = 新值（key存在）

1
2

car['color'] = 'yellow'
print(car)

4.删(删除键值对)

#####a.del 字典[key] —>通过key删除键值对

1
2
3

student = {'name': '小明', 'age': '18', 'study_id': 'py001', 'sex': 'boy'}
del student['age']
print(student)

#####b.pop(key) —>取出key对应的值(实质还是删除key对应的键值对)

1
2

name = student.pop('name')
print(student, name)

###四、字典相关操作

1.字典相关运算

a.==:判断两个字典的值是否相等
b.is:判断两个字典的字典是否相等

in 和 not in: key in 字典/key not in 字典—> 判断key是否在/不在字典里

2.字典相关的函数方法

a.len（字典） —>获取键值对的个数
b.字典.clear() –>清空字典
c.字典.copy() —>将字典中的键值对复制一份产生一个新的字典
d.字典.fromkeys(序列，值) –>创建一个字典，将序列中的每个元素作为key，值作为value

1
2
3
4
5
6
7

dict3 = dict.fromkeys('xyz', 100)
print(dict3)
dict2 = dict.fromkeys(['aa', 'bb', 'cc'], 100)
print(dict2)
输出的结果为：
{'x': 100, 'y': 100, 'z': 100}
{'aa': 100, 'bb': 100, 'cc': 100}

e.
字典.get(key) –>key不存在取None
字典.get(key,默认值) –>key不存在取默认值

f.
字典.values() —>返回所有对应的序列
字典.keys() –>返回所有键对应的序列
字典.items() –>将键值对转换为元组，作为一个序列的元素

1
2
3
4

dict1 = {'a': 1, 'b': 2, 'c': 3}
items = list(dict1.items())
print(items)
输出的结果为：[('a', 1), ('b', 2), ('c', 3)]

g .
字典.setdefault(key) —>添加键值对，键是key，值是None
字典.setdefault(key,值) –>添加键值对，键是key，值是value
注意：key存在的时候，对字典不会有任何操作(不会修改key对应的值)

1
2
3
4

dict1 = {'a': 1, 'b': 2, 'c': 3}
dict1.setdefault('aa', 100)
print(dict1)
输出的结果为：{'a': 1, 'b': 2, 'c': 3, 'aa': 100}

8.字典1.update(字典2) –>使用字典2中的键值对去更新字典1(已经存在的可以更新，不存在就添加)

1
2
3
4
5

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，…}
元素：不可变的数据

1
2
3

set1 = {10, 20, 'abc', (10, 20), 10}
print(set1)      # 10, 20, (10, 20), 'abc'}
# set2 = { }   # 这个是空的字典

####2.集合的增删改查

#####a.查(获取元素)
集合不能单独的获取一个元素，也不能切片，只能通过for- in来遍历

#####b.增（添加元素
1.集合.add(元素) —>在集合中添加一个元素

1
2
3
4

set1 = {1, 2, 3}
set1.add(4)
print(set1)
输出的结果为：{1, 2, 3, 4}

2.集合1.update(序列）—>将集合2中的元素添加到集合1中(字典只添加key)

1
2
3

set1.update({'a, b'})
print(set1)
输出的结果为：{1, 2, 3, 4, 'a, b'}

####3.删（删除元素）
集合.remove(元素) —>删除指定的元素

###六、集合相关的数学运算

集合相关的运算：是否包含，交集，并集，差集，补集

####1.包含：>=
集合1 >= 集合2 —>判断集合1中是否包含集合2
集合2 >= 集合1 —>判断集合2中是否包含集合1

1
2
3
4

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3}
print(set1 >= set2)
输出的结果为：True

2.交集 ： &

&:求两个集合公共的部分

1
2
3
4

set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3, 10, 20}
print(set1 & set2)
输出的结果为：{1, 2, 3}

####3.求并集：|
| –>求连个集合的和

####4.求差集
集合1-集合2 –>求集合1中出来集合2意外的部分

5.求补集

^ –>求两个集合除了公共以外的部分

###七、类型转换

1.整型

int()
浮点数，布尔、部分字符串可以转换为整型。
只有去掉引号后本身就是一个整数的字符串才能转换为整型

2.浮点数

float()
整数，布尔，部分字符串可以转换为浮点数
只有去掉引号，本身就是一个数字的字符串才能转换为浮点数

3.布尔

bool()
所有的数据都可以转换为布尔值
为空为0的值转换为False,其他的数据都转换为True

4.字符串

str()
所有的数据都可以转换成字符串
数据转换成字符串，就是在数据的最外面加引号

5.列表

list()
序列才能转换成列表
将序列中的元素作为列表的元素。字典转换成列表，将字典的key作为列表的元素

1
2

print(list({'a': 100, 'b': 89}.items()))
输出的结果为：[('a', 100), ('b', 89)]

####6.元组
tuple()
只能将序列转换成元组

7.字典

dict()
序列的每个元素有两个元素的数据才能转换成字典

1
2
3
4
5
6

list1 = [(1, 2), ['a', 10]]
print(dict(list1))
输出的结果为：1: 2, 'a': 10}
tuple1 = ((1, 8), {'a', 'b'})
print(dict(tuple1))
输出的结果为：{1: 8, 'b': 'a'}

7.集合

set()
序列可以转换成集合，有去重功能