想象一下，你的程序在执行复杂任务时，不再是冷冰冰的等待光标，而是伴随着色彩斑斓、动态变化的进度条，不仅让等待变得有趣，更让用户对你的作品刮目相看。从基础的文本进度条到高级的图形界面进度条，从简单的百分比显示到复杂的动画效果，我们将一一解锁这些技能，让你的Python技能再上新台阶。

思维导图知识点

使用简单的print语句

对于简单的进度显示，你可以通过计算任务的当前进度并打印出来。

import time  # 导入time模块，用于实现程序中的时间延迟，模拟下载过程中的耗时  
  
total = 100  # 定义一个变量total，并赋值为100，表示下载任务的总单位是100个单位  
# 这里假设下载任务被分为了100个等分的单位，实际应用中这个值可能代表文件大小、数据块数量等  
  
for i in range(total + 1):  # 使用for循环遍历从0到total（包含total）的整数序列  
    # 注意这里使用了total+1，因为range的结束值是开区间，所以需要+1来确保循环能够遍历到100%  
    percent = (i / float(total)) * 100  # 计算当前进度百分比  
    # i是当前遍历到的单位数，float(total)确保进行浮点数除法，从而得到精确的小数结果  
    # 然后将结果乘以100得到百分比  
      
    print(f"\r下载进度: {percent:.2f}%", end="")  # 打印进度信息  
    # \r是一个特殊的转义字符，表示将光标移回当前行的开头，这样每次打印都会覆盖前一次的进度信息  
    # f-string用于格式化字符串，{percent:.2f}%表示将percent变量格式化为保留两位小数的浮点数，并附加%符号  
    # end=""参数的作用是防止print函数自动换行，从而保持进度信息在同一行显示  
      
    time.sleep(0.1)  # 调用time模块的sleep函数，让程序暂停0.1秒  
    # 这里模拟了下载过程中的时间消耗，实际应用中这里可能是执行下载操作的代码  
  
print("\n下载完成！")  # 当循环结束后，打印“下载完成！”信息  
# \n是一个特殊的转义字符，表示换行，这样“下载完成！”信息会出现在新的一行

需要注意的是，由于print函数在每次循环中都会输出进度信息，并且使用了\r来覆盖前一次的输出，所以在命令行或终端中运行时，你会看到进度条不断更新，直到达到100%并显示“下载完成！”的信息。然而，在某些IDE的内置控制台或某些特定环境下，\r的行为可能不符合预期，导致进度条无法正常显示或显示混乱。在这些情况下，可以尝试调整IDE的设置或使用其他方法来实现进度条的显示。

简单的文本进度条

这种进度条使用等号=或井号#等字符来表示进度。

import time  # 导入time模块，用于实现时间延迟，模拟耗时操作  
import sys  # 导入sys模块，特别是为了使用sys.stdout.write和sys.stdout.flush来直接写入和刷新标准输出  
  
def simple_progress_bar(total, progress):  
    """  
    显示一个简单的进度条  
  
    :param total: 进度条的总长度（或总任务量）  
    :param progress: 当前进度（已完成的任务量）  
    """  
    bar_length = 50  # 进度条的长度，这里设置为50个字符  
    filled_length = int(round(bar_length * progress / float(total)))  # 计算已完成的进度条长度  
    # 注意这里使用了float(total)确保除法结果是浮点数，然后通过round和int转换得到整数长度  
    percents = round(100.0 * progress / float(total), 1)  # 计算并格式化当前进度的百分比，保留一位小数  
    bar = '=' * filled_length + '-' * (bar_length - filled_length)  # 根据已完成和未完成的长度生成进度条字符串  
    # 使用'='表示已完成的进度，'-'表示未完成的进度  
    sys.stdout.write(f'\r进度：[{bar}] {percents}%')  # 将进度条信息写回标准输出，\r使光标回到行首  
    # 这样新的进度信息就会覆盖旧的进度信息，实现进度条的更新效果  
    sys.stdout.flush()  # 刷新标准输出缓冲区，确保进度条信息立即显示  
  
