【python】列表、元组、字典和集合的详细解释

叶阿猪

已于 2024-05-28 21:08:23 修改

阅读量1k

点赞数 31

分类专栏： python 文章标签：开发语言 python

于 2024-05-28 12:45:53 首次发布

本文链接：https://blog.csdn.net/MAOZI8/article/details/139263620

版权

python 专栏收录该内容

64 篇文章 1 订阅

订阅专栏

本文是对Python中列表、元组、字典和集合的详细解释，包括定义、常用方法、示例和注意情况。

一. 列表（List）

定义：
列表是Python中可变的有序序列。列表可以包含任意类型的元素，元素之间用逗号分隔，整个列表由方括号[]包围。

常用方法：

append(x)：在列表末尾添加元素x。
insert(i, x)：在索引i处插入元素x。
remove(x)：移除列表中第一个出现的元素x。
pop([i])：移除并返回索引i处的元素，默认移除最后一个。
index(x)：返回元素x在列表中第一次出现的索引。
count(x)：返回元素x在列表中出现的次数。
sort()：对列表进行排序（就地排序）。

示例：

my_list = [1, 2, 3, 4]
my_list.append(5)  # my_list现在是[1, 2, 3, 4, 5]
my_list.insert(1, 'a')  # my_list现在是[1, 'a', 2, 3, 4, 5]

注意情况：

列表是可变的，可以修改列表中的元素。
列表的索引从0开始。

二. 元组（Tuple）

定义：
元组与列表类似，但是元组是不可变的。元组用圆括号()包围（但也可以省略）。

常用方法：

由于元组是不可变的，所以没有修改元素的方法。
可以使用索引和切片操作来访问元素。

示例：

my_tuple = (1, 2, 3, 4)
# 无法修改元组内的元素，例如my_tuple[0] = 0将会报错

注意情况：

元组是不可变的，一旦创建就不能修改。
由于元组是不可变的，所以它们在某些需要不可变性的场合（如作为字典的键或作为集合的元素）中非常有用。

三. 列表（List）和元组（Tuple）的主要区别

可变性：
- 列表（List）是可变的（mutable），意味着你可以修改列表中的元素，包括添加、删除或修改列表中的元素。
- 元组（Tuple）是不可变的（immutable），一旦元组被创建，你就不能修改它的内容。尝试修改元组中的元素会引发TypeError。
语法：
- 列表用方括号[]定义，如my_list = [1, 2, 3]。
- 元组用圆括号()定义，如my_tuple = (1, 2, 3)。但注意，只有一个元素的元组需要在元素后添加一个逗号，如(1,)，否则它会被解释为整数或表达式的一部分。
性能：
- 由于元组是不可变的，因此它们在处理时通常比列表更快，因为Python不需要在每次修改时重新分配内存。
- 列表在需要频繁修改时更合适，因为它们提供了更多的灵活性。
用途：
- 由于元组是不可变的，它们经常用于表示不应该改变的值或一组值，例如，坐标、星期。
- 列表则常用于表示可变的数据集，如用户的购物车项目或任务列表。
作为字典的键和集合的元素：
- 元组由于其不可变性，可以用作字典的键或集合的元素。
- 列表由于其可变性，不能用作字典的键或集合的元素。

如果你需要一个不可变的序列类型，应该使用元组；如果你需要一个可变的序列类型，应该使用列表。

四.列表（List）和元组（Tuple）共同点

1. 索引（Indexing）： 通过索引访问序列中的元素。

索引用于访问序列（如列表或元组）中的单个元素。在Python中，索引是从0开始的，也就是说，第一个元素的索引是0，第二个元素的索引是1，依此类推。

示例：

# 列表索引  
my_list = ['apple', 'banana', 'cherry', 'date']  
print(my_list[0])  # 输出: 'apple'（第一个元素）  
print(my_list[2])  # 输出: 'cherry'（第三个元素）  
  
# 元组索引  
my_tuple = ('apple', 'banana', 'cherry', 'date')  
print(my_tuple[1])  # 输出: 'banana'（第二个元素）

2. 切片（Slicing）： 返回序列的一个子序列。

切片用于访问序列的一部分，通过指定开始和结束的索引（不包括结束索引）来选取子序列。切片的基本语法是sequence[start:stop:step]，其中start是起始索引，stop是停止索引，step是步长（默认为1）。

示例：

# 列表切片  
my_list = ['apple', 'banana', 'cherry', 'date', 'elderberry']  
  
# 获取前三个元素  
print(my_list[:3])  # 输出: ['apple', 'banana', 'cherry']  
  
# 从索引2开始到索引4（不包括）的元素  
print(my_list[2:4])  # 输出: ['cherry', 'date']  
  
# 每隔一个元素取一个（步长为2）  
print(my_list[::2])  # 输出: ['apple', 'cherry', 'elderberry']  
  
# 反转列表（步长为-1）  
print(my_list[::-1])  # 输出: ['elderberry', 'date', 'cherry', 'banana', 'apple']  
  
# 元组切片（与列表相同）  
my_tuple = ('apple', 'banana', 'cherry', 'date', 'elderberry')  
print(my_tuple[1:4])  # 输出: ('banana', 'cherry', 'date')

