Python - List - 进阶之路 - Day02

序列是Python中最基本的数据结构。

序列中的每个元素都分配一个数字 - 它的位置，或索引，第一个索引是0，第二个索引是1，依此类推。

Python有6个序列的内置类型，但最常见的是列表和元组。

序列都可以进行的操作包括索引，切片，加，乘，检查成员。

此外，Python已经内置确定序列的长度以及确定最大和最小的元素的方法。

列表是最常用的Python数据类型，它可以作为一个方括号内的逗号分隔值出现。

列表的数据项不需要具有相同的类型

创建一个列表，只要把逗号分隔的不同的数据项使用方括号括起来即可

# 创建一个 List
students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 查看 List
print(students)

运行结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

一、通过下标来查看 list 中的元素

Python 的 list 是一种有序数据结构，可以像 C 语言数组那样通过下标方式进行访问，常见的下标有正数和负数两种，正数下标以 0 开始，负数下标以 -1 开始计数。以 students 举例说明：

students	1	2	3	4	5	6	7	8	9	10
正数下标	0	1	2	3	4	5	6	7	8	9
负数下标	-10	-9	-8	-7	-6	-5	-4	-3	-2	-1

# 如果要找到 students 中的元素 5，我们可以通过正数下标和负数下标两种方法
print(students[4])
print(students[-6])

运行结果：

5
5

如果索引值大于其长度，将会出现IndexError错误，提示索引值超出了范围：

print(students[10])

运行结果：

Traceback (most recent call last):
  File "/Users/zhulixiang/Downloads/pythonProject/thz/Day02/list.py", line 19, in <module>
    print(students[10])  # 下标超出时会报错，提示：list index out of range
IndexError: list index out of range

除了指定单个下标访问单个元素，还可以用一个冒号分隔起始下标和结束下标的方式访问列表：lst[起始下标 : 结束下标]，比如用 students[1:4] 表示左闭有开区间的 [1:4) 中 1,2,3 的 3 个下标所表示元素

students	1	2	3	4	5	6	7	8	9	10
正数下标	0	1	2	3	4	5	6	7	8	9
负数下标	-10	-9	-8	-7	-6	-5	-4	-3	-2	-1
students[1:4]		2	3	4
students[-9:-6]		2	3	4

我们运行代码看一下实际结果：

# 分别使用正数下标和负数下标
print(students[1:4])
print(students[-9:-6])

运行结果：

[2, 3, 4]
[2, 3, 4]

除了用一个冒号分隔起始下标和结束下标，还可以再增加一个冒号后面带步长参数访问列表：lst[起始下标 : 结束下标 : 步长]，比如 lst[2:7:2] 表示从 2 到 7 的左闭右开区间中以步长 2 间隔的元素，包含了下标为2,4,6的几个元素：

students	1	2	3	4	5	6	7	8	9	10
正数下标	0	1	2	3	4	5	6	7	8	9
负数下标	-10	-9	-8	-7	-6	-5	-4	-3	-2	-1
students[2:7:2]			3		5		7
students[-8:-3:2]			3		5		7

实际代码运行结果如下：

print(students[2:7:2])
print(students[-8:-3:2])

运行结果：

[3, 5, 7]
[3, 5, 7]

二、 List 增加元素的方法

在 Python 中，向 List 添加元素，方法有如下4种方法（append(),extend(),insert(), +加号）

1.  append() 追加单个元素到List的尾部

只接受一个参数，参数可以是任何数据类型，被追加的元素在List中保持着原结构类型。

此元素如果是一个list，那么这个list将作为一个整体进行追加，注意append()和extend()的区别。

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 默认在数组的最后添加一个元素
students.append(11)  

print(students)

# 如果添加 List，也是默认添加到最后
students.append([12, 13, 14])

print(students)

运行结果 ：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, [12, 13, 14]]

2.  extend() 将一个列表中每个元素分别添加到另一个列表中

只接受一个参数；extend()相当于是将list B 连接到list A上。被追加的元素它可以是单个元素，也可以是列表、元组等，但不能是单个的数字。

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
students1 = [11, 12, 13]
students3 = (14, 15, 16)

# 可以新增一个 list
students.extend(students1)
print(students)

# 可以增加一个字符串
students1.extend("a")
print(students1)

# 可以增加一个元组
students.extend(students3)
print(students)

运行结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
[11, 12, 13, 'a']
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 14, 15, 16]

3. insert() 将一个元素插入到列表中

但其参数有两个（如insert(1,”g”)），第一个参数是索引点，即插入的位置，第二个参数是插入的元素。

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# insert 表示在数组的指定下标位置添加元素
students.insert(0, 11)  
print(students)

 运行结果：