# 模拟进度  
total = 100  # 设置总任务量为100  
for i in range(total + 1):  # 循环从0到total（包含total），即模拟从0%到100%的进度  
    simple_progress_bar(total, i)  # 调用simple_progress_bar函数，传入总任务量和当前进度  
    time.sleep(0.1)  # 暂停0.1秒，模拟耗时操作  
print("\n完成!")  # 当循环完成后，打印“完成!”信息，并自动换行

使用sys.stdout.write和sys.stdout.flush

这与使用print类似，但更加直接地控制输出。这种方法在某些情况下（如多线程或多进程环境下）可能更稳定。

# 导入sys模块，用于访问与Python解释器紧密相关的变量和函数，这里主要用于访问stdout（标准输出）  
import sys    
# 导入time模块，用于提供与时间相关的各种函数，这里主要用于在每次更新进度后暂停一段时间  
import time    
  
# 设定总进度为100，代表下载任务的总部分数  
total = 100    
# 使用for循环遍历从0到total（包含total，即101次迭代），每次迭代代表进度增加了一个单位  
for i in range(total + 1):    
    # 计算当前的进度百分比，通过将当前迭代次数i除以总次数total并乘以100得到  
    percent = (i / float(total)) * 100    
    # 使用sys.stdout.write方法写入当前进度信息到标准输出，\r表示将光标移回行首，以便在同一行更新进度  
    # f-string用于格式化字符串，{percent:.2f}%将percent变量格式化为保留两位小数的浮点数，并加上百分号  
    sys.stdout.write(f"\r下载进度: {percent:.2f}%")    
    # sys.stdout.flush()确保立即将缓冲区内容输出到标准输出，而不是等待缓冲区满或程序结束  
    sys.stdout.flush()    
    # time.sleep(0.1)暂停当前线程0.1秒，模拟下载过程中的时间消耗  
    time.sleep(0.1)    
# 循环结束后，打印换行符和“下载完成！”消息，表示下载任务已完成  
print("\n下载完成！")

需要注意的是，这段代码在大多数终端或命令行界面中能够正确运行，并显示逐渐增加的下载进度。但是，在一些不支持\r（回车符，用于将光标移回行首而不换行）的界面中，可能无法看到进度更新的效果，而是会看到进度条不断被新的进度信息覆盖。此外，由于使用了sys.stdout.write而不是print函数来输出进度信息，因此不会在每次更新后自动添加换行符，这也是为了在同一个位置更新进度条所必需的。

自定义形状的进度条

跟文本进度条差不多，这次展示另外一种形状，如果你想要一个特定形状的进度条（比如用星号*表示进度），你可以通过修改simple_progress_bar函数中的字符来实现。

import time  # 导入time模块，用于在循环中模拟耗时操作
import sys  # 导入sys模块，用于操作与Python解释器交互的一些变量和函数


# 定义一个函数，用于显示自定义形状的进度条
def custom_shape_progress_bar(total, progress):
    bar_length = 50  # 设置进度条的总长度为50个字符
    filled_length = int(round(bar_length * progress / float(total)))  # 计算已完成的进度条长度，并四舍五入为整数
    percents = round(100.0 * progress / float(total), 1)  # 计算进度百分比，保留一位小数
    bar = '▋' * filled_length + ' ' * (bar_length - filled_length)  # 构造进度条字符串，使用'▋'表示已完成部分，空格表示未完成部分
    sys.stdout.write(f'\r[{bar}] {percents}% 进度')  # 使用sys.stdout.write打印进度条，\r表示回到当前行的开头，这样进度条会在同一行更新
    sys.stdout.flush()  # 强制将缓冲区的内容输出到标准输出设备，确保进度条即时更新


# 模拟进度
total = 100  # 设置总进度为100
for i in range(total + 1):  # 循环从0到100（包括100），共101次迭代，以模拟进度从0%到100%
    custom_shape_progress_bar(total, i)  # 调用自定义进度条函数，传入总进度和当前进度
    time.sleep(0.1)  # 暂停0.1秒，模拟耗时操作
