我在前面介绍的系统界面功能，包括菜单工具栏、业务表的数据，开始的时候，都是基于模拟的数据进行测试，数据采用JSON格式处理，通过辅助类的方式模拟实现数据的加载及处理，这在开发初期是一个比较好的测试方式，不过实际业务的数据肯定是来自后端，包括本地数据库，SqlServer、Mysql、Oracle、Sqlite、PostgreSQL等，或者后端的WebAPI接口获取，本篇随笔逐步介绍如何对后端的数据接口进行建模以及提供本地WebAPI代理接口类的处理过程。

1、定义Web API接口类并测试API调用基类

我在随笔《使用wxpython开发跨平台桌面应用，动态工具的创建处理》中介绍了关于工具栏和菜单栏的数据类，以及模拟方式获得数据进行展示，如下界面所示。

如菜单数据的类信息，如下所示。

class MenuInfo:

    id: str  # 菜单ID

    pid: str  # 父菜单ID

    label: str  # 菜单名称

    icon: str =   # 菜单图标

    path: str =   # 菜单路径，用来定位视图

    tips: str =   # 菜单提示

    children: list["MenuInfo"] = 

这些数据和后端数据接口的定义一致，那么就很容易切换到动态的接口上。

在系统开发的初期，我们可以先试用模拟方式获得数据集合，如通过一个工具来来获得数据，如下所示。

为了更好的符合实际的业务需求，我们往往需要根据服务端的接口定义来定义调用Web API接口的信息。

我们为了全部采用Python语言进行开发，包括后端的内容，采用 基于SqlAlchemy+Pydantic+FastApi 的后端框架

该后端接口采用统一的接口协议，标准协议如下所示。

{

  "success": false,

   "result":  T , "targetUrl": "string",

  "UnAuthorizedRequest": false,

  "errorInfo": {

    "code": 0,

    "message": "string",

    "details": "string"

  }

}

其中的result是我们的数据返回，有可能是基本类型（如字符串、数值、布尔型等），也有可能是类集合，对象信息，字典信息等等。

如果是分页查询返回结果集合，其结果如下所示。

展开单条记录明细如下所示。

如果我们基于Pydantic模型定义，我们的Python对象类定义代码如下所示

from pydantic import  BaseModel

from typing import Generic, Type, TypeVar, Optional

T = TypeVar("T")



# 自定义返回模型-统一返回结果

class AjaxResponse(BaseModel, Generic[T]):

    success: bool = False

    result: Optional[T] = 

    targetUrl: Optional[str] = 

    UnAuthorizedRequest: Optional[bool] = False

    errorInfo: Optional[ErrorInfo] = 

也就是结合泛型的方式，这样定义可以很好的抽象不同的业务类接口到基类BaseApi中，这样增删改查等处理的接口都可以抽象到BaseApi里面了。

权限模块我们涉及到的用户管理、机构管理、角色管理、菜单管理、功能管理、操作日志、登录日志等业务类，那么这些类继承BaseApi，就会具有相关的接口了，如下所示继承关系。

2、对异步调用进行测试和接口封装

为了理解客户端Api类的处理，我们先来介绍一些简单的pydantic 入门处理，如下我们先定义一些实体类用来承载数据信息，如下所示。

from typing import List, TypeVar, Optional, Generic, Dict, Any

from datetime import datetime

from pydantic import BaseModel, Field

T = TypeVar("T")



class AjaxResult(BaseModel, Generic[T]):

    """测试统一接口返回格式"""

    success: bool = True

    message: Optional[str] = 

    result: Optional[T] = 



class PagedResult(BaseModel, Generic[T]):

    """分页查询结果"""

    total: int

    items: List[T]



class Customer(BaseModel):

    """客户信息类"""

    name: str

    age: int

一般业务的结果是对应的记录列表，或者实体类对象格式，我们先来测试解析下它们的JSON数据，有助于我们理解。

# 对返回结果数据格式的处理

json_data = """{

    "total": 100,

    "items": [

        {"name": "Alice", "age": 25},

        {"name": "Bob", "age": 30},

        {"name": "Charlie", "age": 35}

    ]

}"""

paged_result = PagedResult.model_validate_json(json_data)

print(paged_result.total)

print(paged_result.items)

以上正常解析到数据，输出结果如下所示。

100

[{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 35}]

True

如果我们换为统一返回的结果进行测试，如下所示。

json_data = """{

    "success": true,

    "message": "success",

    "result": {

        "total": 100,

        "items": [

            {"name": "Alice", "age": 25},

            {"name": "Bob", "age": 30},

            {"name": "Charlie", "age": 35}

        ]

    }

}"""



ajax_result = AjaxResult[PagedResult].model_validate_json(json_data)

print(ajax_result.success)

print(ajax_result.message)

print(ajax_result.result.total)

print(ajax_result.result.items)

同样的可以获得正常的输出。

True

success

100

[{'name': 'Alice', 'age': 25}, {'name': 'Bob', 'age': 30}, {'name': 'Charlie', 'age': 35}]

我们通过 model_validate_json 接口可以转换字符串内容为对应的业务类对象，而通过 model_validate 函数可以转换JSON格式为业务类对象。

而对于接口的继承处理，我们采用了泛型的处理，可以极大的减少基类代码的编写，如下基类定义和子类定义，就可以简单很多，所有逻辑放在基类处理即可。

