python列表删除元素的方法,python列表取出指定元素

M3666789

于 2024-04-02 13:47:58 发布

阅读量754

点赞数 30

文章标签：人工智能

本文链接：https://blog.csdn.net/M3666789/article/details/137267569

版权

大家好，给大家分享一下python列表怎么从小到大排序，很多人还不知道这一点。下面详细解释一下。现在让我们来看看！

列表的定义

用[]作为边界逗号作为分隔符，可容纳所有对象的数据类型，如：[]，[1, "a", 5, 'cd']等等，是可迭代的数据类型，可以被修改。我们可以使用下面2种方式来定义列表python工程师证书怎么考。

第一种：直接使用[]

list1 = [1, 1.1, 'abc']
print(list1)  # [1, 1.1, 'abc']

在一个列表中我们可以放入任何的python对象，包括列表本身。在[]中我们放入了一个整型1，一个浮点型1.1，一个字符串'abc'。如此就形成一个拥有3个元素的列表list1，1为list1的第一个元素，1.1为list1的第二个元素，'abc'为list1的第三个元素。当列表中一个元素也没有时，就是一个空列表。

第二种，使用list函数

list1 = list('abcd12345')
print(list1)  # ['a', 'b', 'c', 'd', '1', '2', '3', '4', '5']

list函数可以把一个可迭代对象中的每一个元素取出来，生成一个列表。因为字符串是可迭代对象，所以list函数把字符串中的每一个元素都取出来了，生成了列表list1。

拼接列表（+）

我们可以使用+号来拼接列表。

list1 = list('abc') + [1, 2, 3] + [1.1, 1.2, 1.3]
print(list1)  # ['a', 'b', 'c', 1, 2, 3, 1.1, 1.2, 1.3]

通过使用+号我们可以把多个列表组合成一个列表，并且是上一个列表的最后一个元素接下一个列表的第一个元素。

还可以通过+=的方式来拼接列表。

list1 = list('abc')
print(id(list1))  # 2426617509888
list1 += [1, 2, 3]
print(id(list1))  # 2426617509888
print(list1)  # ['a', 'b', 'c', 1, 2, 3]

列表list1在使用+=拼接列表[1, 2, 3]后，它的元素右'a'、'b'、'c'3个变成了'a'、'b'、'c'、1、2、3共6个。但是列表是可变的数据类型，所以即使它内部元素发生了变化，它的内存地址还是保持不变。

列表重复操作符（*）

*号可以把一个列表中的所有元素重复n次，元素的个数变为原来的n倍。

list1 = [1, 2] * 3
print(list1)  # [1, 2, 1, 2, 1, 2]

list1中的元素1和2被重复3次后变成了6个元素1、2、1、2、1、2。

列表的索引和切片

因为列表是可迭代的，所以列表具有被索引和切片的功能。

索引

索引就是通过下标的方式去获取可迭代对象中的其中一个元素，需要注意的是下标的值(整形)不能超出可迭代对象的范围。举个例子，请看下面的代码：

list1 = [1, 2, 3, 'a', 'b', 'c']
print(list1[0])  # 1

索引分为正序索引和逆序索引。正序索引是从第一个元素开始，第一个元素的下标为0，向后数，每个元素的下标依次递增1。逆序索引是从最后一个元素开始，最后一个元素的下标为-1，向前数，每个元素的下标依次递减1。以列表[1, 2, 3, 'a', 'b', 'c']来举例，我们可以得到如下的索引：

列表[1, 2, 3, 'a', 'b', 'c']中有6个元素，也就是列表的长度为6。正序索引的下标范围是0~5，逆序索引的下标范围是-1~-6，所以list1[0]和list1[-6]都是获取list1的第一个元素1。我们不能用超出索引范围的下标来索引，会报错。如下：

list1 = [1, 2, 3, 'a', 'b', 'c']
print(list1[6])

执行结果如下：

执行结果就报错了，说pythonBase.py文件的第二行print(list1[6])出错了，对列表list1的索引超出了范围。 list1[6]是获取list1的第7个元素，但list1只有6个元素，根本就没有第7个元素，所以python会报错。

切片

