Python 中列表、元组、字典、集合方法汇总-CSDN博客

在 Python 的世界里，列表（List）、元组（Tuple）、字典（Dictionary）和集合（Set）是四种非常重要且常用的数据结构。它们各自有着独特的特点和适用场景，掌握它们的使用方法，是 Python 编程的基础。本文将详细介绍这四种数据结构的常用方法，并通过丰富的示例代码帮助大家理解和记忆。

一、列表（List）

1.1 基本定义

列表是 Python 中最灵活的数据结构之一。它是可变的、有序的，并且可以存储不同类型的元素，甚至可以嵌套其他列表。列表使用方括号 [] 来定义。

1.2 常用方法详解

1.2.1 添加元素

append(obj)：在列表的末尾添加一个元素，该方法直接修改原列表。

fruits = ['apple', 'banana']
fruits.append('cherry')
print(fruits)  # 输出：['apple', 'banana', 'cherry']

extend(iterable)：将一个可迭代对象的所有元素添加到列表末尾。

fruits = ['apple', 'banana']
fruits.extend(['cherry', 'date'])
print(fruits)  # 输出：['apple', 'banana', 'cherry', 'date']

insert(index, obj)：在指定索引位置插入一个元素，原索引及后面的元素依次后移。

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

1.2.2 删除元素

remove(obj)：删除列表中第一个匹配的元素，如果元素不存在会抛出 ValueError 异常。

fruits = ['apple', 'banana', 'cherry']
fruits.remove('banana')
print(fruits)  # 输出：['apple', 'cherry']

pop([index])：删除并返回指定索引位置的元素，默认删除最后一个元素。

numbers = [1, 2, 3, 4]
print(numbers.pop(1))  # 输出：2
print(numbers)         # 输出：[1, 3, 4]

clear()：清空列表中的所有元素，使列表变为空列表。

fruits = ['apple', 'banana']
fruits.clear()
print(fruits)  # 输出：[]

1.2.3 查找元素

index(obj[, start[, end]])：返回第一个匹配元素的索引，搜索范围可以通过 start 和 end 参数指定。

fruits = ['apple', 'banana', 'cherry', 'banana']
print(fruits.index('banana'))      # 输出：1
print(fruits.index('banana', 2))   # 输出：3

count(obj)：统计指定元素在列表中出现的次数。

numbers = [1, 2, 2, 3, 2]
print(numbers.count(2))  # 输出：3

1.2.4 排序和反转

sort(key=None, reverse=False)：对列表进行原地排序，key 参数可以指定排序的依据，reverse 为 True 时降序排列

numbers = [3, 1, 4]
numbers.sort()
print(numbers)  # 输出：[1, 3, 4]

words = ['apple', 'Banana', 'cherry']
words.sort(key=str.lower)
print(words)  # 输出：['apple', 'Banana', 'cherry']（按小写字母排序）

reverse()：反转列表中的元素顺序。

numbers = [1, 2, 3]
numbers.reverse()
print(numbers)  # 输出：[3, 2, 1]

1.2.5 其他常用方法

copy()：返回列表的浅拷贝，创建一个新列表但元素引用相同。

original = [1, [2, 3]]
copy_list = original.copy()
copy_list[1][0] = 99
print(original)  # 输出：[1, [99, 3]]（注意嵌套列表的变化）

len(list)：返回列表的长度，即元素的个数。

fruits = ['apple', 'banana', 'cherry']
print(len(fruits))  # 输出：3

二、元组（Tuple）

2.1 基本定义

元组是不可变的、有序的数据结构，一旦创建就不能修改其元素。元组使用圆括号 () 定义，也可以不使用括号，直接用逗号分隔值。

2. 2 常用方法详解

2.2.1 访问元素

元组的元素可以通过索引访问，索引从 0 开始，也支持负数索引（从后往前数）

my_tuple = (1, 2, 'a', 'b')
print(my_tuple[0])    # 输出：1
print(my_tuple[-1])   # 输出：'b'

