【Python】基础数据结构：列表——元组——字典——集合

今天药忘吃喽~ 2024-03-23 19:06 19阅读 0赞

#### 文章目录 ####

*  一、简述
 *  二、Python中的列表详解
 *   *  2.1 创建列表
     *  2.2 访问列表元素
     *  2.3 修改列表元素
     *  2.4 列表切片
     *  2.5 列表方法
     *  2.6 列表推导式
 *  三、Python中的元组详解
 *   *  3.1 创建元组
     *  3.2 访问元组元素
     *  3.3 元组是不可变的
     *  3.4 元组切片
     *  3.5 元组方法
 *  四、Python中的字典详解
 *   *  4.1 创建字典
     *  4.2 访问字典元素
     *  4.3 修改字典元素
     *  4.4 字典方法
 *  五、Python中的集合详解
 *   *  5.1 创建集合
     *  5.2 集合的基本操作
     *  5.3 集合的数学运算
     *  5.4 集合的应用

## 一、简述 ##

Python提供了多种内置的数据结构，包括列表（`List`）、元组（`Tuple`）和字典（`Dictionary`）。这些数据结构在Python编程中都有着广泛的应用，但它们各有特点和适用场景。

*  **列表是一种有序的集合，可以随时添加和删除其中的元素。列表是可变的，也就是说，你可以修改列表的元素和大小。列表的元素可以是任何类型，包括数字、字符串、布尔值，甚至可以是其他列表。列表通常用于存储有序的元素集合，例如一列数字或一组名字。**
 *  **元组和列表非常相似，但元组是不可变的，也就是说，你不能修改元组的元素和大小。这使得元组比列表更安全，因为你可以确保元组的元素在程序运行过程中不会被改变。元组通常用于存储不应该被改变的数据集，例如一个日期或一个地理位置的经纬度。**
 *  **字典是一种无序的集合，它存储的是键值对。字典的键必须是唯一的，而值可以是任何类型。字典是可变的，也就是说，你可以添加、删除和修改字典的键值对。字典通常用于存储和查找键值对，例如一个电话簿或一个词频统计。**（哈希表）
 *  **集合是一个无序的，不重复的元素集。基本功能包括关系测试和消除重复元素。集合对象还支持union（联合），intersection（交），difference（差）和symmetric difference（对称差集）等数学运算**。

**对比**

*  列表和元组都是**有序**的集合，它们的主要区别在于列表是**可变**的，而元组是**不可变**的。这意味着如果你需要一个可以随时添加、删除和修改元素的集合，你应该使用列表；如果你需要一个一旦创建就不能更改的集合，你应该使用元组。
 *  字典和列表、元组的主要区别在于字典是**无序**的，而且它存储的是键值对而不是单个的元素。这使得字典在处理需要**键值对**的数据时非常有用，例如在查找元素时，字典的查找速度通常比列表和元组快。
 *  集合和列表、元组、字典的主要区别在于集合是**无序**的，**不重复**的元素集。这使得集合在处理需要元素唯一性和集合操作的场合下非常有用，例如在查找元素时，集合的查找速度通常比列表快。  
    ![在这里插入图片描述][9e875609af5f4887bdce91784ad1d367.png]

## 二、Python中的列表详解 ##

Python中的列表（List）是一种常用的数据结构，它可以存储一系列有序的元素。列表是可变的，这意味着你可以在创建列表后添加、删除或更改其元素。列表中的元素可以是任何类型，包括数字、字符串、布尔值，甚至可以是其他列表。

### 2.1 创建列表 ###

创建列表非常简单，只需要将元素放在方括号`[]`中，并用逗号`,`分隔。例如：

my_list = [1, 2, 3, 'apple', 'banana', True]

在上面的例子中，`my_list`就是一个包含了三个整数、两个字符串和一个布尔值的列表。

### 2.2 访问列表元素 ###

你可以通过索引来访问列表中的元素。在Python中，索引是从0开始的。例如，要访问上面列表中的第一个元素，你可以这样做：

first_item = my_list[0]  # first_item 现在是 1

你也可以使用负索引来从列表的末尾开始访问元素。例如，`my_list[-1]`将返回列表中的最后一个元素。

### 2.3 修改列表元素 ###

由于列表是可变的，你可以通过索引来修改列表中的元素。例如：

