## 一、二叉树遍历基础概念

二叉树的遍历是指按照某种顺序访问二叉树中的每个节点，且每个节点仅访问一次。常见的遍历方式包括**前序遍历**、**中序遍历**和**后序遍历**，其核心区别在于根节点、左子树和右子树的访问顺序。



| 遍历类型 | 访问顺序          | 适用场景                     |
|----------|-------------------|------------------------------|
| 前序遍历 | 根节点 → 左子树 → 右子树 | 树的创建、表达式求值前缀表示 |
| 中序遍历 | 左子树 → 根节点 → 右子树 | 表达式求值中缀表示、排序二叉树遍历 |
| 后序遍历 | 左子树 → 右子树 → 根节点 | 释放树资源、表达式求值后缀表示 |


```mermaid
graph TD
Start --> Stop
```

## 二、递归实现
递归实现基于二叉树的递归定义，代码简洁直观，利用函数调用栈自动管理遍历顺序。以下以Python语言为例：
```python
class TreeNode:
    def __init__(self, val=0, left=None, right=None):
        self.val = val
        self.left = left
        self.right = right

# 前序遍历递归实现
def preorderTraversal_recursive(root):
    if not root:
        return []
    return [root.val] + preorderTraversal_recursive(root.left) + preorderTraversal_recursive(root.right)

# 中序遍历递归实现
def inorderTraversal_recursive(root):
    if not root:
        return []
    return inorderTraversal_recursive(root.left) + [root.val] + inorderTraversal_recursive(root.right)

# 后序遍历递归实现
def postorderTraversal_recursive(root):
    if not root:
        return []
    return postorderTraversal_recursive(root.left) + postorderTraversal_recursive(root.right) + [root.val]
```

## 三、非递归实现
非递归实现需手动维护一个栈（Stack）来模拟递归调用栈，更适合理解遍历的底层逻辑，同时可避免递归深度过大导致的栈溢出问题。

### 1. 前序遍历非递归
前序遍历非递归需先将根节点入栈，每次弹出节点并访问，再将其右子节点和左子节点依次入栈（确保左子树优先访问）。
```python
def preorderTraversal_iterative(root):
    if not root:
        return []
    stack, result = [root], []
    while stack:
        node = stack.pop()
        result.append(node.val)
        if node.right:
            stack.append(node.right)
        if node.left:
            stack.append(node.left)
    return result
```

### 2. 中序遍历非递归
中序遍历需优先遍历到最左侧叶子节点，再依次回溯访问根节点和右子树。
```python
def inorderTraversal_iterative(root):
    if not root:
        return []
    stack, result = [], []
    current = root
    while current or stack:
        while current:
            stack.append(current)
            current = current.left
        current = stack.pop()
        result.append(current.val)
        current = current.right
    return result
```

### 3. 后序遍历非递归
后序遍历非递归实现较为复杂，可采用两个栈：第一个栈存储节点，第二个栈存储后序遍历结果，最终反转第二个栈得到顺序结果。
```python
def postorderTraversal_iterative(root):
    if not root:
        return []
    stack1, stack2 = [root], []
    while stack1:
        node = stack1.pop()
        stack2.append(node.val)
        if node.left:
            stack1.append(node.left)
        if node.right:
            stack1.append(node.right)
    return stack2[::-1]
```


## 四、性能分析
| 遍历方式 | 时间复杂度 | 空间复杂度（递归） | 空间复杂度（非递归） |
|----------|------------|--------------------|----------------------|
| 前序遍历 | O(n)       | O(h)（h为树高）   | O(n)                 |
| 中序遍历 | O(n)       | O(h)               | O(n)                 |
| 后序遍历 | O(n)       | O(h)               | O(n)                 |

- **时间复杂度**：所有遍历方式均需访问每个节点一次，时间复杂度为O(n)，n为节点数。
- **空间复杂度**：递归实现受树高影响（最坏情况为O(n)，平衡树为O(log n)），非递归实现依赖栈，最坏情况下栈中需存储所有节点，为O(n)。


## 五、总结
1. **递归实现**：代码简洁，适合简单场景，但可能存在栈溢出风险。
2. **非递归实现**：手动管理栈，灵活性强，适用于复杂场景或对内存控制要求高的场景。
3. **应用场景**：根据具体需求选择遍历方式，如中序遍历常用于二叉搜索树的有序输出，后序遍历常用于释放树资源。

通过对比递归与非递归实现，能更深入理解二叉树遍历的本质，同时提升算法设计与代码优化能力。

二叉树的前中后序遍历

> 使用SPDK NVMe of RDMA 实现多NVMe设备共享



## 一、编译、安装spdk