2.2.2 切片操作

可以使用切片获取元组的子元组，语法为 tuple[start:stop:step]。

my_tuple = (1, 2, 3, 4, 5)
print(my_tuple[1:3])    # 输出：(2, 3)
print(my_tuple[::2])    # 输出：(1, 3, 5)

2.2.3 内置函数

count(obj)：返回指定元素在元组中出现的次数。

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

index(obj[, start[, end]])：返回第一个匹配元素的索引，搜索范围可指定。

my_tuple = ('apple', 'banana', 'cherry')
print(my_tuple.index('banana'))  # 输出：1

len(tuple)：返回元组的长度。

my_tuple = (1, 2, 3)
print(len(my_tuple))  # 输出：3

三、字典（Dictionary）

3.1 基本定义

字典是 Python 中非常重要的映射类型数据结构，它是可变的、无序的（Python 3.7+ 后保持插入顺序）。字典由键值对组成，键必须是唯一且不可变的（如字符串、数字、元组），值可以是任意类型。字典使用花括号 {} 定义。

3.2 常用方法详解

3.2.1 访问元素

get(key[, default])：返回指定键的值，如果键不存在则返回默认值（默认值不指定时为 None）。

person = {'name': 'Alice', 'age': 25}
print(person.get('name'))        # 输出：'Alice'
print(person.get('city', 'N/A'))  # 输出：'N/A'

[] 语法：通过键访问值，如果键不存在会抛出 KeyError 异常。

person = {'name': 'Alice', 'age': 25}
print(person['age'])  # 输出：25

3.2.2 添加和修改元素

update([other])：用另一个字典的键值对更新当前字典，已有键会被覆盖，新键会被添加。

person = {'name': 'Alice', 'age': 25}
person.update({'city': 'Beijing', 'age': 26})
print(person)  # 输出：{'name': 'Alice', 'age': 26, 'city': 'Beijing'}

[] 语法：如果键不存在则添加新的键值对，存在则修改对应的值。

person = {'name': 'Alice'}
person['age'] = 25
person['name'] = 'Bob'
print(person)  # 输出：{'name': 'Bob', 'age': 25}

3.2.3 删除元素

pop(key[, default])：删除并返回指定键的值，如果键不存在且未提供默认值，则抛出 KeyError 异常。

person = {'name': 'Alice', 'age': 25}
age = person.pop('age')
print(age)      # 输出：25
print(person)   # 输出：{'name': 'Alice'}

popitem()：删除并返回字典中的最后一对键值（Python 3.7+ 后按插入顺序，之前是任意对）。

person = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}
item = person.popitem()
print(item)     # 输出：('city', 'Beijing')

clear()：清空字典中的所有键值对。

person = {'name': 'Alice'}
person.clear()
print(person)  # 输出：{}

3.2.4 视图对象

keys()：返回一个包含字典所有键的视图对象，可迭代。

person = {'name': 'Alice', 'age': 25}
print(person.keys())  # 输出：dict_keys(['name', 'age'])

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

person = {'name': 'Alice', 'age': 25}
print(person.values())  # 输出：dict_values(['Alice', 25])

items()：返回一个包含字典所有键值对的视图对象，每个键值对以元组形式存在。

person = {'name': 'Alice', 'age': 25}
print(person.items())  # 输出：dict_items([('name', 'Alice'), ('age', 25)])

3.2.5 其他常用方法

copy()：返回字典的浅拷贝，创建一个新字典但值的引用相同。

original = {'name': 'Alice', 'hobbies': ['reading', 'swimming']}
copy_dict = original.copy()
copy_dict['hobbies'].append('running')
print(original['hobbies'])  # 输出：['reading', 'swimming', 'running']（注意嵌套列表的变化）

len(dict)：返回字典中键值对的数量。

person = {'name': 'Alice', 'age': 25, 'city': 'Beijing'}
print(len(person))  # 输出：3

