python中列表，元组，集合，字典的区别和共同函数

1.列表(List)

①表达式 [ ] 

②特点

1.有序性

列表中的元素是有序的，可以通过元素的下标进行查找

2.可重复性

列表中的元素可以是重复的数据类型

3.可异构性

列表中的元素可以是不同的数据类型

4.可修改性

列表中的元素可以进行增删改查

5.可迭代性

集合是可迭代的对象，可以使用循环遍历集合中的每个元素。

6.动态性

列表的长度可以根据需要动态地增加或减少，不需要事先指定列表的大小。

7.内存管理灵活性

在内存中，列表中的元素是存储在连续的内存空间中的，但列表对象本身有一些额外的机制来管理内存，使得在添加或删除元素时，能够高效地调整内存分配，以适应列表的动态变化。

③特有的操作函数

1.append(x)

在列表末尾添加一个元素x。

my_list = [1,2,3]
# 在列表末尾添加一个元素4
my_list.append(4)
print(my_list) # [1, 2, 3, 4]

2.extend(iterable)

将一个可选代对象的所有元素添加到列表末尾。

"""
    iterable:可迭代对象
"""
my_list = [1,2,3]
my_list1 = ["a","b","c"]
# 将 my_list1可选代对象的所有元素添加到列表末尾。
my_list.extend(my_list1)
print(my_list) # [1, 2, 3, 'a', 'b', 'c']

3.insert(i,x)

在指定位置i插入一个元素x。

my_list = [1,2,3]
# 在下标为 1 的地方插入一个元素 4
my_list.insert(1,4)
print(my_list) # [1, 4, 2, 3]

4.remove(x)

移除列表中第一个值为x的元素。

my_list = [1,2,2,2,3,3,3]
# 移除列表中第一个值为 2 的元素
my_list.remove(2)
print(my_list) # [1, 2, 2, 3, 3, 3]

5.pop([i])

移除列表中指定位置i的元素,并返回该元素。如果不指定位置,默认移除并返回列表的最后一个元素。

my_list = [1,2,3,4,5]
# 移除列表中下标为 1 的元素,并返回该元素
new_list = my_list.pop(1)
print(new_list) # 2
print(my_list) # [1, 3, 4, 5]

my_list1 = [1,2,3,4,5]
# 不指定位置,默认移除并返回列表的最后一个元素。
new_list1 = my_list1.pop()
print(new_list1) # 5
print(my_list1) # [1, 2, 3, 4]

6.clear()

清空列表。

my_list = [1,2,3,4,5]
# 清空列表
my_list.clear()
print(my_list) # [ ]

7.index(x[，start [，end ] ])

返回列表中第一个值为x的元素的索引1,可以指定搜索的起始和结束位置，在未找到指定元素时会抛出 ValueError 异常。

"""
    x：必需，要查找的元素。
    start：可选，查找的起始索引位置，默认为 0。
    end：可选，查找的结束索引位置，默认为列表的长度。查找范围是 [start, end)，
        即包含 start 但不包含 end。
"""

my_list = ["aaa","bbb","ccc","ddd"]
# 查找 'ccc' 的索引
index = my_list.index("ccc")
print(index) # 2

# 从索引 1 到 3 开始查找 'ddd' 的索引
index1 = my_list.index("ddd"，1，3)
print(index1) # 3

8.sort(key=None,reverse=False)

对列表进行排序,可以指定排序的关键字和是否逆序。

"""
    key：可选参数，它是一个函数，该函数接受一个参数，并返回一个用于
        排序的键。默认值为 None，表示直接比较列表中的元素。
    reverse：可选参数，是一个布尔值。如果设置为 True，则列表将按降
            序排序；如果设置为 False（默认值），则列表将按升序排序。
"""
my_list = [2,4,3,5,1]
# 对列表进行升序排序
my_list.sort()
print(my_list)

# 对列表进行降序排序
my_list.sort(reverse=True)
print(my_list)

