一、列表-------有序，可变

1、修改列表中的元素：列表[下标] = 新值
**注意：下标不能越界(目前能越界的只有insert函数）

list1 = ['四川','云南','贵州','新疆']
list1[2] = '福建'
print(list1)
结果：['四川', '云南', '福建', '新疆']

2、列表的其他操作
a.len(列表）---获取列表的长度，即列表中元素的个数
b.+ 列表1+列表2，列表1和列表2中的元素组合在一起，产生一个新的列表。+操作不会对列表1和列表2产生改变，只是生成了一个新的列表。

list1 = ['四川','云南','贵州','新疆']
list2 = ['a','b','c']
print(list1+list2)
结果：['四川', '云南', '贵州', '新疆', 'a', 'b', 'c']

c.列表*数字，让列表中的元素重复几遍

list1 = [1,2,3,4]
print(list1*3)
结果：[1, 2, 3, 4, 1, 2, 3, 4, 1, 2, 3, 4]

d.in,not in 判断某个元素是否在列表中（不能一次性判断某几个元素是否在列表中）

list1 = [1,2,3,4]
result = 1 in list1
print(result)
结果：True

list1 = [1,2,3,4]
list2 = [2,3]
print(list2 in list1)
结果：False

3.获取列表中的最大元素和最小元素（max（列表），min（列表））----这里的最大最小指的是Unicode码

list1 = [1,2,3,4]
list2 = ['gsa','a','safij','8u']
print(max(list1),min(list2))
结果：4 8u

# 写一个程序取出列表的最大值和最小值
list1 = ['hshf', '&)&(', 's',  '*&^&']
list2 = [1, 2, 3, 4]
max = list1[0]
min = list2[0]
for x in list1:
    if x >= max:
        max = x
print(max)
for y in list2:
    if y <= min:
        min = y
print(min)
结果：s
1

4、列表的一些其他操作
a. 列表.count(元素)获取指定元素在列表中出现的次数。

list1 = [1, 2, 3, 4, 2, 3, 4, 5]
print(list1.count(2))
结果：2

b. 列表.extend(序列) 将序列中的每一个元素添加到列表中

list1 = [1, 2, 3, 4, 2, 3, 4, 5]
list1.extend([7,8,9])
print(list1)
结果：[1, 2, 3, 4, 2, 3, 4, 5, 7, 8, 9]

c. 列表.index(元素) 获取指定元素在列表中的索引（如果有一个元素重复多次，则获取第一的索引）

list1 = [1, 2, 3, 4, 2, 3, 4, 5, 7, 8, 9]
print(list1.index(2))
结果：1

d. 列表.reverse（） 反向排列列表中的元素，不会产生新的列表。

list1 = [1, 2, 3, 4, 2, 3, 4, 5, 7, 8, 9]
list1.reverse()
print(list1)
结果：[9, 8, 7, 5, 4, 3, 2, 4, 3, 2, 1]

e. 列表.sort（）对列表进行升序排列（和reverse一起使用，可以实现列表的从大到小排列）

list1 = [1, 2, 3, 4, 2, 3, 4, 5, 7, 8, 9]
list1. sort(reverse = True)
print(list1)
结果：[9, 8, 7, 5, 4, 4, 3, 3, 2, 2, 1]

f. 列表.clear（） 清空列表

list1 = [1, 2, 3, 4, 2, 3, 4, 5, 7, 8, 9]
list1.clear()
print(list1)
结果：[]

g. 列表.copy():将列表中的元素全部复制一份创建一个新的列表

list1 = [1, 2, 3, 4, 2, 3, 4, 5, 7, 8, 9]
print(list1.copy())
结果：[1, 2, 3, 4, 2, 3, 4, 5, 7, 8, 9]

注意下面这种情况

list1 = [1, 2, 3, 4, 2, 3, 4, 5, 7, 8, 9]
list2 = list1       #在这种情况下会发现通过这种方式复制一个列表，对一个列表进行操作的时候，另一个也受到了影响，要想避免这种影响
del list2[0]        #可以copy  或者对列表进行完整的切片
print(list1, list2)
结果：[2, 3, 4, 2, 3, 4, 5, 7, 8, 9] [2, 3, 4, 2, 3, 4, 5, 7, 8, 9]

二、元组--------有序，不可变

元组就是不可变的列表，改、增、删的操作不能用于元组。（不可变指的是元组的元素和个数不能改变）
元组：a 元组用小括号（），元素之间用逗号
b 元素可以是任何数据类型
1、获取单个元素（与列表获取单个元素的方法一致）
元组[下标]------获取单个元素
2、获取长度------len（元组）
3、in，not in-----判断指定的元素是否在元组当中
4、+和，因为+和都生成了新的元组，不会对旧的元组产生影响，所以可以用于元组
补充说明-------获取元组的元素
通过多个变量分别获取元组的元素，变量个数和元组元素个数保持一样

tuple1 = ('张三','李四','王二','麻子')
m, n, o, p = tuple1#  设置的变量必须要与元组的元素个数保持一致
print(m, n, o, p)

m, *n, o = tuple1 #通过在变量前面加*号可以让元组变成列表，获取元组中的多个元素
print(m, n, o)

*m, n = tuple1# n取最后一个元素，剩下的元素作为列表m的元素
print(m, n)

m, *n = tuple1#m取第一个元素，剩下的元素作为列表n的元素
print(m, n)

三、字典------无序、可变

字典也是容器数据类型，数据以键值对的形式出现
键值对：键：值（key:value) 键值对中key是形式，值才是真正要存的内容
键：理论上可以是任何不可变的数据类型，但是实际开发的时候一般使用字符串作为key（键重复的情况下，后面的值会覆盖前面的值）
值：可以是任意数据类型
1、创建字典
a、声明一个字典
创建一个空字典，然后赋给他字典的值
b、将其他类型数据转变成字典（了解，因为很少可以转换成字典）
2、字典的增删改查
a.查：获取字典元素的值-----两种方式，（字典[ke] or 字典.get(key)）推荐使用第一种
字典中获取元素的值是通过key来完成的：字典[key]

dict1 = {'name':'成都','size':'big','climate':'hot','shape':'circle'}
print(dict1['shape'])   #注意key的引号不能忘记
结果：circle

dict1 = {'name':'成都','size':'big','climate':'hot','shape':'circle'}
print(dict1.get('climate'))
结果：hot

b.增加元素\修改元素------通过key获取元素，然后赋予元素新的值，当key本身就存在就是修改元素，当key不存在就是添加元素

dict1 = {'name':'成都','size':'big','climate':'hot','shape':'circle'}
dict1['population'] = '1000万'
print(dict1)
dict1['climate'] = 'wet'
print(dict1)
结果：{'name': '成都', 'size': 'big', 'climate': 'hot', 'shape': 'circle', 'population': '1000万'}
{'name': '成都', 'size': 'big', 'climate': 'wet', 'shape': 'circle', 'population': '1000万'}

c. 删除（del 字典[key] or 字典.pop(key) ）
删除的是键值对
3.相关的数组属性(了解）
字典.keys():获取字典所有的key,返回值的类型是dict_keys，但是可以把它当成列表来用，只要是容器就可以for in,拿出数据
字典.values():获取字典所有的值（value)
字典.items():将字典中所有的键值对转换成一个一个的元组，key作为元组的第一个元素，value作为元组的第二个元素

dict1 = {'name':'成都','size':'big','climate':'hot','shape':'circle'}
print(dict1.keys())   #取出字典所有的key值，以列表的形式返回
print(dict1.values())  #取出字典所有的value值，以列表的形式返回
print(dict1.items())   #取出字典所有的key和value，以列表中包含元组的形式返回
结果：dict_keys(['name', 'size', 'climate', 'shape'])
dict_values(['成都', 'big', 'hot', 'circle'])
dict_items([('name', '成都'), ('size', 'big'), ('climate', 'hot'), ('shape', 'circle')])

4、遍历字典
a. 直接遍历字典，获取到所有的key，然后用key获取到value（字典[key]）

dict1 = {'name':'成都','size':'big','climate':'hot','shape':'circle'}
for key in dict1:       #重点：直接遍历字典，获取到的是字典的key值，有了key，就可以顺利取到value
    print(dict1[key])
结果：成都
big
hot
circle

b.遍历直接获取到key和value（不好用，因为多了一步转换的步骤）

dict1 = {'name':'成都','size':'big','climate':'hot','shape':'circle'}
for key,value in dict1.items():
    print(key, value)
结果：name 成都
size big
climate hot
shape circle

5.列表中有字典、字典中有字典、字典中有列表
根据需要使用不同的数据类型存储数据。
6、其他操作
a.字典.fromkeys(序列，value)----创建一个新的字典，序列的元素作为字典的key，value作为值

print(dict.fromkeys('asjfh','sjaf'))
结果：{'a': 'sjaf', 's': 'sjaf', 'j': 'sjaf', 'f': 'sjaf', 'h': 'sjaf'}

b. key in 字典-----判断字典中是否存在指定的key值

dict1 = {'name':'成都','size':'big','climate':'hot','shape':'circle'}
print('name' in dict1)
结果：True

c.字典1.update(字典2）：使用字典2中的键值对去更新字典1中的键值对，如果字典2中对应的键在字典1中不存在，就添加。存在就更新字典1中的值

dict1 = {'name': '成都', 'size': 'big', 'climate': 'hot', 'shape': 'circle'}
dict1.update({'a': 1,'b': 2})
print(dict1)
结果：{'name': '成都', 'size': 'big', 'climate': 'hot', 'shape': 'circle', 'a': 1, 'b': 2}

四、集合-----无序，可变(集合的元素不能重复）

集合也是一种容器类型的数据类型(序列),数据放在{}中，多个之间用逗号（，）隔开：{1,2，'a'}
集合无序的(不能通过索引去取值），可变（可以增删改），元素不能重复
集合可以进行数学中集合相关的操作：判断是否包含，求交集，并集，补集,差集
1、怎么声明一个集合
a.声明一个变量，赋一个集合值
b.将其他数据类型转化成集合-----因为集合的元素不能重复，所以将其他类型数据转化成集合的时候，自带一个去掉重复元素的功能。
创建一个空列表：set0 = set{} 因为直接创建一个set = {}的话将默认成一个字典。

set1 = set('hsfslkgjsigoeoi')
print(set1)
结果：{'k', 'i', 'h', 's', 'g', 'l', 'f', 'e', 'j', 'o'}

2、增删改查
a. 查：集合没有办法单独获取某个元素，只能用for循环遍历集合的元素
b. 增：集合.add（元素）-----在指定的集合中添加指定的元素。

set1 = {'成都','上海','广州','北京'}
set1.add('南京')
print(set1)
结果：{'成都', '北京', '上海', '南京', '广州'}

集合1.update(集合2）----将集合2添加到集合1中，自动去重

set1 = {'成都','上海','广州','北京'}
set1.update({'南京','天津','北京'})
print(set1)
结果：{'北京', '南京', '成都', '上海', '天津', '广州'}

c. 删除
集合.remove（元素）------删除指定集合的指定元素

set1 = {'北京', '南京', '成都', '上海', '天津', '广州'}   #删除指定集合的指定元素
set1.remove('广州')
print(set1)

set1 = {'北京', '南京', '成都', '上海', '天津', '广州'}     #随机删除一个元素，太可怕了
set1.pop()
print(set1)
结果：{'上海', '天津', '成都', '南京', '北京'}
{'天津', '广州', '成都', '南京', '北京'}

3.判断是否包含
集合1 >= 集合2 -----判断集合1是否包含集合2(判断集合2中的元素是否都在集合1里面）
集合1 <= 集合2 -----判断集合2是否包含集合1（判断集合1中的所有元素是否都在集合2中）
4.可以和数学的集合一样求并集（|），补集（^）,交集（&）,差集（-）
并集（|）：A中的元素+在B中的不在A中的元素
交集（&）：在A中也在B中的元素
差集（-）：A-B 在A中不在B中的元素
补集（^）：A中的元素+B中的元素-A和B中同时出现的元素。
5.其他方法
集合.clear（）：清空集合
len（集合）：获取集合的长度