"""
python列表 list，列表和元组最大的区别就是列表支持修改元素，而元组不能支持。
注意：大部分时候都可使用列表来代替元组，但如果程序不需要修改列表所包含的元素，那么使用元组代替列表会更安全。
    1、创建列表list()，空列，将其他序列转换为列表。
    2、增加列表元素：
        列表名.append('元素'/序列)，在列表末尾添加元素，添加的元素或序列默认为一个值；
        列表名.extend('元素'/序列)，添加的元素值由个数决定；
        列表名.insert(位置,'元素'/序列)，可以指定位置添加元素。
    3、删除列表元素：
        del 列表名[下标]，即可删除单个元素，也可以删除列表的中间一段，del也可以删除普通变量；
        列表名.remove('元素')，该方法只删除第一个找到的元素；
        列表名.pop(下标)，根据下标删除元素；
        列表名.clear()，清楚列表中所有的元素。
    4、修改列表元素，列表的元素就相当于变量，因此程序可以对列表的元素赋值，这样即可修改列表的元素
        列表名[下标索引]='新元素'，索引可以是正负数。
    5、输出显示列表的其他常用方法dir(list)。
    6、统计列表中某个元素出现的次数，列表名.count('元素')。
    7、判断某个元素在列表中出现的位置，列表名.index('元素')。
    8、将列表反向存放，列表名.reverse()。
    9、用于对列表元素排序，列表名.sort()
# 1、创建列表，空列表，一个列表
list1=[]
print(list1,type(list1))  # [] <class 'list'>
list2=[1]
print(list2,type(list2))  # [1] <class 'list'>
# 将元组转换为列表
tup1=(1,2,3,'元组')
list3=list(tup1)
print(list3,type(list3))  # [1, 2, 3, '元组'] <class 'list'>
# 2、增加列表元素
# 列表名.append()
list4=[1,2,3]
list4.append(1)  # 列表名.append('元素'/列表),默认添加的元素在列表末尾
list4.append(('12',2,4,5))  # 在列表中添加元组序列，整个添加的元组是一个元素
print(list4, list4[4], len(list4))  # [1, 2, 3, 1, ('12', 2, 4, 5)] ('12', 2, 4, 5) 5
# 列表名.extend()
list5=[1,2]
list5.extend((-1,2))  # 列表个数由extend()添加的元素个数决定
print(list5,len(list5))  # [1, 2, -1, 2] 4
# 列表名.insert(位置,'元素'/序列),指定列表位置添加元素
list6=[2,3]
list6.insert(1,1)
print(list6,len(list6))  # [2, 1, 3] 3
# 3、删除列表元素
# del 列表名[下标]，即可删除单个元素，也可以删除列表的中间一段，del也可以删除普通变量；
list7=[1,2,3,4,5]
del list7[0]  # 删除列表list7中第1个元素
print(list7)  # [2, 3, 4, 5]
del list7[0:2]  # 删除列表list7中第1个到第3个（不包含）元素
print(list7)  # [4, 5]
# 列表名.remove('元素')，该方法只删除第一个找到的元素；
list8=[1,2,1,2,3]
list8.remove(1)
print(list8)  # [2, 1, 2, 3]
# 列表名.pop(下标)，根据下标删除元素；
list9=[1,2,3,4]
list9.pop(0)
print(list9)  # [2, 3, 4]
# 列表名.clear()，清楚列表中所有的元素。
list10=[1,2,3,4]
list10.clear()
print(list10)  # []
# 4、修改列表元素，列表的元素就相当于变量，因此程序可以对列表的元素赋值，这样即可修改列表的元素
# 列表名[下标索引]='新元素'，索引可以是正负数。
list11=[1,2,3,4,5]
list11[0]=2  # 修改列表第1个元素为2
print(list11)  # [2, 2, 3, 4, 5]
list11[2:4]=2,3  # 修改列表中第3位到第4位（不包含）的元素
print(list11)  # [2, 2, 2, 3, 5]
# 5、输出显示列表的其他常用方法dir(list)。
print(dir(list))
# ['__add__', '__class__', '__contains__', '__delattr__',
# '__delitem__', '__dir__', '__doc__', '__eq__', '__format__',
# '__ge__', '__getattribute__', '__getitem__', '__gt__', '__hash__',
# '__iadd__', '__imul__', '__init__', '__init_subclass__', '__iter__',
# '__le__', '__len__', '__lt__', '__mul__', '__ne__', '__new__', '__reduce__',
# '__reduce_ex__', '__repr__', '__reversed__', '__rmul__', '__setattr__', '__setitem__',
# '__sizeof__', '__str__', '__subclasshook__', 'append', 'clear', 'copy', 'count',
# 'extend', 'index', 'insert', 'pop', 'remove', 'reverse', 'sort']
# 6、统计列表中某个元素出现的次数，列表名.count('元素')。
list12=[1,2,3,4,5,6,1,2,3,41,2]
print(list12.count(1))  # 2
# 7、判断某个元素在列表中出现的位置，列表名.index('元素')。
list13=[1,23,4,5,1,2,3]  # 判断在列表list13中，元素1出现的位置，如果元素重复则只显示第一个。
print(list13.index(1))  # 0
# 判断列表list13中从下标1开始（包含），元素1的位置
print(list13.index(1,1))  # 4
# 判断列表list13中从下标2开始（包含）到下标5结束（不包含），元素4的位置，如果没有这个元素则会报错
print(list13.index(4,2,5))  # 2
# 8、将列表反向存放，列表名.reverse()。
list14=[1,3,5,6,8,0]
list14.reverse()
print(list14)  # [0, 8, 6, 5, 3, 1]
# 9、用于对列表元素排序，列表名.sort()，只能相同类型的元素进行比较
list15=[8,9,7,6,1,2,3,4,5,6,]
list15.sort()  # 默认从小到大进行排序
print(list15)  # [1, 2, 3, 4, 5, 6, 6, 7, 8, 9]
list16=['11','111','1111','gg']
list16.sort()  # 对字符串进行排序，默认按字符串包含的字符的编码来计较大小
print(list16)  # ['11', '111', '1111', 'gg']
# sort()方法除了默认排序之外，还可以传入key和reverse两个参数，而且这两个参数必须通过参数名指定（这种参数叫关键字参数）
list17=['what','your','wo','are','home']
# 指定key为len，指定使用len函数对集合元素生成比较大小的键
list17.sort(key=len)  # 表示安装字符串的长度比较大小
print(list17)  # ['wo', 'are', 'what', 'your', 'home']
list17.sort(key=len,reverse=True)  # reverse=True反向排序，reverse=False正向排序
print(list17)  # ['what', 'your', 'home', 'are', 'wo']

"""
python字典dict：是一种常见的数据结构，用来从存放具有映射关系的数据；语法：{key:value}，key可以是任意不可变类型。
    1、创建字典，dict()和{key:value}都可以用来创建空列表，多个ksy-value对之间用英文,隔开。
    2、增，只需要为不存在的key赋值即可。
    3、删，del 字典名['key']，字典名.pop('key')。
    4、改，对已经存在的key重新赋值。
    5、查，字典名['key']。
    6、字典的常用方法：
        1、字典名.clear()，清空字典的所有key-value对。
        2、字典名.get('key')，根据key来获取value，他相当于方括号语法的增强版。
        3、字典名.update({'key':'value'})，如果字典有key-value则更新，没有则表示添加。
        4、字典名.item()获取字典中所有的key-value对，字典名.keys()获取字典中所有的key，字典名.values()获取所有的value值。
    7、字典名.popitem()，随机弹出字典中的一个key-value对。
    8、dict.fromkeys()，使用给定的多个key创建字典，这些字典对应的value默认都是None，该对象一般不会使用对象调用，通常直接使用dict类直接调用。
    9、使用字典格式化字符串。
