Python on Coding and Life

使用mongodb自带的ObjectID获取记录生成时间

Wed, 01 Jun 2022 14:02:38 +0800

有些时候，我们在写入mongo数据的时候，可能需要记录这条数据的插入时间，我们一般情况下回给记录增加一个 create_time。

实际上，如果我们插入的数据含有 ObjectId 的话，那么其实这个id是包含了生成时间的，同时也可以作为记录的主键，一举多得。

以python为例，我们有这样一条记录：

document = {
    "_id": ObjectId("5dfc8ac5d3fa12967b8888ec"),
    "user": "mike",
    "age": 19,
}

这时候，我们可以使用ObjectId自带的generation_time属性，获取这条记录的插入时间：

time = ObjectId("5dfc8ac5d3fa12967b8888ec").generation_time
print(time)

输出：

datetime.datetime(2019, 12, 20, 8, 48, 5, tzinfo=<bson.tz_util.FixedOffset object at 0x7f874030f9a0>)

需要注意到的是，里面的时区信息，显示的是一个 FixedOffset，即固定偏移，我们看 generation_time 属性的定义：


utc = FixedOffset(0, "UTC")
"""Fixed offset timezone representing UTC."""

class ObjectId(object):
    # ... 省略其他代码 ...
    @property
    def generation_time(self):
        """A :class:`datetime.datetime` instance representing the time of
        generation for this :class:`ObjectId`.

        The :class:`datetime.datetime` is timezone aware, and
        represents the generation time in UTC. It is precise to the
        second.
        """
        timestamp = struct.unpack(">I", self.__id[0:4])[0]
        return datetime.datetime.fromtimestamp(timestamp, utc)

可以看到这个属性是从一个时间戳生成的，并且生成的时候指定了固定的 UTC-0 时区，而我们是处于东八区，因此，如果直接使用 generation_time 属性的话，得到的时间并非我们当前时区的时间，还需要做一个转化，只需要简单的对 datetime.datetime 对象调用astimezone方法，即可：

使用Pip Tools生成好看的依赖文件

Tue, 24 May 2022 14:16:18 +0800

项目地址： https://pypi.org/project/pip-tools/

pip-tools 是一个命令行工具集合，主要有两个命令： pip-compile，pip-sync，现在主要用的是 pip-compile

在写python项目的时候，我们通常会依赖到其他的包，比如写一个后端的服务，我们可能会依赖到flask/pymysql这些基础的包，随着开发的进行，我们还可能会引入更多的依赖。

这些python依赖包构成了一个完整的服务，开发完成后，我们将这些服务部署到服务器上时，只需要安装好对应的依赖，便可以直接运行服务。

但是，如果我们不将生产环境的依赖固定下来的话，整个服务可能会因为某一次服务更新，其中某个的更新带来的不兼容导致整个服务崩溃。比如pyjwt，在1.7.1版本之前生成的jwt-token是一个bytes类型，我们将其转换成为字符串需要使用到decode()方法。但是在更新到2.0之后，生成的jwt-token是一个字符串类型，如果我们对其再调用decode方法的话，就会发生错误。

这就显现出了固定依赖的重要性了。

通常，固定依赖，我们可以在开发环境使用 pip freeze命令，直接将开发环境的所有版本固定下来到一个 requirements.txt 文件里面，这是懒人做法，当然也很有效。但是文件里面会带有一些系统的依赖版本，比如urllib 之类的，这些我们是不需要再次安装的，所以，如果这些依赖出现在 requirements.txt 文件里面，就会显得不那么干净。

这时，我们可以使用 pip-tools里面的 pip-compile 工具，对依赖进行编译，生成一份漂亮的依赖文件。

直接生成最新依赖

首先，我们将项目中直接依赖的包写到requirements.in文件里面

requirements.in

pymysql
flask

使用 pip-compile 自动使用最新依赖版本生成依赖文件

命令： pip-compile, 输出requirements.txt文件：

requirements.txt

#
# This file is autogenerated by pip-compile with python 3.8
# To update, run:
#
#    pip-compile
#
--index-url https://pypi.doubanio.com/simple
--trusted-host pypi.doubanio.com

click==8.1.3
    # via flask
flask==2.1.2
    # via -r requirements.in
importlib-metadata==4.11.4
    # via flask
itsdangerous==2.1.2
    # via flask
jinja2==3.1.2
    # via flask
markupsafe==2.1.1
    # via jinja2