### 1.1、下载
1.1.1 下载spdk源码
首先，我们需要从GitHub上克隆SPDK的源码仓库。打开终端，输入以下命令：

```bash
git clone -b v22.01 https://github.com/spdk/spdk.git
cd spdk
```

**1.1.2 下载子模块**

接下来，我们需要初始化并更新SPDK的子模块。
```bash
git submodule update --init
```

1.1.3 安装依赖

为了确保编译过程顺利进行，我们需要安装SPDK所需的依赖项。运行以下命令来自动安装这些依赖：

```bash
sudo ./scripts/pkgdep.sh
```

1.1.4 编译

现在，我们开始编译SPDK。

```bash
./configure --with-rdma --with-shared
sudo make
```

1.1.5 执行单元测试

编译完成后，我们需要运行单元测试来验证SPDK是否安装成功。

```bash
./test/unit/unittest.sh
```

最后如果输出 **all unit test passed**，代SPDK安装成功

![image.png](/static/img/4b8af98b61d073ef87369c183ffd5fdd.image.webp)

### 1.2、配置设备

1.2.1 绑定设备

在开始之前，我们需要将NVMe设备绑定到SPDK。运行以下命令来完成绑定：

```bash
sudo scripts/setup.sh

# 正确结果：
# 0000:0b:00.0 (15ad 07f0): nvme -> uio_pci_generic

# 查看状态
sudo ./scripts/setup.sh status

# 解绑设备
sudo ./scripts/setup.sh reset
```

![image.png](/static/img/804984a8a2ec3e352222bc9211285eda.image.webp)

**0000:b4:00.0** 和 **0000:b5:00.0**是设备编号，下面会用到

## 二、服务端配置

1. 启动 nvmf_tgt 

在服务端，我们需要启动nvmf_tgt来提供NVMe over Fabrics服务。打开一个新的终端，运行以下命令：

```bash
build/bin/nvmf_tgt
```

终端将输出类似以下的内容：

```plain
[zhousk@slave02 spdk]$ build/bin/nvmf_tgt -i 0
[2025-04-28 19:26:00.347292] Starting SPDK v22.01 git sha1 47737f1 / DPDK 21.11.0 initialization...
[2025-04-28 19:26:00.347451] [ DPDK EAL parameters: [2025-04-28 19:26:00.347487] nvmf [2025-04-28 19:26:00.347515] -c 0x1 [2025-04-28 19:26:00.347543] --log-level=lib.eal:6 [2025-04-28 19:26:00.347567] --log-level=lib.cryptodev:5 [2025-04-28 19:26:00.347623] --log-level=user1:6 [2025-04-28 19:26:00.347651] --base-virtaddr=0x200000000000 [2025-04-28 19:26:00.347709] --match-allocations [2025-04-28 19:26:00.347737] --file-prefix=spdk0 [2025-04-28 19:26:00.347789] --proc-type=auto [2025-04-28 19:26:00.347815] ]
EAL: No available 1048576 kB hugepages reported
EAL: No free 2048 kB hugepages reported on node 1
TELEMETRY: No legacy callbacks, legacy socket not created
[2025-04-28 19:26:00.532151] app.c: 601:spdk_app_start: *NOTICE*: Total cores available: 1
[2025-04-28 19:26:00.673833] reactor.c: 943:reactor_run: *NOTICE*: Reactor started on core 0
[2025-04-28 19:26:00.673911] accel_engine.c: 510:spdk_accel_engine_initialize: *NOTICE*: Accel engine initialized to use software engine.
```

2. 在另一个终端，使用rpc.py脚本来配置NVMe over Fabrics

```bash
# 1. 启动 RDMA
scripts/rpc.py nvmf_create_transport -t RDMA -u 8192 -i 131072 -c 8192

# 2. 将 NVMe 控制器附加到 SPDK 的块设备层
# 0000:b4:00.0 是上文的 BDF
./scripts/rpc.py bdev_nvme_attach_controller -b NVMe1 -t PCIe -a 0000:b4:00.0
# output: NVMe1n1

# 3. 创建 subsystem
# cnode1、SPDK00000000000001 可以自定义
./scripts/rpc.py nvmf_create_subsystem nqn.2016-06.io.spdk:cnode1 -a -s SPDK00000000000001 -d SPDK_Controller1

# 4. 添加 namespace
./scripts/rpc.py nvmf_subsystem_add_ns nqn.2016-06.io.spdk:cnode1 NVMe1n1
# NVMe1n1 是 2 中的输出

# 5. 添加监听
# -a 是本机 ip，-s 是端口，可修改
./scripts/rpc.py nvmf_subsystem_add_listener nqn.2016-06.io.spdk:cnode1 -t rdma -a 192.168.200.202 -s 4420 -f ipv4

# 获取 subsystem 信息
./scripts/rpc.py nvmf_get_subsystems


# 下面是删除操作（可选）

# 删除 subsystem
./scripts/rpc.py nvmf_delete_subsystem nqn.2016-06.io.spdk:cnode1
# 删除 ns
# ns_id 通过 nvmf_get_subsystems 获取
./scripts/rpc.py nvmf_remove_ns <nsid>
# 移除监听
./scripts/rpc.py nvmf_subsystem_remove_listener nqn.2016-06.io.spdk:cnode1 -t rdma -a 192.168.200.202 -s 4420
```