class BaseApi(Generic[T]):

    def test(self) -> AjaxResult[Dict[str, Any]]:

        json_data = """{

            "success": true,

            "message": "success",

            "result": {"name": "Alice", "age": 25}

        }"""

        result = AjaxResult[Dict[str, Any]].model_validate_json(json_data)

        return result



    def get(self, id: int) -> AjaxResult[T]:

        json_data = """{

            "success": true,

            "message": "success",

            "result": {"name": "Alice", "age": 25}

        }"""

        result = AjaxResult[T].model_validate_json(json_data)

        return result



    def getlist(self) -> AjaxResult[List[T]]:

        json_data = """{

            "success": true,

            "message": "success",

            "result": [

                {"name": "Alice", "age": 25},

                {"name": "Bob", "age": 30},

                {"name": "Charlie", "age": 35}

            ]

        }"""

        result = AjaxResult[List[T]].model_validate_json(json_data)

        return result





class UserApi(BaseApi[Customer]): pass



user_api = UserApi()

result = user_api.getlist()

print(result.success)

print(result.message)

print(result.result)



result = user_api.get(1)

print(result.success)

print(result.message)

print(result.result)



result = user_api.test()

print(result.success)

print(result.message)

print(result.result)

可以看到，子类只需要明确好继承关系即可，不需要编写任何多余的代码，但是又有了具体的接口处理。

3、实际HTTTP请求的封装处理

一般对于服务端接口的处理，我们可能需要引入 aiohttp 来处理请求，并结合Pydantic的模型处理，是的数据能够正常的转换，和上面的处理方式一样。

首先我们需要定义一个通用HTTP请求的类来处理常规的HTTP接口数据的返回，如下所示。

class ApiClient:

    _access_token =   # 类变量，用于全局共享 access_token



    @classmethod

    def set_access_token(cls, token):

        """设置全局 access_token"""

        cls._access_token = token



    @classmethod

    def get_access_token(cls):

        """获取全局 access_token"""

        return cls._access_token



    def _get_headers(self):

        headers = {}

        if self.get_access_token():

            headers["Authorization"] = f"Bearer {self.get_access_token()}"

        return headers



    async def get(self, url, params=):

        async with aiohttp.ClientSession() as session:

            async with session.get(

                url, headers=self._get_headers(), params=params

            ) as response:

                return await self._handle_response(response)



    async def post(self, url, json_data=):

        async with aiohttp.ClientSession() as session:

            async with session.post(

                url, headers=self._get_headers(), json=json_data

            ) as response:

                return await self._handle_response(response)



    async def put(self, url, json_data=):

        async with aiohttp.ClientSession() as session:

            async with session.put(

                url, headers=self._get_headers(), json=json_data

            ) as response:

                return await self._handle_response(response)



    async def delete(self, url, params=):

        async with aiohttp.ClientSession() as session:

            async with session.delete(

                url, headers=self._get_headers(), params=params

            ) as response:

                return await self._handle_response(response)



    async def _handle_response(self, response):

        if response.status == 200:

            return await response.json()

        else:

            response.raise_for_status()

这些我来基于通用ApiClient的辅助类，对业务接口的调用进行一个简单基类的封装，命名为BaseApi，接受泛型类型定义，如下所示。

class BaseApi(Generic[T]):

    base_url = "http://jsonplaceholder.typicode.com/" 

    client: ApiClient = ApiClient()



    async def getall(self, endpoint, params=) -> List[T]:

        url = f"{self.base_url}{endpoint}"

        json_data = await self.client.get(url, params=params)

        # print(json_data)

        return list[T](json_data)



    async def get(self, endpoint, id) -> T:

        url = f"{self.base_url}{endpoint}/{id}"

        json_data = await self.client.get(url)

        # return parse_obj_as(T,json_data)

        adapter = TypeAdapter(T)

        return adapter.validate_python(json_data)



    async def create(self, endpoint, data) -> bool:

        url = f"{self.base_url}{endpoint}"

        await self.client.post(url, data)



        return True



    async def update(self, endpoint, id, data) -> T:

        url = f"{self.base_url}{endpoint}/{id}"

        json_data = await self.client.put(url, data)



        adapter = TypeAdapter(T)

        return adapter.validate_python(json_data)



    async def delete(self, endpoint, id) -> bool:

        url = f"{self.base_url}{endpoint}/{id}"

        json_data = await self.client.delete(url)

        # print(json_data)

        return True

我这里使用了一个 测试API接口很好的网站：jsonplaceholder.typicode.com/，它提供了很多不同业务对象的接口信息，如下所示。

统一提供GET/POST/PUT/DELETE等常规Restful动作的处理

如我们获取列表数据的接口如下，返回对应的JSON集合。

 通过对应的业务对象不同的动作处理，我们可以测试各种接口。 

注意，我们上面的接口都是采用了async/awati的对应异步标识来处理异步的HTTP接口请求。

上面我们定义了BaseApi,具有常规的getall/get/create/update/delete的接口，实际开发的时候，这些会根据后端接口请求扩展更多基类接口。

基于基类BaseApi定义，我们创建其子类PostApi，用来获得具体的对象定义接口。

class PostApi(BaseApi[post]):

    # 该业务接口类，具有基类所有的接口



    # 并增加一个自定义的接口

    async def test(self) -> Db:

        url = "http://my-json-server.typicode.com/typicode/demo/db"

        json_data = await self.client.get(url)

        # print(json_data)

        return Db.model_validate(json_data)

这里PostApi 具有基类所有的接口:getall/get/create/update/delete的接口, 并可以根据实际情况增加自定义接口，如test 接口定义。

测试代码如下所示。

async def main(): post_api = PostApi() 



    result = await post_api.getall("posts")

    print(len(result))



    result = await post_api.get("posts", 1)

    print(result)



    result = await post_api.create(

        "posts", {"title": "test", "body": "test body", "userId": 1}

    )

    print(result)



    result = await post_api.update(

        "posts", 1, {"title": "test2", "body": "test body2", "userId": 1, "id": 1}

    )

    print(result)



    result = await post_api.delete("posts", 1)

    print(result)



    result = await post_api.test()

    print(result)





if __name__ == "__main__":

    asyncio.run(main())

运行例子，输出如下结果。

