Windows 版微信长期以来采用简单的异或加密方式处理图片，这种方式虽操作简便，却容易被破解。随着微信 4.0 的全面重构，图片加密方式也随之升级。尽管加密算法千变万化，但仍有规律可循。本文将带你一步步解析微信 4.0 的图片加密机制。

> 先说结论：微信4.0图片采用的加密方式是AES-EBC 128 + 异或加密

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

### .dat文件头(15个字节)
| 大小(字节) | 内容/类型 | 说明 |
| --- | --- | --- |
| 6 | 0x07085631 | .dat文件标识符 |
| 4 | int （小端序） | AES-EBC128 加密长度 |
| 4 | int （小端序） | 异或加密长度 |
| 1 | 0x01 | 未知 |


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

文件末尾采用异或加密，加密长度最大为1MB，多余部分未加密。

---

## 解析过程

> 图片需要频繁使用，不会采用很复杂的加密方式，否则会严重影响性能，从3.0升级到4.0导入数据很快就完成了，也证明了加密方式不复杂（后来发现实际上是从3.0导入的数据没有更换加密方式）

### 文件头解析

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

找几个dat文件对比发现dat文件的都以 **07 08 56 31 08 07 00 04 00 00**开头，姑且认为 **07 08 56 31 08 07 00 04 00 00**就是dat文件的标识符。

继续往后看，发现有很多重复的数据 **`V )noUt _3`**，为什么会出现重复？重复数据有什么特征？

再继续看，发现重复数据是以16个字节为单位循环重复，也就是每16个字节为一个组。

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

对比图片原数据发现原始图片数据这一块全是 **01** 。

**所以：为什么会重复出现？因为原数据就是重复的。**

**有什么特征：每16字节为一组，相同的数据加密后得到密文相同。**

### 特征：每16字节为一组，相同的数据加密后得到密文相同。

**问一下AI**

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

重复出现的16个字节位置并不是从0-15（右边原图） 而是从 15-下一个14（左边dat文件）


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

依次往前顺着找下去，猜想右边原图 **FF D8 FF E0 10 4A 46 49 46 00 01 01 00 00 01** 对应的密文是 左边 **15 49 98 55 0E 05 78 97 38 E8 18 25 FE 97 04 E6**

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

再找几张jpg图片验证一下，发现跟上面一样

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

**这就说明了dat文件的前15个字节是特殊的文件头，并且前几个字节是标识符，后面还有一些表示其他含义的字节暂且未知，从第16个字节开始是加密后的密文**

### 猜想1：dat文件采用的是AES-EBC加密方式
继续往下看，好像看不出来东西了，再发一张图片试试

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

**Google Inc 2016** 这是什么东西，密文怎么可能有这样的字符串。

对比一下原数据，发现从0x00000400开始后面的数据没有加密，直接就是原数据。**00 00 04 00** 这个数据在文件头的15个字节（07 08 56 31 08 07 **00 04 00 00** 00 00 10 00 01）出现了，可能是某种关联（如果采用小端序的话就刚好对应）。

### 结论1：dat文件部分数据没有加密

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

一口气拉到文件最后，发现**后面的数据又不一样了！！**！。

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

问一下AI

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

找了两个jpg图片发现**FFD9**之后还有一些其他的东西，但是没有什么规律，于是自己构造一些特殊的图片，发给微信看看加密之后是什么样的。


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

```python
img_path = "./微信图片_2025-03-12_103844_154.jpg"

with open(img_path,'rb') as f:
    binary_bytes = f.read()

other_bytes = b'\x01' * 16 + b'\x00' * 16 + b'\x01\x02\x03\x04\x05\x06\x07\x08\x09\x10\x11\x12\x13\x14\x15\x16\x17\x18\x19\x2001234567890123456789001122334455667788990000111122223333444455556666777788889999000111222333444555666777888999'

with open('./test.jpg','wb') as f:
    f.write(binary_bytes+other_bytes)
```

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

手动构造的原始图片： **原文**

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

发送到微信得到的加密文件： **密文**

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

密文和原文**结构高度相似**，并不是前面的EBC加密方式，联想到微信3.0采用的异或加密方式，发现采用的就是跟之前一样的异或加密方式。

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

