python之列表

最新推荐文章于 2024-07-03 17:57:26 发布

Roar冷颜

最新推荐文章于 2024-07-03 17:57:26 发布

阅读量1.1k

点赞数 3

分类专栏：零基础入门学习Python学习笔记文章标签： python

本文链接：https://blog.csdn.net/qq_29923461/article/details/119552591

版权

零基础入门学习Python学习笔记专栏收录该内容

9 篇文章 6 订阅

订阅专栏

1 创建列表

使用中括号，将所有准备放入列表中的元素给包裹起来，不同元素之间使用英文逗号分隔：

list = [1, 2, 3, 4, 5, 6]
print(list)
==============================
[1, 2, 3, 4, 5, 6]
>>>

列表可以容纳不同类型的数据，如下所示：

list = [1, 2, 3, 4, "hello", "您好"]
print(list)
==============================
[1, 2, 3, 4, 'hello', '您好']
>>>

2 访问列表中的元素

如果希望按顺序访问列表的每一个元素，可以使用 for 循环语句：

list = [1, 2, 3, 4, "hello", "您好"]
for each in list:
    print(each)
==============================
1
2
3
4
hello
您好
>>>

如果希望随机访问其中一个元素，那么可以使用下标索引的方法：

list = [1, 2, 3, 4, "hello", "您好"]
==============================
>>> list[0]
1
>>> list[1]
2
>>> list[2]
3
>>> list[3]
4
>>> list[4]
'hello'
>>> list[5]
'您好'

当列表很长的时候，有两种方法可以直接访问最后一个元素，如下所示：

list = [1, 2, 3, 4, "hello", "您好"]
length = len(list)
print(list[length - 1])
==============================
您好
>>>

list = [1, 2, 3, 4, "hello", "您好"]
print(list[-1])
==============================
您好
>>>

序列类型的数据都可以使用下标索引的方法，第一个元素的下标是 0，第二个的下标是 1，以此类推：

元素	1	2	3	4	hello	您好
下标	0	1	2	3	4	5

Python 还支持你 “倒着” 进行索引：

元素	1	2	3	4	hello	您好
下标	-6	-5	-4	-3	-2	-1

3 列表切片

将原先的单个索引值改成一个范围即可实现切片：

list = [1, 2, 3, 4, "hello", "您好"]
==============================
>>> list[0:3]
[1, 2, 3]
>>> list[3:6]
[4, 'hello', '您好']
>>> list[:3]
[1, 2, 3]
>>> list[3:]
[4, 'hello', '您好']
>>> list[:]
[1, 2, 3, 4, 'hello', '您好']
>>> list[0:6:2]
[1, 3, 'hello']
>>> list[::2]
[1, 3, 'hello']
>>> list[::-2]
['您好', 4, 2]
>>> list[::-1]
['您好', 'hello', 4, 3, 2, 1]
>>>

4 向列表添加数据

1）append()方法

向列表添加元素可以使用append()方法，它的功能是在列表的末尾添加一个指定的元素。

colors = ["红", "橙", "黄", "绿"]
colors.append("青")
print(colors)
colors.append("蓝")
print(colors)
colors.append("紫")
print(colors)
==============================
['红', '橙', '黄', '绿', '青']
['红', '橙', '黄', '绿', '青', '蓝']
['红', '橙', '黄', '绿', '青', '蓝', '紫']
>>>

append() 方法虽好，不过每次它只能添加一个元素到列表中，而且只能添加到原列表最后一个元素的最后面。

2）extend()方法

extend() 方法则允许一次性添加多个元素：

colors = ["红", "橙", "黄", "绿"]
print(colors)
colors.extend(["青", "蓝", "紫"])
print(colors)
==============================
['红', '橙', '黄', '绿']
['红', '橙', '黄', '绿', '青', '蓝', '紫']
>>>

【注意】extend() 方法的参数必须是一个可迭代对象，然后新的内容是追加到原列表最后一个元素的后面。

3）切片方法

使用万能的切片语法，也可以实现列表元素的添加：