一直幻想着能够成为一个海王，于是做了一个微信自动聊天的工具。

测试微信版本：wechat 3.9.12.17

采用技术：

• Bmob后端云（AI对话和存储需要自动聊天的人和prompt）


• uiautomation


• pyautogui

开发语言：

• python，conda环境下运行

最终的效果大家可以看B站：http://www.bilibili.com/video/BV1yK…

一、获取微信对话内容

这里采用了网上的一些开源项目进行修改，写了一个自己的WeChat控制类，采用的是uiautomation和pyautogui组件进行UI的控制，模拟人的操作。

WeChat控制类的内容比较多，为了方便阅读，这里只呈现一部分，有需要的朋友可以联系我获取。

class WeChat:

    def __init__(self, path, locale="zh-CN"):

        # 微信打开路径

        self.path = path



        # 用于复制内容到剪切板

        self.app = QApplication([])



        self.lc = WeChatLocale(locale)



    # 鼠标移动到控件上

    def move(self,element):

        x, y = element.GetPosition()

        auto.SetCursorPos(x, y)



    # 鼠标快速点击控件

    def click(self,element):

        x, y = element.GetPosition()

        auto.Click(x, y)



    # 鼠标右键点击控件

    def right_click(self,element):

        x, y = element.GetPosition()

        auto.RightClick(x, y)





    # 鼠标快速点击两下控件

    def double_click(self,element):

        x, y = element.GetPosition()

        auto.SetCursorPos(x, y)

        element.DoubleClick()





    # 打开微信客户端

    def open_wechat(self):

        subprocess.Popen(self.path)



    # 搜寻微信客户端控件

    def get_wechat(self):

        return auto.WindowControl(Depth=1, Name=self.lc.weixin)



    # 防止微信长时间挂机导致掉线

    def prevent_offline(self):

        self.open_wechat()

        self.get_wechat()



        search_box = auto.EditControl(Depth=8, Name=self.lc.search)

        self.click(search_box)



    # 搜索指定用户

    def get_contact(self, name):

        self.open_wechat()

        self.get_wechat()



        search_box = auto.EditControl(Depth=8, Name=self.lc.search)

        self.click(search_box)



        pyperclip.copy(name)

        auto.SendKeys("{Ctrl}v")



        # 等待客户端搜索联系人

        time.sleep(0.3)

        search_box.SendKeys("{enter}")



    # 鼠标移动到发送按钮处点击发送消息

    def press_enter(self):

        # 获取发送按钮

        send_button = auto.ButtonControl(Depth=15, Name=self.lc.send)

        self.click(send_button)

        

    # 检测微信发新消息的用户

    def check_new_user(self):

        self.open_wechat()

        self.get_wechat()



        users = []



        # 获取左侧聊天按钮

        chat_btn = auto.ButtonControl(Name=self.lc.chats)

        self.double_click(chat_btn)



        # 持续点击聊天按钮，直到获取完全部新消息

        item = auto.ListItemControl(Depth=10)

        prev_name = item.ButtonControl().Name

        while True:

            # 判断该联系人是否有新消息

            pane_control = item.PaneControl()

            if len(pane_control.GetChildren()) == 3:

                users.append(item.ButtonControl().Name)



            self.click(item)



            # 跳转到下一个新消息

            self.double_click(chat_btn)

            item = auto.ListItemControl(Depth=10)



            # 已经完成遍历，退出循环

            if prev_name == item.ButtonControl().Name:

                break



            prev_name = item.ButtonControl().Name



        return users

二、获取需要自动聊天的人和对应的prompt

这部分信息我存储在Bmob后端云上面，对应的表结构（表名为：autochat，创建的字段为：name、prompt）和测试的内容如下：

获取信息的时候，我采用了子线程的方式，每隔300秒获取一次新的需要自动对话的微信和对应的prompt，代码如下：

# Bmob对象

bmob = Bmob(config['bmob_appid'], config['bmob_secret'])



# 存储从Bmob后端云获取到的自动对话的微信名和对应的prompt

name_prompts = {}



# 从Bmob后端云获取自动聊天的微信名和prompt

def get_user_prompt():

    users = bmob.findObjects('autochat')

    name_prompts.clear()

    for user in users:

        name_prompts[user.name] = user.prompt



# 每隔5分钟获取一次要自动聊天微信名称和对应的prompt

def run_with_interval():

    while True:

        get_user_prompt()

        time.sleep(300)



if __name__ == "__main__":

    t = threading.Thread(target=run_with_interval)

    t.start()

三、组装对话上下文和自动对话

这里主要用到了WeChat类的获取新对话人名字、获取某个人历史聊天记录的方法，和Bmob后端云的AI功能，具体代码如下：

# 执行自动聊天功能

def main():

    wechat = WeChat(path=config['wechat_path'])

    # 创建一个锁

    lock = threading.Lock()



    while True:

        try:

            comtypes.CoInitialize()

            # 确保微信操作的线程安全

            with lock:

                wechat.click(auto.ButtonControl(Name=wechat.lc.facorites))

                users = wechat.check_new_user()

                if len(users) <= 0:

                    time.sleep(5)

                    print("暂时没有新消息")

                    continue



                for user in users:

                    if user not in name_prompts.keys():

                        time.sleep(5)

                        print(f"{user}不在需要自动问答的名单上")

                        continue

                    else:

                        # 获取聊天记录，30这个数字可以调整，越大的话，AI会越了解你，但消耗的token也越多

                        msgList = wechat.get_dialogs(user, 30)

                        if len(msgList) <= 0:

                            continue

                        

                        # 组装上下文对话记录

                        ai = []

                        ai.append({"content": name_prompts[user], "role": "system"})

                        for msg in msgList:

                            chatmsg = msg[2].replace('[动画表情]','')

                            if chatmsg=='':

                                continue



                            if msg[1] == user:

                                ai.append({"content": chatmsg, "role": "user"})

                            else:

                                ai.append({"content": chatmsg, "role": "assistant"})



                        bmob.connectAI()

                        to = bmob.chat2(ai)

                        bmob.closeAI()

                        print('ai:'+to)



                        if to != "":

                            wechat.send_msg(user, to)

        except Exception as e:

            print(e)