四、集合（Set）

4.1 基本定义

集合是无序的、可变的数据结构，元素具有唯一性，且必须是不可变类型（如数字、字符串、元组）。集合使用花括号 {} 或 set() 函数定义，但注意空集合必须用 set() 定义，因为 {} 定义的是空字典。

4.2 常用方法详解

4.2.1 添加元素

add(elem)：向集合中添加一个元素，如果元素已存在则不做任何操作。

my_set = {1, 2, 3}
my_set.add(4)
my_set.add(2)  # 不会报错，但集合中不会有重复的2
print(my_set)  # 输出：{1, 2, 3, 4}

update([iterable])：添加多个元素到集合中，参数可以是列表、元组、集合等可迭代对象。

my_set = {1, 2}
my_set.update([3, 4])
my_set.update({4, 5})  # 已有的4不会重复添加
print(my_set)  # 输出：{1, 2, 3, 4, 5}

4.2.2 删除元素

remove(elem)：删除集合中的指定元素，如果元素不存在则抛出 KeyError 异常。

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

discard(elem)：删除集合中的指定元素，如果元素不存在则不做任何操作。

my_set = {1, 2, 3}
my_set.discard(4)  # 不会报错
print(my_set)  # 输出：{1, 2, 3}

pop()：删除并返回集合中的任意一个元素，因为集合是无序的，所以无法确定会删除哪个元素。

my_set = {1, 2, 3}
item = my_set.pop()
print(item)     # 可能输出1、2或3中的任意一个
print(my_set)   # 输出删除一个元素后的集合

clear()：清空集合中的所有元素。

my_set = {1, 2}
my_set.clear()
print(my_set)  # 输出：set()

4.2.3 集合运算

union(*others)：返回多个集合的并集，即包含所有集合中所有不重复元素的新集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.union(set2))  # 输出：{1, 2, 3, 4, 5}

intersection(*others)：返回多个集合的交集，即只包含所有集合中共同元素的新集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.intersection(set2))  # 输出：{3}

difference(*others)：返回集合的差集，即只包含在当前集合中但不在其他集合中的元素的新集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.difference(set2))  # 输出：{1, 2}

symmetric_difference(other)：返回两个集合的对称差集，即只包含在其中一个集合中但不同时存在于两个集合中的元素的新集合。

set1 = {1, 2, 3}
set2 = {3, 4, 5}
print(set1.symmetric_difference(set2))  # 输出：{1, 2, 4, 5}

4.2.4 集合关系判断

issubset(other)：判断当前集合是否是另一个集合的子集，即当前集合的所有元素都在另一个集合中。

set1 = {1, 2}
set2 = {1, 2, 3}
print(set1.issubset(set2))  # 输出：True

issuperset(other)：判断当前集合是否是另一个集合的超集，即另一个集合的所有元素都在当前集合中。

set1 = {1, 2, 3}
set2 = {1, 2}
print(set1.issuperset(set2))  # 输出：True

isdisjoint(other)：判断两个集合是否没有交集，即它们没有共同的元素。

set1 = {1, 2}
set2 = {3, 4}
print(set1.isdisjoint(set2))  # 输出：True

4.2.5 其他常用方法

copy()：返回集合的浅拷贝，创建一个新集合但元素引用相同。

original = {1, 2, (3,)}
copy_set = original.copy()
print(copy_set)  # 输出：{1, 2, (3,)}

len(set)：返回集合中元素的数量

my_set = {1, 2, 3}
print(len(my_set))  # 输出：3

总结

通过本文的介绍，我们详细了解了 Python 中列表、元组、字典和集合这四种重要的数据结构及其常用方法。在实际编程中，根据具体的需求选择合适的数据结构，可以让我们的代码更加高效、简洁。希望大家通过本文的学习，能够熟练掌握这四种数据结构的使用，在 Python 编程的道路上更进一步。