切片就是索引的高级应用，索引只能获取一个元素，但切片可以获取一个或多个元素，切片的本质就是多次使用索引去获取多个元素。对列表的切片是把索引到的所有元素组成一个列表，再返回这个列表，如果什么元素都没获取到则返回空列表。在切片中下标的值可以超出可迭代对象的索引范围，超出范围部分虽然不会报错，但也获取不到任何值。举个例子，请看下面的代码：

list1 = [1, 2, 3, 'a', 'b', 'c']
print(list1[0:3])  # [1, 2, 3]

切片和索引一样，也是使用中括号。索引只需要在中括号中写一个下标，但切片是一个范围需要两个下标，并且两个下标之间用冒号隔开，表示从第一个下标到第二个下标范围内的元素。切片的范围是一个半开半闭区间(前闭后开)，所以切片范围[0:3]在数学中的范围表示是[0,3)，能取到的整数值有0、1、2。因此list1[0:3]表示获取list1中的第一个、第二个和第三个元素，所以执行结果为[1, 2, 3]。

切片中的下标也可以不写，但冒号一定要写。当我们不写第一个下标时，python默认第一个下标为0；当我们不写第二个下标时，python默认第二个下标为可迭代对象的长度。如下：

list1 = [1, 2, 3, 'a', 'b', 'c']
print(list1[:])  # [1, 2, 3, 'a', 'b', 'c']

我们两个下标都没写，所以python默认的切片范围是[0:6]，在数学中的范围表示是[0,6)，能取到的整数值有0、1、2、3、4、5。获取到了list1中的所有元素，所以执行结果为[1, 2, 3, 'a', 'b', 'c']。

当切片的范围超出索引范围时，python不会报错，没有超出范围部分可以正常的获取到值，超出范围的部分没有任何的值。请看如下代码：

list1 = [1, 2, 3, 'a', 'b', 'c']
print(list1[3:10])  # ['a', 'b', 'c']

切片范围[3:10]，在数学中的范围表示是[3,10)，能取到的整数值有3、4、5、6、7、8、9。list1[3]的值是'a'，list1[4]的值是'b'，list1[5]的值是'c'，list1[6]、list1[7]、list1[8]、list1[9]都是超出索引范围的，超出范围是没有任何值的。所以执行结果为['a', 'b', 'c']。

在切片中，我们可以使用步长的方式来间歇性获取可迭代对象中的元素。举个例子，请看下面的代码：

list1 = [1, 2, 3, 'a', 'b', 'c']
print(list1[0:6:2])  # [1, 3, 'b']

切片[0:6:2]中，0和6我们都知道表示的是切片范围[0:6]。那最后面这个2表示的就是切片的步长了，步长也是用冒号来跟第二个下标隔开的。当我们不写切片步长时，python默认切片步长为1。我们知道，切片的本质就是多次使用索引去获取多个元素。在切片中就需要不断的改变索引的下标去获取元素，步长的意义就是每次索引下标需要递增的值，步长为1时，每获取一次元素下标加1。上面的例子中步长为2，所以是每获取一次元素，下标加2。切片多次使用索引的结果为list1[0]、list1[2]、list1[4]，所以执行的结果为[1, 3, 'b']。

步长为正数时，切片为正序索引。步长为负数时，切片为逆序索引。举个例子，请看下面的代码：

list1 = [1, 2, 3, 'a', 'b', 'c']
print(list1[::-1])  # ['c', 'b', 'a', 3, 2, 1]

切片[::-1]中两个下标都没写，表示的切片范围是[0:6]，会获取到list1中的所有元素。步长为-1，表示逆序索引，也就是从最后一个字符开始索引取值，并且每索引一次下标加-1。切片多次使用索引的结果为list1[-1]、list1[-2]、list1[-3]、list1[-4]、list1[-5]、list1[-6]，所以执行的结果为['c', 'b', 'a', 3, 2, 1]。

修改列表中元素的值

因为列表是可变的数据类型，所以列表具有改变元素的能力。当我们想要改变列表中某个元素的值时，可以通过列表索引的方式把这个元素找出来，然后重新给这个元素赋值。请看如下代码：

list1 = [1, 2, 3, 'a', 'b', 'c']
list1[3] = 4
print(list1)  # [1, 2, 3, 4, 'b', 'c']

list1[3]通过索引找到列表list1的第4个元素，这时第4个元素的值为字符串'a'，然后我们用赋值运算符=给第4个元素重新赋值为整型4。重新赋值后的第4个元素的值变为了4，所以列表list1打印的结果为[1, 2, 3, 4, 'b', 'c']。

