python-序列知识点总结

（一）列表

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)
2

6、判断是否存在：in（not in）

>>> a
[0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5]
>>> 3 in a
True
>>> 6 not in a
True

7、切片

切片的格式是：[开始，结束，步长]，步长默认是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、读取

1. 键作为下标:通过键，读取值

2. get方法：通过键读取值

3. items()：返回键值对集合，需要遍历访问

4. keys()：返回键的集合

5. 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
4

3、添加与修改

字典名[键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

（五）总结

1. 列表（List）是有序的可变容器，元素可以通过下标访问和修改。它使用中括号 [] 来定义，元素之间用逗号分隔。列表是最常用的数据类型之一，可以包含不同类型的元素。

2. 元组（Tuple）也是有序的容器，但是不可变。这意味着它们不能被修改，也不能给元组中的元素赋值。通常使用圆括号 () 来定义元组，元素之间用逗号分隔。

3. 字典（Dictionary）是键值对的无序集合，其中键和对应的值之间用冒号 : 分隔。字典中的键必须是不可变类型，例如字符串、整数、元组等，而值可以是任何类型。字典通常使用花括号 {} 来定义。

4. 集合（Set）是唯一的无序集合，其中没有重复的值。集合是可变的，并支持并集、交集和差集等基本操作。集合通常使用花括号 {} 来定义。