一、元组

1.什么是元组

格式：tuple = (元素1， 元素2， ……, 元素n)
tuple = 元素1, 元素2, ……, 元素n
注意：只有一个元素时， 元素后加逗号
singel_tuple = (元素1,)
singel_tuple = 元素1,

空元组，
empty_tuple = ()

使用（）将多个元素括起来，多个元素之间用逗号隔开

• a.容器，可以同时存储多个数据，不可变的，有序的
  不可变 ---> 不能增删改
  有序 ---> 可以通过下标获取元素

• b.元素,可以是任何类型的数据

tuple1 = (1, 'yue', True, [1, 2], lambda s:s*2)
tuple2 = 1, 2, 3
tuple3 = 1,
print(tuple1, tuple2, tuple3, sep = "\n")

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

tuple2 = (100)
print(type(tuple2))  # <class 'int'>

tuple2 = (100,)
print(type(tuple2))  # <class 'tuple'>

注意： 2.多个数据直接用逗号隔开，表示的也是一个元组

tuple2 = 10, 20, 'abc'
print(tuple2, type(tuple2))  # (10, 20, 'abc') <class 'tuple'>

2.元素的查

元组的元素不支持增删改
列表获取元素的方式，元组都支持：元组[下标]，元组[:],元组[::]
index[]

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)

应用：交换两个数的值

a = 100
b = 200
tuple6 = (a, b)  # 过程简写 a, b = b, a 或 a, b =(b, a)
b, a = tuple6
print(a, b)

方法二：
可以通过在变量前加*来获取部分元素

tuple2 = ('小明', 90, 89, 67, 100)
name, *score = tuple2
print(name, score)  # 小明 [90, 89, 67, 100]

tuple2 = (90, 89, 67, 100, '小明')
*score, name = tuple2
print(score, name)  # [90, 89, 67, 100] 小明

list1 = ['boy', 15300022673, 90, 89, 67, 100, '小明']
sex, tel, *score, name = list1
print(sex, score, name)  # boy [90, 89, 67, 100] 小明

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

tuple3 = (1, 2, 3, 4)
print(*tuple3)  # 1 2 3 4

list1 = ['abc', 100, 200]
print(*list1)  # abc 100 200

3.元组的运算

+，*，==，is, in, not in ---> 和列表一样

print((1, 2, 3) + ('a', 'b', 'c'))  # (1, 2, 3, 'a', 'b', 'c')
print((1,2) * 3)  # (1, 2, 1, 2, 1, 2)

4.len(), max(), min()

tuple3 = 10, 230, 100, 78, 34
print(len(tuple3))  # 5
print(max(tuple3))  # 230
print(min(tuple3))  # 10

5.tuple()

所有的序列都可以转换成元组，注意，字典只能将key值作为元组元素

print(tuple('abcd'))  # ('a', 'b', 'c', 'd')
print(tuple([1, 223, 90]))  # (1, 223, 90)
print(tuple(range(5)))  # (0, 1, 2, 3, 4)
print(tuple({'a': 100, 'b': 200}))  # ('a', 'b')

6.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）: 用来定位值的，要求只能是不可变的数据类型（数字，字符串，元组……）,是唯一的
值（value):存储的数据，可以是任何类型的数据

person = {'name': 'yuxiaoyu', 'age': 28, 'tel':'173****0924'}
dict1 = {1: 2, 22: 33}
# dict2 = {[1, 2]: 2}  # TypeError: unhashable type: 'list'
dict2 = {(1, 2): 22}
dict3 = {'name': 'yuyu', 'name': 'haha'}
print(dict3)  # {'name': 'haha'}如果键不唯一，只取一个

三、字典的增删改查

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

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

• a.字典[key] ---> 获取key对应的值
  注意：key值必须是存在的，否则会报KeyError

student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'gender':'male'}
print(student['name'])
print(student['gender'])
# print((student['score']))  # KeyError: 'score'

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

