python可视化：tqdm进度条控制台输出模块

前言

        在处理大量数据或执行耗时操作时，了解代码执行的进度是至关重要的。在Python中，通过使用进度条可以有效地实现对代码执行进度的可视化展示。

        tqdm 是一个快速、可扩展的Python进度条库，能够实时显示代码执行的进度。并且它提供了简洁的API，因此开发者可以轻松地为循环、迭代器等任务添加进度条，让你一目了然地了解代码执行的进展情况。

        

基础使用

from tqdm import tqdm
import time


# 某个你需要执行的方法
def time_cut(data):
    # 每次调用，休眠data*0.1秒
    time.sleep(data * 0.1)


# 模拟一个耗时的任务，调用同一个方法10次
def some_long_task():
    for index in tqdm(range(10), desc="Processing"):
        # 模拟任务处理时间
        time_cut(index)


# 调用耗时任务函数
some_long_task()

顺序执行

from tqdm import tqdm
import time


def method_A():
    # 模拟方法A的执行
    time.sleep(1)
    return "Method A result"


def method_B():
    # 模拟方法B的执行
    time.sleep(1)
    return "Method B result"


def method_C():
    # 模拟方法C的执行
    time.sleep(1)
    return "Method C result"


# 顺序执行A、B、C三个方法，并显示进度条
def sequential_ABC():
    results = []

    # 使用tqdm显示进度条
    with tqdm(total=100) as pbar:
        # 执行方法A
        result_A = method_A()
        results.append(result_A)
        pbar.update(30)  # 更新进度条

        # 执行方法B
        result_B = method_B()
        results.append(result_B)
        pbar.update(30)  # 更新进度条

        # 执行方法C
        result_C = method_C()
        results.append(result_C)
        pbar.update(40)  # 更新进度条

    return results


# 调用顺序执行方法的函数
if __name__ == "__main__":
    results = sequential_ABC()
    print("结果:", results)

 多线程调用

        这里要注意一下，如果子线程一旦使用print()输出，将导致出现梯形进度条

import concurrent.futures
from tqdm import tqdm
import time


# 并行处理的主函数
def parallel_processing(data_list, num_threads):
    with concurrent.futures.ThreadPoolExecutor(max_workers=num_threads) as executor:
        futures = []
        for data in data_list:
            if data % 2 == 0:
                future = executor.submit(process_data, data)
            else:
                future = executor.submit(process_data1, data)
            futures.append(future)

        # 使用tqdm包装executor.map以显示进度条
        results = []
        with tqdm(total=len(data_list), desc="process") as pbar:
            for future in concurrent.futures.as_completed(futures):
                result = future.result()
                results.append(result)
                pbar.update(1)

    return results


# 你的并行处理函数
def process_data(data):
    time.sleep(data)  # 模拟处理数据的耗时操作
    return data * 2  # 假设这里是对数据进行处理的函数


# 你的并行处理函数
def process_data1(data):
    time.sleep(1)  # 模拟处理数据的耗时操作
    return data * 2  # 假设这里是对数据进行处理的函数


if __name__ == "__main__":
    # 要处理的数据列表
    data_list = list(range(10))

    # 设置线程数量
    num_threads = 4

    # 调用并行处理函数
    results = parallel_processing(data_list, num_threads)

    # 打印结果
    print("处理结果:", results)

         我没研究解决方案，如果有人能解决这一问题，请评论区指教

多进程调用

        【tqdm】貌似不支持管理【下属多进程任务】，因此你可能需要在【tqdm】之上建立进程来管理【tqdm和与之关联的任务】，而不是在tqdm下级建立进程

        并且相同的是，tqdm与多线程一样，如果下属任务有print()操作也将导致梯形进度条

from tqdm import tqdm
import multiprocessing
import time


def method_way1(data):
    # 模拟方法A的执行
    time.sleep(data)
    return f"Method1 sleep {data}"


def method_way2():
    # 模拟方法A的执行
    time.sleep(1)
    return f"Method2 sleep 1"


def method_way3():
    # 模拟方法A的执行
    time.sleep(2)
    return f"Method3 sleep 2"


# 使用tqdm显示进度条
def tqdm_multi(data, desc):
    # 使用tqdm显示进度条
    results = []
    with tqdm(total=100, desc=desc) as pbar:
        # 执行方法1
        result_1 = method_way1(data)
        results.append(result_1)
        pbar.update(40)  # 更新进度条

        # 执行方法2
        result_2 = method_way2()
        results.append(result_2)
        pbar.update(30)  # 更新进度条

        # 执行方法3
        result_3 = method_way3()
        results.append(result_3)
        pbar.update(30)  # 更新进度条

    print(results)


# 调用顺序执行方法的函数
if __name__ == "__main__":
    data = 4
    a = multiprocessing.Process(target=tqdm_multi, args=(data, 'proess A'))
    a.start()
    a.join()

    b = multiprocessing.Process(target=tqdm_multi, args=(data, 'proess B'))
    b.start()

         其实，考虑不在子方法里输出print()也可以，请君自便吧