my_list[0] = 'orange'  # my_list 现在是 ['orange', 2, 3, 'apple', 'banana', True]

### 2.4 列表切片 ###

切片是一种获取列表子集的方法。你可以通过指定开始索引和结束索引来获取一个新的列表。例如：

sub_list = my_list[1:4]  # sub_list 现在是 [2, 3, 'apple']

注意，切片是左闭右开的，也就是说，返回的新列表包含开始索引的元素，但不包含结束索引的元素。

### 2.5 列表方法 ###

Python的列表提供了许多方法，如`append()`、`insert()`、`remove()`、`pop()`、`sort()`等。这些方法可以让你更方便地操作列表。

例如，`append()`方法可以在列表的末尾添加一个新的元素：

my_list.append('grape')  # my_list 现在是 ['orange', 2, 3, 'apple', 'banana', True, 'grape']

`remove()`方法可以删除列表中的特定元素：

my_list.remove('banana')  # my_list 现在是 ['orange', 2, 3, 'apple', True, 'grape']

### 2.6 列表推导式 ###

列表推导式是Python中创建列表的一种简洁方式。它可以用一行代码生成一个新的列表。例如，下面的代码生成了一个包含1到10的平方的列表：

squares = [x**2 for x in range(1, 11)]  # squares 是 [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

## 三、Python中的元组详解 ##

Python中的元组（Tuple）是一种常用的数据结构，它可以存储一系列有序的元素。元组和列表非常相似，但有一个关键的区别：元组是不可变的，这意味着你不能在创建元组后添加、删除或更改其元素。元组中的元素可以是任何类型，包括数字、字符串、布尔值，甚至可以是其他元组或列表。

### 3.1 创建元组 ###

创建元组非常简单，只需要将元素放在圆括号`()`中，并用逗号`,`分隔。例如：

my_tuple = (1, 2, 3, 'apple', 'banana', True)

在上面的例子中，`my_tuple`就是一个包含了三个整数、两个字符串和一个布尔值的元组。

注意，如果你要创建一个只包含一个元素的元组，你需要在元素后面添加一个逗号，例如`my_tuple = (1,)`。

### 3.2 访问元组元素 ###

你可以通过索引来访问元组中的元素。在Python中，索引是从0开始的。例如，要访问上面元组中的第一个元素，你可以这样做：

first_item = my_tuple[0]  # first_item 现在是 1

你也可以使用负索引来从元组的末尾开始访问元素。例如，`my_tuple[-1]`将返回元组中的最后一个元素。

### 3.3 元组是不可变的 ###

一旦元组被创建，你就不能更改它的元素或大小。这意味着你不能像列表那样添加、删除或修改元组的元素。如果你尝试这样做，Python将引发错误。

my_tuple[0] = 'orange'  # 这将引发错误

尽管元组本身是不可变的，但如果元组中的元素是可变的（如列表），那么你可以修改这些元素。

### 3.4 元组切片 ###

切片是一种获取元组子集的方法。你可以通过指定开始索引和结束索引来获取一个新的元组。例如：

sub_tuple = my_tuple[1:4]  # sub_tuple 现在是 (2, 3, 'apple')

注意，切片是左闭右开的，也就是说，返回的新元组包含开始索引的元素，但不包含结束索引的元素。

### 3.5 元组方法 ###

由于元组是不可变的，所以它的方法比列表少。Python的元组只提供了两个方法：`count()`和`index()`。`count()`方法用于计算元组中特定元素的数量，`index()`方法用于找到元组中特定元素的第一个匹配项的索引。

my_tuple = (1, 2, 3, 2, 2, 4)
    count = my_tuple.count(2)  # count 现在是 3
    index = my_tuple.index(2)  # index 现在是 1

## 四、Python中的字典详解 ##

Python中的字典（Dictionary）是一种非常重要的数据结构，它存储的是键值对（key-value pairs）。字典是可变的，这意味着你可以在创建字典后添加、删除或更改其键值对。字典的键和值可以是任何类型，包括数字、字符串、布尔值，甚至可以是其他字典或列表。

### 4.1 创建字典 ###

创建字典非常简单，只需要将键值对放在大括号`{}`中，并用逗号`,`分隔。每个键值对中的键和值用冒号`:`分隔。例如：

my_dict = {
        'name': 'Alice', 'age': 20, 'is_student': True}

在上面的例子中，`my_dict`就是一个包含了三个键值对的字典。