my_list1 = ["aa","aaaa","aaa","aaaaa","a"]
# 按字符串的长度进行降序排序
my_list1.sort(key=len,reverse=True)
print(my_list1)

9.reverse()

反转列表中的元素顺序。

my_list = [1,3,4,5,2]
# 反转列表中的元素位置
my_list.reverse()
print(my_list)

2.元组(Tuple)

①表达式（）

注意：当元组里面只有一个元素时，需要在元素后加上“ ，” 否则python会认为是字符串类型

②特点

1.有序性

元组中的元素是有序的，可以通过元素的下标进行查找

2.可重复性

元组中的元素可以重复的

3.可异构性

元组中的元素可以是不同的数据类型

4.不可修改性

元组中的元素不可以增删改

5.可哈希

由于元组是不可变的，所以它是可哈希的，这意味着元组可以作为字典的键，也可以作为集合中的元素。

6.解包

可以方便地将元组中的元素解包到多个变量中，这在函数返回多个值等场景中非常有用。

7.存储效率高

由于元组的不可变性，Python 在存储元组时可以采用更紧凑的内存布局，在某些情况下，元组的存储效率比列表更高，特别是当数据量较大且不需要修改时。

③特有的操作函数

1.count(x)

返回元素x在元组中出现的次数。

my_Tuple = (1,2,2,2,3)
# 返回元素2在元组中出现的次数
new_Tuple = my_Tuple.count(2)
print(new_Tuple) # 3

2.index(x[,start[,end]])

返回列表中第一个值为x的元素的索引,可以以指定搜索的起始和结束位置，当查找的元素不存在于元组中时，会抛出ValueError异常。

"""
    x：要查找的元素。
    start（可选）：开始查找的索引位置，默认为 0。
    end（可选）：结束查找的索引位置，不包括该位置。
"""
my_tuple = (10, 20, 30, 40, 30)
# 查找单个元素30的索引
index = my_tuple.index(30)
print(index) # 2
# 查找从索引 3 开始查找元素30
index = my_tuple.index(30, 3)
print(index) # 4

3.字典(Dict)

①表达式 { " " : " " }

②特点

1.键值对存储

字典中的数据是以键值对（key-value）的形式存储的，就像现实生活中的字典一样，通过一个特定的键来查找对应的值。

2.无序性

与列表等数据结构不同，字典中的键值对是无序的，没有固定的顺序。这意味着不能通过索引来访问字典中的元素，而是要通过键来获取对应的值。

3.键的唯一性

字典中的键必须是唯一的，如果在创建字典时出现了重复的键，后面的键值对会覆盖前面的。

4.可变性

字典是可变的数据结构，可以在创建后动态地添加、删除或修改键值对。

5.值的多样性

字典中的值可以是任意类型的数据，包括整数、字符串、列表、字典等，甚至可以是不同类型数据的混合。

6.高效的查找和访问

基于哈希表实现，使得通过键来查找和访问值的速度非常快，时间复杂度通常为 O (1)，无论字典中有多少个键值对，都能快速找到对应的键值。

7.可迭代性

可以通过循环遍历字典的键、值或键值对。

③特有的操作函数

1.keys()

返回一个包含字典所有键的视图对象。

my_dict = {"name":"xiyue","evg":20}
# 返回一个包含字典所有键的视图对象。
new_dict = my_dict.keys()
print(new_dict) # dict_keys(['name', 'evg'])

2.values()

返回一个包含字典所有值的视图对象。

my_dict = {"name":"xiyue","evg":20}
# 返回一个包含字典所有值的视图对象。
new_dict = my_dict.values()
print(new_dict) # dict_values(['xiyue', 20])

3.items()

返回一个包含字典所有键值对的视图对象。

my_dict = {"name":"xiyue","evg":20}
# 返回一个包含字典所有键值对的视图对象。
new_dict = my_dict.items()
print(new_dict) # dict_items([('name', 'xiyue'), ('evg', 20)])

4.get(key,default=None)

