数据大杂烩：探索Python数据容器的通用操作

素颜马尾好姑娘i 2024-03-23 19:51 50阅读 0赞

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

*  一 数据容器的对比总结
 *   *  1.1 容器简单分类
     *  1.2 容器特点对比
 *  二 数据容器的通用操作
 *   *  2.1 通用操作详解
     *  2.2 通用操作总结

## 一 数据容器的对比总结 ##

### 1.1 容器简单分类 ###

数据容器可以从以下视角进行简单的分类：

*  是否支持下标索引
    
     *  支持：**列表、元组、字符串** —— 序列类型
     *  不支持：**集合、字典** —— 非序列类型
 *  是否支持重复元素：
    
     *  支持：**列表、元组、字符串** —— 序列类型
     *  不支持：**集合、字典** —— 非序列类型
 *  是否可以修改
    
     *  支持：**列表、集合、字典**
     *  不支持：**元组、字符串**

### 1.2 容器特点对比 ###

<table> 
 <thead> 
  <tr> 
   <th></th> 
   <th>列表</th> 
   <th>元组</th> 
   <th>字符串</th> 
   <th>集合</th> 
   <th>字典</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>元素数量</td> 
   <td>支持多个</td> 
   <td>支持多个</td> 
   <td>支持多个</td> 
   <td>支持多个</td> 
   <td>支持多个</td> 
  </tr> 
  <tr> 
   <td>元素类型</td> 
   <td>任意</td> 
   <td>任意</td> 
   <td>仅字符</td> 
   <td>任意</td> 
   <td>Key: Value<br>Key：除字典外M任意类型<br>Value：任意类型</td> 
  </tr> 
  <tr> 
   <td>下标索引</td> 
   <td>支持</td> 
   <td>支持</td> 
   <td>支持</td> 
   <td>不支持</td> 
   <td>不支持</td> 
  </tr> 
  <tr> 
   <td>重复元素</td> 
   <td>支持</td> 
   <td>支持</td> 
   <td>支持</td> 
   <td>不支持</td> 
   <td>不支持</td> 
  </tr> 
  <tr> 
   <td>可修改性</td> 
   <td>支持</td> 
   <td>不支持</td> 
   <td>不支持</td> 
   <td>支持</td> 
   <td>支持</td> 
  </tr> 
  <tr> 
   <td>数据有序</td> 
   <td>是</td> 
   <td>是</td> 
   <td>是</td> 
   <td>否</td> 
   <td>否</td> 
  </tr> 
  <tr> 
   <td>使用场景</td> 
   <td>可修改、可重复的一批数据记录场景</td> 
   <td>不可修改、可重复的一批数据记录场景</td> 
   <td>一串字符的记录场景</td> 
   <td>不可重复的数据记录场景</td> 
   <td>以Key检索Value的数据记录场景</td> 
  </tr> 
 </tbody> 
</table>

## 二 数据容器的通用操作 ##

### 2.1 通用操作详解 ###

1.  **访问元素：**
    
     *  列表和元组：使用索引来访问单个元素，例如 `my_list[0]`。
     *  字典：通过键来访问对应的值，例如 `my_dict["key"]`。
    
        my_list = [1, 2, 3, 4, 5]
        my_tuple = (10, 20, 30, 40, 50)
        my_dict = {
              "a": 1, "b": 2, "c": 3}
        
        print(my_list[2])  # 输出: 3
        print(my_tuple[1])  # 输出: 20
        print(my_dict["b"])  # 输出: 2
2.  **切片操作：**
    
     *  列表和元组：使用切片语法来获取子序列，例如 `my_list[start:end]`。
     *  字符串：使用切片获取子字符串，例如 `my_string[start:end]`。
    
        my_list = [1, 2, 3, 4, 5]
        my_string = "Hello, World!"
        
        print(my_list[1:4])  # 输出: [2, 3, 4]
        print(my_string[7:12])  # 输出: World
3.  **遍历元素：**
    
     *  使用 `for` 循环遍历容器中的每个元素。
    
        my_set = {
              1, 2, 3, 4, 5}
        
        for item in my_set:
            print(item)
        # 输出:
        # 1
        # 2
        # 3
        # 4
        # 5
4.  **长度获取：**
    
     *  使用 `len()` 函数获取容器中元素的数量。
    
        my_list = [1, 2, 3, 4, 5]
        my_dict = {
              "a": 1, "b": 2, "c": 3}
        
        print(len(my_list))  # 输出: 5
        print(len(my_dict))  # 输出: 3
5.  **成员检查：**
    
     *  使用 `in` 关键字检查元素是否存在于容器中。
    
        my_list = [1, 2, 3, 4, 5]
        
        if 3 in my_list:
            print("3 exists in the list")
        # 输出: 3 exists in the list
6.  **连接/合并容器：**
    
     *  列表和元组：使用 `+` 运算符来连接或合并容器。
     *  字典：使用 `update()` 方法来合并字典。
    
        list1 = [1, 2, 3]
        list2 = [4, 5, 6]
        
        merged_list = list1 + list2
        print(merged_list)  # 输出: [1, 2, 3, 4, 5, 6]