### 4.2 访问字典元素 ###

你可以通过键来访问字典中的值。例如，要访问上面字典中的’name’键对应的值，你可以这样做：

name = my_dict['name']  # name 现在是 'Alice'

如果你尝试访问字典中不存在的键，Python将引发`KeyError`。为了避免这种错误，你可以使用`get()`方法来访问字典中的值，如果键不存在，`get()`方法将返回`None`或者你指定的默认值。

city = my_dict.get('city', 'New York')  # city 现在是 'New York'

### 4.3 修改字典元素 ###

你可以通过键来修改字典中的值。例如：

my_dict['age'] = 21  # my_dict 现在是 {'name': 'Alice', 'age': 21, 'is_student': True}

你也可以使用`update()`方法来一次更新字典中的多个键值对。

my_dict.update({
        'age': 22, 'city': 'London'})  # my_dict 现在是 {'name': 'Alice', 'age': 22, 'is_student': True, 'city': 'London'}

### 4.4 字典方法 ###

Python的字典提供了许多方法，如`keys()`、`values()`、`items()`、`pop()`、`clear()`等。这些方法可以让你更方便地操作字典。

例如，`keys()`方法可以返回字典中所有的键，`values()`方法可以返回字典中所有的值，`items()`方法可以返回字典中所有的键值对：

keys = my_dict.keys()  # keys 现在是 dict_keys(['name', 'age', 'is_student', 'city'])
    values = my_dict.values()  # values 现在是 dict_values(['Alice', 22, True, 'London'])
    items = my_dict.items()  # items 现在是 dict_items([('name', 'Alice'), ('age', 22), ('is_student', True), ('city', 'London')])

`pop()`方法可以删除并返回字典中特定键的值，`clear()`方法可以清空字典：

age = my_dict.pop('age')  # age 现在是 22，my_dict 现在是 {'name': 'Alice', 'is_student': True, 'city': 'London'}
    my_dict.clear()  # my_dict 现在是 {}

## 五、Python中的集合详解 ##

Python中的集合（Set）是一种独特的数据结构，它提供了一种有效的方式来处理数据的唯一性和集合操作。集合是无序的，不重复的元素集，这意味着集合中的元素是唯一的，且不保证插入顺序。

### 5.1 创建集合 ###

创建集合非常简单，只需要将元素放在大括号`{}`中，并用逗号`,`分隔。例如：

my_set = {
        1, 2, 3, 'apple', 'banana', True}

在上面的例子中，`my_set`就是一个包含了三个整数、两个字符串和一个布尔值的集合。

注意，如果你要创建一个空集合，你需要使用`set()`函数，而不是空的大括号，因为空的大括号`{}`在Python中表示一个空字典。

empty_set = set()  # 创建一个空集合

### 5.2 集合的基本操作 ###

集合提供了一系列的基本操作，包括添加元素、删除元素和检查元素是否存在。

my_set = {
        1, 2, 3}
    
    my_set.add(4)  # my_set 现在是 {1, 2, 3, 4}
    my_set.remove(1)  # my_set 现在是 {2, 3, 4}
    print(2 in my_set)  # 输出 True

### 5.3 集合的数学运算 ###

集合支持一些常见的数学运算，如并集、交集、差集和对称差集。

set1 = {
        1, 2, 3, 4}
    set2 = {
        3, 4, 5, 6}
    
    print(set1.union(set2))  # 输出 {1, 2, 3, 4, 5, 6}
    print(set1.intersection(set2))  # 输出 {3, 4}
    print(set1.difference(set2))  # 输出 {1, 2}
    print(set1.symmetric_difference(set2))  # 输出 {1, 2, 5, 6}

### 5.4 集合的应用 ###

由于集合中的元素是唯一的，所以集合常常被用来去除列表中的重复元素。

my_list = [1, 2, 2, 3, 3, 3]
    my_set = set(my_list)  # my_set 现在是 {1, 2, 3}

集合也常常被用在成员测试中，因为在集合中查找元素通常比在列表中查找元素更快。

my_set = {
        1, 2, 3, 4, 5}
    print(3 in my_set)  # 输出 True

--------------------

把 永 远 爱 你 写 进 诗 的 结 尾 ~

[9e875609af5f4887bdce91784ad1d367.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/14/8825620c9dcd4f3c989dc8b26bb8818e.png