【Python学习第五篇】之Python的clear() 、remove()、copy()、pop()函数方法
👨🎓博主简介
🏅云计算领域优质创作者
🏅华为云开发者社区专家博主
🏅阿里云开发者社区专家博主
💊交流社区：运维交流社区 欢迎大家的加入！
🐋 希望大家多多支持，我们一起进步！😄
🎉如果文章对你有帮助的话，欢迎 点赞 👍🏻 评论 💬 收藏 ⭐️ 加关注+💗
前言
这里写代码的工具为：PyCharm 2022.3.3
Python 版本为：3.8.5
工作平台：Windows
回顾上节
上一节，我们
一、clear() 函数方法
clear()函数是一个非常有用的函数，能够快速、简单地清空列表和字典的所有元素。通过使用clear()函数，我们可以重复利用列表对象、清空缓存数据等，提高代码的性能和效率。
但需要注意，在使用clear()函数时要谨慎操作。
此方法仅支持可变容器类型，比如：列表、字节数组、字典和集合。语法如下：
a.clear() # 通用语法
list.clear() # 列表
bytearray.clear() # 字节数组
dict.clear() # 字典
set.clear() # 集合- 【示例1】
lst=[1,2,3]
bta=bytearray(b'abc')
dct={'a':1,'b':2}
st={1,2,3}
print(lst,"\n",bta,"\n",dct,"\n",st)
print("---"*30)
lst.clear()
bta.clear()
dct.clear()
st.clear()
print(lst,"\n",bta,"\n",dct,"\n",st)结果为：
[1, 2, 3]
bytearray(b'abc')
{'a': 1, 'b': 2}
{1, 2, 3}
------------------------------------------------------------------------------------------
[]
bytearray(b'')
{}
set()
对于序列来说，此操作等同于del s[:] 和 s[:]=[]，但不是del s，即只清空容器里的内容，而不会将容器对象删除。
- 【示例2】
print("clear()方法清空内容")
s = [1,2,3]
print(s)
s.clear()
print(s)
print("---"*30)
print("del 方法清空内容1")
s1 = [1,2,3]
print(s1)
del s1[:]
print(s1)
print("---"*30)
print("del 方法清空内容2")
s2 = [1,2,3]
print(s2)
#del s2
#print(s2)
# 对序列中的切片子序列进行clear()操作，不会对原序列起作用；
print("---"*30)
print("del 方法清空内容3")
s3 = [1,2,3]
s3 [:2].clear()
print(s3)结果为：
clear()方法清空内容
[1, 2, 3]
[]
------------------------------------------------------------------------------------------
del 方法清空内容1
[1, 2, 3]
[]
------------------------------------------------------------------------------------------
del 方法清空内容2
[1, 2, 3]
------------------------------------------------------------------------------------------
del 方法清空内容3
[1, 2, 3]
进行clear()及copy()操作是为了与不支持切片操作的可变容器（例如：字典和集合）的接口保持一致。clear()是一个原地操作。
二、remove() 函数方法
在Python中，remove() 是一个常用的列表（list）方法。其主要用途是从列表中删除指定的内容，支持列表、字节数组、集合。
以下是 remove() 函数的基本语法：
a.remove(x) # 通用语法
list.remove(x) # 列表
bytearray.remove(x) # 字节数组
set.remove(x) # 集合其中，x 是你想要从列表中删除的元素。
删除s中第一个等于x的项目，执行原地操作，返回值为None，不同类型的规则如下：
总结：如果元素不存在于列表中，remove() 会引发一个 ValueError。
- 【示例1】如果元素不存在于 中，remove() 会引发一个 ValueError。
list = [1,2,3,4]
print(list) # 输出:[1,2,3,4]
list.remove(3)
print(list) # 输出:[1,2,4]
list.remove(5)
print(list) # 输出ValueError报错
- 【示例2】如果元素不存在于 中，remove() 会引发一个 ValueError。
这里的字节数组（ABC）代表的是ASCII值；首先，我们需要明确一点，一个字符串如"ABC"是由字符组成的，每个字符在计算机中都有对应的ASCII值，这些ASCII值是可以被转换为二进制的。
让我们来逐个处理这些字符：
- 'A' 的ASCII值是 65，转化为二进制是 1000001。
- 'B' 的ASCII值是 66，转化为二进制是 1000010。
- 'C' 的ASCII值是 67，转化为二进制是 1000011。
所以，字符串"ABC"的二进制表示是 1000001, 1000010, 1000011。
但是，我们在字节数组中要使用的是ASCII值，所以，如果remove(65)则是删除A、remove(66)则是删除B、remove(67)则是删除C。
bta = bytearray(b"ABC")
print(bta) # 输出:(b"ABC")
bta.remove(66)
print(bta) # 输出:(b"AC")
bta.remove(1)
print(bta) # 输出ValueError报错
- 【示例3】如果元素不存在于 中，remove() 会引发一个 KeyError。
se = {1,2,3}
print(se) # 输出:{1,2,3}
se.remove(2)
print(se) # 输出:{1,3}
se.remove(4)
print(se) # 输出:KeyError: 4
如果删除一个不存在的元素，会报错：KeyError，可以使用以下方法处理：
se2 = {1,2,3}
try:
se2.remove(5)
except KeyError:
pass
print(se2) # 输出结果为：{1,2,3}
解析：
定义了一个集合se2，并尝试从该集合中移除元素5。
如果元素5不存在于集合se2中，代码会引发一个KeyError异常，但这个异常被try/except块捕获并忽略，因此程序会继续执行，不会停止。
最后，代码会打印出集合se2的内容。由于元素5不在集合se2中，所以集合se2的内容在代码执行后仍然为{1,2,3}。try：属于一个流程控制语句，用于在运行时捕获和处理异常。try语句用来尝试执行一些可能会引发异常的代码，而except语句则用来捕获并处理这些异常。完整的格式为：try: 内容 except 异常值: 内容；
所以，当你看到try和except KeyError一起使用时，这意味着代码尝试执行一些可能会引发KeyError（键错误）的操作，例如访问字典中或集合中不存在的键。如果try中的代码引发了KeyError，那么程序将跳转到相应的except块，并执行在那里的代码。pass是一个一个空操作符，表示什么都不做；它通常用于占位或作为语法上的需要，以确保代码的完整性。
当程序需要包含一个语句块，但该语句块没有任何实际的操作时，可以使用pass来填充这个位置。这样做可以保持代码的语法正确性，同时避免出现语法错误。
- 【示例4】使用循环删除列表中的所有指定元素（用于重复元素）。
list1 = [1, 2, 3, 2, 4, 2, 5]
element_to_remove = 2
for i in list1:
if i == element_to_remove:
list1.remove(i)
print(list1) # 输出：[1, 3, 4, 5]
代码解析：
在这个例子中，我们循环遍历列表
list1，如果元素等于element_to_remove（即2），就使用remove()方法删除它。最终，列表list1中的所有2都被删除了。
小结：
讲解此remove方法都用到了 都属于后面的流程控制语句，现在看着有点懵，没关系，到后面学到，可以在返回来看看，这里可以做一个学习记号。
附加：
如果想删除 中的所有值；可直接使用 ；或者；
如果想删除 中的某一个值或相等的值，可以使用 。
如果想按索引删除序列中的元素，可使用 ，第九小结会讲到pop()函数方法的使用。
三、copy() 函数方法
copy() 方法用于创建一个对象的浅拷贝（shallow copy）。浅拷贝是指创建一个新的对象，该对象包含原始对象中的元素的副本，但不递归复制嵌套对象的元素。这意味着原始对象和拷贝对象共享嵌套对象的引用。简单来说就是复制的意思；
copy()方法只支持容器类型，如列表、字节数组、字典、集合等。
copy() 方法通常用于复制列表、字典和其他可变对象，以便在不影响原始对象的情况下进行修改。
以下是 copy() 函数的基本语法：
s.copy() # 通用语法
list.copy() # 列表
bytearray.copy() # 字节数组
dict.copy() # 字典
set.copy() # 集合
frozenset.copy() # 冻结集合 copy()函数方法不是原地操作，执行时需要将拷贝的对象赋值给一个变量。冻结集合(frozenset)虽然是不可变对象，但它也实现了copy()方法，可能是为了与set兼容。
- 【示例1】 复制列表
original_list = [1, 2, 3, 4] # 原数据
copied_list = original_list.copy() # 对原数据进行复制
# 修改拷贝后的列表，不会影响原始列表
copied_list.append(5) # 在复制后的数据中再加一个5
print(original_list) # 输出原数据结果为：[1, 2, 3, 4]
print(copied_list) # 输出复制后的数据结果为：[1, 2, 3, 4, 5]
- 【示例2】 复制字典
original_dict = {'a': 1, 'b': 2, 'c': 3} # 原数据
copied_dict = original_dict.copy() # 对原数据进行复制
# 修改拷贝后的字典，不会影响原始字典
copied_dict['d'] = 4 # 在复制的字典中加一个d:4，不会影响原数据
copied_dict['e'] = 5 # 在复制的字典中加一个e:5，不会影响原数据
print(original_dict) # 输出原数据结果为：{'a': 1, 'b': 2, 'c': 3}
print(copied_dict) # 输出复制后的数据结果为：{'a': 1, 'b': 2, 'c': 3, 'd': 4, 'e': 5}
需要注意的是，copy() 方法仅创建原始对象的浅拷贝。如果原始对象包含嵌套的可变对象（例如列表内包含另一个列表），则拷贝后的对象仍然会共享这些嵌套对象的引用。如果需要深度拷贝（即递归地复制嵌套对象），可以使用 copy 模块中的 deepcopy() 方法。
- 【示例3】对原数据进行操作
lst=[1,2,3,[4,5]] # 原数据
print(lst) # 输出原数据：[1, 2, 3, [4, 5]]
lst_copy=lst.copy() # 复制原数据
print(lst_copy) # 输出复制的数据：[1, 2, 3, [4, 5]]
lst_copy.append(6) # 对复制的数据添加一个数据
print(lst_copy) # 输出添加后的复制的数据：[1, 2, 3, [4, 5], 6]
lst[0]=7 # 对原数据进行修改，0坐标也就是1改为7
print(lst) # 输出原数据结果：[7, 2, 3, [4, 5]]
lst[-1] [-1]=-1 # 对原数据内部数据修改
print(lst) # 输出原数据结果：[7, 2, 3, [4, -1]]
print(lst_copy) # 再次输出复制后的数据；
# 输出结果为：[1, 2, 3, [4, -1], 6]
# 发现内部数据发生了变化，而第一层没有发生变化
不可变对象不支持通过copy()方法进行浅拷贝，因为没有意义，这相当于直接改变引用，如果需要深拷贝，则需要使用内置库的copy.deepcopy()函数；
关于浅拷贝和深拷贝的更多知识可查看次网站：https://www.gairuo.com/p/python-library-copy
- 【示例4】浅拷贝与深拷贝
copy：浅拷贝
deepcopy：深拷贝
a.append()：修改浅对象
a.deepcopy()：修改深对象
import copy
a = [1, 2, ['a', 'b']] # 原对象
b = a # 赋值，传引用
c = copy.copy(a) # 浅拷贝
d = copy.deepcopy(a) # 深拷贝
a.append(3) # 修改浅对象a
a[2][0] = 0 # 修改深 原对象列表元素中的第一个值
print( '原内容：', a, '# 原对象修改后的值')
print( '再赋值：', b, '# 只是引用，就是原对象')
print( '浅拷贝：', c, '# 受到对象内部对象的变化，外部的不受影响')
print( '深拷贝：', d, '# 不受原对象的变化')
# 输出结果
'''
原内容： [1, 2, [0, 'b'], 3] # 原对象修改后的值
再赋值： [1, 2, [0, 'b'], 3] # 只是引用，就是原对象
浅拷贝： [1, 2, [0, 'b']] # 受到对象内部对象的变化，外部的不受影响
深拷贝： [1, 2, ['a', 'b']] # 不受原对象的变化
'''
可以用 https://pythontutor.com/live.html 进行在线测试，观看实时效果。
小结：
由于 Python 内部引用计数的特性，对于不可变对象，浅拷贝和深拷贝的作用是一致的，就相当于复制了一份副本，原对象内部的不可变对象的改变，不会影响到复制对象；
浅拷贝的拷贝。其实是拷贝了原始元素的引用（内存地址），所以当拷贝可变对象时，原对象内可变对象的对应元素的改变，会在复制对象的对应元素上，有所体现；
深拷贝在遇到可变对象时，又在内部做了新建了一个副本。所以，不管它内部的元素如何变化，都不会影响到原来副本的可变对象。
四、pop() 函数方法
pop() 方法用于从列表、字典或集合中删除并返回指定位置或键的元素（或值）。pop() 方法有不同的用法，具体取决于数据类型。
以下是 pop() 函数的基本语法：
s.pop() # 通用语法
s.pop(i) # 通用语法2
# 其他类型的语法
list.pop(index=-1, /) # 列表
bytearray.pop(index=-1, /) # 字节数组
dict.pop(k[,d]) # 字典
set.pop() # 集合s.pop(i)的作用是在提取在i（字典是键，不能为空）位置上的项，并将其从s中移除。应用该方法时，不同类型的数据的行为如下。
1. 在列表中使用 pop()
在列表中，pop() 方法通常用于删除并返回指定索引位置的元素。如果不提供索引，则默认删除并返回列表中的最后一个元素。
my_list = [1, 2, 3, 4, 5] # 定义一个列表[1, 2, 3, 4, 5]
print(my_list) # 输出列表：[1, 2, 3, 4, 5]
# 删除并返回索引为 2 的元素（值为 3）
popped_element = my_list.pop(2)
print(popped_element) # 输出结果为: 3
print(my_list) # 输出结果为: [1, 2, 4, 5]
# 不写默认删除最后一个，删除并返回最后一个元素（值为 5）
popped_element = my_list.pop()
print(popped_element) # 输出结果为: 5
print(my_list) # 输出结果为: [1, 2, 4]
lst=[1,2,[3,4]] # 定义一个列表
print(lst) # 输出结果为：[1, 2, [3, 4]]
lst.pop(0) # 删除第0个坐标，从0开始逐步向后，[3,4]被视为一体
print(lst) # 输出结果为：[2, [3, 4]]
lst.pop(1) # 删除第1个坐标，从0开始逐步向后，[3,4]被视为一体，这里不能删除2，因为在第二个里面已经删除了0，1自然就接替了0，所以，删除后面的[3,4]就是1
print(lst) # 输出结果为：[2]
2. 在字典中使用 pop()
在字典中，pop() 方法用于删除并返回指定键的值。如果键不存在于字典中，并且提供了默认值，那么返回默认值，否则会引发 KeyError 异常。
my_dict = {'a': 1, 'b': 2, 'c': 3} # 定义一个字典
print(my_dict) # 输出字典：{'a': 1, 'b': 2, 'c': 3}
# 删除并返回键为 'b' 的值
popped_value = my_dict.pop('b')
print(popped_value) # 输出结果为: 2
print(my_dict) # 输出结果为: {'a': 1, 'c': 3}
# 删除并返回键为 'x' 的值（提供默认值）
popped_value = my_dict.pop('x', 0)
print(popped_value) # 输出结果为: 0
dic={'a':1,'b':2,'c':3} # 定义一个字典
print(dic) # 输出字典结果：{'a': 1, 'b': 2, 'c': 3}
popped_value = dic.pop('b') # 删除并返回键为 'b' 的值
print(popped_value) # 输出结果为: 2
print(dic) # 输出结果为: {'a': 1, 'c': 3}
dic.pop('d') # 删除并返回键为 'd' 的值，字典中没有d，则抛出KeyError
print(dic) # 输出结果为：抛出KeyError
3. 在集合中使用 pop()
在集合中，pop() 方法用于删除并返回集合中的一个随机元素。由于集合是无序的，不能预测哪个元素会被弹出。
my_set = {1, 2, 3, 4, 5} # 定义一个集合
print(my_set) # 输出定义的集合：{1, 2, 3, 4, 5}
# 删除并返回一个随机元素
popped_element = my_set.pop()
print(popped_element) # 输出: 随机元素，例如 1 或 2 或 3
print(my_set) # 输出: 剩余元素组成的集合
my_set = {1,2} # 定义一个集合
print(my_set) # 输出集合：{1, 2}
my_set.pop() # 随机删除一个元素，那么此时里面元素就剩一个了；
my_set.pop() # 在随机删除一个元素,这时候里面就已经没有元素了；
print(my_set) # 输出集合：set()，这时候里面就是空的了；
my_set.pop() # 在随机删除一个元素，因为已经是空的了，如果在删除的话就会抛出KeyError。
print(my_set) # 输出集合：抛出KeyError
4. 在字节数组中使用pop()
默认删除最后一项，如果容器为空或是索引超出范围则抛出KeyError。
bta = bytearray(b'abc') # 定义一个字节数组
print(bta) # 输出结果为：bytearray(b'abc')
popped_value = bta.pop(1) # 删除字节数组中的第一位
print(bta) # 输出结果为：bytearray(b'ac')
pop() 方法在不同的数据类型中有不同的用法，但它通常用于删除并返回一个元素，可以根据需要提供索引、键或默认值。pop() 方法是一个原地操作。注意：传值时只能用位置参数，不能传关键字参数，既不能写成index=n这种形式。
附加：
如果想删除 中的所有值；可直接使用 ；或者；
如果想删除 中的某一个值或相等的值，可以使用 。
如果想按索引删除序列中的元素，可使用 ，第九小结会讲到pop()函数方法的使用。
讲到这里就完成了第一篇《认识Python》，接下来我还会持续输出Python学习文章，大家可以订阅我的专栏：《python 学习》
🐋 希望大家多多支持，我们一起进步！😄
🎉如果文章对你有帮助的话，欢迎 点赞 👍🏻 评论 💬 收藏 ⭐️ 加关注+💗