Python是一种广泛使用的编程语言，以其简洁和可读性著称。在开发和调试过程中，遇到错误和问题是不可避免的。Python为此提供了一个强大的调试工具——Pdb（Python Debugger）。Pdb是Python标准库中自带的调试器，可以帮助开发者跟踪代码执行、查看变量值、设置断点等功能。本文将详细介绍Pdb的使用方法，并结合实例展示其强大的调试能力。

1. Pdb简介

Pdb是Python内置的调试器，支持命令行操作，可以在Python解释器中直接调用。Pdb提供了一系列命令来控制程序的执行，查看和修改变量值，甚至可以在运行时修改代码逻辑。

2. 如何启动Pdb

在Python代码中启动Pdb有多种方式，以下是几种常见的方法：

2.1 在代码中插入断点

在代码中插入import pdb; pdb.set_trace()可以在运行到该行时启动Pdb：

def factorial(n):

    if n == 0:

        return 1

    else:

        return n * factorial(n-1)



import pdb; pdb.set_trace()

print(factorial(5))

2.2 通过命令行启动

可以通过命令行启动Python脚本，并在需要调试的地方使用pdb模块：

python -m pdb myscript.py

3. Pdb的基本命令

Pdb提供了许多命令来控制调试过程，以下是一些常用命令：

• b (break): 设置断点


• c (continue): 继续执行程序直到下一个断点


• s (step): 进入函数内部逐行执行


• n (next): 执行下一行，不进入函数内部


• p (print): 打印变量的值


• q (quit): 退出调试器

4. 实战示例

让我们通过一个具体的例子来演示Pdb的使用。假设我们有一个简单的Python脚本，用于计算列表中元素的平均值：

def average(numbers):

    total = sum(numbers)

    count = len(numbers)

    return total / count



numbers = [1, 2, 3, 4, 5]

print(average(numbers))

4.1 设置断点并启动调试

我们希望在计算平均值之前检查total和count的值：

import pdb; pdb.set_trace()



def average(numbers):

    total = sum(numbers)

    count = len(numbers)

    return total / count



numbers = [1, 2, 3, 4, 5]

print(average(numbers))

运行上述代码，当程序执行到pdb.set_trace()时，将进入调试模式：

PS C:\src\uml\2024\07> python -m pdb myscript.py

> c:\src\uml\2024\07\myscript.py(1)<module>()

-> import pdb; pdb.set_trace()

(Pdb) n

> c:\src\uml\2024\07\myscript.py(3)<module>()

-> def average(numbers):

(Pdb) m

*** NameError: name 'm' is not defined

(Pdb) n

> c:\src\uml\2024\07\myscript.py(8)<module>()

-> numbers = [1, 2, 3, 4, 5]

(Pdb) n

> c:\src\uml\2024\07\myscript.py(9)<module>()

-> print(average(numbers))

(Pdb) n

3.0

--Return--

> c:\src\uml\2024\07\myscript.py(9)<module>()->

-> print(average(numbers))

4.2 查看变量值

在调试模式下，可以使用p命令查看变量值：

(Pdb) p numbers

[1, 2, 3, 4, 5]

(Pdb)

通过这种方式，可以一步步检查变量的值和程序的执行流程。

5. 高级功能

除了基本命令，Pdb还提供了许多高级功能，如条件断点、调用栈查看等。

5.1 查看调用栈

使用where命令可以查看当前的调用栈：

(Pdb) where

  <frozen runpy>(198)_run_module_as_main()

  <frozen runpy>(88)_run_code()

  c:\users\heish\miniconda3\lib\pdb.py(1952)<module>()->

-> pdb.main()

  c:\users\heish\miniconda3\lib\pdb.py(1925)main()

-> pdb._run(target)

  c:\users\heish\miniconda3\lib\pdb.py(1719)_run()

-> self.run(target.code)

  c:\users\heish\miniconda3\lib\bdb.py(600)run()

-> exec(cmd, globals, locals)

  <string>(1)<module>()->

> c:\src\uml\2024\07\myscript.py(9)<module>()->

-> print(average(numbers))

6. 总结

Pdb是Python提供的一个功能强大的调试工具，掌握它可以大大提高代码调试的效率。在开发过程中，遇到问题时不妨多利用Pdb进行调试，找出问题的根源。通过本文的介绍，希望大家能够更好地理解和使用Pdb，为Python编程之路增添一份助力。

一、你的flask服务开启https了吗？

1.事件起因

计划做文心一言插件，我购买了服务器，开始按照我的想象部署插件，结果工作不错，但是最后一步图片显示不正常。哭晕了，如下图所示。

仔细阅读，发现返回图片地址什么的都很正常啊，也可以访问得到，但是为什么就不能看到呢，很奇怪。

经多方排查，最终确定是图片跨域导致无法显示。

2.解决思路

知道是跨域问题就好了，因为文心一言是https访问，所以提供服务的也需要https，那么就开始作了（解决）。

二、解决办法

1.无效1.0解决办法

知道要https那我就加https了，直接百度解决办法。

• Flask(更具体地说其实是Werkzeug)，支持使用即时证书，这对于通过HTTPS快速提供应用程序非常有用，而且不会搞乱系统的证书。你只有需要做的就是将 ssl_context ='adhoc' 添加到程序的 app.run() 调用中。遗憾的是，Flask CLI无法使用此选项。举个例子，下面是官方文档中的“Hello，World” Flask应用程序，并添加了TLS加密：