s = [1, 2, 3, 4, 5]
print(s)
s[len(s):] = [6]
print(s)
s[len(s):] = [7, 8, 9]
print(s)
==============================
[1, 2, 3, 4, 5]
[1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

4）insert()方法

insert() 方法允许在列表的任意位置添加数据。insert() 方法有两个参数，第一个参数指定的是插入的位置，第二个参数指定的是插入的元素：

s = [1, 3, 4, 5]
print(s)
s.insert(1, 2)
print(s)
s.insert(0, 0)
print(s)
s.insert(len(s), 6)
print(s)
==============================
[1, 3, 4, 5]
[1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5]
[0, 1, 2, 3, 4, 5, 6]
>>>

5 向列表删除数据

1）remove() 方法

利用remove() 方法，可以将列表中指定的元素删除：

colors = ["红", "橙", "黄", "绿", "青", "蓝", "紫"]
print(colors)
colors.remove("绿")
print(colors)
==============================
['红', '橙', '黄', '绿', '青', '蓝', '紫']
['红', '橙', '黄', '青', '蓝', '紫']
>>>

【注意】
$\bullet$ 如果列表中存在多个匹配的元素，那么它只会删除第一个
$\bullet$ remove() 方法要求你指定一个待删除的元素，如果指定的元素压根儿不存在，那么程序就会报错。

2）pop() 方法

有时候我们可能需要删除某个指定位置上的元素，那么可以使用 pop() 方法，它的参数就是元素的下标索引值：

colors = ["红", "橙", "黄", "绿", "青", "蓝", "紫"]
print(colors)
colors.pop(3)
print(colors)
==============================
['红', '橙', '黄', '绿', '青', '蓝', '紫']
['红', '橙', '黄', '青', '蓝', '紫']
>>>

pop() 方法这个参数其实是可选的，如果你没有指定一个参数，那么它“弹”出来的就是最后一个元素：

colors = ["红", "橙", "黄", "绿", "青", "蓝", "紫"]
print(colors)
colors.pop()
print(colors)
==============================
['红', '橙', '黄', '绿', '青', '蓝', '紫']
['红', '橙', '黄', '绿', '青', '蓝']
>>>

3）clear() 方法

使用clear()方法可以清空列表：

colors = ["红", "橙", "黄", "绿", "青", "蓝", "紫"]
print(colors)
colors.clear()
print(colors)
==============================
['红', '橙', '黄', '绿', '青', '蓝', '紫']
[]
>>>

6 修改列表中的元素

列表跟字符串最大区别就是：列表是可变的，而字符串是不可变的。替换列表中的元素跟访问元素类似，都是使用下标索引的方法，然后使用赋值运算符就可以将新的值给替换进去了：

colors = ["红", "橙", "黄", "绿", "青", "蓝", "紫"]
print(colors)
colors[0] = "red"
print(colors)
==============================
['红', '橙', '黄', '绿', '青', '蓝', '紫']
['red', '橙', '黄', '绿', '青', '蓝', '紫']
>>>

如果有连续的多个元素需要替换，可以利用切片来实现：

colors = ["红", "橙", "黄", "绿", "青", "蓝", "紫"]
print(colors)
colors[3:] = ["green", "cyan", "blue", "purple"]
print(colors)
==============================
['红', '橙', '黄', '绿', '青', '蓝', '紫']
['红', '橙', '黄', 'green', 'cyan', 'blue', 'purple']
>>>

7 排序与翻转

1）sort() 方法实现排序

使用sort()方法可以实现一组无序数字的排序：

nums = [3, 1, 9, 6, 8, 3, 5, 3]
nums.sort()
print(nums)
==============================
[1, 3, 3, 3, 5, 6, 8, 9]
>>>

sort()方法默认情况下是从小到大进行排列，也可以对其参数reverse进行设置使其按照从大到小的顺序排列：

nums = [3, 1, 9, 6, 8, 3, 5, 3]
nums.sort(reverse = True)
print(nums)
==============================
[9, 8, 6, 5, 3, 3, 3, 1]
>>>

【注意】sort()方法中的参数reverse默认情况下为False，只有将其设置为True时，才能将列表中的数字从大到小进行排列。

2）reverse()方法实现翻转

reverse方法可以将列表中的数据实现翻转：

colors = ["红", "橙", "黄", "绿", "青", "蓝", "紫"]
colors.reverse()
print(colors)
==============================
['紫', '蓝', '青', '绿', '黄', '橙', '红']
>>>

8 定位列表中的元素

1）count()方法

如果想知道一个列表中某个元素的个数，可以使用 count()方法：

nums = [3, 1, 9, 6, 8, 3, 5, 3]
print(nums.count(3))
==============================
3
>>>

2）index()方法

如果想查找列表中某个元素的索引值，可以使用index()方法：

colors = ["红", "橙", "黄", "绿", "青", "蓝", "紫"]
print(colors.index("绿"))
==============================
3
>>>

当所查找的元素具有多个时，index()方法返回的是该元素第一次出现的索引值。

nums = [3, 1, 9, 6, 8, 3, 5, 3]
print(nums.index(3))
==============================
0
>>>

index() 方法有两个可选的参数 —— start 和 end ，就是指定查找的开始和结束的下标位置：

nums = [3, 1, 9, 6, 8, 3, 5, 3]
print(nums.index(3, 1, 7))
==============================
5
>>>

9 拷贝列表中的元素

列表还有一个方法叫 copy() ，用于拷贝一个列表：

nums = [3, 1, 9, 6, 8, 3, 5, 3]
nums_copy = nums.copy()
print(nums_copy)
==============================
[3, 1, 9, 6, 8, 3, 5, 3]
>>>

也可以使用切片的语法来实现列表拷贝：

nums = [3, 1, 9, 6, 8, 3, 5, 3]
nums_copy = nums[:]
print(nums_copy)
==============================
[3, 1, 9, 6, 8, 3, 5, 3]
>>>

上面这两种拷贝方法实现的效果是等同的。这两种拷贝的方法，在 Python 中都称为浅拷贝。

10 列表的加法和乘法

列表的加法，其实也是拼接，所以要求加号（+）两边都应该是列表：

m = [1, 2, 3]
n = [4, 5, 6]
print(m + n)
==============================
[1, 2, 3, 4, 5, 6]
>>>

列表的乘法，则是重复列表内部的所有元素若干次：

m = [1, 2, 3]
n = m * 3
print(n)
==============================
[1, 2, 3, 1, 2, 3, 1, 2, 3]
>>>

11 嵌套列表

Python 是允许列表进行嵌套的：

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
print(matrix)
==============================
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>>

可以把创建二维列表的语句这么写：

matrix = [[1, 2, 3],
          [4, 5, 6],
          [7, 8, 9]]
print(matrix)
==============================
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>>

这两种写法是等价的，只是后者在理解上更为直观。

12 访问嵌套列表

访问嵌套列表中的元素，可以使用嵌套的 for 语句来实现：

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for i in matrix:
    for each in i:
       print(each)
==============================
1
2
3
4
5
6
7
8
9
>>>

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
for i in matrix:
    for each in i:
        print(each, end='    ')
    print()
==============================
1    2    3    
4    5    6    
7    8    9    
>>>

通过下标同样可以访问嵌套列表：

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
==============================
>>> matrix[0]
[1, 2, 3]
>>> matrix[1]
[4, 5, 6]
>>> matrix[2]
[7, 8, 9]
>>> matrix[0][0]
1
>>> matrix[1][1]
5
>>> matrix[2][2]
9
>>>

13 初始化二维列表

A = [0] * 3
print(A)
==============================
[0, 0, 0]
>>>

可以利用for 语句来创建并初始化二维列表：

A = [0] * 3
for i in range(3):
    A[i] = [0] * 3
print(A)
A[1][1] = 1
print(A)
==============================
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]
>>> 
>>> A[0] is A[1]
False
>>> A[1] is A[2]
False
>>>

