Python 列表、元组、字典、集合数据类型的区别|深拷贝与浅拷贝的区别

列表、元组、字典、集合的区别

列表是有序、可变的，允许重复的数据结构。
元组是有序、不可变的，允许重复的数据结构。
字典是无序的键值对集合，键必须唯一且不可变。
集合是无序、不重复的元素集合。

列表与元组可变与不可变区别举例

# 元组中 使用sorted对元组进行排序，排序后的内容是一个新的列表，并不会改变元组最开始的值
my_tuple = (1, 6, 3, 4, 5)
list_1 = sorted(my_tuple)
print(list_1)  # 输出 [1, 3, 4, 5, 6]
print(my_tuple)  # 输出 (1, 6, 3, 4, 5)

# 列表中 使用sort对列表进行就地排序，打印列表发现已是排序后的内容，
my_list = [1, 6, 3, 4, 5]
list_change = my_list.sort()
print(list_change)  # 输出 None
print(my_list)  # 输出 [1, 3, 4, 5, 6]

深拷贝与浅拷贝的区别（列表和字典中使用）

浅拷贝是创建了一个对象，该对象的元素是原始对象的引用。修改新对象会影响原始对象，因为它们共享相同的引用元素。

import copy

list = [1, 2, [3, 4]]
new_list = list.copy()

# 修改新列表中的引用元素
new_list[2][0] = 5

print(list)  # 输出: [1, 2, [5, 4]]
print(new_list)  # 输出: [1, 2, [5, 4]]

在这个例子中，原始列表中的第三个元素是一个嵌套列表。通过浅拷贝，创建了一个新列表 new_list，它与原始列表共享同一个嵌套列表。当修改新列表中的嵌套列表时，原始列表也会受到影响。

深拷贝创建了一个全新的独立对象，包括对象本身以及对象中的所有元素。修改新对象不会影响原始对象，它们是完全独立的。

import copy
dict = {'name': 'John', 'age': 30, 'info': {'city': 'Cheng DU', 'country': 'CN'}}
new_dict = copy.deepcopy(dict)
# 修改新字典中的元素
new_dict['age'] = 31
new_dict['info']['city'] = 'ZiGong'
print(dict)  # 输出: {'name': 'John', 'age': 30, 'info': {'city': 'Cheng DU', 'country': 'CN''}}
print(new_dict)  # 输出: {'name': 'John', 'age': 31, 'info': {'city': 'ZiGong', 'country': 'CN’}}

在这个例子中，原始字典中的一个键值对是一个嵌套字典。通过深拷贝，创建了一个新字典 new_dict，它是原始字典的完全独立复制。当修改新字典中的键值对时，原始字典不受影响。

备注：
如果需要创建一个对象的副本，并且其中的元素是可变的，同时希望保留原始对象的引用关系，可以选择浅拷贝。
如果需要创建一个对象的完全独立复制，以便在修改新对象时不影响原始对象，那么深拷贝是更合适的选项。

列表常用函数

append:在列表末尾添加一个元素
extend(iterable): 将可迭代对象中的元素逐个添加到列表末尾。
insert(index, item): 在指定索引位置插入一个元素。
remove(item): 从列表中移除第一个匹配的元素。
pop(index): 移除并返回指定索引位置的元素。
index(item): 返回第一个匹配元素的索引。
count(item): 返回指定元素在列表中出现的次数。
sort(): 对列表进行排序（就地排序，改变原列表）。
reverse(): 反转列表中的元素（就地反转，改变原列表）。

# append
my_list = [1, 2, 3]
my_list.append(5)
print(my_list)  # 输出: [1, 2, 3, 5]

# extend
my_list = [1, 2, 3]
my_list.extend([4, 5, 6])
print(my_list)  # 输出: [1, 2, 3, 4, 5, 6]

# insert
my_list = [1, 2, 3]
my_list.insert(1, 4)
print(my_list)  # 输出: [1, 4, 2, 3]

# remove(item):
my_list = [1, 2, 3, 2]
my_list.remove(2)
print(my_list)  # 输出: [1, 3, 2]

# pop(index)
my_list = [1, 2, 3]
popped_item = my_list.pop(1)
print(popped_item)  # 输出: 2
print(my_list)  # 输出: [1, 3]