• 安装库 pip install pyopenssl

from flask import Flask

app = Flask(__name__)

 

@app.route("/")

def hello():

    return "Hello World!"

 

if __name__ == "__main__":

    app.run(ssl_context='adhoc')

这样启动起来就是https了，但是访问问题依旧，图片仍然没有显示。。。。。。仔细看来浏览器说是假的ssl，那就继续解决。

2.无效2.0自签名证书解决办法

所谓的自签名证书是使用与同一证书关联的私钥生成签名的证书，就是自己动手丰衣足食。

• 生成证书


• flask加载证书

openssl req -x509 -newkey rsa:4096 -nodes -out cert.pem -keyout key.pem -days 365

from flask import Flask

app = Flask(__name__)

 

@app.route("/")

def hello():

    return "Hello World!"

 

if __name__ == "__main__":

    app.run(ssl_context=('cert.pem', 'key.pem'))

复制代码

然后看结果，依然无效，因为是自签名。。。。。。

3.0终极解决办法

后来发现要真正的证书，那么你必须要有域名，才会发给你，就是说证书和域名是绑定的，就跟户籍一样，户籍都没有说什么学区房，没人理你。

• 为此我花了8块买了一个cn一年的域名，并且进行了实名。


• 在腾讯云申请ssl证书，参考地址 cloud.tencent.com/document/pr…


• 申请地址 console.cloud.tencent.com/ssl
  申请时必须先证明该证书属于你，需要按提示加入cname，进行验证。申请完毕略等一会就会通过，下载证书即可，具体包含以下几个问题件：

• 加载证书
  因为有4个文件，没有详细写，因此我测试了几次，最终成功。

if __name__ == '__main__':

    app.run(debug=True, host='0.0.0.0', ssl_context=( 'erniebotplugins.cn_bundle.crt','erniebotplugins.cn.key'), port=8081)

三、最终效果

用上最终大招后，最终成功，具体效果如下。

可见现在ssl非常普遍，不安全别的网站都懒得搭理你。

Hello伙伴们，好几天不见啦。最近也是晚上打球太累，加上一直在研究mybatis的多租户问题，简直是没有太多的精力了。正好周六的晚上有一点点的空隙，就是洗完澡之后，顿时觉得整个人轻松下来了。有伙伴跟我一样的感受吗？

话不多说，现在我们来开始今天的主题：《如何实现一个桌面倒计时程序》。

身为打工人，一定是想着下班的那一刻吧。就像我昨天和我的伙伴开玩笑说：一个月就盼望着发工资的那一天。shigen找到了一段程序来实现下班倒计时，一起来看看实现的效果吧：

页面上动态的显示当前时间和剩余时间，假设shigen的文章要在今天的23点写完，那么我还剩2小时25分钟的准备时间。是不是挺神奇的，另外，还可以实现到点了自动关机。人走电脑关，看看老板还有什么理由让你去加班🤫🤫🤫。

那就上今天的代码吧：

 # -*- encoding: utf-8 -*-

 __date__ = '2023/11/18 19:27:08'

 

 """

 距离下班时间倒计时

 """

 

 import time

 from tkinter import *

 

 

 def refresh_current_time():

     """刷新当前时间"""

     clock_time = time.strftime('%Y-%m-%d %H:%M:%S')

     curr_time.config(text=clock_time)

     curr_time.after(1000, refresh_current_time)

 

 

 def refresh_down_time():

     """刷新倒计时时间"""

     # 当前时间戳

     now_time = int(time.time())

     # 下班时间时分秒数据过滤

     work_hour_val = int(work_hour.get())

     if work_hour_val > 23:

         down_label.config(text='小时的区间为（00-23）')

         return

     work_minute_val = int(work_minute.get())

     if work_minute_val > 59:

         down_label.config(text='分钟的区间为（00-59）')

         return

     work_second_val = int(work_second.get())

     if work_second_val > 59:

         down_label.config(text='秒数的区间为（00-59）')

         return

     # 下班时间转为时间戳

     work_date = str(work_hour_val) + ':' + str(work_minute_val) + ':' + str(work_second_val)

     work_str_time = time.strftime('%Y-%m-%d ') + work_date

     time_array = time.strptime(work_str_time, "%Y-%m-%d %H:%M:%S")

     work_time = time.mktime(time_array)

     if now_time > work_time:

         down_label.config(text='已过下班时间')

         return

     # 距离下班时间剩余秒数

     diff_time = int(work_time - now_time)

     while diff_time > -1:

         # 获取倒计时-时分秒

         down_minute = diff_time // 60

         down_second = diff_time % 60

         down_hour = 0

         if down_minute > 60:

             down_hour = down_minute // 60

             down_minute = down_minute % 60

         # 刷新倒计时时间

         down_time = str(down_hour).zfill(2) + '时' + str(down_minute).zfill(2) + '分' + str(down_second).zfill(2) + '秒'

         down_label.config(text=down_time)

         tk_obj.update()

         time.sleep(1)

         if diff_time == 0:

             # 倒计时结束

             down_label.config(text='已到下班时间')

             # 自动关机，定时一分钟关机，可以取消

             # down_label.config(text='下一分钟将自动关机')

             # os.system('shutdown -s -f -t 60')

             break

         diff_time -= 1

 

 

 # 程序主入口

 if __name__ == "__main__":

     # 设置页面数据

     tk_obj = Tk()

     tk_obj.geometry('400x280')

     tk_obj.resizable(0, 0)

     tk_obj.config(bg='white')

     tk_obj.title('倒计时应用')

     Label(tk_obj, text='下班倒计时', font='宋体 20 bold', bg='white').pack()

     # 设置当前时间

     Label(tk_obj, font='宋体 15 bold', text='当前时间：', bg='white').place(x=50, y=60)

     curr_time = Label(tk_obj, font='宋体 15', text='', fg='gray25', bg='white')

     curr_time.place(x=160, y=60)

     refresh_current_time()

     # 设置下班时间

     Label(tk_obj, font='宋体 15 bold', text='下班时间：', bg='white').place(x=50, y=110)

     # 下班时间-小时

     work_hour = StringVar()

     Entry(tk_obj, textvariable=work_hour, width=2, font='宋体 12').place(x=160, y=115)

     work_hour.set('18')

     # 下班时间-分钟

     work_minute = StringVar()

     Entry(tk_obj, textvariable=work_minute, width=2, font='宋体 12').place(x=185, y=115)

     work_minute.set('00')

     # 下班时间-秒数

     work_second = StringVar()

     Entry(tk_obj, textvariable=work_second, width=2, font='宋体 12').place(x=210, y=115)

     work_second.set('00')

     # 设置剩余时间

     Label(tk_obj, font='宋体 15 bold', text='剩余时间：', bg='white').place(x=50, y=160)

     down_label = Label(tk_obj, font='宋体 23', text='', fg='gray25', bg='white')

     down_label.place(x=160, y=155)

     down_label.config(text='00时00分00秒')

     # 开始计时按钮

     Button(tk_obj, text='START', bd='5', command=refresh_down_time, bg='green', font='宋体 10 bold').place(x=150, y=220)

     tk_obj.mainloop()