print("\n完成!")  # 循环结束后，打印"完成!"，并换行

带有时间的进度条

这个进度条将显示当前进度百分比，并同时显示已经过去的时间和剩余时间的估算（基于当前进度和总任务数）。

import time  
import sys  
  
# 假设我们总共有100个任务要完成  
total_tasks = 100  
  
# 开始时间  
start_time = time.time()  
  
# 用于存储上一次更新时间  
last_update_time = start_time  
  
# 遍历任务  
for i in range(total_tasks + 1):  # 加1是为了在循环结束时也能显示100%  
    # 计算当前进度百分比  
    progress = (i / total_tasks) * 100  
  
    # 更新时间，但每0.1秒更新一次以避免控制台输出过于频繁  
    current_time = time.time()  
    if current_time - last_update_time > 0.1:  
        # 计算已经过去的时间  
        elapsed_time = current_time - start_time  
  
        # 估算剩余时间（基于当前进度和已用时间）  
        if progress > 0:  
            estimated_remaining_time = (elapsed_time / progress) * (100 - progress)  
        else:  
            estimated_remaining_time = 0  # 如果进度为0，则剩余时间为0  
  
        # 清除当前行（为了在同一行更新进度条）  
        # 注意：在Windows上可能需要使用'\r'而不是'\r\n'  
        sys.stdout.write('\r')  
  
        # 显示进度条  
        # 使用50个字符的宽度来显示进度，可以根据需要调整  
        progress_bar = '[' + '=' * int(progress / 2) + ' ' * (25 - int(progress / 2)) + ']'  
        # 注意：这里的'/2'是为了让进度条更紧凑，因为我们要用50个字符表示100%的进度  
  
        # 格式化并打印进度、时间和剩余时间  
        print(f'Progress: {progress_bar} {progress:.2f}% | Elapsed: {elapsed_time:.2f}s | Remaining: {estimated_remaining_time:.2f}s', end='')  
  
        # 更新上一次更新时间  
        last_update_time = current_time  
  
    # 暂停以模拟任务执行时间  
    time.sleep(0.1)  
  
# 完成后换行  
print()

1. 导入必要的库：time用于时间操作，sys用于访问与Python解释器紧密相关的变量和函数，特别是sys.stdout.write用于向标准输出写入内容。
2. 设置总任务数：定义total_tasks变量，表示要完成的任务总数。
3. 记录开始时间：使用time.time()获取当前时间戳，并存储在start_time变量中。
4. 遍历任务：通过for循环遍历从0到total_tasks（包括total_tasks，用于显示100%的进度）的整数序列。
5. 计算进度和更新时间：在循环内部，计算当前进度百分比，并检查是否需要更新进度条（通过比较当前时间和上一次更新时间）。
6. 清除当前行：使用sys.stdout.write(‘\r’)清除当前行的内容，以便在同一行上更新进度条。
7. 显示进度条：根据进度百分比绘制进度条，并计算已用时间和剩余时间的估算值。
8. 格式化输出：使用print函数（注意end=''参数以避免在末尾添加换行符）来格式化并打印进度、时间和剩余时间的信息。
9. 暂停以模拟任务：使用time.sleep(0.1)模拟每个任务的执行时间。
10. 完成后换行：在循环结束后，打印一个空行以美化输出。

progress实现进度条

注意 progress 输出的进度条可能在Pycharm控制台上无法显示，Windows最好在黑窗口中运行，MAC最好在终端上运行

progress 换行进度条

import time  # 导入time模块，用于在迭代中引入暂停，以模拟长时间运行的任务
from progress.bar import IncrementalBar  # 从progress.bar模块导入IncrementalBar类，用于显示进度条

num = range(1, 11)  # 创建一个range对象，表示从1到10的整数序列

bar = IncrementalBar('倒计时', max=len(num))  # 创建一个IncrementalBar实例，命名为'倒计时'，并设置其最大值为num的长度（即10）
for item in num:  # 遍历num中的每个元素
    bar.next()  # 调用bar的next方法，以更新进度条到下一个位置
    time.sleep(1)  # 暂停1秒，模拟长时间运行的任务
    bar.finish()