print(student.get('age'))  # 30
print(student.get('score'))  # None

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

• c.直接遍历字典（推荐使用）
  通过for-in遍历字典拿到的是key值

student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'gender':'male'}

for x in student:
    print(x)  # 打印student的key

• d.其他遍历方式（了解）
  直接遍历拿到值
  （将字典先遍历一遍，将字典里面的值取出，放到一个容器里面，浪费CPU资源）

for value in student.values():
    print(value)  # 打印student的值

遍历拿到key和value

for key, value in student.items():
    print(key, value)  # 打印student的键和值

print(student.items())  # dict_items([('name', '小明'), ('age', 30), ('study_id', 'py001'), ('gender', 'male')])

(在上面的基础上，items还要进行类型的转换，消耗CPU资源）

2.增（添加键值对）

字典[key] = 值 （key不存在）

car = {}
car['color'] = 'yellow'
print(car)  # {'color': 'yellow'}

car['price'] = 300000
print(car)  # {'color': 'yellow', 'price': 300000}

3.修改（修改值）

字典[key] = 新值（key存在）

car['color'] = 'red'
print(car)  # {'color': 'red', 'price': 300000}

4.删（删除键值对）

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

student = {'name': '小明', 'age': 30, 'study_id': 'py001', 'gender':'male'}
del student['age']
print(student)  # {'name': '小明', 'study_id': 'py001', 'gender': 'male'}

• b. pop(key) ---> 取出key对应的值（实质还是删除key对应的键值对）

name = student.pop('name')
print(student, name)  # {'study_id': 'py001', 'gender': 'male'} 小明

四、字典的相关操作

1. 字典相关运算

== : 判断两个字典的值是否相等
is : 判断两个字典的地址是否相等

in 和 not in : key in 字典 / key not in 字典 （看键是否在字典）

print({'a': 100, 'b': 200} == {'b': 200, 'a': 100})  # True
print({'a': 100, 'b': 200} is {'b': 200, 'a': 100})  # False
print('a' in {'a': 100, 'b': 200})  # True
print(100 in {'a': 100, 'b': 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)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(dict1 is dict2)  # False

• 4.dict.fromkeys(序列,值) (静态方法）
  ---> 创建一个字典，将序列中的每个元素作为key,值作为value

dict3 = dict.fromkeys('abcd', 100)
print(dict3)  # {'a': 100, 'b': 100, 'c': 100, 'd': 100}

• 5.字典.get(key) --> key不存在取None
  字典.get(key,默认值) --> key不存在取默认值

student = {}
print(student.get('name'))  # None
print(student.get('name', '无名'))  # 无名

• 6.字典.values() ---> 返回所有值对应的序列
  字典.keys() ---> 返回所有键对应的序列
  字典.items() ---> 将键值对转换成元组，作为一个序列的元素
  注意：返回的都不是列表，是其他类型的序列

dict1 = {'a': 1, 'b': 2, 'c': 3, 'd': 4}
print(dict1.items(),type(dict1.items()))  # dict_items([('a', 1), ('b', 2), ('c', 3), ('d', 4)]) <class 'dict_items'>

items = list(dict1.items())
print(items,type(items))  # [('a', 1), ('b', 2), ('c', 3), ('d', 4)] <class 'list'>

• 7.字典.setdefault(key) ---> 添加键值对，键是key,值是None
  字典.setdefault(key,值) ---> 添加键值对，键是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}
dict1.setdefault('bb', 100)
print(dict1)  # {'a': 1, 'b': 2, 'c': 3, 'd': 4, 'aa': None, 'bb': 100}

• 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, 'abc', (10, 200)}
# set2 = {[1, 2]}  # TypeError: unhashable type: 'list'
# set3 = {{'a': 1}}  # TypeError: unhashable type: 'dict'
set4 = {}  # 这是一个空的字典

2.集合的增删改查

a.查（获取元素）

集合不能单独获取一个元素，也不能切片，只能通过for-in来遍历

for x in set1:
    print(x)
# abc
# (10, 200)
# 10

b.增

• 集合.add(元素) --> 在集合中添加一个元素

set1 = {1, 2, 3}
set1.add(4)
print(set1)  # {1, 2, 3, 4}

• 集合.update(序列) --> 将序列中的元素添加到集合中（序列为字典时，只添加键到集合中）

set1.update({'a', 'b'})
print(set1)  # {1, 2, 3, 4, 'a', 'b'}

set1.update('fsdf1231')
print(set1)  # {1, 2, 3, 4, '2', '3', 's', 'd', '1', 'b', 'f', 'a'}

set2 = {1, 2, 3}
set2.update([4, 5, 6])
print(set2)  # {1, 2, 3, 4, 5, 6}

set2.update({'a': 7, 'b': 8, 'c': 9})
print(set2)  # {1, 2, 3, 4, 5, 6, 'c', 'b', 'a'}

3.删（删除元素）

• 集合.remove(元素) ---> 删除指定的元素

set2 = {1, 2, 3}
set2.remove(1)
print(set2)  # {2, 3}

4.改（集合不能改）

六、集合相关的数学运算

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

1.包含

集合1 >= 集合2 --> 判断集合1中是否包含集合2
集合2 <= 集合2 --> 判断集合2中是否包含集合1

set1 = {1 ,2, 3, 4, 5}
set2 = {3, 4, 5}
print(set1 >= set2)  # True

set1 = {1 ,2, 3, 4, 5, 10}
set2 = {3, 4, 5, 6}
print(set1 >= set2)  # False

2.交集 &

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

set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 & set2)  # {1, 3, 5}