# 1、创建字典，创建一个空字典，既可以使用花括号{}，也可以使用dict()创建
dict1={}  # 创建一个空字典{}
dict2=dict()  # 创建一个空字典dict()
print(dict1,dict2,type(dict1),type(dict2))  # {} {} <class 'dict'> <class 'dict'>
dict3={"语文":99,11:1}  # 创建多个key-value对的字典
print(dict3,type(dict3),dict3[11])  # {'语文': 99, 11: 1} <class 'dict'> 1
# 2、增，通过key增加
dict4={}
dict4["数学"]=100  # 添加不存在的key
print(dict4,type(dict4))
# 3、删，del 字典名['key']，字典名.pop('key')，字典名.clear()
dict5={"英语":89,"政治":90}
del dict5["英语"]
print(dict5)  # {'政治':90}
dict5.pop('政治')
print(dict5)  # {}
print(dict5.clear())  # 清空所有key-value对
# 4、改，通过对key重新赋值达到修改目的
dict6={"历史":90,"生物":80}
dict6["历史"]=70  #  通过key重新赋值
print(dict6)  # {'历史': 70, '生物': 80}
dict6.update({"历史":91,"化学":100})  # 通过已存在的key修改，不存在的添加
print(dict6)  # {'历史': 91, '生物': 80, '化学': 100}
# 5、查，通过[key]，get('key')查看字典
dict7={"科学":100,"地理":20}  # 通过key查看字典value
print(dict7["科学"])  # 100  # 通过get(key)方法查看字典value
print(dict7.get("科学"))  # 100
# 字典名.setdefault()，根据key来获取value的值，如果key不存在则会自动添加。
print(dict7.setdefault("科学"))  # 100
print(dict7.setdefault("人文"))  # None
print(dict7.setdefault("人文",100))
print(dict7)  # {'科学': 100, '地理': 20, '人文': None}
# 6、字典的常用方法：
# dir()，查看字典的方法有哪些
print(dir(dict))
# ['__class__', '__contains__', '__delattr__', '__delitem__',
# '__dir__', '__doc__', '__eq__', '__format__', '__ge__',
# '__getattribute__', '__getitem__', '__gt__', '__hash__',
# '__init__', '__init_subclass__', '__iter__', '__le__',
# '__len__', '__lt__', '__ne__', '__new__', '__reduce__',
# '__reduce_ex__', '__repr__', '__setattr__', '__setitem__',
# '__sizeof__', '__str__', '__subclasshook__', 'clear', 'copy',
# 'fromkeys', 'get', 'items', 'keys', 'pop', 'popitem',
# 'setdefault', 'update', 'values']
# 字典名.item(),获取字典中所有的key - value对，返回一个dict_items对象
dict8={"亚洲":2000,"非洲":100}
time1=dict8.items()
print(time1,type(time1))  # dict_items([('亚洲', 2000), ('非洲', 100)]) <class 'dict_items'>
# 将time1转化为列表
print(list(time1),type(list(time1)))  # [('亚洲', 2000), ('非洲', 100)] <class 'list'>
# 访问第二个key-value对
print(list(time1)[1])  # ('非洲', 100)
# 字典名.keys(),获取字典中所有的key，返回一个dict_keys对象
dict9={"欧洲":1999,"美洲":2001}
kys=dict9.keys()
print(kys,type(kys))  # dict_keys(['欧洲', '美洲']) <class 'dict_keys'>
# 字典名.values(),获取所有的value值，返回一个dict_values对象。
dict10={"太平洋":20,"大西洋":30,"北冰洋":15}
val=dict10.values()
print(val,type(val))  # dict_values([20, 30, 15]) <class 'dict_values'>
# 7、字典名.popitem()，随机弹出字典中最后的一个key - value对。
dict11={"地球人":"地","火星人":"火","水星人":"水","金星人":"金"}
print(dict11.popitem())  # ('金星人', '金')
# 8、dict.fromkeys()，使用给定的多个key创建字典，这些字典对应的value默认都是None，该对象一般不会使用对象调用，通常直接使用dict类直接调用。
# 使用列表创建包含两个key的子集
dic12=dict.fromkeys(["a","b"])
print(dic12,type(dic12))  # {'a': None, 'b': None} <class 'dict'>
# 使用元组创建
dic13=dict.fromkeys((1,2,3))
print(dic13,type(dic13))  # {1: None, 2: None, 3: None} <class 'dict'>
# 使用元组创建字典，并默认指定的value
dic14=dict.fromkeys(('a','b'),100)
print(dic14,type(dic14))  # {'a': 100, 'b': 100} <class 'dict'>
# 10、使用字典格式化字符串。
temp='书名是：%(name)s,价格是：%(price)0.12f,出版社是:%(publish)s'
book={"name":"python疯狂讲义","price":"100","publish":"电子社"}
print(temp) # {'a': 100, 'b': 100} <class 'dict'>
# 书名是：%(name)s,价格是：%(price)0.12f,出版社是:%(publish)s