progress基础进度条

这个简单的案例展示了如何使用IncrementalBar来创建一个基本的进度条，该进度条在每次迭代时自动更新。

from progress.bar import IncrementalBar  
import time  
  
# 假设我们要执行100个任务  
max_value = 100  
  
# 创建一个IncrementalBar实例，传入最大值  
bar = IncrementalBar('Processing', max=max_value)  
  
# 模拟任务执行  
for i in range(max_value):  
    # 在这里执行一些操作，比如处理文件、计算等  
    time.sleep(0.1)  # 模拟耗时操作  
    # 更新进度条  
    bar.next()  
  
# 当所有任务完成后，确保进度条完成显示  
bar.finish()

progress自定义前缀和后缀的进度条

我们可以在前缀中显示任务名称，在后缀中显示剩余时间

from progress.bar import IncrementalBar  
import time  
  
# 假设我们要执行100个任务  
max_value = 100  
  
# 创建一个IncrementalBar实例，传入最大值和自定义的前缀、后缀  
bar = IncrementalBar('Processing Files: ', suffix='%(percent)d%% - %(eta)ds', max=max_value)  
  
# 注意：IncrementalBar本身不直接计算ETA（预计剩余时间），但我们可以模拟或忽略它  
  
# 模拟任务执行  
for i in range(max_value):  
    time.sleep(0.1)  # 模拟耗时操作  
    bar.next()  
  
bar.finish()

注意：虽然在这个示例中我们使用了suffix参数来包含%(eta)ds，但IncrementalBar默认不计算ETA。如果你需要ETA，你可能需要使用Bar或ProgressBar类，并手动更新进度和预计时间。

alive_progress进度条

注意 alive_progress
输出的进度条可能在Pycharm控制台上无法显示，Windows最好在黑窗口中运行，MAC最好在终端上运行

alive_progress基本进度条

这个简单的案例展示了如何使用alive_progress包来创建一个基本的进度条，该进度条在循环迭代时自动更新。

from alive_progress import alive_bar  # 导入alive_bar  
import time  
  
# 总任务数  
total_tasks = 100  
  
# 使用with语句自动管理alive_bar的生命周期  
with alive_bar(total_tasks) as bar:  # 创建一个alive_bar对象，并将其总数设置为total_tasks  
    for i in range(total_tasks):  # 遍历任务  
        # 模拟耗时操作  
        time.sleep(0.1)  
        bar()  # 调用bar对象本身来更新进度条，这里可以传递一些参数来自定义进度条，但在这个例子中我们保持简单  
  
# 当with语句块结束时，alive_bar会自动完成并清理资源

自定义样式和主题的进度条

这个案例展示了如何自定义alive_progress进度条的样式和主题，包括进度条的颜色、填充字符等。

# 导入alive_progress包中的alive_bar类，用于创建进度条实例  
# 同时导入config_handler类，用于配置进度条的全局样式和主题  
from alive_progress import alive_bar, config_handler

# 导入time模块，用于在模拟任务执行时添加延迟，从而观察进度条的更新过程  
import time

# 使用config_handler的set_global方法设置进度条的全局样式和主题  
# 这里设置了主题为'smooth'，进度条样式为'blocks'（块状填充），旋转器样式为'twirls'  
config_handler.set_global(
    theme='smooth',  # 设置全局主题为'smooth'，这通常影响颜色方案和背景  
    bar='blocks',  # 设置全局进度条样式为'blocks'，即使用块状来填充进度条  
    spinner='twirls',  # 设置全局旋转器样式为'twirls'，这是一种特定的旋转动画效果  
)

# 定义需要执行的总任务数  
total_tasks = 100

