【python基础学习】List(列表)

前置Python学习Ⅰ：【python基础学习】基础语法结构-CSDN博客

1.列表

Python 的列表 list 是一种内置的数据结构，允许你存储多个项目。列表可以存储任意类型的对象，包括数字、字符串、其他列表，甚至是自定义对象。

1.1基础操作

# 创建一个空列表
empty_list = []

# 创建一个包含多个元素的列表
my_list = [1, 2, 3, "hello", True]

print(my_list[0])  # 访问第一个元素
print(my_list[-1])  # 访问最后一个元素

my_list[1] = 99  # 修改第二个元素
print(my_list)

1.2 添加/删除元素

常用添加操作：append，extend，insert
常用删除操作：remove，pop，clear

my_list = [1, 99, 3, "hello", True]
my_list.append(4)  # append操作，将元素附加在列表最后面
# my_list[len(my_list):] = [4]  # 等同上一行append操作
print(my_list)  # 输出结果为: [1, 99, 3, 'hello', True, 4]


my_list.extend(["灭霸", 888, False])  # extend操作，将一个列表拓展在另一个列表后面
# my_list[len(my_list):] = ["灭霸", 888, False]  # 等同上一行extend操作
print(my_list)  # 输出结果为: [1, 99, 3, 'hello', True, 4, "灭霸", 888, False]


my_list.insert(1, 'world')  # insert操作,在指定位置插入元素
print(my_list)  # 输出: [1, 'world', 99, 3, 'hello', True, 4, "灭霸", 888, False]

# 删除元素：
my_list.remove(99)  # remove操作,删除列表内第一次出现的该元素，若无则报错
print(my_list)  # 输出: [1, 'world', 3, 'hello', True, 4, "灭霸", 888, False]

removed_element = my_list.pop(2)  # pop操作，不放回取出指定下标位置元素
print(removed_element)  # 输出: 3
print(my_list)  # 输出: [1, 'world', 'hello', True, 4, "灭霸", 888, False]

my_list.clear()  # 清空列表
print(my_list)

1.3 列表切片操作

my_list = [1, 2, 3, 4, 5]

# 获取从索引[1,3)的列表元素
sub_list = my_list[1:3]
print(sub_list)  # 输出: [2, 3]

# 获取从开头到索引3-1的元素，即[0,3)
print(my_list[:3])  # 输出: [1, 2, 3]

# 获取从索引 2 到结束的元素
print(my_list[2:])  # 输出: [3, 4, 5]

# 获取从索引[0,3)，步长为2的元素
print(my_list[0:3:2])  # 输出: [1, 3]

# 通过切片操作来修改列表
my_list[3:] = [6, 7, 8]
print(my_list)  # 输出: [1, 2, 3, 6, 7, 8]

 1.4 一些常见的其他列表方法

my_list = [1, 2, 3, 6, 7, 8]
my_list.reverse()  # 反转
print(my_list)

my_list.sort()  # 排序
print(my_list)

if my_list.count(1) == 1:
    my_list[my_list.index(1)] = 99
print(my_list)

print(my_list.index(99,0,3))  #index(x, start, end), 表示在[0,3)下标中查找是否存在99
new_list = my_list.copy()
# new_list = my_list[:]  # 同上一行代码效果一致
print(new_list)

1.5 列表的拷贝

浅拷贝：创建一个新的对象，但不递归复制嵌套对象，嵌套对象仍然引用原始对象的嵌套对象，适用于需要复制对象但不需要单独修改内部嵌套对象的情况。
深拷贝：创建一个新的对象及其所有嵌套对象的完全独立副本，适用于需要完全独立的对象副本的情况，以避免意外的共享引用。

具体区别见如下代码：

x = [1, 2, 3]
y = x
print(x,"\n",y)
x[1] = 4
print(x,"\n",y)  # 发现x和y随着x[1]的修改同时发生变化，都输出：[1, 4, 3]
# 在python中表列表的引用，即x和y都指向同一数据

y = x.copy()
# y = x[:]
x[1] = 5
print(x,"\n",y)  # 使用copy()或切片操作才是对y重新赋值