### 猜想2：dat文件后面采用的是异或加密

结合猜想1、猜想2和结论1可以得出dat文件结构如下图所示：

**dat包含文件头、AES-EBC加密、非加密、异或加密四个部分**

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

## 三个问题：
1. **AES、非加密、异或加密的起止位置是什么？**
2. **dat文件头存了什么信息？**
3. **异或密钥是什么？AES-EBC加密密钥是什么？**

前两个问题用控制变量法花一些时间多找几个不同的图片很容易就能分析出来，大家可以自己去分析一下。

### .dat文件头(15个字节)
| 大小(字节) | 内容/类型 | 说明 |
| --- | --- | --- |
| 6 | 0x07085631 | .dat文件标识符 |
| 4 | int （小端序） | AES-EBC128 加密长度 |
| 4 | int （小端序） | 异或加密长度 |
| 1 | 0x01 | 未知 |

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

文件末尾采用异或加密，加密长度最大为1MB，多余部分未加密。

例如：一个文件小于1kB，则全部是AES加密，如果大于1kB且小于1MB（实际是1MB零1KB），则前1KB部分采用AES加密，剩余部分采用异或加密。如果文件大于1MB，则前1KB采用AES加密，后面1MB采用异或加密，中间部分未加密。

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

对于第三个问题，首先异或密钥很容易找到，根据异或运算的可逆性，结合jpg文件末尾的 **FF D9** 两个字节，可以找找一张微信生成的缩略图（一般为_t.dat结尾），两次异或运算即可得到异或密钥。代码如下：

```python
def get_decode_code_v4(wx_dir):
    cache_dir = os.path.join(wx_dir, 'cache')
    if not os.path.isdir(wx_dir) or not os.path.exists(cache_dir):
        raise ValueError(f'微信路径输入错误，请检查：{wx_dir}')
    ok_flag = False
    for root, dirs, files in os.walk(cache_dir):
        if ok_flag:
            break
        for file in files:
            if file.endswith(".dat"):
                # 构造源文件和目标文件的完整路径
                src_file_path = os.path.join(root, file)
                with open(src_file_path, 'rb') as f:
                    data = f.read()
                    if not data.startswith(b'\x07\x08V1\x08\x07'):
                        continue
                    file_tail = data[-2:]

                    jpg_known_tail = b'\xff\xd9'
                    # 推导出密钥
                    xor_key = [c ^ p for c, p in zip(file_tail, jpg_known_tail)]
                    if len(set(xor_key)) == 1:
                        print(f'[*] 找到异或密钥: 0x{xor_key[0]:x}')
                        return xor_key[0]
    return -1
```

:::warning
AES-EBC加密密钥根据**观察法**容易得出：`aes_key = b'cfcd208495d565ef'`

2025年4月1日微信4.0.3正式版更改了这个密钥，我又**观察**了一下，防止微信再更改就先保密一段时间，等稳定了再放出来。
:::

## **于是，很容易写出dat文件的解密代码**

```python
import os
from Crypto.Cipher import AES

def decode_dat_v4(xor_key: int, file_path, out_path, dst_name='') -> str | bytes:
    """
    适用于微信4.0图片.dat，解密文件，并生成图片
    :param xor_key: int 异或密钥
    :param file_path: dat文件路径
    :param out_path: 输出文件夹
    :param dst_name: 输出文件名，默认为输入文件名
    :return:
    """

    if not os.path.exists(file_path) or os.path.isdir(file_path):
        return ''

    # 读取加密文件的内容
    with open(file_path, 'rb') as f:
        header = f.read(0xf)
        encrypt_length = struct.unpack_from('<H', header, 6)[0]
        encrypt_length0 = encrypt_length // 16 * 16 + 16
        encrypted_data = f.read(encrypt_length0)
        res_data = f.read()
    aes_key = b'cfcd208495d565ef'

    # 初始化AES解密器（ECB模式）
    cipher = AES.new(aes_key, AES.MODE_ECB)

    # 解密数据
    decrypted_data = cipher.decrypt(encrypted_data)

    # 获取图片后缀名
    image_type = get_image_type(decrypted_data[:10])
    output_file_name = os.path.basename(file_path)[:-4] if not dst_name else dst_name
    output_file = os.path.join(out_path, output_file_name + '.' + image_type)
    if os.path.exists(output_file):
        return output_file

    # 移除填充（假设使用的是PKCS7或PKCS5填充）
    pad_length = decrypted_data[-1]  # 获取填充长度
    decrypted_data = decrypted_data[:-pad_length]

    # 将解密后的数据写入输出文件
    with open(output_file, 'wb') as f:
        f.write(decrypted_data)
        f.write(res_data[0:-0x100000])
        f.write(bytes([byte ^ xor_key for byte in res_data[-0x100000:]]))

    # print(f"解密完成，已保存到: {output_file}")
    return output_file
```