3.求并集

| --> 求两个集合的和

set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 | set2)  # {1, 2, 3, 4, 5, 7, 9}

4.求差集

集合1 - 集合2 --> 求集合1中除了集合2以外的部分

set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 - set2)  # {2, 4}

5.求补集

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

set1 = {1, 2, 3, 4, 5}
set2 = {1, 3, 5, 7, 9}
print(set1 ^ set2)  # {2, 4, 7, 9}

七、类型转换

1.整型

int()
浮点数、布尔、部分字符串可以转换成整型

只有去掉引号后本身就是一个整数的字符串才能转换成整型

print(int('34'))  # 34
print(int('+34'))  # 34
print(int('-34'))  # -34
# print(int('34.5'))  # ValueError: invalid literal for int() with base 10: '34.5'

2.浮点数

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

print(float(100))  # 100.0
print(float(True))  # 1.0
print(float('34.90'))  # 34.9
print(float('100'))  # 100.0

3.布尔

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

num = 230
if num % 2:
    print('是奇数')
else:
    print('是偶数')

4.字符串

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

print(str(100))  # 00
print([str(True)])  # ['True']
print(str([1, 2, 3, 4]))  # [1, 2, 3, 4]
print(str({'a': 1, 'b': 2}))  # {'a': 1, 'b': 2}
print(str(lambda  x:x*2))  # <function <lambda> at 0x0000000002381E18>
print(len(str([1, 2, 3, 4])))  # 12

5.列表

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

print(list('abcd'))  # ['a', 'b', 'c', 'd']
print(list((23, 45, 'ac')))  # [23, 45, 'ac']
print(list({'a': 100, 'b': 200}))  # ['a', 'b']
print(list({'a': 100, 'b': 200}.items()))  # [('a', 100), ('b', 200)]

6.元组

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

print(tuple('abcd'))  # ('a', 'b', 'c', 'd')
print(tuple({'a': 100, 'b': 200}))  # ('a', 'b')

7.字典

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

list1 = [(1, 2)]
print(dict(list1))  # {1: 2}

tuple1 = ((1, 2), ['a', 10])
print(dict(tuple1))  # {1: 2, 'a': 10}

8.集合

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

print(set([1, 1, 90, 3, 10, 10]))  # {10, 1, 90, 3}