代码就是简简单单的204行，要实现到点自动关机的伙伴可以把63-64行的代码注释打开即可。

那最后总结一下吧，为什么shigen会选取这个程序作为今天的分享呢？

1. 跨平台。首先python是跨平台的，其次tkinter也是跨平台的，意味着在常见的操作系统都可以执行这个代码，实现倒计时的效果；


2. 新思路。其实shigen之前也做了一个类似的桌面时钟效果，做的更加酷炫一点的话，其实可以当作屏保了；


3. 小工具的改造。其实shigen的mac上也有很多的小工具，但是都是在命令行执行的，改在了GUI界面岂不是更加的nice和方便，也实现傻瓜式操作。

枚举（Enum）是一种有助于提高代码可读性和可维护性的数据类型，允许我们为一组相关的常量赋予有意义的名字。

在Python中，枚举类（Enum）提供了一种简洁而强大的方式来定义和使用枚举。

一、枚举类

1.1 什么是枚举类？

枚举类是一种特殊的数据类型，用于表示一组具有离散取值的常量。它将常量与有意义的名字关联起来，使得代码更易读、更易维护。枚举类的每个成员都有一个唯一的名称和一个关联的值。

枚举类的典型用例包括表示颜色、方向、状态、星期几等常量值。使用枚举可以增强代码的可读性，减少硬编码的风险。

1.2 Python中的枚举类

在Python中，使用内置模块enum来创建和使用枚举类。

enum模块提供了Enum类，允许定义自己的枚举类型。

二、定义和使用枚举类

2.1 定义枚举类

要定义一个枚举类，需要导入Enum类并创建一个继承自它的子类。在子类中，我们定义枚举成员，并为每个成员分配一个名称和一个关联的值。

示例代码：

from enum import Enum



class Color(Enum):

    RED = 1

    GREEN = 2

    BLUE = 3

在这个示例中，定义一个名为Color的枚举类，它有三个成员：RED、GREEN和BLUE，每个成员都有一个整数值与之关联。

2.2 访问枚举成员

定义枚举类，可以通过成员名来访问枚举成员。例如：

print(Color.RED)    # 输出：Color.RED

print(Color.GREEN)  # 输出：Color.GREEN

2.3 获取枚举成员的值

要获取枚举成员的关联值，可以使用成员的value属性。例如：

print(Color.RED.value)    # 输出：1

print(Color.GREEN.value)  # 输出：2

2.4 比较枚举成员

枚举成员可以使用相等运算符进行比较。可以直接比较枚举成员，而不必比较它们的值。例如：

color1 = Color.RED

color2 = Color.GREEN



print(color1 == color2)  # 输出：False

2.5 迭代枚举成员

使用for循环来迭代枚举类的所有成员。例如，要打印所有颜色的名称和值：

for color in Color:

    print(f"{color.name}: {color.value}")

2.6 将值映射到枚举成员

根据枚举成员的值来获取成员本身，可以通过枚举类的__members__属性来实现。

例如，要根据值获取Color枚举成员：

value = 2

color = Color(value)

print(color)  # 输出：Color.GREEN

三、枚举的最佳实践

第三部分：枚举的最佳实践

枚举是一种有用的数据类型，但在使用时需要遵循一些最佳实践，以确保代码的可读性和可维护性。

3.1 使用枚举代替魔术数字

在代码中使用枚举来代替魔术数字（不明确的常量值）可以增加代码的可读性。枚举为常量提供了有意义的名字，使得代码更容易理解。

例如，使用枚举来表示星期几：

from enum import Enum



class Weekday(Enum):

    MONDAY = 1

    TUESDAY = 2

    WEDNESDAY = 3

    THURSDAY = 4

    FRIDAY = 5

    SATURDAY = 6

    SUNDAY = 7

3.2 避免硬编码

尽量避免在代码中硬编码枚举成员的值。如果需要使用枚举成员的值，最好使用枚举成员本身而不是其值。这可以提高代码的可读性，使得代码更容易维护。

例如，避免这样的写法：

if day == 1:  # 避免硬编码

    print("Today is Monday")

而使用枚举成员：

if day == Weekday.MONDAY:  # 更具表现力

    print("Today is Monday")

3.3 使用枚举成员的名称

枚举成员的名称通常应该使用大写字母，以便与常规变量和函数名称区分开。这是一种约定，有助于提高代码的可读性。例如，使用RED而不是red。