从上述可以看出，A在内存中的存储如下所示：
在这里插入图片描述

B = [[0] * 3] * 3
print(B)
B[1][1] = 1
print(B)
==============================
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
[[0, 1, 0], [0, 1, 0], [0, 1, 0]]
>>> 
>>>> B[0] is B[1]
True
>>> B[1] is B[2]
True
>>>

而B在内存中的存储如下所示：
在这里插入图片描述

B通过乘号对一个嵌套列表进行拷贝，这种拷贝方式只是对同一个列表的引用。

14 浅拷贝和深拷贝

在一些编程语言中，经常会有 “变量就是盒子” 这样的比喻，因为赋值操作就像是往盒子里面放东西。
但在 Python 中变量并不是一个盒子，当赋值运算发生的时候，Python 并不是将数据放进变量里面，而是将变量与数据进行挂钩，这个行为我们称之为引用。

x = [1, 2, 3]
y = x
print(y)
x[1] = 1
print(y)
==============================
[1, 2, 3]
[1, 1, 3]
>>>

通过上面的例子可以看出，将一个变量赋值给另外一个变量时，其实就是将一个变量的引用传递给另外一个变量。因此对x列表中元素进行修改之后，y列表的相应元素也进行了修改。因此，赋值运算在内存中的存储为：
在这里插入图片描述