## 相关链接

* [万字长文带你了解Windows微信](https://blog.lc044.love/post/13)
* [微信4.0 数据库详解](https://blog.csdn.net/m0_59452630/article/details/146692092?spm=1011.2415.3001.5331)



探究微信4.0图片加密方式

# 基于 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://memotrace.cn/tools/](https://memotrace.cn/tools/)
## 总结
这段脚本通过文件名自动提取日期，并写入图片的 EXIF 数据，简化了拍摄时间的修正流程。希望这篇文章对你管理照片有所帮助！如果你在使用过程中有任何问题或建议，欢迎留言讨论。

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


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



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

万字长文带你了解Windows微信

## PyQt5 自定义可拖拽列表组件：实现动态排序、上下移动与删除功能
写在前面：

在本篇教程中，将实现一个基于 **PyQt5** 的自定义列表组件，这个组件支持拖拽排序、点击按钮上下移动、以及点击删除的功能。

实现效果：


![预览.gif](https://blog.lc044.love/static/img/82ba082dc03977ae0b3331c2427d57cb.%C3%A9%C2%A2%C2%84%C3%A8%C2%A7%C2%88.gif)

:::success
为什么不用Qt自带的`QListWidget` 和 `QListView`？

1. `QListWidget` 支持拖拽，但仅限于默认的文字图标样式的item，不支持item上显示自定义widget（拖拽之后会出现空白）
2. **自定义拖拽图像**：默认的 `QListWidget` 直接拖动列表项的文字或图标，而我们希望通过截图方式，让拖拽过程中显示小部件的实际样式。
3. **控制拖拽行为**：在自定义组件中，可以细粒度地控制拖拽行为，甚至动态调整拖拽图像、拖拽位置、以及拖拽结果的处理逻辑。例如，我们可以在拖拽时调整列表项的大小，或者设置复杂的拖拽区域判断。

:::

### 环境准备
首先，请确保你的环境中安装了 **PyQt5**，可以使用以下命令安装：

```python
pip install PyQt5
```

### 项目需求分析
实现一个自定义列表组件，要求如下：

1. 每个列表项由一个标签和三个操作按钮组成（上移、下移、删除）。
2. 支持拖拽排序，使用户可以自由地重新排列列表项的顺序。
3. 能够通过按钮快速将项上下移动或删除。

### 代码详解
#### 1. 项目结构
首先我们创建以下几个类：

+ `CustomWidget`: 定义列表项样式，包括标签和按钮。
+ `FileInfo`: 存储每个列表项的信息。
+ `FileItem`: 继承 `QStandardItem`，保存自定义数据。
+ `FileListView`: 主列表视图类，实现拖拽、排序和按钮操作的核心逻辑。

#### 2. 自定义列表项 `CustomWidget`
`CustomWidget` 负责定义每个列表项的外观，包括：

+ 标签显示项的名称。
+ `↑` 按钮（上移）、`↓` 按钮（下移）、以及 `删除` 按钮。
+ 鼠标悬停效果。

代码实现如下：

```python
class CustomWidget(QWidget):
    """自定义列表项，带有标签和删除按钮"""

    def __init__(self, text):
        super(CustomWidget, self).__init__()
        self.is_selected = False
        self.label = QLabel(os.path.basename(text))
        self.btn_up = QPushButton("↑")
        self.btn_down = QPushButton("↓")
        self.btn_delete = QPushButton("删除")

        # 创建布局
        layout = QHBoxLayout()
        layout.addWidget(self.label)
        spacerItem = QtWidgets.QSpacerItem(40, 20, QtWidgets.QSizePolicy.Expanding, QtWidgets.QSizePolicy.Minimum)
        layout.addItem(spacerItem)
        layout.addWidget(self.btn_up)
        layout.addWidget(self.btn_down)
        layout.addWidget(self.btn_delete)
        layout.setContentsMargins(0, 0, 10, 0)
        self.setLayout(layout)
        self.setStyleSheet("QWidget,QLabel{background: rgb(238,244,249);}")
```

通过 `QLabel` 显示标签信息，`QPushButton` 添加操作按钮，并设置 `QHBoxLayout` 布局，使标签和按钮水平排列。

#### 3. 数据结构 `FileInfo` 和 `FileItem`
`FileInfo` 类保存每个列表项的具体信息，如文件名、路径和排序所需的页码。

```python
class FileInfo:
    def __init__(self, file, index):
        self.filename = os.path.basename(file)
        self.filepath = file
        self.index = index
        self.selected = True
```

`FileItem` 继承自 `QStandardItem`，在每项中存储 `FileInfo` 数据。

```python
class FileItem(QStandardItem):
    def __init__(self, fileinfo):
        super(FileItem, self).__init__()
        self.setData(fileinfo, Qt.UserRole)  # 存储自定义文本数据
```

#### 4. 列表视图 `FileListView`
`FileListView` 是组件的核心部分，定义了以下功能：

+ **拖拽排序**：通过 `mousePressEvent` 和 `startDrag` 实现拖拽效果。
+ **列表操作**：调用 `add_item` 添加列表项，通过 `remove_item` 删除项。

##### 关键功能实现
+ **拖拽**：

在 `FileListView` 的 `startDrag` 方法中，生成自定义小部件的截图作为拖拽图像，并设置拖拽热点，确保拖拽开始时图像与鼠标对齐。

```python
def startDrag(self, supportedActions):
    index = self.currentIndex()
    if index.isValid():
        item_widget = self.indexWidget(index)
        if item_widget:
            pixmap = item_widget.grab()  
            drag = QDrag(self)
            drag.setPixmap(pixmap)
            drag.setHotSpot(self.start_drag_pos - item_widget.pos())
            drag.exec_(supportedActions)
```

+ **上下移动**：

按钮 `↑` 和 `↓` 实现上下移动功能。通过获取目标行号和源行号，进行插入和删除操作。

```python
def move_item_up(self, item):
    row = item.row()
    if row > 0:
        new_item = FileItem(item.data(Qt.UserRole).copy())
        self.model.removeRow(item.row())
        self.model.insertRow(row - 1, new_item)
        self.set_item_widget(new_item)
```

+ **删除**：

当点击删除按钮时，调用 `remove_item` 方法，将指定项从模型中移除。

```python
def remove_item(self, item):
    self.model.removeRow(item.row())
```

#### 5. 初始化组件
在 `main` 函数中，我们创建一个 `FileListView` 实例，并添加几个示例项，展示组件的完整效果。

```python
if __name__ == '__main__':
    app = QApplication(sys.argv)
    view = FileListView()
    for i in range(5):
        view.add_item(f'Item {i + 1}', i)
    view.show()
    sys.exit(app.exec_())
```

#### 效果预览
运行后，窗口会显示一个列表，每个项可以通过拖拽排序、点击按钮上移或下移，或者删除，方便用户进行自由操作。

![](https://blog.lc044.love/static/img/82ba082dc03977ae0b3331c2427d57cb.é¢è§.gif)

### 总结
通过本教程，我们实现了一个功能丰富的 PyQt5 自定义列表组件，主要包括以下要点：

1. 自定义小部件，实现项目内容的布局和交互。
2. 使用 `QStandardItem` 和 `QStandardItemModel` 维护列表数据。
3. 通过自定义拖拽和按钮操作，实现上下移动、删除和排序功能。

本组件适用于需要动态排序的项目管理类应用，如文件列表、任务管理等。


## 完整代码
[https://github.com/LC044/pyqt_component_library](https://github.com/LC044/pyqt_component_library)



使用 PyQt5 实现自定义可拖拽列表组件

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