3.4 考虑枚举成员的值类型

枚举成员的值通常是整数，但根据上下文和需求，可以选择不同的值类型，如字符串。选择适当的值类型可以使代码更具表现力。

3.5 考虑用法和上下文

在定义枚举时，考虑其用法和上下文。命名枚举成员和选择合适的值应该反映其在应用程序中的含义和用途。这有助于其他开发人员更容易理解和使用枚举。

3.6 枚举的不可变性

枚举成员是不可变的，一旦创建就不能更改其值。这有助于确保枚举成员的稳定性，并防止意外的修改。

遵循这些最佳实践可以帮助你有效地使用枚举，提高代码的可读性和可维护性。枚举是一种强大的工具，可以在代码中代替魔术数字，并提供有意义的常量名称。

总结

Python的枚举类是一种强大的工具，用于表示一组相关的常量，并提高代码的可读性和可维护性。通过枚举，我们可以为常量赋予有意义的名称，避免硬编码的值，以及更容易进行比较和迭代。

在实际编程中，枚举类可以提供一种清晰、可维护且更具表现力的方式来处理常量值。

写多了kotlin和android，最近想搞点小东西，于是拿出了长期没有宠爱的python，打算搞个小项目

想想应该写什么，对了，该吃饭了，诶，刚好，写一个能随机选择吃什么的小程序吧，只需要点击按钮，就会随机出现菜谱，然后再点一下，就会得出今天吃什么的结论

思路是这样的，读入一个txt文件，文件中写满想吃的东西，做到数据和代码区分，然后开始写UI，UI通过按钮点击随机展示美食即可

麻辣香锅

糖醋排骨

红烧肉

...

    import pygame

    import random

    ​

    class App:

        def __init__(self):

            # 初始化 Pygame

            pygame.init()

    ​

            # 创建窗口和设置标题

            self.window_size = (600, 300)

            self.window = pygame.display.set_mode(self.window_size)

            pygame.display.set_caption("What to Eat Today")

    ​

            # 设置字体对象

            self.font = pygame.font.Font('myfont.ttf', 32)

    ​

            # 加载菜单数据

            self.menu = []

            with open("menu.txt", "r") as f:

                for line in f:

                    line = line.strip()

                    if line != "":

                        self.menu.append(line)

                    print(line) # 打印数据

    ​

    if __name__ == "__main__":

        app = App()

    ​

运行一下

nice，文件已经读入

这个时候的UI是一闪而过的，因为程序瞬间就执行完毕了，ok，那么我们就需要用一个循环维持UI窗口，然后设置开始选择按键，以及键盘控制按键，同时设置变量

today_menu表示今天吃的东西，

btn_start_stop表示按键文字，

cur_menu表示正处于随机中的美食，当我们按下开始按键时，cur_menu开始变换，当我们按下关闭按键时，cur_menu的数据就赋值到today_menu中，

show_wheel表示当前正处于随机中，还是已经结束了

只要增加一个无限循环，一切就会好起来的

            # 随机选择一道菜

            self.today_menu = ""

            self.btn_start_stop = "start"

            self.cur_menu = ""

    ​

            # 游戏主循环

            self.running = True

            self.show_wheel = False

    ​

    ​

            # 开关程序

            while self.running:

                for event in pygame.event.get():

                    if event.type == pygame.QUIT:

                        self.running = False

                    elif event.type == pygame.MOUSEBUTTONDOWN:

                    ...

    ​

                    # 增加一个elif 按键s，show_wheel为true, 按下q, show_wheel为false

                    elif event.type == pygame.KEYDOWN:

                    ...

运行结果

现在已经有了窗口，接下来需要在上面画东西了