# 使用with语句和alive_bar上下文管理器创建一个进度条实例  
# alive_bar的构造函数接收总任务数（total_tasks）和标题（'Custom Style Progress Bar'）作为参数  
# with语句确保了进度条实例在代码块执行完毕后能够被正确关闭和清理  
with alive_bar(total_tasks, title='Custom Style Progress Bar') as bar:
    # 开始一个循环，模拟执行总任务数指定的任务  
    for i in range(total_tasks):
        # 使用time.sleep函数模拟任务执行的耗时，这里每次循环等待0.1秒  
        # 这使得进度条能够随着循环的迭代而逐渐更新  
        time.sleep(0.1)
        bar()  # 显式调用bar()来更新进度条  

# 当with语句块结束时，alive_bar上下文管理器将自动处理进度条的完成状态  
# 无需显式调用任何完成方法，进度条将自动显示完成状态

更多alive_progress进度条

网址：https://github.com/rsalmei/alive-progress

tqdm进度条

tqdm 是一个快速、可扩展的 Python 进度条库，可以在 Python 长循环中添加一个进度提示信息，用户只需要封装任意的迭代器 tqdm(iterator)

基本的 for 循环进度条

在一个基本的 for 循环中使用 tqdm 来显示进度条。

from tqdm import tqdm
import time

# 假设我们要处理100个任务
for i in tqdm(range(100)):  # 使用tqdm封装range
    time.sleep(0.1)  # 模拟每个任务需要一些时间

# 输出：将显示一个进度条，从0%到100%，每完成一个迭代项就更新一次

手动更新进度条

在某些情况下，你可能无法直接使用迭代器，这时可以手动更新进度条。

from tqdm import tqdm
import time

# 创建一个tqdm对象，但不立即开始
pbar = tqdm(total=100)  # 设置总任务量为100

for i in range(100):
    time.sleep(0.1)  # 模拟任务处理时间
    pbar.update(1)  # 手动更新进度条，每次增加1

pbar.close()  # 完成后关闭进度条

# 输出：同样显示从0%到100%的进度条

嵌套循环进度条

在嵌套循环中使用 tqdm，为外层循环和内层循环都添加进度条。

from tqdm import tqdm  
import time  
  
# 外层循环  
outer_pbar = tqdm(range(10), desc='Outer loop')  # desc参数用于设置进度条描述  
for i in outer_pbar:  
    inner_pbar = tqdm(range(10), desc=f'Inner loop {i}', leave=False)  # leave=False表示进度条完成后不保留  
    for j in inner_pbar:  
        time.sleep(0.05)  # 模拟任务处理时间  
    outer_pbar.update(1)  # 外层循环也需要更新进度条，尽管在这里它会自动更新  
  
# 输出：首先显示外层循环的进度条，每次外层迭代开始时显示内层循环的进度条

在 Pandas 中使用 tqdm

当使用 Pandas 进行数据处理时，可以利用 tqdm 显示处理进度。

from tqdm import tqdm
import pandas as pd
import numpy as np
import time

# 创建一个大的DataFrame
df = pd.DataFrame(np.random.randint(0, 100, size=(1000, 4)), columns=list('ABCD'))

# 假设我们要对每一行进行处理
for i in tqdm(df.index, total=df.shape[0], desc='Processing rows'):
    time.sleep(0.01)
    # 这里只是简单地取每行的A列值，实际中可以是复杂的处理
    _ = df.loc[i, 'A']

    # 输出：显示处理行的进度条

PySimpleGUI制作进度条

PySimpleGUI是一个用于创建图形用户界面的Python库，它封装了多个GUI框架（如Tkinter、PyQt等），使得创建GUI变得更加简单。

基本进度条

展示如何在PySimpleGUI窗口中创建一个基本的进度条，并通过按钮点击事件来更新进度。

import PySimpleGUI as sg  
import time  
  
# 定义窗口布局  
layout = [  
    [sg.Text('进度条示例', size=(30, 1), font=("Helvetica", 25))],  
    [sg.ProgressBar(100, orientation='h', size=(30, 20), key='-PROGRESS-')],  
    [sg.Button('更新进度', size=(10, 1)), sg.Button('退出', size=(10, 1))]  
]  
  
# 创建窗口  
window = sg.Window('进度条示例', layout)  
  