获取指定键的值,如果键不存在,则返回默认值

"""
    key：必需参数，指定要查找的键。
    default：可选参数，当指定的键不存在于字典中时，返回该默认值。
            如果不提供该参数，默认值为 None。
"""
my_dict = {
    "name":"xiyue",
    "evg":20
}
# 获取存在指定键evg的值
new_dict = my_dict.get("evg")
print(new_dict) # 20
# 获取不存在的键的值，不指定默认值
new_dict1 = my_dict.get("abc")
print(new_dict1) # None
# 获取不存在的键的值，指定默认值
new_dict2 = my_dict.get("zxc","该键不存在")
print(new_dict2) # 该键不存在

5.setdefault(key,default=None)

如果键存在,则返回对应的值;如果键不存在,则插入键并将默认值作为值插入,然后返回默认值。

"""
    key：必需参数，指定要查找的键。
    default：可选参数，当指定的键不存在于字典中时，将该键插入字典并设置为该默认值。
            如果不提供该参数，默认值为 None。
"""
my_dict = {
    "name":"xiyue",
    "evg":20
}
# 查找键存在的情况
new_dict = my_dict.setdefault("evg",30)
# 注意：调用 setdefault('evg', 30) 时，由于键 'evg' 存在，返回该键对应的值 20，字典内容不会改变。
print(new_dict) # 20
# 查找键不存在的情况,指定默认值的情况
new_dict1 = my_dict.setdefault("abc",100)
print(new_dict1) # 100
print(my_dict) # {'name': 'xiyue', 'evg': 20, 'abc': 100}
# 查找键不存在的情况,不指定默认值的情况
new_dict2 = my_dict.setdefault("zxc")
print(new_dict2) # None
print(my_dict) # {'name': 'xiyue', 'evg': 20, 'abc': 100, 'zxc': None}

6.update([other])

将另一个字典的键值对更新到当前字典中

"""
    other：可以是一个字典，或者是包含键值对的可迭代对象（如元组的列表），用于提供要更新到目标字典中的键值对。
          如果省略该参数，update() 方法不会改变原字典。
"""
my_dict = {
    "a" : 1 ,
    "b" : 2
}
my_dict1 = {
    "c" : 3 ,
    "d" : 4
}
# 将另一个字典的键值对更新到当前字典中
my_dict.update(my_dict1)
print(my_dict) # {'a': 1, 'b': 2, 'c': 3, 'd': 4}
# 有相同的key时，会覆盖原有字典的vales数据
my_dict2 = {
    "d" : 5 ,
    "e" : 5
}
my_dict1.update(my_dict2)
print(my_dict1) # {'c': 3, 'd': 5, 'e': 5}
# 关键字参数来更新字典，这些关键字参数会被转换为键值对并更新到目标字典中。
my_dict2.update(p=100,m=200)
print(my_dict2) # {'d': 5, 'e': 5, 'p': 100, 'm': 200}

7.pop(key[,default])

如果键在字典中存在,则移除并返回该键的值;如果不存在,则返回默认值。

"""
    key：必需参数，表示要移除的键。
    default：可选参数，如果指定的key不存在于字典中，将返回此默认值。
             如果不提供该参数，并且key不存在，会引发KeyError异常。
"""
my_dict = {
    "a":1,
    "b":2,
    "c":3,
}
# 移除存在的键值对
new_dict = my_dict.pop("a")
print(new_dict) # 1
# 尝试移除不存在的键，提供默认值
new_dict1 = my_dict.pop("zxc",20)
print(new_dict1) # 20
# 移除不存在的键，不提供默认值
new_dict2 = my_dict.pop("abc")
print(new_dict2) # 程序错误，没有结果

8.popitem()

移除并返回字典中的最后一个键值对。

my_dict = {
    "a":1,
    "b":2,
    "c":3,
}
# 移除并返回字典中的最后一个键值对。
my_dict.popitem()
print(my_dict) # {'a': 1, 'b': 2}
my_dict.popitem()
print(my_dict) #{'a': 1}

