【Python】Python 之一些数据结构基本操作

---

前言

记录一些简单的python数据结构基本操作

推荐一个入门的 python 使用方法查阅的网站：
Python 3 菜鸟教程

Python 数据结构概述

1. 列表（List）
   描述：有序、可变的集合，可以包含不同类型的元素。
   特点：支持索引、切片、动态扩展，支持修改元素。
   创建：my_list = [1, 2, 3, ‘a’, ‘b’]
   常用操作：
   append(), extend(), insert()
   remove(), pop(), index()
   切片操作，例如：my_list[1:3]
2. 元组（Tuple）
   描述：有序、不可变的集合，常用于存储不需要修改的数据。
   特点：不支持修改元素，访问速度较快，适合存储常量数据。
   创建：my_tuple = (1, 2, 3)
   常用操作：
   索引访问、切片等，类似于列表，但不支持修改元素。
3. 字典（Dictionary）
   描述：无序的键值对集合（哈希表）。每个键是唯一的。
   特点：通过键来快速访问值，不支持重复键。
   创建：my_dict = {‘name’: ‘Alice’, ‘age’: 30}
   常用操作：
   get(), setdefault(), keys(), values(), items()
   del 或 pop() 删除元素
4. 集合（Set）
   描述：无序、不可重复的集合。通常用于去重和集合运算。
   特点：不包含重复元素，不支持索引。
   创建：my_set = {1, 2, 3, 4}
   常用操作：
   add(), remove(), discard()
   集合运算：union(), intersection(), difference(), issubset()
5. 队列（Queue）
   描述：按顺序处理元素的数据结构，遵循“先进先出”（FIFO）原则。
   实现：可以使用 collections.deque 或 queue.Queue 来实现队列。
   常用操作：
   append() 用于入队，popleft() 用于出队
   queue.Queue 支持线程安全的队列操作
6. 栈（Stack）
   描述：按照“后进先出”（LIFO）原则处理元素的数据结构。
   实现：可以使用列表来实现栈（append() 和 pop()），或使用 collections.deque。
   常用操作：
   append() 入栈，pop() 出栈
7. 有序字典（OrderedDict）
   描述：OrderedDict 是 collections 模块中的一种字典，它保持元素的插入顺序。
   特点：不像普通字典那样无序，它会记住元素的添加顺序。
   创建：from collections import OrderedDict
   my_ordered_dict = OrderedDict([(‘a’, 1), (‘b’, 2)])
8. 链表（LinkedList）
   描述：链表是一种由节点组成的线性数据结构，每个节点包含数据和指向下一个节点的引用。
   实现：Python 标准库没有直接实现链表，但可以通过类和对象手动实现。
9. 堆（Heap）
   描述：堆是一种特殊的树状数据结构，可以实现优先队列。
   实现：可以使用 heapq 模块来实现最小堆。
   常用操作：
   heapq.heappush(), heapq.heappop(), heapq.heapify()
10. 双端队列（Deque）
    描述：deque 是双端队列（Double-Ended Queue）的缩写，允许从队列两端添加或删除元素。
    实现：collections.deque
    常用操作：
    append(), appendleft(), pop(), popleft()
11. 字符串（String）
    描述：字符串是字符的序列，可以像列表一样进行索引和切片操作，且不可变。
    特点：在内存中是不可变的，每个操作都会创建一个新的字符串。
    创建：my_string = “Hello”
    常用操作：
    字符串拼接、查找、替换等，例如：replace(), find(), split()
12. 默认字典（defaultdict）
    描述：defaultdict 是 collections 模块提供的字典子类，它允许你在访问不存在的键时返回默认值。
    创建：from collections import defaultdict
    my_dict = defaultdict(int) # 默认值是0
    常用操作：
    访问时，如果键不存在，会自动使用提供的默认工厂函数来生成默认值。
13. 计数器（Counter）
    描述：Counter 是 collections 模块提供的一个特殊字典，用于计数集合中每个元素的出现次数。
    创建：from collections import Counter
    my_counter = Counter([‘apple’, ‘banana’, ‘apple’, ‘orange’])
    常用操作：
    most_common(), elements()

虽然上面看起来很多，但实际上常用的也就下面几种：
字符串（String）、列表（List）、元组（Tuple）、字典（Dictionary）、集合（Set）
其他的数据结构一般也能通过上面这些实现

列表

添加符合要求的元素

1. append() 方法将元素添加到列表的末尾：

my_list = [1, 2, 3]
my_list.append(4)
print(my_list)  # 输出: [1, 2, 3, 4]

2. insert(index, value) 方法在指定位置 index 插入元素。注意，index 不能超过列表的长度。

