一、列表（list）
- 列表是一种无序的、可重复的数据序列，可以随时添加、删除其中的元素。
- 列表页的每个元素都分配一个数字索引，从 0 开始
- 列表使用方括号创建，使用逗号分隔元素
- 列表元素值可以是任意类型，包括变量
- 使用方括号对列表进行元素访问、切片、修改、删除等操作，开闭合区间为[)形式
- 列表的元素访问可以嵌套
- 方括号内可以是任意表达式
1、创建列表
hello = (1, 2, 3)
li = [1, "2", [3, 'a'], (1, 3), hello]
2、访问元素
li = [1, "2", [3, 'a'], (1, 3)]
print (li[3]) #(1, 3)
print (li[-1]) #[3, 'a']
3、切片访问
格式: list_name[begin : end : step] begin 表示起始位置(默认为0)，end 表示结束位置(默认为最后一个元素)，step 表示步长(默认为1)
hello = (1, 2, 3)
li = [1, "2", [3, 'a'], (1, 3), hello]
print(li) # [1, '2', [3, 'a'], (1, 3), (1, 2, 3)]
print(li[1:2]) # ['2']
print(li[:2]) # [1, '2']
print(li[:]) # [1, '2', [3, 'a'], (1, 3), (1, 2, 3)]
print(li[2:]) # [[3, 'a'], (1, 3), (1, 2, 3)]
print(li[1:-1:2]) # ['2', (1, 3)]
访问内嵌 list 的元素：
li = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ['a', 'b', 'c']]
print(li[1:-1:2][1:3]) # (3, 5)
print(li[-1][1:3]) # ['b', 'c']
print(li[-1][1]) # b
4、修改列表
通过使用方括号，可以非常灵活的对列表的元素进行修改、替换、删除等操作。
li = [0, 1, 2, 3, 4, 5]
li[len(li) - 2] = 22 # 修改 [0, 1, 2, 22, 4, 5]
li[3] = 33 # 修改 [0, 1, 2, 33, 4, 5]
li[1:-1] = [9, 9] # 替换 [0, 9, 9, 5]
li[1:-1] = [] # 删除 [0, 5]
5、删除元素
可以使用del语句来删除列表的指定范围的元素。
li = [0, 1, 2, 3, 4, 5]
del li[3] # [0, 1, 2, 4, 5]
del li[2:-1] # [0, 1, 5]
6、列表操作符
- +用于合并列表
- *用于重复列表元素
- in 用于判断元素是否存在于列表中
- for … in … 用于遍历列表元素
[1, 2, 3] + [3, 4, 5] # [1, 2, 3, 3, 4, 5]
[1, 2, 3] * 2 # [1, 2, 3, 1, 2, 3]
3 in [1, 2, 3] # True
for x in [1, 2, 3]: print(x) # 1 2 3
7、列表函数
- len(list)列表元素个数
- max(list)列表元素中的最大值
- min(list)列表元素中的最小值
- list(seq)将元组转换为列表
li = [0, 1, 5]
max(li) #5
min(li) #0
len(li) #3
8、列表方法
- list.append(obj)在列表末尾添加新的对象
- list.count(obj)返回元素在列表中的出现次数
- list.extend(seq)在列表末尾一次性追加另一个序列的多个值
- list.index(obj)返回查找对象的索引位置，如果没有找到则抛出异常
- list.insert(index, obj)将指定对象插入列表的指定位置
- list.pop([index = -1])移除列表中的一个元素（默认最后一个元素），并且返回该元素的值
- list.remove(obj)移除列表中某个值的第一个匹配项
- list.reverse()反向排序列表
- list.sort(cmp=None, key=None,
reverse=False)对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数 - list.clear()清空列表，还可以使用del list[:]、li=[]等方式实现
- list.copy()复制列表，默认使用等号赋值给另一个变量，实际上是引用列表变量
9、列表推导式
列表推导式提供了从序列创建列表的简单途径。通常应用程序将一些操作应用于某个序列的每个元素，用其获得的结果作为生成新列表的元素，或者根据确定的判定条件创建子序列。
每个列表推导式都在 for 之后跟一个表达式，然后有零到多个 for 或 if 子句。返回结果是一个根据表达从其后的 for 和 if 上下文环境中生成出来的列表。如果希望表达式推导出一个元组，就必须使用括号。
将列表中每个数值乘三，获得一个新的列表：
vec = [2, 4, 6]
[(x, x**2) for x in vec] #[(2, 4), (4, 16), (6, 36)]
对序列中每一个元素逐个调用某方法：
freshfruit = [' banana', ' loganberry', 'passion fruit ']
[weapon.strip() for weapon in freshfruit]#strip（）去除字符串前后的空格，但不包括字符串中间的空格
#['banana', 'loganberry', 'passion fruit']
用if子句作为过滤器：
vec = [2, 4, 6]
[3*x for x in vec if x > 3]
#[12, 18]
vec1 = [2, 4, 6]
vec2 = [4, 3, -9]
[x*y for x in vec1 for y in vec2]
#[8, 6, -18, 16, 12, -36, 24, 18, -54]
[vec1[i]*vec2[i] for i in range(len(vec1))]
#[8, 12, -54]
列表嵌套解析：
matrix = [
[1, 2, 4],
[4, 5, 6],
[7, 8, 9],
]
new_matrix = [[row[i] for row in matrix] for i in range(len(matrix[0]))]
print (new_matrix)
#[[1, 4, 7], [2, 5, 8], [3, 6, 9]]
二、元组（tuple）
- 元组与列表类似，不同之处在于元组的元素不能修改
- 元组使用小括号，列表使用方括号
- 元组创建很简单，只需要在括号中添加元素，并使用逗号隔开即可
- 没有 append()，insert() 这样进行修改的方法，其他方法都与列表一样
- 字典中的键必须是唯一的同时不可变的，值则没有限制
- 元组中只包含一个元素时，需要在元素后面添加逗号，否则括号会被当作运算符使用
1、访问元组
访问元组的方式与列表是一致的。元组的元素可以直接赋值给多个变量，当变量数
扫描二维码关注公众号，回复：
4363451 查看本文章
a, b, c = (1, 2, 3)
print (a, b, c)
2、组合元组
元组中的元素是不允许修改的，当我们可以对元组进行连接组合
tup1 = (12, 34.56);
tup2 = ('abc', 'xyz')
tup3 = tup1 + tup2;
print (tup3)
# (12, 34.56, 'abc', 'xyz')
3、删除元组
元组中的元素值是不允许删除的，当我们可以使用del语句来删除整个元组
元组函数：
len(tuple)元组元素个数
max(tuple)元组元素中的最大值
min(tuple)元组元素中的最小值
tuple(tuple)将列表转换为元组
元组推导式
t = 1, 2, 3
print(t)
# (1, 2, 3)
u = t, (3, 4, 5)
print(u)
# ((1, 2, 3), (3, 4, 5))
三、字典（dict）
- 字典是另一种可变容器模型，可存储任意类型对象
- 字典的每个键值(key=>value)对用冒号(:)分割，每个对之间用逗号(,)分割，整个字典包括在花括号({})中
- 键必须是唯一的，但值则不必
- 值可以是任意数据类型
- 键必须是不可变的，例如：数字、字符串、元组可以，但列表就不行
- 如果用字典里没有的键访问数据，会报错
- 字典的元素没有顺序，不能通过下标引用元素，通过键来引用
- 字典内部存放的顺序和 key 放入的顺序是没有关系的
格式如下：
d = {key1 : value1, key2 : value2 }
1、访问字典
dis = {'a': 1, 'b': [1, 2, 3]}
print(dis['b'][2])
# 3
2、修改字典
dis = {'a': 1, 'b': [1, 2, 3], 9: {'name': 'hello'}}
dis[9]['name'] = 999
print(dis)
# {'a': 1, 9: {'name': 999}, 'b': [1, 2, 3]}
3、删除字典
用del语句删除字典或字典元素。
dis = {'a': 1, 'b': [1, 2, 3], 9: {'name': 'hello'}}
del dis[9]['name']
print(dis)
del dis # 删除字典
# {'a': 1, 9: {}, 'b': [1, 2, 3]}
4、字典函数
len(dict)计算字典元素个数，即键的总数
str(dict)输出字典，以可打印的字符串表示
type(variable)返回输入的变量类型，如果变量是字典就返回字典类型
key in dict判断键是否在字典中
5、字典方法
- dict.clear() 删除字典内所有元素
- dict.copy() 返回一个字典的浅复制
- dict.fromkeys(seq[, value])
创建一个新字典，以序列seq中元素做字典的键，value为字典所有键对应的初始值。 - dict.get(key, default = None) 返回指定键的值，如果值不在字典中，返回默认值
- dict.items() 以列表形式返回可遍历的（键， 值）元组数组
- dict.keys() 以列表返回一个字典所有的键
- dict.values() 以列表返回字典中所有的值
- dict.setdefault(key, default=None)
如果key在字典中，返回对应的值。如果不在字典中，则插入key及树设置的默认值default，并返回default，default默认值为None。 - dict.update(dict2) 把字典参数dict2的键/值对更新到字典dict里
dic1 = {'a': 'a'}
dic2 = {9: 9, 'a': 'b'}
dic1.update(dic2)
print(dic1)
# {'a': 'b', 9: 9}
- dict.pop(key[, default]) 删除字典给定键key说对应的值，返回值为被删除的值。key值必须给出，否则返回default值。
- dict.popitem() 随机返回并删除字典中的一对键/值对（一般删除末尾对）
6、字典推导式
构造函数dict()直接从键值对元组列表中构建字典。如果有固定的模式，列表推导式指定特定的键值对：
>>> dict([('sape', 4139), ('guido', 4127), ('jack', 4098)])
{'sape': 4139, 'jack': 4098, 'guido': 4127}
此外，字典推导式可以用来创建任意键和值的表达式词典：
>>> {x: x**2 for x in (2, 4, 6)}
{2: 4, 4: 16, 6: 36}
如果关键字只是简单的字符串，使用关键字参数指定键值对有时候更方便：
dict(sape=4139, guido=4127, jack=4098)
{'sape':4139, 'jack':4098, 'guido':4127}
四、集合（set）
集合是一个无序不重复元素的序列。
1、创建集合
- 可以使用大括号{}或者set()函数创建集合
- 创建一个空集合必须用set()而不是{}，因为{}是用来创建一个空字典
- set(value)方式创建集合，value可以是字符串、列表、元组、字典等序列类型
- 创建、添加、修改等操作，集合会自动去重
{1, 2, 1, 3} #{} {1, 2, 3}
set('12345') #字符串{’3‘， ’5‘， ‘4’， ‘2’， ‘1’}
set([1, 'a', 22.4]) #列表{1， 'a', 23.4}
set((1, 'a', 23.4)) #元组{1， 'a', 23.4}
set({1:1, 'b':9}) #字典{1， 'b'}只是取出了字典的key值
2、添加元素
将元素val添加到结合set中，如果元素已经存在，则不进行任何操作：
set.add(val)
也可以用update方法批量天剑元素，参数可以使列表、元组、字典等：
set.update(list1, list2, ... )
3、移除元素
如果存在元素val则移除，不存在就报错：
set.remove(val)
如果存在元素val则移除，不存在也不会报错：
set.discard(val)
随机移除一个元素：
set.pop()
4、元素个数
与其他序列一样，可以用len(set)获取集合的元素个数。
5、清空集合
set.clear()
set = set()
6、判断元素是否存在
val in set
7、其他方法
- set.copy() 赋值集合
- set.difference(set2) 求差集，在set中却不在set2中
- set.intersection(set2) 求交集，同时存在于set和set2中
- set.union(set2) 求并集，所有set和set2的元素
- set.symmetric_difference(set2) 求对称差集， 不同时代出现在两个集合中的元素
- set.isdisjoint(set2) 如果两个集合没有相同的元素，则返回true
- set.issubset(set2) 如果set是set2的一个子集，返回true
- set.issuperset(set2) 如果set是set2的一个超集，则返回true
8、集合计算
a = set('abracadabra')
b = set('alacazam')
print(a) # a 中唯一的字母
# {'a', 'r', 'b', 'c', 'd'}
print(a - b) # 在 a 中的字母，但不在 b 中
# {'r', 'd', 'b'}
print(a | b) # 在 a 或 b 中的字母
# {'a', 'c', 'r', 'd', 'b', 'm', 'z', 'l'}
print(a & b) # 在 a 和 b 中都有的字母
# {'a', 'c'}
print(a ^ b) # 在 a 或 b 中的字母，但不同时在 a 和 b 中
# {'r', 'd', 'b', 'm', 'z', 'l'}
9、集合推导式
a = {x for x in 'abracadabra' if x not in 'abc'}
print (a)
#{'d', 'r'}