元组

1.什么时元组

容器型数据类型；不可变(不支持增删改)、有序（支持下标操作）
将小括号作为容器的标志，多个元素用逗号隔开；元素的要求和列表一样。例如：(10, 23, 30)

2. 查 - 和列表一样

注意：元组切片的结果是元组
tuple1 = (10, 20, 30)
print(tuple1[1:]) # (20, 30)

3.相关运算 - 和列表一样

+，*， ==，！=， in/ not in, len(),max(),min(),sum()
tuple(数据) - 将数据转换成元组，所有的序列都可以转换成元组

4.元组特有的操作

1）单个元素的元组:在只有一个元素的元组中，元素后必须有逗号
list1 = [10]
print(type(list1), list1)

tuple1 = (10) # <class 'int'> 10
print(type(tuple1), tuple1)

tuple1 = (10,) # <class 'tuple'> (10,)
print(type(tuple1), tuple1)

2)如果一个元组的值中有多个元素，元组的括号可以省略
tuple2 = 'abc', 123, True
print(type(tuple2)) # <class 'tuple'>

3)获取元素，通过让变量的个数和元组中元素的个数保持一致来分别获取元组中元素的值
tuple3 =(1, 2, 3)
print(tuple3[0], tuple3[1], tuple3[2]) # 1 2 3
x, y, z = tuple3
print(x, y, z) # 1 2 3

a, b = (10, 20) # a, b = 10, 20
x1 = 100
x2 = 200
x1, x2 = x2, x1 # x1, x2 =( x2, x1) = (200, 100)
4）可以通过在某一个变量前加来获取不带的变量获取完后剩下的元素
注意：带*只能有一个，而且这个变量的结果是一个列表
tuple4 = ('小明', 30, 80, 90, 78, 56, 65)
name, age, *scores = tuple4
print(name, age) # 小明 30
print(scores) # [80, 90, 78, 56, 65]

tuple4 = ('小明', 30, 80, 90, 78, 56, 65)
name, *scores, age = tuple4
print(name, age) # 小明 65
print(scores) # [30, 80, 90, 78, 56]

x, y, *z = [1, 2, 3, 4, 5]
print(x, y)
print(z) # [3, 4, 5]--列表
*可以在列表中运用

字典

1.什么是字典（dict）

字典是容器型数据类型：可变(支持增删改)，无序(不支持下标操作)
字典容器的标志是{}，多个元素用逗号隔开

2.元素

"""
字典中的元素是键值对，以'key:value'的形式存在。而且key和value必须成对出现。
键（key） - 不可变的，唯一的(一般使用字符串作为键)
值(value) - 没有要求（和列表的元素一样）
键值对单独拿出来没有意义

注意：字典保存数据，真正要存储的是值，键只是为了对不同的值进行区分而存在的
"""
dict1 = {'分数': 100, 10: 98, '分数': 180}
print(dict1) # {'分数': 180, 10: 98} 一般后面的

dict2 = {[1, 2]: 100}
print(dict2) # TypeError: unhashable type: 'list' 列表是可变的

dict3 = {10: 100, 'abc': 200, (1, 2): 300}
print(dict3) {10: 100, 'abc': 200, (1, 2): 300} :不可变的都可以作为键

print({'a': 100, 'b': 200} == {'b': 200, 'a': 100}) # True 证明无序

3.查 - 获取字典的值

1）获取单个值：
"""
a.字典[key] - 获取字典中指定key对应的值
注意：如果key不存在会报错
b.
字典.get(key) - 获取字典中指定key对应的值，如果key不存在不会报错而是返回None
字典.get(key, 默认值) - 获取字典中指定key对应的值，如果key不存在不会报错而是返回默认值
"""

class1 ={'name': 'py1903', 'student_num': 23, 'address': '18-8', 'teacher': 'MJ'}
print(class1['name']) # py1903
print(class1['wei']) # KeyError: 'wei' wei不存在