浅拷贝：利用列表的copy()方法或者切片来实现；
深拷贝：利用 copy 模块的deepcopy() 函数来实现；

1）浅拷贝

x = [1, 2, 3]
y = x.copy()
x[1] = 1
print(x)
print(y)
==============================
[1, 1, 3]
[1, 2, 3]
>>>

从上述例子可以看出，利用copy()方法得到的y列表元素不会因为x列表中元素的改变而改变。
在这里插入图片描述

也可以利用切片方法来实现浅拷贝：

x = [1, 2, 3]
y = x[:]
x[1] = 1
print(x)
print(y)
==============================
[1, 1, 3]
[1, 2, 3]

利用切片的方法y也是获得x指向的这个列表的一个拷贝。

2）深拷贝

上述浅拷贝处理一维列表是没有问题的，对于嵌套列表的拷贝，只是拷贝了其引用：

>>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> y = x.copy()
>>> x[1][1] = 0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]

copy模块包含两个拷贝函数，其中copy()函数也可以实现浅拷贝。在使用copy模块时需要import copy：

>>> import copy
>>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> y = copy.copy(x)
>>> x[1][1] = 0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>>

浅拷贝的实现逻辑如下图所示：
在这里插入图片描述

深拷贝可以用于处理多维列表，copy模块的另外一个拷贝函数deepcopy()能够实现深拷贝：

