（一）列表
1、创建
直接创建:列表名=[];
list()函数创建：列表名=list();
>>> a=[1,2,3]
>>> a
[1, 2, 3]
>>> a=list(range(6))
>>> a
[0, 1, 2, 3, 4, 5]
>>> a=list(range(1,5))
>>> a
[1, 2, 3, 4]2、增加元素
- 连接符“+”：用于两个列表之间的连接
- a.append(b)：将元素b插入列表a之后（插入的内容视为一个元素）
- a.extend(b)：将列表b插入列表a之后，插入的内容视为多个
- a.insert(index,b)：指定位置插入，在第index位置（从0开始计算）插入值b
>>> [1,2,3]+[4] #连接符“+”
[1, 2, 3, 4]
>>> a
[1, 2, 3, 4]
>>> a.append(5)
>>> a
[1, 2, 3, 4, 5]
>>> a.extend([1,2,3])
>>> a
[1, 2, 3, 4, 5, 1, 2, 3]
>>> a.insert(0,6)
>>> a
[6, 1, 2, 3, 4, 5, 1, 2, 3]3、修改
直接赋值：列表名[索引值]=新值
>>> a
[0, 1, 2, 3, 4, 5]
>>> a[0]=6
>>> a
[6, 1, 2, 3, 4, 5]4、删除
del ()：指定删除元素。
pop()：删除最后一个元素,并返回该值
remove()：删除首次出现的指定元素
>>> a=list(range(6))
>>> a
[0, 1, 2, 3, 4, 5]
>>> del a[1] //删除索引值为1的元素
>>> a
[0, 2, 3, 4, 5]
>>> a.pop() //删除最后一个元素
5
>>> a
[0, 2, 3, 4]
>>> a.remove(3) //删除首次内容为3的元素
>>> a
[0, 2, 4]5、访问
index(b，start，len):从start到len范围内，查找值b首次出现的下标，start默认为0，len默认列表的长度，即默认查找整个列表
count()：统计袁术出现的次数
>>> a
[0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5]
>>> a.index(2)
2
>>> a.count(3)
26、判断是否存在：in（not in）
>>> a
[0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5]
>>> 3 in a
True
>>> 6 not in a
True7、切片
切片的格式是：[开始，结束，步长]，步长默认是1
当只有两个参数时候是[开始，结束],而且是包含左边，不包含右边
切片的核心是快速灵活的选择列表的元素，选择之后，可以进行增删改查等一系列操作，
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[1:5]
[1, 2, 3, 4]
>>> a[0:9:2]
[0, 2, 4, 6, 8]切片的特殊操作：
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[len(a):]=[10,11] //末尾增加元素
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> a[:3]=[] //删除前三个元素
>>> a
[3, 4, 5, 6, 7, 8, 9, 10, 11]8、复制列表
- 浅复制：直接赋值。例如：b=a[]，a的值复制给了b
- 深复制：copy()或deepcopy(）例如：b=copy.copy(a)或b=copy.deepcopy(a),把列表a中的值复制给b，copy是一个类，需要导入
浅复制：a的值复制给b之后，当a列表的值改动，b列表的值也跟着改动
>>> a
[3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> b=a
>>> b
[3, 4, 5, 6, 7, 8, 9, 10, 11]
>>> a[0]=88
>>> a
[88, 4, 5, 6, 7, 8, 9, 10, 11]
>>> b
[88, 4, 5, 6, 7, 8, 9, 10, 11]深复制：a复制给b之后，列表a和列表b互不印象
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> import copy
>>> b=copy.copy(a)
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a[0]=11
>>> a
[11, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> b
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]9、排序
- 自身排序方法：sort（）：升降序；reverse():逆序
- 内置函数：sorted()：升序，reversed（）：逆序
- 打乱排序：random中的shuffle()
自身排序方法：
>>> a
[8, 7, 0, 1, 9, 4, 3, 5, 2, 6]
>>> a.reverse() #逆序
>>> a
[6, 2, 5, 3, 4, 9, 1, 0, 7, 8]
>>> a.sort() #升序
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a.sort(reverse=True) #降序
>>> a
[9, 8, 7, 6, 5, 4, 3, 2, 1, 0]内置函数：
>>> a
[4, 8, 0, 1, 7, 2, 3, 9, 6, 5]
>>> sorted(a)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> a
[1, 8, 0, 4, 3, 7, 5, 9, 6, 2]
>>> reversed(a)
<list_reverseiterator object at 0x000001E8548D7E80>
>>> for i in a:print(i)1
8
0
4
3
7
5
9
6
2打乱排序：
>>> a
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> import random
>>> random.shuffle(a)
>>> a
[8, 7, 0, 1, 9, 4, 3, 5, 2, 6]10、内置函数：
- all：所有的元素是否等价于true（0为flase，非0为true）即：所有元素中是否非0
- any：所有元素是否存在元素等价于true，即：所有元素是否有非0值
- max（列表）、min（列表）：求列表的最大值
- sum（列表）：所有元素之和
- zip（列表a,列表b）:多个列表组合成元组
- enumerate(列表)：返回枚举对象
11、列表推导式
[表达式 for 变量 in 迭代对象 if 语句]
例如：
>>> b = [x**2 for x in range(10) if x % 2 == 0]
>>> b
[0, 4, 16, 36, 64]（二）元组
1、创建
- 直接创建：元组名=（值1，值2.....）
- tuple（）：元祖名=tuple（值1，值2.....）
- zip(a,b)：a和b可以是列表，也可以是元祖，连接a和b，生成元祖对
>>> a=(1,2,3)
>>> a
(1, 2, 3)
>>> b=tuple(range(6))
>>> b
(0, 1, 2, 3, 4, 5)
>>> c=zip(a,b)
>>> for i in c:print(i)
(1, 0)
(2, 1)
(3, 2)2、序列解包：对多个变量同时赋值
>>> x1,y1,z1=1,2,3 #或是(x1,y1,z1)=(1,2,3)
>>> x1
1
>>> y1
2
>>> z1
3（三）字典
1、创建
直接创建
dict（）
dict.fromkeys()：只创建值，没有值
>>> a={'a':1,'b':2} //方法一：直接创建
>>> a
{'a': 1, 'b': 2}
>>> a=['a','b','c','c'] //方法二：dict（）
>>> b=[1,2,3,4]
>>> c=dict(zip(a,b))
>>> c
{'a': 1, 'b': 2, 'c': 4}
>>> d=dict.fromkeys(['a','b','c'])
>>> d
{'a': None, 'b': None, 'c': None}2、读取
键作为下标:通过键，读取值
get方法：通过键读取值
items()：返回键值对集合，需要遍历访问
keys()：返回键的集合
values()：返回值的集合
>>> c['a'] #1,键作为下标:通过键，读取值
1
>>> c.get('a') #2. get方法：通过键读取值
1
>>> for i in c.items(): #3,items()：返回键值对集合，遍历方式一print(i)('a', 1)
('b', 2)
('c', 4)
>>> for key,value in c.items(): #遍历方式二print(key,value,sep=':')a:1
b:2
c:4
>>> for i in c.keys(): #4、keys()：返回键的集合print(i)a
b
c
>>> for i in c.values(): #5、values()：返回值的集合print(i)1
2
43、添加与修改
字典名[键a]=值b：当键a不存在时，语句是增加键值对，当键a存在时，会对值进行修改
>>> c
{'a': 1, 'b': 2, 'c': 4}
>>> c['c']=3 //c键存在，对其修改
>>> c
{'a': 1, 'b': 2, 'c': 3}
>>> c['d']=4 //d键不存在，对其增加键值
>>> c
{'a': 1, 'b': 2, 'c': 3, 'd': 4}（四）集合
1、创建
- 直接创建：集合名={值1，值2.....}
- set（）方法：若内容重复，自动归类
>>> a={3,5}
>>> a
{3, 5}
>>> b=set(range(5))
>>> b
{0, 1, 2, 3, 4}2、删除
- pop():无参数，删除第一个元素，返回删除的值
- remove()：指定删除元素
- clear()：删除全部元素
>>> b
{0, 1, 2, 3, 4, 6}
>>> b.pop() #删除第一个元素
0
>>> b
{1, 2, 3, 4, 6}
>>> b.remove(6) #删除值为6的元素
>>> b
{1, 2, 3, 4}
>>> b.clear() #全部删除
>>> b
set()3、增加
add(值)
>>> a
{0, 1, 2, 3}
>>> a.add(4)
>>> a
{0, 1, 2, 3, 4}4、运算
- 并集 ：aIb
- 交集：a&b
- 差集：a-b
- 对称差集：a^b
- 判断子集：a<b
>>> a={1,2,3}
>>> b={1,2,4}
>>> a|b //并集
{1, 2, 3, 4}
>>> a&b //交集
{1, 2}
>>> a-b //差集
{3}
>>> a^b //对称差集
{3, 4}
>>> a<b //判断子集
False（五）总结
-
列表（List）是有序的可变容器，元素可以通过下标访问和修改。它使用中括号 [] 来定义，元素之间用逗号分隔。列表是最常用的数据类型之一，可以包含不同类型的元素。
-
元组（Tuple）也是有序的容器，但是不可变。这意味着它们不能被修改，也不能给元组中的元素赋值。通常使用圆括号 () 来定义元组，元素之间用逗号分隔。
-
字典（Dictionary）是键值对的无序集合，其中键和对应的值之间用冒号 : 分隔。字典中的键必须是不可变类型，例如字符串、整数、元组等，而值可以是任何类型。字典通常使用花括号 {} 来定义。
-
集合（Set）是唯一的无序集合，其中没有重复的值。集合是可变的，并支持并集、交集和差集等基本操作。集合通常使用花括号 {} 来定义。