9.clear()

清空字典。

my_dict = {
    "a":1,
    "b":2,
    "c":3,
}
# 清空字典
my_dict.clear()
print(my_dict) # {}

4.集合(Set)

①表达式{ }

②特点

1.无序性

集合中的元素是无序的，无法通过下标查询到集合中的元素

2.互异性

集合中每个元素都是唯一的，即集合中不会出现重复的函数

3.确定性

集合中的元素必须是确定的，不存在模棱两可的情况

4.可修改性

集合中的元素可以进行添加、删除元素等操作来修改集合的内容

5.支持集合运算

集合支持各种常见的集合运算，如并集、交集、差集和对称差集等       

6.元素类型可混合

集合中的元素可以是不同类型的数据，只要它们是可哈希的（hashable）

7.可迭代性

集合是可迭代的对象，可以使用循环遍历集合中的每个元素。

③特有的操作函数

1.add(x)

向集合中添加一个元素x。

my_set = {1, 2, 3}
# 向集合中添加一个元素4
my_set.add(4)
print(my_set) # {1, 2, 3, 4}

2.remove(x)

移除集合中的第一个x,如果x不存在于集合中,则抛出KeyErriora

my_set = {1, 2, 3}
# 移除集合中的元素2
my_set.remove(2)
print(my_set) # {1, 3}
# 移除集合中不存在的元素4
my_set.remove(4)
print(my_set) # 程序报错

3.discard(x)

移除集合中的第一个x,如果x不存在于集合中,不会出错误。

my_set = {1, 2, 3}
# 移除集合中的元素2
my_set.discard(2)
print(my_set) # {1, 3}
# 移除集合中不存在的元素4
my_set.discard(4)
print(my_set) # {1, 3}

4.clear()

清空集合。

my_set = {1, 2, 3}
# 清空集合。
my_set.clear()
print(my_set) #set()

5.union(*others)

返回一个新集合,包含所有集合的元素（并集）。

"""
    *others：表示可以传入一个或多个集合、可迭代对象（如列表、元组等），用于与调用该方法的集合求并集。
    注意：1.union() 方法返回的是一个新的集合，不会修改原始集合。
        2.传入的参数可以是集合，也可以是其他可迭代对象，
          union() 方法会自动将可迭代对象中的元素添加到结果集合中。
"""
my_set = {1, 2, 3}
my_set1 = {3, 4, 5}
# 求两个集合的并集
new_set = my_set.union(my_set1)
print(new_set) # {1, 2, 3, 4, 5}
# 求多个集合的并集
my_set2 = {5, 6, 7}
new_set1 = my_set.union(my_set1, my_set2)
print(new_set1) # {1, 2, 3, 4, 5, 6, 7}
# 求可迭代对象求并集
list = [3,4,5]
new_set2 = my_set.union(list)
print(new_set2) # {1, 2, 3, 4, 5}

6.intersection(*others)

返回一个新集合,包含所有集合共有的元素（交集）。

"""
    *others：表示可以传入一个或多个集合、可迭代对象（如列表、元组等），用于与调用该方法的集合求交集。
    注意：1.intersection() 方法返回的是一个新的集合，不会修改原始集合。
        2.传入的参数可以是集合，也可以是其他可迭代对象，
          intersection() 方法会自动将可迭代对象中的元素添加到结果集合中。
"""
my_set = {1, 2, 3}
my_set1 = {3, 4, 5}
# 求两个集合的交集
new_set = my_set.intersection(my_set1)
print(new_set) # {3}
# 求多个集合的交集
my_set2 = {5, 6, 7}
new_set1 = my_set.intersection(my_set1, my_set2)
print(new_set1) # set()
# 求可迭代对象求交集
list = [3,4,5]
new_set2 = my_set.intersection(list)
print(new_set2) # {3}

7.difference(*others)

返回一个新集合,包含只在当前集合中的元素（差集）。