4. 获取 subsystem 信息

```json
./scripts/rpc.py nvmf_get_subsystems
```

输出下面这些信息

```json
[
  {
    "nqn": "nqn.2014-08.org.nvmexpress.discovery",
    "subtype": "Discovery",
    "listen_addresses": [],
    "allow_any_host": true,
    "hosts": []
  },
  {
    "nqn": "nqn.2016-06.io.spdk:cnode1",
    "subtype": "NVMe",
    "listen_addresses": [
      {
        "transport": "RDMA",
        "trtype": "RDMA",
        "adrfam": "IPv4",
        "traddr": "192.168.200.202",
        "trsvcid": "4420"
      }
    ],
    "allow_any_host": true,
    "hosts": [],
    "serial_number": "SPDK00000000000001",
    "model_number": "SPDK_Controller1",
    "max_namespaces": 32,
    "min_cntlid": 1,
    "max_cntlid": 65519,
    "namespaces": [
      {
        "nsid": 1,
        "bdev_name": "NVMe1n1",
        "name": "NVMe1n1",
        "nguid": "35354A30581000030025384700000003",
        "uuid": "35354a30-5810-0003-0025-384700000003"
      }
    ]
  }
]
```

此时 **nvmf_tgt** 显示 

[2025-04-28 19:26:24.621233] rdma.c:2668:nvmf_rdma_listen: *NOTICE*: *** NVMe/RDMA Target Listening on 192.168.200.202 port 4420 ***


**这样就完成了！！！**


## 三、客户端配置
在客户端，我们可以使用SPDK自带的测试工具来验证NVMe over Fabrics的配置是否成功。

```plain
./build/examples/perf -r 'trtype:RDMA adrfam:IPv4 traddr:192.168.200.202 trsvcid:4420' -q 128 -o 4096 -w read -t 10
```

![image.png](/static/img/000fd7102586a961833db68879d691b0.image.webp)

【学习笔记】SPDK NVMe of RDMA

探究方式

# 基于 PyQt5 实现分组列表滚动吸顶效果
在很多应用场景中，例如 QQ 好友列表，我们都需要展示大量分组数据，同时希望在滚动时分组标题始终固定显示在顶部，提升用户体验。本文将详细介绍如何利用 PyQt5 实现类似效果——在滚动区域中，当前分组标题始终显示在最上面，当滚动到下一个分组时，自动切换为新的标题。