pymysql==1.0.2
    # via -r requirements.in
werkzeug==2.1.2
    # via flask
zipp==3.8.0
    # via importlib-metadata

这样，我们就得到了一份漂亮的依赖文件，我们还可以清晰的看到某一个依赖包是哪个包的依赖。

Python Functools: 几个有意思的工具函数

Thu, 05 May 2022 09:38:45 +0800

functools 模块应用于高阶函数，即参数或（和）返回值为其他函数的函数，如装饰器、sorted函数的key参数等。通常来说，此模块功能适用于所有可调用对象。

https://docs.python.org/zh-cn/3/library/functools.html

发现functools里面有几个有意思的函数，记录一下：

cmp_to_key

将(旧式的)比较函数转换为新式的 key function . 在类似于 sorted() ， min() ， max() ， heapq.nlargest() ， heapq.nsmallest() ， itertools.groupby() 等函数的 key 参数中使用。此函数主要用作将 Python 2 程序转换至新版的转换工具，以保持对比较函数的兼容。

比较函数意为一个可调用对象，该对象接受两个参数并比较它们，结果为小于则返回一个负数，相等则返回零，大于则返回一个正数。key function则是一个接受一个参数，并返回另一个用以排序的值的可调用对象。

实例：

使用sorted + cmp_to_key，实现逆序排序

from functools import cmp_to_key
def mycmp(a, b):
    return b - a
arr = [1,9,3,7,8,2]
arr = sorted(arr, key=cmp_to_key(mycmp))
print(arr)

输出：

[9, 8, 7, 3, 2, 1]

一般的 key function 只接受一个参数，使用cmp_to_key，可以实现自定义的排序逻辑，如上述，也可以实现其他逻辑，比较经典的是 leetcode-179最大数，要求我们将数字按照特定的规律排序，然后返回一个长的字符串，参考答案：

class Solution:
    def largestNumber(self, nums: List[int]) -> str:
        # 第一步：定义比较函数，把最大的放左边
        # 第二步：排序
        # 第三步：返回结果
        def compare(x, y): return int(y+x) - int(x+y)
        nums = sorted(map(str, nums), key=cmp_to_key(compare))
        print(cmp_to_key)
        return "0" if nums[0]=="0" else "".join(nums)

如上述的排序，也可以做一个自定义的排序逻辑，如：如果是偶数，排序在前面，奇数排序在后面，然后奇数和偶数各自排序：

使用python socket实现双向的tcp通信

Fri, 22 Apr 2022 13:53:32 +0800

很久之前玩过的python socket，今天用来做个双向的通信程序。

服务端代码：

server.py

# coding: utf-8
# tcp stream server
import socket
import logging
import time
import datetime as dt
from threading import Thread, currentThread
# 配置logging
logging.basicConfig(
    level=logging.INFO,
    format="%(asctime)s %(levelname)s %(process)s %(threadName)s |%(message)s",
)


class Server:
    """ socket 服务端 """
    def __init__(self, host='localhost', port=8099):
        self._sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
        self._sock.bind((host, port))
        self.msg = None

    def read(self, conn: socket.socket = None):
        """ 从tcp连接里面读取数据 """
        while True:
            try:
                data = conn.recv(1024).decode()
            except Exception as e:
                logging.info("recv failed: %s", e)
                return
            logging.info("[R %s]<< %s", currentThread().getName(), data)
            self.msg = data
            time.sleep(1)

    def write(self, conn: socket.socket = None):
        """ 向tcp连接里面写入数据 """
        while True:
            msg = f"{dt.datetime.now()} - {self.msg}"
            logging.info("[W %s]>> %s", currentThread().getName(), msg)
            try:
                conn.send(msg.encode())
            except Exception as e:
                logging.info("send failed: %s", e)
                return
            time.sleep(1)

    def serve(self):
        """ 开启服务 """
        self._sock.listen()
        logging.info("Serving...")
        while True:
            logging.info("Waiting for connection...")
            conn, addr = self._sock.accept()
            logging.info("Recived new conn: %s from %s", conn, addr)
            # 开启读写线程处理当前连接
            Thread(target=self.read, args=(conn, )).start()
            Thread(target=self.write, args=(conn, )).start()


if __name__ == '__main__':
    s = Server()
    s.serve()

以上就是服务端代码，简单的开启了一个socket服务器，接受连接，然后开启两个线程，每隔一秒，同时向连接中读写数据。