通过切片的方式可以同时修改多个元素的值。

list1 = [1, 2, 3, 'a', 'b', 'c']
list1[3:6] = [4, 5, 6]
print(list1)  # [1, 2, 3, 4, 5, 6]

python内置函数

len()	返回列表的长度（元素个数）
min()	返回列表中值最小的元素（所有元素必须有可比性）
max()	返回列表中值最大的元素（所有元素必须有可比性）
del	删除列表或列表中的元素

内置函数len

我们向len函数传入一个列表，它会返回这个列表的长度（整型）。

list1 = [1, 2, 3, 'a', 'b', 'c']
number = len(list1)
print(number)  # 6

内置函数min

我们向min函数传入一个列表，它会返回这个列表中值最小的元素，前提是这个列表中的所有元素必须具有可比性。比如所有的元素全都是数字，全都是字符串。

list1 = [6, 3, 2, 4, 1.1, 5]
value = min(list1)
print(value)  # 1.1
list2 = ['abc', '123', 'Baa', '/_', '?']
print(min(list2))  # /_

如果这个列表中的元素不具有可比性就会报错，例如整型和字符串是不能比较大小的。

list1 = [1, 2, 3, '4', '5', 6]
value = min(list1)
print(value)

执行结果如下：

报错显示类型错误，字符串和整型不能比较大小。

内置函数max

我们向max函数传入一个列表，它会返回这个列表中值最大的元素，前提是这个列表中的所有元素必须具有可比性。比如所有的元素全都是数字，全都是字符串。

list1 = [6, 3, 2, 4, 1.1, 5]
value = max(list1)
print(value)  # 6
list2 = ['abc', '123', 'Baa', '/_', '?']
print(max(list2))  # abc

内置函数del

函数del可以删除列表中的元素，也可以删除整个列表。我们使用索引或切片找出列表中的某一个或多个元素，然后使用del函数就可以把它们从列表中删除。

list1 = [1, 2, 3, 'a', 'b', 'c']
del list1[0]
print(list1)  # [2, 3, 'a', 'b', 'c']
list2 = ['abc', 1, 'x', 66, '233']
del list2[1:3]
print(list2)  # ['abc', 66, '233']

我们还可以使用del删除整个列表，当我们删除整个列表之后，就不能再使用这个列表了，因为这个列表已经不存在了。当我们是用del删除列表后再去打印这个列表就会报错。

list1 = [1, 2, 3, 'a', 'b', 'c']
del list1
print(list1)

执行结果如下：

报错显示变量名错误，变量list1未定义。因为list1已经被整个删除掉了，所以在内存中找不到list1。

列表类内置函数

列表类内置函数是在列表这个类型中定义的函数，所以想要使用这些函数，前提是使用的对象必须是一个列表。

增加元素

内置函数append

我们给append函数传入一个任意的python对象，它可以把这个python对象添加到列表的末尾，变成列表当前的最后一个元素。

list1 = [1, 2, 3]
print(list1)  # [1, 2, 3]
list1.append(4)
print(list1)  # [1, 2, 3, 4]
list1.append(['a', 'b', 1])
print(list1)  # [1, 2, 3, 4, ['a', 'b', 1]]

内置函数extend

我们给extend函数传入一个列表list_，它可以把list_中所有的元素添加到列表的后方。类似于列表的拼接，可以用来同时给列表增加多个元素。

list1 = [1, 2, 3]
print(list1)  # [1, 2, 3]
list1.extend([4, 'a', []])
print(list1)  # [1, 2, 3, 4, 'a', []]

内置函数insert

函数insert接收两个参数，第一个参数为索引下标，第二个参数为任意python对象。它会根据传入的索引下标，把传入的python对象插入到列表中索引下标对应的位置。如果当前位置存在元素，则当前位置上的元素以及后面的元素全部向后移动一个位置。如果传入的索引下标超出当前列表的索引范围，则把传入的python对象插入到列表的末尾，变成列表当前的最后一个元素。

list1 = [1, 2, 3]
print(list1)  # [1, 2, 3]
list1.insert(1, 4)
print(list1)  # [1, 4, 2, 3]
list1.insert(5, 6)
print(list1)  # [1, 4, 2, 3, 6]

删除元素

内置函数pop