print(class1.get('address')) # 18-8
print(class1.get('ad')) # None 不报错

print(class1.get('teacher', '小明')) # MJ
print(class1.get('', '00001')) #00001

2）遍历

"""
for 变量 in 字典：
循环体
变量取到是字典中的所有的key
"""
print('----------------------遍历1----------------------')
class1 ={'name': 'py1903', 'student_num': 23, 'address': '18-8', 'teacher': 'MJ'}
for x in class1:
print(x, class1[x])

3)其他遍历方式

for x in class1.values():
print(x)
for key, value in class1.items():
print(key, value)

字典相关操作

1.增/改

"""
增- 添加键值对； 改 - 修改某个key对应的值
字典[key] = 值 - 当key不存在就增加，当key存在就是修改
"""
dog = {'name': '财财', 'age': 3, 'color': '黄色', 'type': '土狗'}
dog['gender'] = '公' # 增加键值对
print(dog) # 增加：{'name': '财财', 'age': 3, 'color': '黄色', 'type': '土狗', 'gender': '公'}

dog['age'] = 4
print(dog) # 修改：{'name': '财财', 'age': 4, 'color': '黄色', 'type': '土狗', 'gender': '公'}

2.删 - 删除键值对

"""
1)del 字典[key] - 删除字典中指定key对应的键值对
"""
del dog['color']
print(dog)
"""

2. 字典.pop(key) - 取出字典中指定key对应的值
   """
   del_name = dog.pop('name')
   print(dog, del_name) # {'age': 4, 'type': '土狗', 'gender': '公'} 财财

3.相关运算：

1）==，!=
print({'a': 100, 'b': 200} == {'b': 200, 'a': 100}) # True

2）in/not in

key in 字典 - 判断字典中是否存在指定的key
dog = {'name': '财财', 'age': 3, 'color': '黄色', 'type': '土狗'}
print('财财' in dog) # False
print('name' in dog) # True

3)len()

4)dict()

"""
能转换成字典的数据：数据本身必须是一个序列，序列中的元素还是一个序列，而且序列中必须有且只有两个元素
"""
dict1 = dict([(1,2),'ab', range(2)])
print(dict1) # {1: 2, 'a': 'b', 0: 1} ---一般不关注
注意：将字典转换成列表、元组、集合的时候是将字典的key作为元素
dog = {'name': '财财', 'age': 3, 'color': '黄色', 'type': '土狗'}
print(list(dog)) # ['name', 'age', 'color', 'type']
print(tuple(dog)) # ('name', 'age', 'color', 'type')

4.字典相关方法

print('---------------字典相关方法-------------')
1）字典.clear() - 清空字典
dog = {'name': '财财', 'age': 3, 'color': '黄色', 'type': '土狗'}
dog.clear()
print(dog) # {}

2)字典.copy() - 赋值字典中所有的键值对，产生一个新的字典（浅拷贝）
3）dict.fromkeys(序列, 值) - 创建一个新的字典，将序列中的元素作为key，后面的值作为value;返回一个字典
注意：如果没有给值，就是None, 只能赋一样的值
dict2 = dict.fromkeys('abcde')
print(dict2) # {'a': None, 'b': None, 'c': None, 'd': None, 'e': None}
dict3 = dict.fromkeys('abc', range(3))
print(dict3) # {'a': range(0, 3), 'b': range(0, 3), 'c': range(0, 3)}
4）item()，keys(), values()
"""
字典.keys() - 获取字典所有的key，以序列的形式返回（与以前讲的序列不同）
字典.values（） - 获取字典中所有的value，以序列的形式返回
字典.items() - 同时获取字典中所有的key和值，以序列的形式返回，序列中的元素是（key，values）元组
"""
dog = {'name': '财财', 'age': 3, 'color': '黄色', 'type': '土狗'}
print(dog.keys()) # dict_keys(['name', 'age', 'color', 'type'])
print(dog.items()) # dict_items([('name', '财财'), ('age', 3), ('color', '黄色'), ('type', '土狗')])
print(list(dog.items())) # 转成列表 [('name', '财财'), ('age', 3), ('color', '黄色'), ('type', '土狗')]
print('--------------------')
5）字典.setdefault(key, value) - 添加键值对，key不存在的时候添加，如果存在不会修改
dog = {'name': '财财', 'age': 3, 'color': '黄色', 'type': '土狗'}
dog.setdefault('name', '小花')
print(dog) # {'name': '财财', 'age': 3, 'color': '黄色', 'type': '土狗'}