在切片中，如果省略了start，则默认为0；如果省略了stop，则默认为序列的长度；如果省略了step，则默认为1。注意，切片操作返回的是原序列的一个子序列，而不是对原序列的修改。

另外，切片操作在列表和元组上是完全相同的，因为切片返回的都是一个新的序列（对于列表，是列表的一个新子列表；对于元组，是元组的一个新子元组）。原始序列不会被改变。

3. 长度（Length）： 返回序列的元素个数。

示例：

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)

print(len(my_list))  # 输出: 5
print(len(my_tuple))  # 输出: 5

4. 连接（Concatenation）： 使用+操作符连接两个序列。

示例：

my_list = [1, 2, 3]
my_tuple = (4, 5, 6)

print(my_list + [7, 8])  # 输出: [1, 2, 3, 7, 8]
# 注意：元组与列表连接后，结果类型将是列表
print(my_tuple + (7, 8))  # TypeError: can only concatenate tuple (not "list") to tuple
# 如果要连接元组，则必须确保都是元组
print(my_tuple + (7, 8))  # 输出: (4, 5, 6, 7, 8)

5. 重复（Repetition）： 使用*操作符重复序列多次。

示例：

my_list = [1, 2, 3]
my_tuple = (1, 2, 3)

print(my_list * 2)  # 输出: [1, 2, 3, 1, 2, 3]
print(my_tuple * 2)  # 输出: (1, 2, 3, 1, 2, 3)

6. 成员资格（Membership）： 使用in关键字检查元素是否存在于序列中。

示例：

my_list = [1, 2, 3, 4, 5]
my_tuple = (1, 2, 3, 4, 5)

print(3 in my_list)  # 输出: True
print(3 in my_tuple)  # 输出: True

7. 计数（Count）： 使用count()方法计算元素在序列中出现的次数。

示例：

my_list = [1, 2, 2, 3, 2]
my_tuple = (1, 2, 2, 3, 2)

print(my_list.count(2))  # 输出: 3
print(my_tuple.count(2))  # 输出: 3

8. 索引位置（Index）： 使用index()方法查找元素在序列中首次出现的位置。

示例：

my_list = [1, 2, 3, 4, 2]
my_tuple = (1, 2, 3, 4, 2)

print(my_list.index(2))  # 输出: 1
print(my_tuple.index(2))  # 输出:

五. 字典（Dictionary）

定义：
字典是Python中无序的键值对集合。键是唯一的，值可以是任意类型。字典用大括号{}包围。

常用方法：

keys()：返回字典中所有的键。
values()：返回字典中所有的值。
items()：返回字典中所有的键值对。
get(key[, default])：返回指定键的值，如果键不存在则返回默认值。

示例：

my_dict = {"name": "Alice", "age": 15}
print(my_dict["name"])  # 输出"Alice"
print(my_dict.get("age", 20))  # 输出15，因为age键存在，所以返回其值
print(my_dict.get("class", "Unknown"))  # 输出"Unknown"，因为class键不存在

注意情况：

字典的键必须是不可变类型（如整数、浮点数、字符串、元组等）。
字典是无序的，即元素的插入顺序和遍历顺序可能不一致。

六. 集合（Set）

定义：
集合是一个无序且不包含重复元素的元素集合。集合用大括号{}或set()函数创建。

常用方法：

add(x)：向集合中添加元素x。
remove(x)：从集合中移除元素x（如果元素不存在则触发KeyError）。
discard(x)：从集合中移除元素x（如果元素不存在则不触发任何异常）。
pop()：随机移除并返回集合中的一个元素（如果集合为空则触发KeyError）。
union(other)：返回两个集合的并集。

示例：

my_set = {1, 2, 3}
my_set.add(4)  # my_set现在是{1, 2, 3, 4}
my_set.discard(3)  # my_set现在是{1, 2, 4}

注意情况：

集合中的元素必须是不可变的。
集合是无序的，不保证元素的插入顺序。
集合中的元素是唯一的，不能包含重复元素。
集合不支持索引操作，因为集合本质上是一个哈希表，和列表不一样。

集合和字典的区别

存储方式：

集合只存储元素本身。
字典存储键值对，每个键都映射到一个值。

元素唯一性：

集合中的元素是唯一的。
字典中的键是唯一的，但值可以重复。

操作：

集合支持集合运算，如并集、交集、差集等。
字典支持通过键来访问、修改和删除值。

用途：

集合主要用于成员关系测试和消除重复元素。
字典主要用于存储具有唯一标识符的数据项，并快速根据键找到对应的值。

语法：

集合使用大括号{}或set()函数创建，元素之间用逗号分隔。
字典也使用大括号{}创建，但包含键值对，键值对之间用逗号分隔，键和值之间用冒号:分隔。

性能：

由于字典是基于哈希表实现的，因此通过键访问值的操作通常非常快。
集合也基于哈希表，因此成员关系测试也很快。

可变性：

集合和字典都是可变的，但它们的可变性体现在不同的操作上。集合可以添加和删除元素，而字典可以添加、修改和删除键值对。