![示例效果](https://blog.lc044.love/static/img/cd8fb2f344ff20e153cdba66e6e4ba72.demo2.gif)

---

## 一、背景与需求
在实际项目中，我们经常会遇到展示大量控件的情况，尤其是需要按照分组进行展示时。如果直接将所有控件堆叠在一个固定高度的窗口中，很容易导致信息密集、查找困难。为此，我们常常采用 `QScrollArea` 来实现内容的滚动展示。

**需求主要包括：**

1. **标题吸顶效果**  
当用户向下滚动页面时，分组标题始终固定在窗口上方，让用户清楚当前所在分组。
2. **分组切换交互**  
当滚动到下一个分组时，当前分组的标题自动消失，替换为新分组的标题。

为此，我们需要：

+ 获取当前滚动区域的左上角坐标；
+ 监听滚动事件，动态判断各个分组的可见情况；
+ 根据可见性更新吸顶标题的内容和显示状态。

---

## 二、设计思路
整个实现主要分为两部分：

1. **分组控件设计**  
每个分组由一个按钮（显示分组标题）和一个 `QListWidget`（展示分组中的项）组成。按钮具备展开/折叠功能，通过调整 `QListWidget` 的高度实现显示或隐藏分组内容。
2. **吸顶逻辑处理**  
主窗口中，所有分组控件放置于一个 `QScrollArea` 内。利用滚动条的 `valueChanged` 信号捕捉滚动事件，计算各分组控件在 `viewport` 中的位置，并判断哪个分组处于顶部。当检测到顶部分组后，更新一个单独的固定按钮（吸顶控件）的文本显示当前分组标题。

这种设计既能满足吸顶效果，又兼顾了分组数据的展开与折叠需求。

---

## 三、代码解析
下面对关键代码进行详细说明：

### 1. 分组控件类 `FriendGroupWidget`
```python
class FriendGroupWidget(QWidget):
    def __init__(self, group_name, friends):
        super().__init__()
        self.group_name = group_name
        self.friends = friends
        self.expanded = False  # 默认折叠状态

        # 布局包含一个按钮和一个列表
        self.layout = QVBoxLayout(self)
        self.layout.setContentsMargins(0, 0, 0, 0)
        self.button = QPushButton(group_name)
        self.button.setCheckable(True)
        self.button.setChecked(False)
        self.button.clicked.connect(self.toggle_list)

        # 创建 QListWidget 存储好友，并关闭其滚动条
        self.list_widget = QListWidget()
        self.list_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        for friend in friends:
            self.list_widget.addItem(friend)
        self.list_widget.setFixedHeight(0)
        self.layout.addWidget(self.button)
        self.layout.addWidget(self.list_widget)
        self.list_widget.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)

    def toggle_list(self):
        if self.expanded:
            # 折叠：高度设为 0
            self.list_widget.setFixedHeight(0)
            self.expanded = False
        else:
            # 展开：计算 QListWidget 展开所需的总高度
            count = self.list_widget.count()
            if count > 0:
                rowHeight = self.list_widget.sizeHintForRow(0)
                totalHeight = rowHeight * count + 2 * self.list_widget.frameWidth()
            else:
                totalHeight = 0
            self.list_widget.setFixedHeight(totalHeight)
            self.expanded = True
```

**说明：**

+ 每个分组包含一个按钮和一个 `QListWidget`。按钮点击时调用 `toggle_list` 方法，控制列表的展开和折叠。
+ 为了更好的滚动体验，列表的垂直滚动条被关闭，通过计算列表项总高度来动态设置 `QListWidget` 的高度。

### 2. 主窗口类 `MainWindow`
```python
class MainWindow(QWidget, Ui_Form):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.setWindowTitle("QQ好友分组")
        self.resize(300, 500)
        self.layout = QVBoxLayout(self)
        # 用于存储所有好友分组的容器 widget

        # 模拟多个好友分组，每个分组包含多个好友
        groups = {
            "家人": [f'家人{i}' for i in range(15)],
            "朋友": [f'朋友{i}' for i in range(15)],
            "同学": [f'同学{i}' for i in range(15)],
            "陌生人": [f'陌生人{i}' for i in range(15)],
        }
        self.group_widgets = []
        self.group_widgets_dic = {}
        # 为每个分组创建一个 FriendGroupWidget，并加入主窗口布局中
        for group_name, friends in groups.items():
            group_widget = FriendGroupWidget(group_name, friends)
            self.group_widgets.append(group_widget)
            self.verticalLayout_2.addWidget(group_widget)
            self.group_widgets_dic[group_name] = group_widget

        self.verticalLayout_2.addStretch()
        self.scrollArea.verticalScrollBar().valueChanged.connect(self.handleScroll)
        self.button.setVisible(False)
        self.button.clicked.connect(self.click_handel)
```

**说明：**

+ 主窗口使用 `QScrollArea` 展示所有分组，通过遍历模拟数据构建多个 `FriendGroupWidget`。
+ 利用 `verticalScrollBar().valueChanged` 信号监听滚动事件，在 `handleScroll` 方法中实时计算当前处于顶部的分组。
+ 窗口中还存在一个独立的按钮控件（吸顶控件），用于在滚动时显示当前分组标题，点击该按钮可以切换对应分组的展开状态。

### 3. 滚动吸顶逻辑 `handleScroll`
```python
def handleScroll(self, value):
    """滚动时检测当前顶部可见的分组，并打印分组名称"""
    viewport = self.scrollArea.viewport()
    top_visible_group = None
    top_offset = None
    for group_widget in self.group_widgets:
        # 将每个分组的坐标转换到 viewport 坐标系中
        pos_y = group_widget.list_widget.mapTo(viewport, QPoint(0, 0)).y()
        print(pos_y, group_widget.list_widget.height())
        if not group_widget.expanded:
            continue
        # 判断分组是否至少部分可见（即 bottom > 0）
        if pos_y < 10:
            # 如果分组的顶部在 viewport 之上或正好位于顶部，则选择离顶部最近的
            if pos_y <= 0:
                if top_offset is None or pos_y > top_offset:
                    top_offset = pos_y
                    top_visible_group = group_widget
            else:
                # 如果当前没有处于顶部的分组，则选择顶部位置最小的
                if top_offset is None or pos_y < top_offset:
                    top_offset = pos_y
                    top_visible_group = group_widget
    if top_visible_group:
        print("当前最上面可见的分组:", top_visible_group.group_name)
        self.button.setText(top_visible_group.group_name)
        self.button.setVisible(True)
    else:
        self.button.setVisible(False)
```

**说明：**

+ 该方法通过 `mapTo` 方法将每个分组的坐标转换为 `viewport` 坐标系，计算各分组控件相对于滚动区域的位置。
+ 根据各分组在 `viewport` 中的垂直坐标，判断哪个分组处于顶部，并将吸顶控件更新为当前分组标题。
+ 如果没有分组符合条件，则隐藏吸顶控件。

## 四、总结
通过以上实现，我们利用 PyQt5 的控件与信号机制，实现了一个分组列表的滚动吸顶效果。具体优势在于：

+ **交互体验提升**  
用户在滚动时能够实时了解当前分组信息，无论列表项数量如何变化，都能保持良好的导航体验。
+ **模块化设计**  
分组控件与吸顶逻辑分离，各自职责明确，便于后续扩展或功能修改。

这种基于事件监听与控件坐标映射的方法，不仅适用于 QQ 好友分组，还可以推广到其他需要吸顶效果的场景。希望本文的讲解能为你的 PyQt5 项目开发提供新的思路和灵感！

---

欢迎大家留言讨论，如有任何问题或改进建议，也可以在评论区交流。Happy coding!



## 完整代码
```python
"""
## PyQt5实现分组列表滚动吸顶效果

> 有时候一个展示页面内的控件数量展示较多，固定高度下放置不了，那么自然就会把控件放置到QScrollArea中，可能滚动区域中放置的好几块分类的数据，那么在滚动的时候我想知道当前属于哪个分类，我就需要往上滚动，交互体验不佳。

### 需求：

1. 滚动到详细内容的时候，我希望分类标题是一直展示的（类似列表和列表头的效果）
2. 一个QScrollArea中能支持多个标题吸顶，也就是滚动到第二个标题的时候，第一个标题自动消失，开始第二个标题吸顶

### 设计分析：

1. 如果要实现吸顶效果，需要知道QScrollArea当前左上角坐标、待吸顶控件坐标
2. 需要能监听到滚动发生后的事件，用于更新吸顶控件坐标
3. 用label显示标题、QListWidget显示分组项
3、准备一个和分组标题一样的label2控件，判断当前所在的分组，将label2的内容显示为当前分组。不需要显示的时候label2隐藏，需要显示的时候label2显示
"""

import sys

from PyQt5 import QtWidgets
from PyQt5.QtCore import Qt, QPoint
from PyQt5.QtWidgets import QApplication, QWidget, QVBoxLayout, QPushButton, QListWidget, QScrollArea

from test import Ui_Form


class FriendGroupWidget(QWidget):
    def __init__(self, group_name, friends):
        super().__init__()
        self.group_name = group_name
        self.friends = friends
        self.expanded = False  # 默认折叠状态

        # 布局包含一个按钮和一个列表
        self.layout = QVBoxLayout(self)
        self.layout.setContentsMargins(0, 0, 0, 0)
        self.button = QPushButton(group_name)
        self.button.setCheckable(True)
        self.button.setChecked(False)
        self.button.clicked.connect(self.toggle_list)

        # 创建 QListWidget 存储好友，并关闭其滚动条
        self.list_widget = QListWidget()
        self.list_widget.setVerticalScrollBarPolicy(Qt.ScrollBarAlwaysOff)
        for friend in friends:
            self.list_widget.addItem(friend)
        self.list_widget.setFixedHeight(0)
        self.layout.addWidget(self.button)
        self.layout.addWidget(self.list_widget)
        self.list_widget.setVerticalScrollMode(QtWidgets.QAbstractItemView.ScrollPerPixel)

    def toggle_list(self):
        if self.expanded:
            # 折叠：高度设为 0
            self.list_widget.setFixedHeight(0)
            self.expanded = False
        else:
            # 展开：计算 QListWidget 展开所需的总高度
            count = self.list_widget.count()
            if count > 0:
                rowHeight = self.list_widget.sizeHintForRow(0)
                totalHeight = rowHeight * count + 2 * self.list_widget.frameWidth()
            else:
                totalHeight = 0
            self.list_widget.setFixedHeight(totalHeight)
            self.expanded = True


class MainWindow(QWidget, Ui_Form):
    def __init__(self):
        super().__init__()
        self.setupUi(self)
        self.setWindowTitle("QQ好友分组")
        self.resize(300, 500)
        self.layout = QVBoxLayout(self)
        # 用于存储所有好友分组的容器 widget

        # 模拟多个好友分组，每个分组包含多个好友
        groups = {
            "家人": [f'家人{i}' for i in range(15)],
            "朋友": [f'朋友{i}' for i in range(15)],
            "同学": [f'同学{i}' for i in range(15)],
            "陌生人": [f'陌生人{i}' for i in range(15)],
        }
        self.group_widgets = []
        self.group_widgets_dic = {}
        # 为每个分组创建一个 FriendGroupWidget，并加入主窗口布局中
        for group_name, friends in groups.items():
            group_widget = FriendGroupWidget(group_name, friends)
            self.group_widgets.append(group_widget)
            self.verticalLayout_2.addWidget(group_widget)
            self.group_widgets_dic[group_name] = group_widget

        self.verticalLayout_2.addStretch()
        self.scrollArea.verticalScrollBar().valueChanged.connect(self.handleScroll)
        self.button.setVisible(False)
        self.button.clicked.connect(self.click_handel)

    def handleScroll(self, value):
        """滚动时检测当前顶部可见的分组，并打印分组名称"""
        viewport = self.scrollArea.viewport()
        top_visible_group = None
        top_offset = None
        for group_widget in self.group_widgets:

            # 将每个分组的坐标转换到 viewport 坐标系中
            pos_y = group_widget.list_widget.mapTo(viewport, QPoint(0, 0)).y()
            print(pos_y, group_widget.list_widget.height())
            if not group_widget.expanded:
                continue
            # 判断分组是否至少部分可见（即 bottom > 0）
            if pos_y<10:
                # 如果分组的顶部在 viewport 之上或正好位于顶部，则选择离顶部最近的
                if pos_y <= 0:
                    if top_offset is None or pos_y > top_offset:
                        top_offset = pos_y
                        top_visible_group = group_widget
                else:
                    # 如果当前没有处于顶部的分组，则选择顶部位置最小的
                    if top_offset is None or pos_y < top_offset:
                        top_offset = pos_y
                        top_visible_group = group_widget
        if top_visible_group:
            print("当前最上面可见的分组:", top_visible_group.group_name)
            self.button.setText(top_visible_group.group_name)
            self.button.setVisible(True)
        else:
            self.button.setVisible(False)

    def click_handel(self):
        group_name = self.button.text()
        self.group_widgets_dic[group_name].toggle_list()

if __name__ == '__main__':
    app = QApplication(sys.argv)
    window = MainWindow()
    window.show()
    sys.exit(app.exec_())

```



基于 PyQt5 实现分组列表滚动吸顶效果

在日常的照片管理中，我们常会遇到 EXIF 信息中的拍摄日期不准确或者缺失的情况。有些图片（截图、程序生成、去除隐私的拍摄照片）的元数据中没有图片的拍摄日期，从网盘或者其他地方下载的图片的创建日期会变成下载时候的日期，导入相册中无法正确识别到图片的日期，导致相册按时间混乱。

这些图片的文件名大都含有时间信息，这篇文章将分享一个完整的 Python 脚本，用于根据图片文件名自动提取日期，并将其写入图片的 EXIF 元数据中，便于照片管理和排序。

---

## 主要功能
这段代码实现了以下功能：

1. **提取文件名中的日期时间**：支持多种常见的日期格式，包括时间戳。
2. **校验日期有效性**：确保提取到的日期在合理范围内（如 1970 年到 2035 年之间）。
3. **修改 EXIF 元数据**：将提取的日期写入 `DateTimeOriginal` 字段，并设置其他相关字段。
4. **灵活的修改逻辑**：可选择强制使用给定日期，或者自动选择最早日期进行更新。

---

## 核心代码解析
### 1. 提取文件名中的日期
代码首先通过正则表达式从文件名中提取日期时间，支持的格式包括：

+ `YYYYMMDD_HHMMSS` 格式，例如 `20201231_200936`
+ 时间戳格式（10 位秒级或 13 位毫秒级时间戳）
+ 混合格式，例如 `YYYYMMDD-HHMMSS` 或 `YYYYMMDD_HHMMSS[附加内容]`

以下是提取日期时间的核心代码：

```python
def extract_datetime_from_filename(filename) -> datetime | None:
    patterns = [
        r"(\d{8})_(\d{6})",  # 格式：YYYYMMDD_HHMMSS
        r"(\d{13}|\d{10})",  # 格式：TIMESTAMP
        r"(\d{8})[_|-](\d{6}).*?"  # 格式：YYYYMMDD_HHMMSS[其他内容]
    ]
    for pattern in patterns:
        match = re.search(pattern, filename)
        if match:
            if len(match.groups()) == 2:
                date_part, time_part = match.groups()
                try:
                    return datetime.strptime(date_part + time_part, "%Y%m%d%H%M%S")
                except ValueError:
                    continue
            elif len(match.groups()) == 1:
                timestamp = match.group(1)
                try:
                    if len(timestamp) == 13:
                        return datetime.fromtimestamp(int(timestamp) / 1000)
                    else:
                        return datetime.fromtimestamp(int(timestamp))
                except ValueError:
                    continue
    return None
```

### 2. 校验日期的有效性
提取到的日期可能会超出合理范围（例如系统错误生成的无效时间戳）。因此，我们用以下代码确保日期在合理范围内：

```python
start_time = datetime(1970, 1, 1, 0, 0, 0)
end_time = datetime(2035, 1, 1, 0, 0, 0)

def valid_time(dt):
    if start_time <= dt <= end_time:
        return dt
    else:
        return None
```

### 3. 修改 EXIF 信息
代码使用了 [piexif](https://github.com/hMatoba/Piexif) 库来加载和修改图片的 EXIF 元数据。以下是核心逻辑：

+ 获取 `DateTimeOriginal`，与提取的日期比较，取较早者。
+ 如果 EXIF 数据不存在，则创建并插入新的日期信息。
+ 更新 EXIF 中的品牌信息（如 `Make` 和 `Model`）。

以下是主要代码段：

```python
def modify_image(image_file: ImageFile, given_date, is_force):
    try:
        exif_dict = piexif.load(image_file.file_path)
        date_time_original = get_exif_date(exif_dict, piexif.ExifIFD.DateTimeOriginal, 'Exif', None)
        if is_force:
            dates = [d for d in [date_time_original, given_date] if d is not None]
            earliest_date = min(dates)
        else:
            earliest_date = given_date

        if date_time_original != earliest_date:
            exif_dict["Exif"][piexif.ExifIFD.DateTimeOriginal] = earliest_date.strftime("%Y:%m:%d %H:%M:%S").encode("utf-8")
            exif_dict["0th"][piexif.ImageIFD.Make] = 'MemoTrace'.encode("utf-8")
            exif_dict["0th"][piexif.ImageIFD.Model] = 'EasyBox'.encode("utf-8")

        exif_bytes = piexif.dump(exif_dict)
        piexif.insert(exif_bytes, image_file.save_path)
        print(f"DateTimeOriginal 已更新为最早日期：{earliest_date}")
    except Exception as e:
        print(f"处理图片时出错：{e} {traceback.format_exc()}")
```

### 4. 示例运行
以下是代码的运行示例：

```python
if __name__ == '__main__':
    img_path = './dist/图片/Screenshot_20201231_200936.jpg'
    new_path = 'IMG_20201007_150144(3).jpg'
    image_file = ImageFile(img_path)
    image_file.save_path = new_path
    modify_image(image_file, None, False)
```

运行结果如下：

```plain
DateTimeOriginal 已更新为最早日期：2020-12-31 20:09:36
```

![image.png](https://blog.lc044.love/static/img/01192a9a40403b39489a47bcf663c3cf.image.webp)
---

## 运行环境和依赖
+ Python 版本：`>=3.9`
+ 依赖库：`piexif`

安装依赖：

```bash
pip install piexif
```

---

## 完整代码
完整代码如下：

```python
"""
根据文件名获取图片的日期，修改图片exif元数据里的拍摄日期
"""

import os.path
import re
import shutil
import traceback
from datetime import datetime

import piexif


def get_exif_date(exif_dict, field, key='Exif', default="Unknown"):
    """
    安全获取 EXIF 字段的日期，如果字段不存在或解析失败，返回默认值。
    """
    try:
        date_str = exif_dict[key].get(field, b"").decode("utf-8")
        return datetime.strptime(date_str, "%Y:%m:%d %H:%M:%S")
    except (KeyError, ValueError, UnicodeDecodeError):
        return default


start_time = datetime(1970, 1, 1, 0, 0, 0)
end_time = datetime(2035, 1, 1, 0, 0, 0)


def valid_time(dt):
    if start_time <= dt <= end_time:
        return dt
    else:
        return None


def extract_datetime_from_filename(filename) -> datetime | None:
    # 定义正则表达式，匹配常见的时间格式
    patterns = [
        r"(\d{8})_(\d{6})",  # 格式：YYYYMMDD_HHMMSS
        r"(\d{13}|\d{10})",  # 格式：TIMESTAMP (13位毫秒级时间戳)
        r"(\d{8})[_|-](\d{6}).*?"  # 格式：YYYYMMDD_HHMMSS[其他内容]
    ]
    result = None
    for pattern in patterns:
        match = re.search(pattern, filename)
        if match:
            if len(match.groups()) == 2:  # 包含日期和时间
                date_part, time_part = match.groups()
                try:
                    result = datetime.strptime(date_part + time_part, "%Y%m%d%H%M%S")
                    return valid_time(result)
                except ValueError:
                    continue
            elif len(match.groups()) == 1:  # 只包含时间戳
                timestamp = match.group(1)
                try:
                    if len(timestamp) == 13:
                        result = datetime.fromtimestamp(int(timestamp) / 1000)  # 转换为秒
                    else:
                        result = datetime.fromtimestamp(int(timestamp))  # 转换为秒
                    return valid_time(result)
                except (ValueError, OverflowError):
                    continue
    return None


class ImageFile:
    def __init__(self, file_path):
        self.save_path = file_path
        self.file_path = file_path
        self.file_name = os.path.basename(file_path)
        self.save_inplace = True
        self.save_fmt = 'auto'
        self.save_quality = 95

    def get_file_time_by_name(self):
        return extract_datetime_from_filename(self.file_name)


def modify_image(image_file: ImageFile, given_date, is_force):
    """
    修改图片的拍摄时间为given_date
    :param image_file:
    :param given_date:
    :param is_force: 是否强制设置为given_date,否：取当前图片拍摄时间和给定时间的最小值
    :return:
    """
    file_path = image_file.file_path
    if not given_date:
        given_date = image_file.get_file_time_by_name()
    try:
        # 打开图片并加载 EXIF 数据
        try:
            exif_dict = piexif.load(file_path)
            # 获取 EXIF 日期
            date_time_original = get_exif_date(exif_dict, piexif.ExifIFD.DateTimeOriginal, 'Exif', None)
            if is_force:
                modify_date = get_exif_date(exif_dict, piexif.ImageIFD.DateTime, '0th', None)
                dates = [d for d in [date_time_original, modify_date, given_date] if d is not None]
                earliest_date = min(dates)
            else:
                earliest_date = given_date
            # 如果 DateTimeOriginal 已经是最早的，则无需修改
            if date_time_original != earliest_date:
                # 更新 DateTimeOriginal
                exif_dict["Exif"][piexif.ExifIFD.DateTimeOriginal] = earliest_date.strftime("%Y:%m:%d %H:%M:%S").encode(
                    "utf-8")
                exif_dict["0th"][piexif.ImageIFD.Make] = 'MemoTrace'.encode("utf-8")
                exif_dict["0th"][piexif.ImageIFD.Model] = 'EasyBox'.encode("utf-8")
                exif_dict["0th"][piexif.ImageIFD.Software] = 'EasyBox-0.1.0'.encode("utf-8")
        except:
            earliest_date = given_date
            exif_dict = {
                '0th': {},
                'Exif': {}
            }
            if earliest_date:
                # 更新 DateTimeOriginal
                exif_dict["Exif"][piexif.ExifIFD.DateTimeOriginal] = earliest_date.strftime("%Y:%m:%d %H:%M:%S").encode(
                    "utf-8")
            exif_dict["0th"][piexif.ImageIFD.Make] = 'MemoTrace'.encode("utf-8")
            exif_dict["0th"][piexif.ImageIFD.Model] = 'EasyBox'.encode("utf-8")
            exif_dict["0th"][piexif.ImageIFD.Software] = 'EasyBox-0.1.0'.encode("utf-8")
        # 保存修改后的图片
        exif_bytes = piexif.dump(exif_dict)
        # img.save(image_file.save_path, exif=exif_bytes, quality=image_file.save_quality, subsampling=0)
        if image_file.save_path != image_file.file_path:
            shutil.copy(file_path, image_file.save_path)
        piexif.insert(exif_bytes, image_file.save_path)
        print(f"DateTimeOriginal 已更新为最早日期：{earliest_date}")
    except Exception as e:
        print(f"处理图片时出错：{e} {traceback.format_exc()}")


if __name__ == '__main__':
    img_path = './dist/图片/Screenshot_20201231_200936.jpg'
    new_path = 'IMG_20201007_150144(3).jpg'
    given_date = None
    image_file = ImageFile(img_path)
    image_file.save_path = new_path
    modify_image(image_file, None, False)

```

---

## 下载

软件下载地址 [https://github.com/LC044/EasyBox](https://github.com/LC044/EasyBox)

## 总结
这段脚本通过文件名自动提取日期，并写入图片的 EXIF 数据，简化了拍摄时间的修正流程。希望这篇文章对你管理照片有所帮助！如果你在使用过程中有任何问题或建议，欢迎留言讨论。

相关应用程序正在开发中，欢迎关注以便获取最新资源


![image.png](https://blog.lc044.love/static/img/f2756d8910cdb9d7410d0fb7df8d216a.image.webp)



基于文件名修改图片的拍摄日期

👨🏻‍💻这是一个充满知识💬的链接，快点进来看看你的好友给你分享了什么干货吧❣️