python3 随机延时 线程序号

（1）随机延时

delay_x_y_s( x,y ) 的意思是：

先固定延时 x 秒

再随机延时 0到y 秒

 

delay_between_x_y_s 的意思是：

随机延时 x到y 秒 

 

（2）线程序号

使用方法：直接调用函数 序号()

不加参数默认返回 (1)、(2)、(3)、....

参数为 int 类型时，返回int类型的序号值。

参数为字符串类型的模板时，返回模板并用序号值替换模板中的字符"1"。

import time
import random
import threading
import re


# region 随机延时

# 固定延时x秒
def delay_x_0_s(fixed_delay_num):
    x = float(fixed_delay_num)
    time.sleep(x)


# 随机延时 0~y 秒
def delay_0_y_s(random_delay_num):
    y = float(random_delay_num)
    time.sleep(random.random() * y)


# 先固定延时x秒，再随机延时 0~y 秒
# 延时区间，包前不包后
def delay_x_y_s(fixed_delay_num, random_delay_num):
    delay_x_0_s(fixed_delay_num)
    delay_0_y_s(random_delay_num)


# 随机延时 x~y 秒
# 延时区间，包前不包后
def delay_between_x_y_s(start_delay_num, end_delay_num):
    x = float(start_delay_num)
    y = float(end_delay_num)
    delay_x_0_s(x)
    delay_0_y_s(y - x)


# endregion 随机延时


if __name__ == '__main__':
    def delay_1_2_s():
        delay_x_y_s(1, 2)

    for i in range(5):
        start_time = time.time()
        delay_1_2_s()
        end_time = time.time()
        print()
        print(end_time - start_time)


# region 线程序号

class 线程序号类:
    def __init__(self):
        self._序号集 = {}

    @staticmethod
    def 实例化():
        return 线程序号类()

    def 序号_重置(self, 下一个序号数字=1):
        序号值 = 下一个序号数字 - 1
        线程标识符 = threading.currentThread().ident
        self._序号集[线程标识符] = 序号值

    def 序号(self, 字符串模板="(1)"):
        # region 获取序号值
        线程标识符 = threading.currentThread().ident
        try:
            序号值 = self._序号集[线程标识符]
        except:
            序号值 = 0

        try:
            序号值 += 1
        except:
            序号值 = 1
        self._序号集[线程标识符] = 序号值
        # endregion

        # region 输出序号值
        if repr(type(字符串模板)) == "<class 'int'>": return 序号值
        字符串模板 = str(字符串模板)
        数字match = re.match("([^0-9]*)([0-9]*)([\s\S]*)", 字符串模板)
        模板序号值 = f"{数字match.group(1)}{序号值}{数字match.group(3)}"
        return 模板序号值
        # endregion

_静态序号生成器 = 线程序号类.实例化()

def 序号_重置(下一个序号数字=1):
    _静态序号生成器.序号_重置(下一个序号数字)

def 序号(字符串模板="(1)"):
    return _静态序号生成器.序号(字符串模板)

# endregion 线程序号


if __name__ == '__main__':
    def delay_0_500_ms():
        delay_x_y_s(0, 500/1000)

    def mythread_1():
        for i in range(5):
            delay_0_500_ms()
            print(f"{序号()}:这是第一个线程")

    def mythread_2():
        for i in range(5):
            delay_0_500_ms()
            print(f'{序号("_1_")}: —————— 这是第二个线程')

    print()
    print()
    threading.Thread(target=mythread_1).start()
    threading.Thread(target=mythread_2).start()