所用到的就是draw函数

        def draw(self):

            # 绘制界面

            self.window.fill((255, 255, 255))

    ​

            # 绘制菜单

            menu_surface = self.font.render(f"Today's Menu: {self.today_menu}", True, (0, 0, 0))

            ...

    ​

            # 绘制按钮

            button_size = min(self.window_size[0] // 4, self.window_size[1] // 4)

            ...

    ​

            btn_start = self.font.render(f"{self.btn_start_stop}", True, (0, 0, 0))

             # 缩小start 文字字号 以适应按钮

            btn_start = pygame.transform.scale(btn_start, (button_size // 3 * 2, button_size // 3 * 2))

            self.window.blit(btn_start, (button_x + button_size // 2 - btn_start.get_width() // 2, button_y + button_size // 2 - btn_start.get_height() // 2))

    ​

            # 滚轮动画

            ...

            pygame.display.update()

运行

上面的代码仅仅能够展示一个静态的页面，

虽然界面平平无奇，似乎只有两行字？不然，实际上暗藏玄🐔，只要我们加上这段，

            # 绘制滚轮动画

            if self.show_wheel:

                wheel_size = min(self.window_size) // 2

                wheel_x = self.window_size[0] // 2 - wheel_size // 2

                wheel_y = self.window_size[1] // 2 - wheel_size // 2

                wheel_rect = pygame.Rect(wheel_x, wheel_y, wheel_size, wheel_size)

                ...

    ​

                # 随机选择并显示菜谱

                menu_index = random.randint(0, len(self.menu) - 1)

                menu_surface = self.font.render(self.menu[menu_index], True, (0, 0, 0))

                self.window.blit(menu_surface, (wheel_x + wheel_size // 2 - menu_surface.get_width() // 2, wheel_y + wheel_size // 2 - menu_surface.get_height() // 2))

                self.cur_menu = self.menu[menu_index]

当我们点击“start"

发现中间的菜谱动了起来，动了起来！都是大家爱吃的，只需要点击右边的stop就可以固定结果！

真正麻烦的在于那个滚轮动画，可以想见，我们需要额外的一个无限循环，每一帧都要修改cur_menu，同时更新动画中的菜谱，然后点击stop后，将cur_menu赋值给到today_menu，最麻烦的不是这些逻辑，而是位置，滚轮动画的位置设置为窗口正中间，然后画了两条线，看起来更好看，有一种，狙击枪瞄准的感觉

最后，进行简单优化，比如设置定时关闭等，全代码如下，如果你也不知道吃什么，就用这段代码 + 在同目录自定义一个txt文件，把自己想吃的写上去吧

    import pygame

    import random

    ​

    class App:

        def __init__(self):

            # 初始化 Pygame

            pygame.init()

    ​

            # 创建窗口和设置标题

            self.window_size = (600, 300)

            self.window = pygame.display.set_mode(self.window_size)

            pygame.display.set_caption("What to Eat Today")

    ​

            # 设置字体对象

            self.font = pygame.font.Font('myfont.ttf', 32)

    ​

            # 加载菜单数据

            self.menu = []

            with open("menu.txt", "r") as f:

                for line in f:

                    line = line.strip()

                    if line != "":

                        self.menu.append(line)

    ​

            # 随机选择一道菜

            self.today_menu = ""

            self.btn_start_stop = "start"

            self.cur_menu = ""

    ​

            # 游戏主循环

            self.running = True

            self.show_wheel = False

            self.wheel_count = 0     # 记录滚轮动画播放的帧数

    ​

    ​

            # 开关程序

            while self.running:

                for event in pygame.event.get():

                    if event.type == pygame.QUIT:

                        self.running = False

                    elif event.type == pygame.MOUSEBUTTONDOWN:

                        if not self.show_wheel:

                            self.show_wheel = True

                            self.wheel_count = 0  # 点击按钮后重置计数器为0

                            self.btn_start_stop = "stop"

                        else:

                            self.show_wheel = False

                            self.today_menu = self.cur_menu  # 点击停止赋值

                            self.btn_start_stop = "start"

    ​

                    # 增加一个elif 按键s，show_wheel为true, 按下q, show_wheel为false

                    elif event.type == pygame.KEYDOWN:

                        if event.key == pygame.K_s:  # 按下 s 键

                            self.show_wheel = True

                            self.wheel_count = 0  # 重置计数器为0

                        elif event.key == pygame.K_q:  # 按下 q 键

                            self.show_wheel = False

                            self.today_menu = self.cur_menu  # 停止赋值

    ​

                self.draw()

    ​

        def draw(self):

            # 绘制界面

            self.window.fill((255, 255, 255))

    ​

            # 绘制菜单

            menu_surface = self.font.render(f"Today's Menu: {self.today_menu}", True, (0, 0, 0))

            menu_x = self.window_size[0] // 2 - menu_surface.get_width() // 2

            menu_y = self.window_size[1] // 2 - menu_surface.get_height() // 2

            self.window.blit(menu_surface, (menu_x, menu_y))

    ​

            # 绘制按钮

            button_size = min(self.window_size[0] // 4, self.window_size[1] // 4)

            button_x = self.window_size[0] - button_size - 20

            button_y = self.window_size[1] - button_size - 20

            button_rect = pygame.Rect(button_x, button_y, button_size, button_size)

            pygame.draw.circle(self.window, (255, 0, 0), (button_x + button_size // 2, button_y + button_size // 2), button_size // 2)

            pygame.draw.rect(self.window, (255, 255, 255), button_rect.inflate(-button_size // 8, -button_size // 8))

    ​

            btn_start = self.font.render(f"{self.btn_start_stop}", True, (0, 0, 0))

             # 缩小start 文字字号 以适应按钮

            btn_start = pygame.transform.scale(btn_start, (button_size // 3 * 2, button_size // 3 * 2))

            self.window.blit(btn_start, (button_x + button_size // 2 - btn_start.get_width() // 2, button_y + button_size // 2 - btn_start.get_height() // 2))

    ​

            # 绘制滚轮动画

            if self.show_wheel:

                wheel_size = min(self.window_size) // 2

                wheel_x = self.window_size[0] // 2 - wheel_size // 2

                wheel_y = self.window_size[1] // 2 - wheel_size // 2

                wheel_rect = pygame.Rect(wheel_x, wheel_y, wheel_size, wheel_size)

                pygame.draw.circle(self.window, (0, 0, 0), (wheel_x + wheel_size // 2, wheel_y + wheel_size // 2), wheel_size // 2)

                pygame.draw.circle(self.window, (255, 255, 255), (wheel_x + wheel_size // 2, wheel_y + wheel_size // 2), wheel_size // 2 - 10)

                pygame.draw.line(self.window, (0, 0, 0), (wheel_x + 10, wheel_y + wheel_size // 2), (wheel_x + wheel_size - 10, wheel_y + wheel_size // 2))

                pygame.draw.line(self.window, (0, 0, 0), (wheel_x + wheel_size // 2, wheel_y + 10), (wheel_x + wheel_size // 2, wheel_y + wheel_size - 10))

    ​

                # 随机选择并显示菜谱

                menu_index = random.randint(0, len(self.menu) - 1)

                menu_surface = self.font.render(self.menu[menu_index], True, (0, 0, 0))

                self.window.blit(menu_surface, (wheel_x + wheel_size // 2 - menu_surface.get_width() // 2, wheel_y + wheel_size // 2 - menu_surface.get_height() // 2))

                self.cur_menu = self.menu[menu_index]

                # 播放一定帧数后停止动画

                self.wheel_count += 1

                if self.wheel_count > 500:

                    self.show_wheel = False

                    self.today_menu = self.cur_menu  # 自动停止赋值

            pygame.display.update()

    ​

    if __name__ == "__main__":

        app = App()
作者：小松漫步
来源：juejin.cn/post/7272257829770887223


    ​