我们给pop函数传入一个索引下标，它会删除列表中索引下标对应的元素。并把删除的这个元素返回回来，我们可以使用一个变量来接收也可以不接收。

list1 = [1, 2, 3]
print(list1)  # [1, 2, 3]
list1.pop(1)
print(list1)  # [1, 3]
list2 = ['a', 'b', 5, 'c']
print(list2)  # ['a', 'b', 5, 'c']
value = list2.pop(2)
print(value)  # 5
print(list2)  # ['a', 'b', 'c']

当不传入参数，默认删除最后一个元素。

list1 = [1, 2, 3]
print(list1)  # [1, 2, 3]
list1.pop()
print(list1)  # [1, 2]

内置函数remove

remove函数可以删除指定的元素，我们需要删除列表中的那个元素，就给remove函数传递和元素相同的值。

list1 = [1, 2, 3]
print(list1)  # [1, 2, 3]
list1.remove(1)
print(list1)  # [2, 3]
list2 = ['a', 'b', 'c']
print(list2)  # ['a', 'b', 'c']
list2.remove('c')
print(list2)  # ['a', 'b']

当要删除的元素不存在时，会报错。

list1 = [1, 2, 3, 'a', 'b', 'c']
list1.remove(4)
print(list1)

执行结果如下：

报错显示值错误，要删除的元素不在列表中。

统计某种元素个数

内置函数count

count函数可以统计某种元素在列表中的个数，我们需要统计列表中的那种元素，就给count函数传递和元素相同的值。

list1 = [1, 2, 3, 1, 'a', 1, 4, 1]
times = list1.count(1)
print(times)  # 4

第一个元素是1，第4个元素是1，第6个元素是1，第8个元素是1。1在列表list1中有4个，所以统计出来的个数是4。

当要统计的元素不存在时，返回0。

list1 = [1, 2, 3, 1, 'a', 1, 4, 1]
times = list1.count(7)
print(times)  # 0

查看元素的索引值

内置函数index

index函数可以返回某个元素的索引下标，我们需要查看列表中的那个元素的索引下标，就给index函数传递和元素相同的值。

list1 = [1, 2, 3, 'a', 'b', 'c']
index = list1.index('a')
print(index)  # 3

当要查找的元素不存在时，会报错。

list1 = [1, 2, 3, 'a', 'b', 'c']
index = list1.index(4)
print(index)

执行结果如下：

报错显示值错误，4不在列表中。

复制列表

内置函数copy

copy函数可以复制当前列表，并返回一个复制列表，我们需要用一个变量来接收返回回来的复制列表。

list1 = [1, 2, 3, 'a', 'b', 'c']
list2 = list1.copy()
print(list1)  # [1, 2, 3, 'a', 'b', 'c']
print(list2)  # [1, 2, 3, 'a', 'b', 'c']

倒转列表

内置函数reverse

reverse函数可以把列表中元素的顺序倒转过来。

list1 = [1, 2, 3, 'a', 'b', 'c']
list1.reverse()
print(list1)  # ['c', 'b', 'a', 3, 2, 1]

排序

内置函数sort

sort函数可以对列表排序，前提是列表中所有的元素必须具有可比性。比如所有的元素全都是数字，全都是字符串。sort函数默认对列表进行升序排序（从小到大排序）。

list1 = [4, 2, 5, 1, 3, 7, 6]
list1.sort()
print(list1)  # [1, 2, 3, 4, 5, 6, 7]

当我们想要进行降序排序时（从大到小排序），可以使用关键字参数reverse。关键字参数reverse接收一个bool值（True或者False），用来控制排序的方式是升序还是降序。当reverse=True时为降序，当reverse=False时为升序。

list1 = [4, 2, 5, 1, 3, 7, 6]
list1.sort(reverse=True)
print(list1)  # [7, 6, 5, 4, 3, 2, 1]
list1.sort(reverse=False)
print(list1)  # [1, 2, 3, 4, 5, 6, 7]

sort函数还有一个关键字参数key，key接收一个函数。当我们使用key=function时，sort会把这个function作用于所有的元素，通过function作用后的值的大小来对元素排序。这个地方初学者看不懂的话没事，等我们后面学到更多的知识点再回来看它就好理解了。