[11, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

4. + 加号，将两个list相加，会返回到一个新的list对象

注意与前三种的区别。前面三种方法（append, extend, insert）可对列表增加元素的操作，他们没有返回值，是直接修改了原数据对象。 注意：将两个list相加，需要创建新的list对象，从而需要消耗额外的内存，特别是当list较大时，尽量不要使用“+”来添加list，而应该尽可能使用List的append()方法。

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
students1 = [11, 12, 13]

# list 之间的相加，组成新的 list 的顺序和代码中的顺序一致
students3 = students + students1
print(students3)

students4 = students1 + students
print(students4)

运行结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13]
[11, 12, 13, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

三、 List 元素修改

1. 修改单个元素

修改单个元素非常简单，直接对元素赋值即可。请看下面的例子：

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 直接通过元素的下标重新赋值即可
students[0] = 123

print(students)

运行结果：

[123, 2, 3, 4, 5, 6, 7, 8, 9, 10]

2. 修改一组元素

Python 支持通过切片语法给一组元素赋值。在进行这种操作时，如果不指定步长（step 参数），Python 就不要求新赋值的元素个数与原来的元素个数相同；这意味，该操作既可以为列表添加元素，也可以为列表删除元素。

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 将下标为 0、1、2、3 的元素重新赋值为 11、22、33、44
students[0:4] = [11, 22, 33, 44]

print(students)

运行结果：

[11, 22, 33, 44, 5, 6, 7, 8, 9, 10]

四、 List 元素的删除

1. pop()：根据索引值删除元素

如果删除不存在的元素下标，就会报错：pop index out of range

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
students1 = [11, 12, 13]

# 默认删除数组最后的元素
students.pop()  
print(students)

# 如果 pop()中传入下标后就表示删除指定的元素
students1.pop(0)  
print(students1)

运行结果：

[1, 2, 3, 4, 5, 6, 7, 8, 9]
[12, 13]

2. del：根据索引值删除元素

del 是 Python 中的关键字，专门用来执行删除操作，它不仅可以删除整个列表，还可以删除列表中的某些元素。

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 删除指定下标的元素
del students[0]

print(students)

运行结果：

[2, 3, 4, 5, 6, 7, 8, 9, 10]

del 也可以删除中间一段连续的元素，例子如下:

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 删除下标为 0、1、2 的元素 1、2、3
del students[0：3]

print(students)

运行结果：

[4, 5, 6, 7, 8, 9, 10]

3. remove()：根据元素值进行删除

需要注意的是，remove() 方法只会删除第一个和指定值相同的元素，而且必须保证该元素是存在的，否则会引发 ValueError 错误

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 删除值为 1 的元素
students.remove(1)

print(students)

运行结果：

[2, 3, 4, 5, 6, 7, 8, 9, 10]

五、List 列表查找元素及其他方法

1. index() 方法

index() 方法用来查找某个元素在列表中出现的位置（也就是索引），如果该元素不存在，则会导致 ValueError 错误，所以在查找之前最好使用 count() 方法判断一下。

index() 的语法格式为：

listname.index(obj, start, end)

其中，listname 表示列表名称，obj 表示要查找的元素，start 表示起始位置，end 表示结束位置。

start 和 end 参数用来指定检索范围：

• start 和 end 可以都不写，此时会检索整个列表；
• 如果只写 start 不写 end，那么表示检索从 start 到末尾的元素；
• 如果 start 和 end 都写，那么表示检索 start 和 end 之间的元素。

index() 方法会返回元素所在列表中的索引值。 

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

# 找指定元素为 1 的下标
print(students.index(1))

# 找 1 - 8 之间元素为 3 的下标
print(students.index(3, 1, 8))

# 找元素 4 之前的元素为 7 的下标
print(students.index(7, 4))

# 查看一个不存在的元素的下标
print(students.index(11))

运行结果如下：

0
2
6
Traceback (most recent call last):
  File "/Users/zhulixiang/Downloads/pythonProject/thz/Day02/list.py", line 98, in <module>
    print(students.index(11))
ValueError: 11 is not in list

2. count()方法

count() 方法用来统计某个元素在列表中出现的次数，基本语法格式为：

listname.count(obj)

其中，listname 代表列表名，obj 表示要统计的元素。

如果 count() 返回 0，就表示列表中不存在该元素，所以 count() 也可以用来判断列表中的某个元素是否存在。

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 10]

# 输出 students 中元素 10 有几个
print(students.count(10))

# 如果当前 list 没有该元素返回 0
print(students.count(100))

运行结果：

2
0

3. clear() 方法

clear() 函数用于清空列表，类似于 del

students = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

print(students.clear())

运行结果：

None

 运行结果

4.  sort() 排序

sort() 函数用于对原列表进行排序，如果指定参数，则使用比较函数指定的比较函数。

sort()方法语法：默认是降序排列

list.sort(cmp=None, key=None, reverse=False)

• cmp -- 可选参数, 如果指定了该参数会使用该参数的方法进行排序。
• key -- 主要是用来进行比较的元素，只有一个参数，具体的函数的参数就是取自于可迭代对象中，指定可迭代对象中的一个元素来进行排序。
• reverse -- 排序规则，reverse = True 降序， reverse = False 升序（默认）。 

lo = [1, 2, 45, 38208, 23283, 289238, 10, 89]

# 默认是正序
lo.sort()  
print(lo)

# 倒叙排列
lo.sort(reverse=True)  
print(lo)

# 反转，效果等同于 lo.sort(reverse=True)  
lo.reverse()  
print(lo)

运行结果

[1, 2, 10, 45, 89, 23283, 38208, 289238]
[289238, 38208, 23283, 89, 45, 10, 2, 1]
[1, 2, 10, 45, 89, 23283, 38208, 289238]

六、 多维数组

# 多维数组
l3 = [[1, 2, 3], [1, 4, 5, 7]]
l4 = [[[1, 2, 3], [1, 4, 5, 7]], [9, 90, 10]]

# 多位数组的取值要先找到指定的下标，然后依次写出在数组的下标即可
# 找到 l3 中元素 7
print(l3[1][3])

# 找到 l4 中元素 7
print(l4[0][1][3])

运行结果：

7
7