元组

1.什么是元组(tuple)

python提供的容器型数据类型，不可变并且有序。（元组就是不可变的列表）
不可变 - 不支持增删改，只支持查
有序 - 每个元素对应一个确定的下标

2.字面量和元素

（元素1，元素2，元素3···）
其中的元素可以是任何类型的数据，并且类型可以不一样，同样的元素可以有多个

注意：如果小括号里只有一个元素，那么就是这个元素本身。只有在元素后添加一个逗号，才代表这是一个元组。

空的元组：tuple1 = ()

只有一个元素的元组：tuple2 = (1,)

直接将多个元素用逗号隔开，不加小括号，表示的也是一个元组：tuple3 = 1, 2, 3

3.元组获取元素和列表是一样的

获取单个元素：tuple[index]

获取部分，切片，生成的是新的元组：tuple[index:index:step]

遍历

补充：

特殊的获取方式：
1.变量1，变量2··· = 元组 --- 用左边的变量依次获取元组中元素的值。（要求左边的变量个数要和元组中元素的个数相同）
2.变量1，*变量2 = 元组 --- 通过带*号的变量获取元组中剩余的部分；
注意：这个结构中带*号的变量只能有一个，不带*号的变量可以有多个
3.*号取出来的是一个列表

name, *scores = ('小明', 100, 89, 67, 99)
print(name,scores)

name, num, *scores = ('小明', 100, 89, 67, 99)
print(name, num, scores)

*info, num1, num2 = (('小明', 100, 89, 67, 99))
print(info, num1, num2)

info1, *nums, num1 = ('小明', 100, 89, 67, 99)
print(info1, nums, num1)

补充：

1.获取元组和列表中的数据

nums = (1, 2, 3)
nums2 = [11, 22, 33]
print('===：',*nums, *nums2)
print(1, 2, 3)
print(nums,nums2)

input:
===： 1 2 3 11 22 33 # 取出来的是int
1 2 3
(1, 2, 3) [11, 22, 33]

4.相关运算（和列表一样）

+, *
in / not in
len(), max(), min(), sum(), tuple() 元素内容类型必须要一样

5.排序

sorted(序列) - 对序列中的元素排序，产生一个新的列表(不管是什么序列，排完后最后都是列表)
原序列不变
注意：列表.sort() -- 修改原列表中元素的顺序; sorted(列表) -- 产生一个新的列表

6.join的使用

字符串.join(序列) - 将序列中的元素取出，用指定的字符串连2在一起
要求序列中的元素必须是字符串。

字典

1.什么是字典（dict）

python提供的容器类型数据，可变且无序
可变 - 支持元素的增删改
无序 - 不支持下标操作

2.字面量和元素

大括号括起来，里面多个键值对，每个键值对用逗号隔开。键值对就是字典的元素。
{key1:value1, key2:value2, key3:value3...}
键值对 - 键/key:值/value(键值对)；键值对必须成对出现，而且脱离字典单独出现没有意义
键/key - 必须是不可变的，而且是唯一的。实际一般将字符串作为键
值/value - 可以是任意类型的数据

注意：字典存储数据，实质是通过值来存储的。key是值对应的标签和获取值的方式

空字典：dict1 = {}
dict1 = {'a':100, 10:200, (1,2):'abc','a':111}
'a':100 会被 'a':111 覆盖

3.什么时候使用字典

什么时候使用字典：多个不同意义的数据（需要区分），就使用字典。例如：保存一个人的信息，一辆车的不同信息
什么时候使用列表：存储多个相同意义的数据（不需要区分），就是用列表。例如：保存一个班的学生信息，保存所有的价格

4.字典元素的增删改查

1.查（获取值value）
注意：字典中的键值对单独取出来没有任何意义

a.
字典[key] - 获取字典中key对应值
注意：当key不存在的时候，会报KeyError

b.
字典.get(key)- 获取字典中key对应值;当key不存在的时候不会报错，并且取到一个默认值None
字典.get(key,值1) - 获取字典中key对应值;当key不存在的时候不会报错，并且取到指定的值1

c.
遍历字典
注意：直接通过for-in遍历字典取到的是key
遍历字典的values(), 获取所有的值（不建议使用，当处理的数据多时，内存消耗大）
遍历字典的items(), 直接获取key和value（不建议使用，当处理的数据多时，内存消耗大）

dict1 = {'a':100, 'b':200, 'c':300}
# 遍历字典取到的是key（推荐使用）
for key in dict1:
    # key
    print(key,end=' ')
    # value
    print(dict1[key])

# 遍历字典的values(), 获取所有的值（不建议使用，当处理的数据多时，内存消耗大）
for value in dict1.values():
    print(value)

# 遍历字典的items(), 直接获取key和value（不建议使用，当处理的数据多时，内存消耗大）
for k,value in dict1.items():
    print(k,value)

2.增、改
字典[key] = 值 - 当key不存在时，就是添加键值对；当key存在时，就是修改key对应的值