def square(number: int):  # 定义一个名为square的函数，接收一个参数number，声明参数类型为整型
    """
    求一个整数的平方
    
    :param number: 一个整数
    :return: 这个整数的平方
    """
    number **= 2  # 通过求幂赋值运算符，求出number的平方后把结果重新赋值给number
    return number  # 返回number


list1 = [4, 2, -5, 1, 3, 7, 6]
list1.sort(key=square)
print(list1)  # [1, 2, 3, 4, -5, 6, 7]
list1.sort()
print(list1)  # [-5, 1, 2, 3, 4, 6, 7]

我们用关键字key接收函数square，sort把square作用于每一个元素，就是把每一个元素当作参数传入square函数中进行计算。对4的作用返回16，对2作用返回4，对-5作用返回25，对1作用返回1，对3作用返回9，对7作用返回49，对6作用返回36。通过作用后的值的大小来给元素排序为[1, 2, 3, 4, -5, 6, 7]，正常情况排序为[-5, 1, 2, 3, 4, 6, 7]。

列表比较运算符

我们一般不使用比较运算符去比较列表的大小，因为这没有什么意义，我们常用比较运算符来比较两个列表的值是否相等。列表是具有比较大小的功能的，两个列表比较大小时，首先比较两个列表的第一个元素，第一个元素值大的列表大；如果第一个元素的值相等，就比较第二个元素，第二个元素值大的列表大；如果第二个元素的值相等，则判断第三个...依此类推。列表比较大小的前提是，参与比较的元素具有可比性，如果一个元素是整型，一个元素是字符串则没法比较，python会报错。

比较运算符（==）

==用于判断两个列表是否相等，如果相等返回True，不相等返回False。

list1 = [4, 2, -5, 1, 3, 7, 6]
list2 = ['a', 'b', 1, 2.3]
print(list1 == list2)  # False
list3 = [1, 'a', 3.3, [3]]
list4 = [1, 'a', 3.3, [3]]
print(list3 == list4)  # True

比较运算符（!=）

!=用于判断两个列表是否不相等，如果不相等返回True，相等返回False。

list1 = [4, 2, -5, 1, 3, 7, 6]
list2 = ['a', 'b', 1, 2.3]
print(list1 != list2)  # True
list3 = [1, 'a', 3.3, [3]]
list4 = [1, 'a', 3.3, [3]]
print(list3 != list4)  # False

比较运算符（<）

<用于判断左边的列表是否小于右边的列表，如果小于返回True，大于或等于返回False。

list1 = ['4', 2, -5, 1, 3, 7, 6]
list2 = ['a', 'b', 1, 2.3]
print(list1 < list2)  # True
list3 = [1, 'a', 3.3, [3]]
list4 = [1]
print(list3 < list4)  # False
list5 = [1, 'a', 1]
list6 = [1, 'a', 1]
print(list5 < list6)  # False

列表list1和list2的第一个元素都是字符串，所以它们有可比性。字符'4'的ASCⅡ值小于字符'a'的ASCⅡ值，所以list1小于list2。列表list3和list4的第一个元素都是整型1，第一个元素相等了，只能比较第二个元素。但是list4没有第二个元素，有总是大于无的，所以list3大于list4。list5和list6中每一个元素都是相等的，所以list5等于list6。

比较运算符（>）

>用于判断左边的列表是否大于右边的列表，如果大于返回True，小于或等于返回False。

list1 = ['4', 2, -5, 1, 3, 7, 6]
list2 = ['a', 'b', 1, 2.3]
print(list1 > list2)  # False
list3 = [1, 'a', 3.3, [3]]
list4 = [1]
print(list3 > list4)  # True
list5 = [1, 'a', 1]
list6 = [1, 'a', 1]
print(list5 > list6)  # False

比较运算符（<=）

<=用于判断左边的列表是否小于等于右边的列表，如果小于或等于返回True，不小于且不等于（大于）返回False。

list1 = ['4', 2, -5, 1, 3, 7, 6]
list2 = ['a', 'b', 1, 2.3]
print(list1 <= list2)  # True
list3 = [1, 'a', 3.3, [3]]
list4 = [1]
print(list3 <= list4)  # False
list5 = [1, 'a', 1]
list6 = [1, 'a', 1]
print(list5 <= list6)  # True

比较运算符（>=）

>=用于判断左边的列表是否大于等于右边的列表，如果大于或等于返回True，不大于且不等于（小于）返回False。