7.  **复制容器：**
    
     *  使用 `copy()` 方法或切片来复制列表和元组。
     *  使用 `copy()` 方法复制集合。
     *  使用 `copy()` 方法或 `dict()` 构造函数复制字典。
    
        original_list = [1, 2, 3]
        copied_list = original_list.copy()
        
        print(copied_list)  # 输出: [1, 2, 3]
8.  **删除元素：**
    
     *  列表和元组：使用 `del` 语句来删除元素，例如 `del my_list[0]`。
     *  字典：使用 `del` 语句或 `pop()` 方法删除键值对。
    
        my_list = [1, 2, 3, 4, 5]
        del my_list[2]
        print(my_list)  # 输出: [1, 2, 4, 5]
9.  **清空容器：**
    
     *  使用 `clear()` 方法来清空列表、集合和字典。
    
        my_set = {
              1, 2, 3, 4, 5}
        my_set.clear()
        print(my_set)  # 输出: set()
10. **排序：**
    
     *  列表：使用 `sort()` 方法或 `sorted()`或者`sorted(容器, [reverse=True])` 函数来排序列表。
     *  集合：使用 `sorted()` 或者`sorted(容器, [reverse=True])` 函数对集合进行排序。
     *  排序后都会得到列表（list）对象。
    
        my_list = [3, 1, 4, 1, 5, 9, 2, 6]
        sorted_list = sorted(my_list)
        print(sorted_list)  # 输出: [1, 1, 2, 3, 4, 5, 6, 9]
11. **查找最值：**
    
     *  使用 `max()` 和 `min()` 函数来查找列表或元组中的最大和最小值。
    
        my_tuple = (10, 5, 8, 12, 3)
        max_value = max(my_tuple)
        min_value = min(my_tuple)
        
        print("Max:", max_value)  # 输出: Max: 12
        print("Min:", min_value)  # 输出: Min: 3
12. **列表推导、字典解析等：**
    
     *  利用列表推导来创建新的列表。
     *  使用字典解析来创建新的字典。
    
        my_list = [1, 2, 3, 4, 5]
        squared_list = [num ** 2 for num in my_list]
        print(squared_list)  # 输出: [1, 4, 9, 16, 25]
13. **转换为其他类型：**
    
     *  使用 `list()`, `tuple()`, `set()` 和 `dict()` 等构造函数来进行类型转换。
    
        my_tuple = (1, 2, 3)
        my_list = list(my_tuple)
        print(my_list)  # 输出: [1, 2, 3]
14. **添加/删除元素：**
    
     *  列表：使用 `append()`, `insert()` 和 `remove()` 方法来添加和删除元素。
     *  集合：使用 `add()` 和 `remove()` 方法来添加和删除元素。
     *  字典：使用赋值来新增或修改键值对，使用 `pop()` 方法删除键值对。

### 2.2 通用操作总结 ###

<table> 
 <thead> 
  <tr> 
   <th>操作</th> 
   <th>描述</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>访问元素</td> 
   <td>使用索引或键来访问容器中的元素。</td> 
  </tr> 
  <tr> 
   <td>切片操作</td> 
   <td>使用切片语法获取子序列或子字符串。</td> 
  </tr> 
  <tr> 
   <td>遍历元素</td> 
   <td>使用 <code>for</code> 循环遍历容器中的每个元素。</td> 
  </tr> 
  <tr> 
   <td>长度获取</td> 
   <td>使用 <code>len()</code> 函数获取容器中元素的数量。</td> 
  </tr> 
  <tr> 
   <td>成员检查</td> 
   <td>使用 <code>in</code> 关键字检查元素是否存在于容器中。</td> 
  </tr> 
  <tr> 
   <td>连接/合并容器</td> 
   <td>使用<code>+</code>运算符来连接或合并容器。</td> 
  </tr> 
  <tr> 
   <td>复制容器</td> 
   <td>使用 <code>copy()</code> 方法或切片来复制容器。</td> 
  </tr> 
  <tr> 
   <td>删除元素</td> 
   <td>使用 <code>del</code> 语句来删除容器中的元素。</td> 
  </tr> 
  <tr> 
   <td>清空容器</td> 
   <td>使用 <code>clear()</code> 方法来清空容器。</td> 
  </tr> 
  <tr> 
   <td>排序</td> 
   <td>使用 <code>sorted()</code> 函数来对容器进行排序。</td> 
  </tr> 
  <tr> 
   <td>查找最值</td> 
   <td>使用 <code>max()</code> 和 <code>min()</code> 函数来查找容器中的最大和最小值。</td> 
  </tr> 
  <tr> 
   <td>列表推导、字典解析等</td> 
   <td>利用推导式来创建新的容器。</td> 
  </tr> 
  <tr> 
   <td>转换为其他类型</td> 
   <td>使用构造函数来进行容器类型之间的转换。</td> 
  </tr> 
 </tbody> 
</table>