# index(item)
my_list = [1, 2, 3, 2]
index = my_list.index(2)
print(index)  # 输出: 1

# count(item)
my_list = [1, 2, 3, 2]
count = my_list.count(2)
print(count)  # 输出: 2

# sort()
my_list = [3, 1, 2]
my_list.sort()
print(my_list)  # 输出: [1, 2, 3]

# reverse()
my_list = [1, 5, 4]
my_list.reverse()
print(my_list)  # 输出: [4, 5, 1]

字典常用函数

keys(): 返回一个包含字典所有键的视图，对象类型为dict_keys。
values(): 返回一个包含字典所有值的视图，对象类型为dict_values。
items(): 返回一个包含字典所有键值对的视图，对象类型为items_keys。
get(key, default): 返回指定键的值，如果键不存在，则返回默认值。
pop(key, default): 删除指定键的值，如果键不存在，则返回默认值。
update(dictionary): 使用其他字典或键值对更新当前字典。
popitem(): 随机删除字典中的一个键值对（通常是最后一个）并返回。
clear(): 清空字典中的所有键值对。

# keys
my_dict = {'a': 1, 'b': 2, 'c': 3}
keys = my_dict.keys()
print(keys)  # 输出: dict_keys(['a', 'b', 'c'])
print(type(keys))

# values()
my_dict = {'a': 1, 'b': 2, 'c': 3}
values = my_dict.values()
print(values)  # 输出: dict_values([1, 2, 3])

# items()
my_dict = {'a': 1, 'b': 2, 'c': 3}
items = my_dict.items()
print(items)  # 输出: dict_items([('a', 1), ('b', 2), ('c', 3)])


# get(key, default)
my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.get('a', 0)
print(value)  # 输出: 1

value = my_dict.get('d', 0)
print(value)  # 输出: 0

# pop(key, default)
my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.pop('a', 0)
print(value)  # 输出: 1
print(my_dict)
value = my_dict.pop('d', 0)
print(value)  # 输出: 0

# update(dictionary)
my_dict = {'a': 1, 'b': 2}
my_dict.update({'c': 3})
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

# popitem()
my_dict = {'a': 1, 'b': 2, 'c': 3}
item = my_dict.popitem()
print(item)  # 输出: ('c', 3)
print(my_dict)  # 输出: {'a': 1, 'b': 2}

# clear()
my_dict = {'a': 1, 'b': 2, 'c': 3}
my_dict.clear()
print(my_dict)  # 输出: {}

元组常用函数

len(tuple): 返回元组中元素的个数。
index(item): 返回第一个匹配元素的索引。
count(item): 返回指定元素在元组中出现的次数。
sorted(tuple): 返回一个排序后的新列表，不改变原始元组

# len
my_tuple = (1, 2, 3, 4, 5)
length = len(my_tuple)
print(length)  # 输出 5

# index
my_tuple = (1, 2, 3, 4, 5)
index_1 = my_tuple.index(2)
print(index_1)  # 输出 1

# count
my_tuple = (1, 2, 3, 3, 5)
counts = my_tuple.count(3)
print(counts)  # 输出 2

# sorted
my_tuple = (1, 6, 3, 4, 5)
list_1 = sorted(my_tuple)
print(list_1)  # 输出 [1, 3, 4, 5, 6]
print(my_tuple)  # 输出 (1, 6, 3, 4, 5)

集合常用函数

set.add(element): 向集合中添加一个元素。
set.remove(element): 从集合中移除指定元素，如果元素不存在则引发 KeyError 异常。
set.pop(): 随机移除并返回集合中的一个元素。
set.union(other_set) 方法用于返回一个包含两个集合中所有元素的新集合，即两个集合的合并结果。

# add
my_set = {1, 2, 3}
my_set.add(4)
print(my_set)  # 输出 {1, 2, 3, 4}

# pop
my_set = {1, 2, 3, 4}
element = my_set.pop()
print(element)  # 输出集合中的一个元素，如 1

# remove
my_set = {1, 2, 3, 4}
my_set.remove(3)
print(my_set)  # 输出 {1, 2, 4}

# union
set1 = {1, 2, 3}
set2 = {3, 4, 5}
union_set = set1.union(set2)
print(union_set)  # 输出合并后的集合，如 {1, 2, 3, 4, 5}