x = [[1,2,3],[4,5,6],[7,8,9]]
y = x[:]
# y = x.copy()
x[0][0] = 10
print(x,"\n",y,"\n\n")  # 发现即使使用copy()或切片操作，x和y仍随x[0][0]的修改同时发生变化，都输出：[[10, 2, 3], [4, 5, 6], [7, 8, 9]]
# 理解：copy()或切片实现的复制只是单纯将外层对象拷贝，二维列表的外层存储指针，仅拷贝指针而不拷贝指向的数据

# 上述拷贝皆是“浅拷贝”



# 深拷贝：
import copy  # 该包其下有copy()和deepcopy()拷贝函数，前者为浅拷贝，后者为深拷贝
x = [[1,2,3],[4,5,6],[7,8,9]]
y = copy.deepcopy(x)
x[0][0] = 10
print(x,"\n",y)  # 输出结果不一致了
# 解释：深拷贝会拷贝外层对象和其下全部子对象

 1.6 列表推导式[expression for target in iterable]

x = [i+1 for i in range(10)]
print(x)  # 输出[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

oho = [1,2,3,4,5]
oho = [i*2 for i in oho]  
print(oho)  # 输出[2, 4, 6, 8, 10]

code = [ord(i) for i in "YuHui"]  # ord用于获取字符的 Unicode 码点
print(code)


# 常用于提取多维列表的某行某列，如下：
l = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

print(l[0])  # 第一行

l2 = [row[0] for row in l]  # 提取列表l的第一列
print(l2)

l3 = [l[i][i] for i in range(len(l))]  # 获取主对角线上的值
print(l3)

l4 = [l[i][len(l)-i-1] for i in range(len(l))]  # 获取反对角线上的值
print(l4)

oho = [i*2 for i in oho] 和for i in range(len(oho)):    oho[i] =  oho[i]*2的区别：
前者使用列表推导式是直接创建一个新列表赋值给oho这个变量名，而后者使用循环迭代逐个修改原列表的值

1.7 列表学习强化：

######################################################### ① #########################################################
B = [[0] * 3] * 3
print(B)
B[1][1] = 1
print(B,"\n")  # 输出：[[0, 1, 0], [0, 1, 0], [0, 1, 0]]
# 解释：[[0]*3]创建了一个二维列表[[0,0,0]]，然后再*3 使得这个列表的第一个元素[0,0,0]被**浅拷贝**了三次
# “[X]*3”结果为[X,X,X],对 X 复制三份，不修改原列表维度
# 理解：第一个“*3”是对非列表元素0的复制不涉及列表拷贝，所以“[0] * 3”的结果为正常创建的列表[0,0,0];
#       第二个“*3”是对列表[0,0,0]的复制，非deepcopy即浅拷贝引用，出现上述情况

# 修改：
A = [0] * 3
for i in range(3):
    A[i] = [0]*3
print(A)
A[1][1] = 1
print(A,"\n")

# 列表推导式法：
S = [[0]*3 for i in range(3)]
print(S)
S[1][1] = 1
print(S,"\n")

######################################################### ② #########################################################
# 高阶：[expression for target in iterable if condition]
even = [i for i in range(10) if i % 2 == 0]
print(even)
words = ["Great","YuHui","Brilliant", "Excellent", "Fantastic"]  # 寻找以“F”为开头的单词
F_word = [word for word in words if word[0] == "F"]
print(F_word)

######################################################### ③ #########################################################
# 嵌套循环的列表推导式[expression for target1 in iterable1 for target2 in iterable2 ... for target3 in iterable3]
Z = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flatten = [c for row in Z  for c in row] # 将二维列表展开为一维
print(flatten)

######################################################### ④ #########################################################
# 终极：[expression for target1 in iterable1 if condition1 for target2 in iterable2 if condition2 ... for target3 in iterable3 if condition3]
# 遵循Keep It Simple & Stupid（KISS原则）

学习up推荐：列表（I）_哔哩哔哩_bilibili