list1 = ['4', 2, -5, 1, 3, 7, 6]
list2 = ['a', 'b', 1, 2.3]
print(list1 >= list2)  # False
list3 = [1, 'a', 3.3, [3]]
list4 = [1]
print(list3 >= list4)  # True
list5 = [1, 'a', 1]
list6 = [1, 'a', 1]
print(list5 >= list6)  # True

列表成员运算符

成员运算符是用来判断某个python对象是否跟某个序列（可迭代对象）中的某个元素的值相同。也可以理解成是否在这个列表中，但其实看的还是元素的值是否有和这个python对象的值一样的情况。

in	判断某个对象是否在列表中，在则返回True，不在则返回False
not in	判断某个对象是否不在列表中，不在则返回True，在则返回False

成员运算符（in）

当某个python对象跟某个序列（可迭代对象）中的某个元素的值相同时，返回True；找不到相同值的元素时，返回False。

list1 = [4, 2, -5, 1, 3, 7, 6, [1, 2]]
print([1, 2] in list1)  # True
list2 = ['a', 'b', 1, 2.3, ['a', 1, 3, 2]]
print(5 in list2)  # False

列表list1中最后一个元素的值是一个列表[1, 2]，所以[1, 2] in list1返回True。列表list2中没有元素的值为5，所以5 in list2返回False。

成员运算符（not in）

当某个python对象在某个序列（可迭代对象）中找不到值相同的元素时，返回True；找到相同值的元素时，返回False。

list1 = [4, 2, -5, 1, 3, 7, 6, [1, 2]]
print(2 not in list1)  # False
list2 = ['a', 'b', 1, 2.3, ['a', 1, 3, 2]]
print(5 not in list2)  # True

列表list1中第二个元素的值是2，所以2 not in list1返回False。列表list2中没有元素的值为5，所以5 not in list2返回True。

列表身份运算符

身份运算符可以判断两个列表的内存地址是否一致。因为列表是可变的数据类型，所以即使两个列表的值是相等的，它们的内存地址也可能不同。

is	判断左右两边的内存地址是否相同，相同返回True，否则返回False
is not	判断左右两边的内存地址是否不同，不同返回True，否则返回False

身份运算符（is）

is用于判断左右两个对象的内存地址是否相同，如果相同返回True，不同返回False。举个例子，请看下面的代码：

list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(id(list1))  # 1685687177280
print(id(list2))  # 1685687494336
print(list1 is list2)  # False

list1和list2是相等的，但它们的内存地址不同。它们存储在内存中不同的地方，这就是可变数据类型的特性。

我们使用列表类内置函数copy来复制列表，复制出来的列表和原列表内存地址也不相同。

list3 = [1, 'a', 3.3, [3]]
list4 = list3.copy()
print(id(list3))  # 2658515329536
print(id(list4))  # 2658519922560
print(list3 is list4)  # False

通过赋值运算符（=）赋值出来的列表内存地址是相同的。

list5 = [1, 'a', 1]
list6 = list5
print(id(list5))  # 2465201371776
print(id(list6))  # 2465201371776
print(list5 is list6)  # True

身份运算符（is not）

is not用于判断左右两个对象的内存地址是否不同，如果不同返回True，相同返回False。举个例子，请看下面的代码：

list1 = [1, 2, 3]
list2 = [1, 2, 3]
print(id(list1))  # 2156988928128
print(id(list2))  # 2156989245120
print(list1 is not list2)  # True
list3 = [1, 'a', 3.3, [3]]
list4 = list3.copy()
print(id(list3))  # 2156988965376
print(id(list4))  # 2156989298880
print(list3 is not list4)  # True
list5 = [1, 'a', 1]
list6 = list5
print(id(list5))  # 2156989299200
print(id(list6))  # 2156989299200
print(list5 is not list6)  # False

要注意内存地址相同的可变对象

当两个列表的内存地址相同时，我们修改其中任意一个列表，另一个列表也会跟着改变。

list1 = [1, 2, 3]
list2 = list1
list1.append(4)
print(list1)  # [1, 2, 3, 4]
print(list2)  # [1, 2, 3, 4]
list2.remove(1)
print(list1)  # [2, 3, 4]
print(list2)  # [2, 3, 4]

两个对象的内存地址相同时，其中一个对象修改了内存中的值。另一个对象去相同的内存地址取值，取出来的就是修改后的值。