Python常用数据结构（列表、元组、字典、集合）

列表：

list1 = [1,'ans',2983,12,'Hello','nihao']
#一个列表中可以存放多个不同数据类型的值，例如上面例子中有数字也有字符串

list1.append("十四五六七")
#输出[1, 'ans', 2983, 12, 'Hello', 'nihao', '十四五六七']
#append方法在列表末尾增加新的值

list1.insert(0,123456)
#输出[123456, 1, 'ans', 2983, 12, 'Hello', 'nihao', '十四五六七']
#列表名.insert(下标，插入的值) 在对应下标位置插入对应的值

list1.count(1)
#输出1，因为list1列表中只有一个数字1
#列表名.count(值) 返回值在列表中出现的次数

list1.remove('nihao')
#输出[123456, 1, 'ans', 2983, 12, 'Hello', '十四五六七']
#列表名.remove(值) 从头遍历列表，找到第一个匹配的值，并删除

list1.reverse()
#输出['十四五六七', 'Hello', 12, 2983, 'ans', 1, 123456]
#反转list1列表

test = [1,2,3,4,5]
list1.extend(test)
#输出['十四五六七', 'Hello', 12, 2983, 'ans', 1, 123456, 1, 2, 3, 4, 5]
#将test列表中的所有元素添加到list1列表中

list2 = [9,3,1,5,6,7,8,2]
list2.sort()
#输出[1, 2, 3, 5, 6, 7, 8, 9]
#列表名.sort() 对列表中的元素进行排序（不可逆的）

del list1[0]
#输出['Hello', 12, 2983, 'ans', 1, 123456, 1, 2, 3, 4, 5]
#del 列表名[下标] 删除该列表中下表对应的元素

list1.pop(0)
#输出[12, 2983, 'ans', 1, 123456, 1, 2, 3, 4, 5]
#列表名.pop(下标) 从列表中弹出下标对应的元素，下标为空时默认弹出最后一个元素

列表推导式（举例如下）：

列表推导式(举例如下)：
list3 = list(map(lambda x: x**2,range(10)))
#输出[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
等同于
list4 = [x**2 for x in range(10)]


list5 = [(x,y) for x in [1,2,3] for y in [3,1,4] if x != y]
#输出[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]
等同于
list6 = []
for x in [1,2,3]:
    for y in [3,1,4]:
        if x != y:
            list6.append((x,y))


list7 = [x * 3 for x in [x + 123 for x in [4,5,6]]]
#列表嵌套，输出[381, 384, 387]

元组：

元组是由多个用逗号分隔的值。元组是不可变的，一旦创建便只能够查找元素、删除整个元组。

a = 'Kobe','NAsi','DAls','Allmn'    #第一种
#a = ('Kobe', 'NAsi', 'DAls', 'Allmn') ， 此时a是一个元组
#元组是不可变的，在元组中不能增加、删除、编辑元素，能够查找元素和删除整个数组

a = ('Kode','hello','math')    #第二种
#a = ('Kode', 'hello', 'math') ， a是一个元组

a = (123,)    #创建只有一个元素的元组时，在值后面要跟一个逗号
是元组： a = (12,)    a = 12,    #type(a) = <class 'tuple'>
不是元组： a = (12)    a = 12    #type(a) = <class 'int'>

集合：

集合是一个无序不重复元素的集，主要作用于去重，因为集合中的元素是没有重复的。

可以把其他数据类型转换成集合，就可以直接把重复的元素去掉，然后再转回原来的数据结构即可，举例如下：

a = [1,2,3,1,2,3]
a = list(set(a))
#输出a = [1, 2, 3],即实现去重效果，重复的元素都去掉了

大括号或set()函数可以用来创建集合，但set()函数可以创建空集合，{}创建的是空字典。

如果要存放一个单词的所有字符：
a = set("Hello World!")    #返回a = {'H', 'o', 'l', 'r', 'W', 'd', 'e', ' ', '!'}，集合中元素无序排列
如果要存放一个单词：
a = {"Hello World!"}    #返回a = {'Hello World!'}

集合还支持求解交集、差集、对称差集等数学运算。

a = {'a','b','c','d'}
a.pop()    #会从a集合中随机弹出一个元素（这里的弹出是指在a集合中删除该元素，并将该元素返回到输出界面上）
a.add('dsa')    #添加该元素到集合中

字典：

字典是无序的键值对{key:value}集合，同一字典中的键必须是互不相同的（键相当于主键，是不能重复的）。一个大括号{}创建一个空字典。键值对之间用逗号分隔，这就是字典的输出形式。

a = {"key":"value","name":"qiaozhi","age":12,"gender":"男"}
a["key"]    #返回'value',即a["key"] = 'value'
a["number"] = 123    #在a字典中创建新的键值对'number': 123
#此时a = {'key': 'value', 'name': 'qiaozhi', 'age': 12, 'gender': '男', 'number': 123}
del a['number']    #删除键为“number”的键值对
#此时a = {'key': 'value', 'name': 'qiaozhi', 'age': 12, 'gender': '男'}
'number' in a    #输出False，因为a中没有'number'这个键对应的键值对
‘name’ in a    #输出True，a字典中有'name'这个键对应的键值对

字典中的键是不可变类型，确保键的唯一性。dict()可以从包含键值对的元组中创建字典。

a = dict((("name","Kubo"),("age",1234)))
#输出a = {'name': 'Kubo', 'age': 1234}
a.keys() = dict_keys(['name', 'age'])    #返回a字典的所有键
a.values() = dict_values(['Kubo', 1234])    #返回a字典的所有值
a.items() = dict_items([('name', 'Kubo'), ('age', 1234)])    #返回a字典的所有键值对

setdefault()方法，向字典中的元素添加数据时，首先要判断该元素是否存在，不存在则需创建一个默认值，存在的话则直接添加元素。

a = {}    #a是一个空字典
a.setdefault('book',[]).append('MySQL')
#如果a字典中没有book键，则创建{'book':[]},即创建book键值对，默认值就是[]，然后执行append添加MySQl在[]中
#如果a字典中有book键的键值对，则在book对应的值（数据类型为列表）中添加MySQL
#此时a = {'book': ['MySQL']}
a.setdefault('book',[]).append('Python')
#此时a = {'book': ['MySQL', 'Python']}

当索引不存在的键值对时，会报错。dict.get(key,default)方法，在dict中索引key键时，如果key键不存在，则返回default，而不会报错。(如果key键存在，则返回key键对应的值)

#例句如上代码段
a['name']    #会报KeyError: 'name'错误
a.get('name','不存在')    #输出：不存在
a.get('book','不存在')    #输出：['MySQL', 'Python']

enumerate()方法在遍历的时候可以返回元素索引值，适用于列表等等数据结构。

for i,j in enumerate(a['book']):
    print(i,j)
#返回：
#0 MySQL
#1 Python

for i,j in enumerate(['a','b','c','d']):
    print(i,j)
#返回：
#0 a
#1 b
#2 c
#3 d

zip()函数可以同时遍历两个序列类型。

a = ['name','age']
b = ['Kubo',18]
for i,j in zip(a,b):
    print("{} is {}".format(i,j))
#返回：
#name is Kubo
#age is 18