# 事件循环  
while True:  
    event, values = window.read()  
    if event == sg.WIN_CLOSED or event == '退出':  # 如果点击了关闭窗口按钮或退出按钮  
        break  
    elif event == '更新进度':  # 如果点击了更新进度按钮  
        for i in range(101):  # 进度从0到100  
            window['-PROGRESS-'].update(i)  # 更新进度条  
            time.sleep(0.1)  # 暂停0.1秒以模拟进度  
  
# 关闭窗口  
window.close()

带标签的进度条

在进度条旁边添加一个标签来显示当前进度百分比。

import PySimpleGUI as sg  
import time  
  
# 定义窗口布局  
layout = [  
    [sg.Text('带标签的进度条示例', size=(30, 1), font=("Helvetica", 25))],  
    [sg.Text('当前进度: 0%', size=(15, 1), key='-STATUS-'), sg.ProgressBar(100, orientation='h', size=(30, 20), key='-PROGRESS-')],  
    [sg.Button('更新进度', size=(10, 1)), sg.Button('退出', size=(10, 1))]  
]  
  
# 创建窗口  
window = sg.Window('带标签的进度条示例', layout)  
  
# 事件循环  
while True:  
    event, values = window.read()  
    if event == sg.WIN_CLOSED or event == '退出':  
        break  
    elif event == '更新进度':  
        for i in range(101):  
            window['-PROGRESS-'].update(i)  
            window['-STATUS-'].update(f'当前进度: {i}%')  
            time.sleep(0.1)  
  
# 关闭窗口  
window.close()

实时任务进度条

模拟一个需要较长时间完成的任务，并实时更新进度条。

import PySimpleGUI as sg  
import time  
  
# 定义窗口布局  
layout = [  
    [sg.Text('实时任务进度条示例', size=(30, 1), font=("Helvetica", 25))],  
    [sg.ProgressBar(1000, orientation='h', size=(40, 20), key='-PROGRESS-'), sg.Text('任务执行中...', size=(20, 1))],  
    [sg.Cancel()]  # 添加一个取消按钮  
]  
  
# 创建窗口  
window = sg.Window('实时任务进度条示例', layout)  
  
# 进度条变量  
progress = 0  
  
# 模拟任务  
try:  
    while True:  
        event, values = window.read(timeout=100)  # 设置超时时间为100毫秒  
        if event == sg.WIN_CLOSED or event == 'Cancel':  
            break  
        progress += 10  # 假设每次循环进度增加10  
        window['-PROGRESS-'].update(progress)  
        if progress >= 1000:  # 假设任务总进度为1000  
            break  
        time.sleep(0.1)  # 暂停0.1秒  
except Exception as e:  
    print(e)  
  
# 关闭窗口  
window.close()

推荐阅读

Python基础

Python全网最全基础课程笔记(一)——基础入门
Python全网最全基础课程笔记(二)——变量
Python全网最全基础课程笔记(三)——所有运算符+运算符优先级
Python全网最全基础课程笔记(四)——基本数据类型
Python全网最全基础课程笔记(五)——选择结构+Python新特性Match
Python全网最全基础课程笔记(六)——循环结构
Python全网最全基础课程笔记(七)——列表，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(八)——字典，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(九)——集合，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(十)——元组，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(十一)——字符串所有操作，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(十二)——函数，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！
Python全网最全基础课程笔记(十三)——作用域，跟着思维导图和图文来学习，爆肝2w字，无数代码案例！

Flink入门到就业

2024年最新Flink教程,从基础到就业，大家一起学习–基础篇
2024年最新Flink教程,从基础到就业，大家一起学习–入门篇
2024年最新Flink教程,从基础到就业，大家一起学习–Flink集群部署
2024年最新Flink教程,从基础到就业，大家一起学习–flink部署和集群部署(从本地测试到公司生产环境如何部署项目源码)
2024年最新Flink教程,从基础到就业，大家一起学习–Flink运行架构底层源码详解+实战
2024年最新Flink教程,从基础到就业，大家一起学习–Flink DataStream API-第一篇+源码讲解