"""
    *others：表示可以传入一个或多个集合、可迭代对象（如列表、元组等），用于与调用该方法的集合求差集。
    注意：1.difference() 方法返回的是一个新的集合，不会修改原始集合。
        2.传入的参数可以是集合，也可以是其他可迭代对象，
          difference() 方法会自动将可迭代对象中的元素添加到结果集合中。
"""
my_set = {1, 2, 3}
my_set1 = {3, 4, 5}
# 求两个集合的差集
new_set = my_set.difference(my_set1)
print(new_set) # {1, 2}
# 求多个集合的差集
my_set2 = {5, 6, 7}
new_set1 = my_set.difference(my_set1, my_set2)
print(new_set1) # {1, 2}
# 求可迭代对象求差集
list = [2,3,4,5]
new_set2 = my_set.difference(list)
print(new_set2) # {1}

8.symmetric_difference(*others)

返回一个新集合,包含在当前集合或其它集合中,但不在两者共有的元素（对称差集）。

"""
    *others：在symmetric_difference() 方法中只可以接受一个参数，而且必须为集合类型，如果不是集合类型，会引发 TypeError 异常
    注意：symmetric_difference() 方法返回的是一个新的集合，不会修改原始集合。
"""
my_set = {1, 2, 3, 4}
my_set1 = {3, 4, 5, 6}
# 求两个集合的对称差集
new_set = my_set.symmetric_difference(my_set1)
print(new_set) # {1, 2, 5, 6}
# 求可迭代对象求差集
list = [2,3,4,5]
set1 = set(list)
new_set2 = my_set.symmetric_difference(set1)
print(new_set2) # {1, 5}

9.issubset(other)

判断当前集合是否是另一个集合的子集。

# 示例 1：set1 是 set2 的子集
set1 = {1, 2, 3}
set2 = {1, 2, 3, 4, 5}
result1 = set1.issubset(set2)
print(result1) # True

# 示例 2：set1 不是 set2 的子集
set3 = {1, 2, 3}
set4 = {4, 5, 6}
result2 = set3.issubset(set4)
print(result2) # False

# 示例 3：set1 和 set2 相等
set5 = {1, 2, 3}
set6 = {1, 2, 3}
result3 = set5.issubset(set6)
print(result3) # True

# 示例 4：使用其他可迭代对象作为参数
set7 = {1, 2, 3}
list8 = [1, 2, 3, 4, 5]
result4 = set7.issubset(list8)
print(result4) # True

10.issuperset(other)

判断当前集合是否是另一个集合的超集。

# 示例 1：set1 是 set2 的超集
set1 = {1, 2, 3, 4, 5}
set2 = {1, 2, 3}
result1 = set1.issuperset(set2)
print(result1) # True

# 示例 2：set1 不是 set2 的超集
set3 = {1, 2}
set4 = {1, 2, 3}
result2 = set3.issuperset(set4)
print(result2) # False

# 示例 3：两个集合相等时，一个集合是另一个集合的超集
set5 = {1, 2, 3}
set6 = {1, 2, 3}
result3 = set5.issuperset(set6)
print(result3) # True

5.公共的函数及作用

（以下都是以列表示例）

1.len(x)

返回x的长度,对于字典和集合,返回元素的数量。

list = [1,2,3,4,5]
new_list = len(list)
print(new_list) # 5

2.max(x)

返回x中的最大值。

list = [1,2,3,4,5]
new_list = max(list)
print(new_list) # 5

3.min(x)

返回x中的最小值。

list = [1,2,3,4,5]
new_list = min(list)
print(new_list) # 1

4.sum(x[,start])

返回x中所有元素的总和,可以指定起始值。

list = [1,2,3,4,5]
new_list = sum(list)
print(new_list) # 15

5.str(x)

将x转换为字符串。

list = [1,2,3,4,5]
print(type(list)) # 
new_list = str(list)
print(new_list) # [1, 2, 3, 4, 5]
print(type(new_list)) #