3.删（删除键值对）
a.
del 字典[key] - 删除字典中指定的key对应的键值对
b.
字典.pop(key) - 取出字典中指定的key对应的键值对

5.字典的适用方法

1.比较运算
==,!=
注意：
判断两个字典是否相等，只看键值对数量，长相是否一样，不管键值对的顺序
字典不支持比较大小

2. in / not in
   key in 字典
key not in 字典

3.len(),max(),min()
dict(数据) - 数据要求是序列，并且序列中的元素都是只有两个元素的子序列，一般这个序列是字典。

print(dict([(1,2), ('a', 'b'),[10, 'abc']]))

input:{1: 2, 'a': 'b', 10: 'abc'}

补充：关于字典转列表/元组/集合

dict2 = {'name':'xiaohua', 'color':'black', 'height':170}
print(list(dict2)) 

input:['name', 'color', 'height']

字典转列表/元组/集合都是将字典中的key取出来作为列表/元组/集合的元素

4.相关方法
1.字典.clear() - 清空字典
注意：清空容器推荐使用clear操作，而不是重新赋一个空的容器。这样节省电脑资源
只有容器本身不存在的时候，才使用赋一个空容器
2.字典.copy() - 复制字典中的元素，产生一个新的字典
原理和列表切片一样，如果直接赋值，修改其中一个字典的元素，会影响另外一个字典中的元素。因为地址相同
补充：拷贝赋值，会产生新的地址，赋值后互不影响

3. dict.fromkeys(序列, 值) -- 以序列中所有的元素作为key，指定的值作为value创建一个新的字典

new_dict = dict.fromkeys('abc', (10, 20, 30))
print(new_dict)

new_dict = dict.fromkeys(['name', 'age', 'tel'], 0)
print(new_dict)

input:{'a': (10, 20, 30), 'b': (10, 20, 30), 'c': (10, 20, 30)}
{'name': 0, 'age': 0, 'tel': 0}

4
字典.keys() - 将字典所有的key取出产生一个新的序列
字典.values() - 将字典所有的value取出产生一个新的序列
字典.items() - 将字典所有的key和value做为一个元祖取出产生一个新的序列
没啥用

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
print(dict2.keys(), dict2.values(), dict2.items())

input:
dict_keys(['name', 'color', 'height']) 
dict_values(['xiaohua', 'black', 170])
dict_items([('name', 'xiaohua'), ('color', 'black'), ('height', 170)])

5.字典.setdefault(key, value=None)
字典.setdefault(key) - 当key不存在的时候，添加键值对key:None
字典.setdefault(key, value) - 当key不存在的时候，添加键值对key:value
注意：这个操作当key存在的时候，不会修改

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}

dict2.setdefault('name2', '小胡')
dict2.setdefault('sex')
print(dict2)

input:{'name': 'xiaohua', 'color': 'black', 'height': 170, 'name2': '小胡', 'sex': None}

6.字典1.update(字典2/只有2个元素的序列)
使用字典2中的键值对去更新字典1;如果字典2中的key，字典1中本身存在就是修改,不存在就添加

dict2 = {'name': 'xiaohua', 'color': 'black', 'height': 170}
dict2.update({'height': 180, 'age': 18})
print(dict2)

dict2.update([('a', 100), ('age', 30)])
print(dict2)

input:{'name': 'xiaohua', 'color': 'black', 'height': 180, 'age': 18}
{'name': 'xiaohua', 'color': 'black', 'height': 180, 'age': 30, 'a': 100}

集合

1.什么是集合（set）

可变的，无序的；元素是唯一并且不可变

2.字面量

{元素1，元素2，元素3···}

补充：
1.空集合：set1 = set()
2.集合自带去重功能

3.增删改查

1.查
集合不能单独地获取单个元素，只能一个一个的遍历，因为无序。
2.增
a.集合.add(元素)- 在集合里添加指定的元素
b.集合.update(序列) - 将序列中的元素添加到集合中
# 如果集合内的数字为连续数字，那么集合会自动排序这几个数字，且添加时数字之间不会插入添加的元素

set1 = {6,7,4,5,8}
set1.add('abc')
print(set1)

set1.update('abc')
print(set1)

set1.update({'aa':10, 'bb':20})  # 如果序列是字典，只把key添加进去
print(set1)

3,删
集合.remove(元素) --- 删除集合中指定的元素

4.数学集合运算

交集（&）：获取两个集合公共的元素，产生一个新的集合
并集（|）：将两个集合中的元素合并在一起，产生一个新的集合
差集（-）：集合1 - 集合2 ：求集合1中去掉集合2中元素还剩下的元素
补集（^）：将两个集合合并在一起，去掉公共的部分，剩下的部分产生新的集合，并集-交集
子集的判断：
集合1>集合2 --- 判断集合1中是否包含集合2,集合2元素全部在集合1中才是包含
集合1<集合2 --- 判断集合2中是否包含集合1.