dog.setdefault('name1', '小白') # {'name': '财财', 'age': 3, 'color': '黄色', 'type': '土狗', 'name1': '小白'}
print(dog)

6)字典.update(序列) - 使用序列去更新字典，这个序列必须是字典或可以转换成字典 （没有就增加，有就修改）
dict1 = {'a':10, 'b':20, 'c': 30}
dict1.update({'b':200, 'd':300, 'e': 400})
print(dict1) # {'a': 10, 'b': 200, 'c': 30, 'd': 300, 'e': 400}
dict1.update([(1,2), (2, 3), (3, 4)])
print(dict1) # {'a': 10, 'b': 200, 'c': 30, 'd': 300, 'e': 400, 1: 2, 2: 3, 3: 4}

集合

1.什么是集合（set）

容器型数据类型；可变（支持增删改），无序（不支持下标操作）
将{}作为容器标志，里面多个元素用逗号隔开
set()表示空集合，set0 = set(), {} - 表示空字典

2.元素

"""
不可变：列表，字典，集合不能作为元素
唯一,(自带去重功能)
"""
set1 = {12, 34, 'abc', True, (1,2)}
print(set1) # {(1, 2), True, 34, 12, 'abc'}
set2 = {[1, 2], 100} TypeError: unhashable type: 'list'
print(set2)
set3 ={1, 1, 2, 2, 3}
print(set3) #{1, 2, 3}

集合去重
list1 = [1, 1, 2, 2, 3]
age =list(set(list1))
print(age) # [1, 2, 3]

3.查

集合不能单独取出一个元素，只能通过遍历一个一个的取出所有元素
set2 = {1, 30, 7, 89, 9}
for item in set2:
print(item) # 能取出元素，但是无序

4.增

"""
1）集合.add(元素) - 在集合中添加一个元素
2）集合.update(序列) - 将序列中的元素全部添加到集合中(序列中的元素不可变)
"""
set2 = {1, 30, 7, 89, 9}
set2.add(200)
print(set2) # {1, 7, 200, 9, 89, 30} 无序

set2.update('abc')
print(set2) # {1, 7, 200, 9, 'a', 'c', 'b', 89, 30}

set2.update([[1, 2], 22]) TypeError: unhashable type: 'list'
print(set2) - 序列中的元素不可变

5.删除

集合.remove(元素) - 删除集合中指定的元素
set2 = {1, 30, 7, 89, 9}
set2.remove(30)
print(set2)

6.改 - 集合不支持改操作

7.数学集合运算

1）集合运算
set1 = {1, 2, 3, 4, 5, 6}
set2 = {4, 5, 6, 7, 8}
a.并集(|) - 将两个集合中的元素合并产生一个新的集合
print(set1 | set2) # {1, 2, 3, 4, 5, 6, 7, 8}

b.交集(&) - 将两个集合中公共的元素取出来产生一个新的集合
print(set1 & set2) # {4, 5, 6}

c.对称差集(^) - 并集减去交集
print(set1 ^ set2) # {1, 2, 3, 7, 8}

d.差集(-) - 集合1-（集合1和集合2交集）
print(set1 - set2) # {1, 2, 3}
print(set2 - set1) # {8, 7}

8.判断集合的包含关系

集合1 > 集合2 - 判断集合1中是否包含集合2
集合1 < 集合2
print({10, 20, 30} > {1, 2}) # False - 不是判断大小
print({10, 20, 30} > {10, 20}) # True