>>> import copy
>>> x = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> y = copy.deepcopy(x)
>>> x[1][1] = 0
>>> x
[[1, 2, 3], [4, 0, 6], [7, 8, 9]]
>>> y
[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>>

深拷贝的实现逻辑如下图所示：
在这里插入图片描述

在python中默认使用的是浅拷贝而不是深拷贝，主要是为了提高效率。

15 列表推导式

要使一个列表中的每一个数字变为原来的两倍，可以使用下面这个循环语句：

>>> nums = [1, 2, 3, 4, 5]
>>> for i in range(len(nums)):
		nums[i] = nums[i] * 2
>>> nums
[2, 4, 6, 8, 10]
>>>

写成列表推导式就是：

>>> nums = [1, 2, 3, 4, 5]
>>> nums = [i * 2 for i in nums]
>>> nums
[2, 4, 6, 8, 10]
>>>

【注意】：这可不仅仅是少写了一行代码而已，从程序的执行效率上来说，列表推导式的效率通常是要比循环语句快上一倍左右的速度。
列表推导式的基本语法如下：

[expression for target in iterable]

>>> x = [i for i in range(10)]
>>> x
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> x = [i + 1 for i in range(10)]
>>> x
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
>>>

列表推导式也可以用来处理字符串：

>>> y = [c * 2 for c in "HelloWorld"]
>>> y
['HH', 'ee', 'll', 'll', 'oo', 'WW', 'oo', 'rr', 'll', 'dd']
>>>

如果想将每一个字符都转化为Unicode编码并保存为列表，可以使用ord函数：

>>> code = [ord(c) for c in "HelloWorld"]
>>> code
[72, 101, 108, 108, 111, 87, 111, 114, 108, 100]
>>>

利用列表推导式处理矩阵也是非常方便，比如下面代码是将矩阵第 2 列的元素给提取出来：

>>> matrix = [[1, 2, 3],
	          [4, 5, 6],
	          [7, 8, 9]]
>>> col2 = [row[1] for row in matrix]
>>> col2
[2, 5, 8]
>>>

又比如，下面代码是获取矩阵主对角线上的元素（就是从左上角到右下角这条对角线上的元素）：

>>> diag = [matrix[i][i] for i in range(len(matrix))]
>>> diag
[1, 5, 9]
>>>

利用列表推导式，可以很轻松地创建一个二维列表：

>>> S = [[0] * 3 for i in range(3)]
>>> S
[[0, 0, 0], [0, 0, 0], [0, 0, 0]]
>>> S[1][1] = 1
>>> S
[[0, 0, 0], [0, 1, 0], [0, 0, 0]]
>>>

列表推导式其实还可以添加一个用于筛选的 if 分句，完整语法如下：

[expression for target in iterable if condition1]

>>> even = [i for i in range(10) if i % 2 == 0]
>>> even
[0, 2, 4, 6, 8]
>>>

>>> even = [i + 1 for i in range(10) if i % 2 == 0]
>>> even
[1, 3, 5, 7, 9]
>>>

从上述两个例子可以看出，列表推导式先执行for语句，再执行if语句，最后执行左侧的表达式。
在一个字符串列表中，找出首字母为给定字符的字符串也可以使用列表推导式：

>>> strings = ["red", "first", "bule", "black", "funny"]
>>> fstrings = [s for s in strings if s[0] == 'f']
>>> fstrings
['first', 'funny']
>>>

列表推导式还可以变得更复杂一些，那就是实现嵌套，语法如下：

[expression for target1 in iterable1
            for target2 in iterable2
            ...
            for targetN in iterableN]

>>> matrix = [[1, 2, 3],
	          [4, 5, 6],
	          [7, 8, 9]]
>>> nums = [col for row in matrix for col in row]
>>> nums
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

利用for循环实现如下：

>>> matrix = [[1, 2, 3],
	      [4, 5, 6],
	      [7, 8, 9]]
>>> nums = []
>>> for row in matrix:
		for col in row:
	   		 nums.append(col)   
>>> nums
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>>

从上述例子可以看出，对于嵌套列表表达式，外层循环放在前面，内层循环放在后面。

>>> strings = [x + y for x in "hello" for y in "HELLO"]
>>> strings
['hH', 'hE', 'hL', 'hL', 'hO', 'eH', 'eE', 'eL', 'eL', 'eO', 'lH', 'lE', 'lL', 'lL', 'lO', 'lH', 'lE', 'lL', 'lL', 'lO', 'oH', 'oE', 'oL', 'oL', 'oO']
>>> _ = []
>>> for x in "hello":
		for y in "HELLO":
			_.append(x + y)
>>> _
['hH', 'hE', 'hL', 'hL', 'hO', 'eH', 'eE', 'eL', 'eL', 'eO', 'lH', 'lE', 'lL', 'lL', 'lO', 'lH', 'lE', 'lL', 'lL', 'lO', 'oH', 'oE', 'oL', 'oL', 'oO']
>>>

每层嵌套还可以附带一个用于条件筛选的if 分句：

[expression for target1 in iterable1 if condition1
            for target2 in iterable2 if condition2
            ...
            for targetN in iterableN if conditionN]

>>> [[x, y] for x in range(10) if x % 2 == 0 for y in range(10) if y % 3 == 0]
[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]
>>> _ = []
>>> for x in range(10):
		if x % 2 == 0:
			for y in range(10):
				if y % 3 == 0:
					_.append([x, y])		
>>> _
[[0, 0], [0, 3], [0, 6], [0, 9], [2, 0], [2, 3], [2, 6], [2, 9], [4, 0], [4, 3], [4, 6], [4, 9], [6, 0], [6, 3], [6, 6], [6, 9], [8, 0], [8, 3], [8, 6], [8, 9]]
>>>