my_list = [1, 2, 3]
my_list.insert(1, 1.5)  # 在索引1的位置插入1.5
print(my_list)  # 输出: [1, 1.5, 2, 3]

3. 可以使用切片来在指定位置插入一个或多个元素：

my_list = [1, 2, 3]
my_list[1:1] = [1.5, 1.7]  # 在索引1的位置插入1.5和1.7
print(my_list)  # 输出: [1, 1.5, 1.7, 2, 3]

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

my_list = [1, 2, 3]
my_list.extend([4, 5])
print(my_list)  # 输出: [1, 2, 3, 4, 5]

• append()：在列表末尾添加元素是 O(1) 操作，因此非常高效。
• insert()：在列表中间插入元素可能需要移动其他元素，所以时间复杂度是 O(n)，尤其是对于大列表，可能较慢。
• 切片操作：在指定位置插入多个元素时也会涉及到移动元素，因此在处理大型列表时可能比 append() 慢。
• extend()：将一个可迭代对象添加到列表末尾是 O(k) 操作，其中 k 是被添加的元素数量，比逐个使用 append() 添加元素效率更高。

删除符合要求的元素

1. 使用列表推导式来创建一个不包含偶数的新列表

my_list = [1, 2, 3, 4, 5, 6]
my_list = [x for x in my_list if x % 2 != 0]

2. 使用 list 的 remove 方法和循环来直接修改原列表

my_list = [1, 2, 3, 4, 5, 6]
i = 0
while i < len(my_list):
    if my_list[i] % 2 == 0:
        my_list.pop(i)
    else:
        i += 1

---

字典

添加键值对

1. 使用赋值操作：

my_dict = {'a': 1, 'b': 2}
my_dict['c'] = 3
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3}

2. 使用 update() 方法：

my_dict = {'a': 1, 'b': 2}
my_dict.update({'c': 3, 'd': 4})
print(my_dict)  # 输出: {'a': 1, 'b': 2, 'c': 3, 'd': 4}

添加键值对：append() 和 update() 都是高效的，时间复杂度是 O(1)。update() 适用于一次添加多个键值对。

删除键值对

1. 使用 del 关键字：

my_dict = {'a': 1, 'b': 2, 'c': 3}
del my_dict['b']
print(my_dict)  # 输出: {'a': 1, 'c': 3}

2. 使用 pop() 方法：

my_dict = {'a': 1, 'b': 2, 'c': 3}
value = my_dict.pop('b')
print(my_dict)  # 输出: {'a': 1, 'c': 3}
print(value)    # 输出: 2

3. 使用 popitem() 方法（删除并返回最后一个插入的键值对）：

my_dict = {'a': 1, 'b': 2, 'c': 3}
key, value = my_dict.popitem()
print(my_dict)  # 输出: {'a': 1, 'b': 2}
print(key, value)  # 输出: 'c' 3

删除键值对：
del 和 pop() 都有 O(1) 时间复杂度，pop() 还返回删除的值。
popitem() 也是 O(1) 时间复杂度，但只适用于删除最后一个插入的项。

查找键值对

1. 查找键对应的值
   可以通过键来查找对应的值。如果键存在，返回对应的值；如果键不存在，会抛出 KeyError 异常。

my_dict = {'name': 'Alice', 'age': 25, 'city': 'New York'}

# 查找键 'name' 对应的值
value = my_dict['name']
print(value)  # 输出: Alice

2. 使用 get() 方法查找
   get() 方法可以安全地查找键对应的值。如果键存在，返回对应的值；如果键不存在，返回 None 或者指定的默认值

# 查找键 'name' 对应的值
value = my_dict.get('name')
print(value)  # 输出: Alice

# 查找不存在的键，返回 None
value = my_dict.get('gender')
print(value)  # 输出: None

# 查找不存在的键，返回指定的默认值
value = my_dict.get('gender', 'Unknown')
print(value)  # 输出: Unknown

3. 检查键是否存在
   你可以使用 in 关键字来检查某个键是否存在于字典中。

# 检查键 'name' 是否存在
if 'name' in my_dict:
    print("Key 'name' exists")  # 输出: Key 'name' exists

# 检查键 'gender' 是否存在
if 'gender' not in my_dict:
    print("Key 'gender' does not exist")  # 输出: Key 'gender' does not exist

此外
当你需要统计某些元素的频率时，可以使用 get(x, 0) 来初始化不存在的键的值为 0，然后进行累加。
通过 get(x, 0) 可以初始化原本不存在的键为一个默认值

words = ['apple', 'banana', 'apple', 'orange', 'banana', 'apple']
word_count = {}

for word in words:
    word_count[word] = word_count.get(word, 0) + 1

print(word_count)
# 输出: {'apple': 3, 'banana': 2, 'orange': 1}

---

总结

后期将持续更新记录…