Python 实战项目：结合 while 循环和 time 模块的 15 个创意应用-51CTO.COM

Python 的 while 循环和 time 模块是非常实用的工具，可以用来创建各种有趣的应用。今天我们就来探索一下如何将这两个工具结合起来，实现一些创意十足的小项目。从简单的倒计时器到复杂的自动化任务，我们会一步步引导你完成这些项目。

1. 倒计时器

首先，我们来做一个简单的倒计时器。这个项目会从用户输入的时间开始倒数，直到时间结束。

import time

# 获取用户输入的时间（秒）
seconds = int(input("请输入倒计时的秒数: "))

while seconds > 0:
    print(f"倒计时: {seconds} 秒")
    time.sleep(1)  # 暂停1秒
    seconds -= 1

print("时间到！")

解释：

input() 函数获取用户输入的时间。
while 循环在 seconds 大于 0 时继续执行。
time.sleep(1) 让程序暂停1秒。
每次循环后，seconds 减少1，直到为0。

2. 进度条

接下来，我们做一个进度条，显示任务的完成进度。

import time

total_steps = 100
step = 0

while step <= total_steps:
    percent = (step / total_steps) * 100
    bar = ('=' * int(percent / 2)).ljust(50)
    print(f"[{bar}] {percent:.2f}%", end='\r')
    time.sleep(0.1)  # 模拟任务处理时间
    step += 1

print("\n任务完成！")

解释：

total_steps 定义总步数。
while 循环在 step 小于等于 total_steps 时继续执行。
percent 计算当前进度的百分比。
bar 创建进度条字符串。
end='\r' 让输出在同一行更新。
time.sleep(0.1) 模拟任务处理时间。

3. 简易闹钟

我们可以用 while 循环和 time 模块制作一个简易闹钟。

import time

# 获取用户输入的闹钟时间（格式：HH:MM）
alarm_time = input("请输入闹钟时间 (HH:MM): ")
current_time = time.strftime("%H:%M")

while current_time != alarm_time:
    current_time = time.strftime("%H:%M")
    time.sleep(1)

print("闹钟响了！")

解释：

input() 获取用户输入的闹钟时间。
time.strftime("%H:%M") 获取当前时间。
while 循环在当前时间不等于闹钟时间时继续执行。
time.sleep(1) 每秒检查一次时间。

4. 自动刷新网页

如果你需要定期刷新某个网页，可以用 selenium 库结合 while 循环和 time 模块来实现。

from selenium import webdriver
import time

# 启动浏览器
driver = webdriver.Chrome()

url = "https://www.example.com"
refresh_interval = 60  # 刷新间隔（秒）

while True:
    driver.get(url)
    print("页面已刷新")
    time.sleep(refresh_interval)

解释：

webdriver.Chrome() 启动 Chrome 浏览器。
driver.get(url) 打开指定的网页。
while True 无限循环。
time.sleep(refresh_interval) 每隔一段时间刷新一次页面。

5. 数据采集

使用 requests 库和 while 循环，可以定期从某个网站抓取数据。

import requests
import time

url = "https://api.example.com/data"
interval = 30  # 抓取间隔（秒）

while True:
    response = requests.get(url)
    if response.status_code == 200:
        data = response.json()
        print(data)
    else:
        print("请求失败")
    time.sleep(interval)

解释：

requests.get(url) 发送 HTTP GET 请求。
response.status_code 检查响应状态码。
response.json() 解析 JSON 格式的数据。
time.sleep(interval) 每隔一段时间抓取一次数据。

6. 自动发送邮件

使用 smtplib 和 email 库，结合 while 循环和 time 模块，可以定期发送邮件。

import smtplib
from email.mime.text import MIMEText
import time

sender = 'your_email@example.com'
receiver = 'receiver_email@example.com'
password = 'your_password'
subject = '定期邮件'
body = '这是一封定期发送的邮件。'

msg = MIMEText(body)
msg['From'] = sender
msg['To'] = receiver
msg['Subject'] = subject

server = smtplib.SMTP('smtp.example.com', 587)
server.starttls()
server.login(sender, password)

send_interval = 3600  # 发送间隔（秒）

while True:
    server.sendmail(sender, receiver, msg.as_string())
    print("邮件已发送")
    time.sleep(send_interval)

解释：

MIMEText 创建邮件内容。
smtplib.SMTP 连接 SMTP 服务器。
server.starttls() 启用 TLS 加密。
server.login() 登录邮箱。
server.sendmail() 发送邮件。
time.sleep(send_interval) 每隔一段时间发送一次邮件。

7. 自动备份文件

可以定期备份文件，确保数据安全。

import shutil
import time
import os

source_file = 'path/to/source/file.txt'
backup_dir = 'path/to/backup/directory'
backup_interval = 3600  # 备份间隔（秒）

if not os.path.exists(backup_dir):
    os.makedirs(backup_dir)

while True:
    backup_file = os.path.join(backup_dir, f"backup_{int(time.time())}.txt")
    shutil.copy(source_file, backup_file)
    print(f"文件已备份到 {backup_file}")
    time.sleep(backup_interval)

解释：

shutil.copy() 复制文件。
os.path.join() 拼接备份文件路径。
os.makedirs() 创建备份目录。
time.time() 获取当前时间戳。
time.sleep(backup_interval) 每隔一段时间备份一次文件。

8. 实时监控系统资源

使用 psutil 库，可以实时监控系统的 CPU 和内存使用情况。

import psutil
import time

check_interval = 5  # 监控间隔（秒）

while True:
    cpu_usage = psutil.cpu_percent(interval=1)
    memory_usage = psutil.virtual_memory().percent
    print(f"CPU 使用率: {cpu_usage}%")
    print(f"内存使用率: {memory_usage}%")
    time.sleep(check_interval)

解释：

psutil.cpu_percent(interval=1) 获取 CPU 使用率。
psutil.virtual_memory().percent 获取内存使用率。
time.sleep(check_interval) 每隔一段时间检查一次系统资源。

9. 自动下载文件

可以定期从某个 URL 下载文件。

import requests
import time
import os

url = "https://example.com/file.zip"
download_dir = 'path/to/download/directory'
download_interval = 3600  # 下载间隔（秒）

if not os.path.exists(download_dir):
    os.makedirs(download_dir)

while True:
    file_name = os.path.join(download_dir, f"file_{int(time.time())}.zip")
    response = requests.get(url)
    if response.status_code == 200:
        with open(file_name, 'wb') as file:
            file.write(response.content)
        print(f"文件已下载到 {file_name}")
    else:
        print("下载失败")
    time.sleep(download_interval)

解释：

requests.get(url) 发送 HTTP GET 请求。
response.content 获取文件内容。
with open(file_name, 'wb') as file 写入文件。
time.sleep(download_interval) 每隔一段时间下载一次文件。

10. 自动重启服务

如果某个服务挂了，可以自动重启它。

import subprocess
import time

service_name = 'your_service'
check_interval = 60  # 检查间隔（秒）

while True:
    result = subprocess.run(['systemctl', 'is-active', service_name], capture_output=True, text=True)
    if 'inactive' in result.stdout:
        subprocess.run(['systemctl', 'start', service_name])
        print(f"{service_name} 已重启")
    else:
        print(f"{service_name} 正在运行")
    time.sleep(check_interval)

解释：

subprocess.run() 执行系统命令。
capture_output=True 捕获命令输出。
text=True 以文本形式返回输出。
time.sleep(check_interval) 每隔一段时间检查一次服务状态。

11. 自动更新软件

可以定期检查并更新软件。

import subprocess
import time

update_command = 'sudo apt update && sudo apt upgrade -y'
check_interval = 3600  # 检查间隔（秒）

while True:
    subprocess.run(update_command, shell=True)
    print("软件已更新")
    time.sleep(check_interval)

解释：

subprocess.run(update_command, shell=True) 执行更新命令。
time.sleep(check_interval) 每隔一段时间更新一次软件。

12. 自动清理日志文件

定期清理日志文件，防止磁盘空间被占满。

import os
import time

log_dir = 'path/to/log/directory'
cleanup_interval = 3600  # 清理间隔（秒）

while True:
    for file_name in os.listdir(log_dir):
        file_path = os.path.join(log_dir, file_name)
        if os.path.isfile(file_path):
            os.remove(file_path)
            print(f"已删除 {file_path}")
    time.sleep(cleanup_interval)

解释：

os.listdir(log_dir) 获取日志目录中的文件列表。
os.path.join(log_dir, file_name) 拼接文件路径。
os.remove(file_path) 删除文件。
time.sleep(cleanup_interval) 每隔一段时间清理一次日志文件。

13. 自动同步文件夹

可以定期同步两个文件夹的内容。

import shutil
import time
import os

source_dir = 'path/to/source/directory'
target_dir = 'path/to/target/directory'
sync_interval = 3600  # 同步间隔（秒）

if not os.path.exists(target_dir):
    os.makedirs(target_dir)

while True:
    for item in os.listdir(source_dir):
        source_item = os.path.join(source_dir, item)
        target_item = os.path.join(target_dir, item)
        if os.path.isfile(source_item):
            shutil.copy(source_item, target_item)
            print(f"已同步 {source_item} 到 {target_item}")
        elif os.path.isdir(source_item):
            shutil.copytree(source_item, target_item)
            print(f"已同步 {source_item} 到 {target_item}")
    time.sleep(sync_interval)

解释：

shutil.copy() 复制文件。
shutil.copytree() 复制目录。
time.sleep(sync_interval) 每隔一段时间同步一次文件夹。

14. 自动发送短信

使用 twilio 库，可以定期发送短信。

from twilio.rest import Client
import time

account_sid = 'your_account_sid'
auth_token = 'your_auth_token'
client = Client(account_sid, auth_token)

to_phone_number = '+1234567890'
from_phone_number = '+0987654321'
message_body = '这是一条定期发送的短信。'
send_interval = 3600  # 发送间隔（秒）

while True:
    message = client.messages.create(
        to=to_phone_number,
        from_=from_phone_number,
        body=message_body
    )
    print(f"短信已发送，消息ID: {message.sid}")
    time.sleep(send_interval)

解释：

Client(account_sid, auth_token) 创建 Twilio 客户端。
client.messages.create() 发送短信。
time.sleep(send_interval) 每隔一段时间发送一次短信。

15. 自动记录系统事件

可以定期记录系统事件，方便后续分析。

import logging
import time

log_file = 'path/to/log/file.log'
log_interval = 60  # 记录间隔（秒）

logging.basicConfig(filename=log_file, level=logging.INFO, format='%(asctime)s - %(message)s')

while True:
    logging.info("系统正常运行")
    time.sleep(log_interval)

解释：

logging.basicConfig() 配置日志记录。
logging.info() 记录日志信息。
time.sleep(log_interval) 每隔一段时间记录一次系统事件。

实战案例：自动备份数据库

假设你有一个 MySQL 数据库，需要定期备份。我们可以结合 while 循环和 time 模块来实现这个功能。

import os
import time
import subprocess

db_host = 'localhost'
db_user = 'root'
db_password = 'your_password'
db_name = 'your_database'
backup_dir = 'path/to/backup/directory'
backup_interval = 3600  # 备份间隔（秒）

if not os.path.exists(backup_dir):
    os.makedirs(backup_dir)

while True:
    timestamp = int(time.time())
    backup_file = os.path.join(backup_dir, f"{db_name}_{timestamp}.sql")
    
    # 构建 mysqldump 命令
    dump_cmd = f"mysqldump -h {db_host} -u {db_user} -p{db_password} {db_name} > {backup_file}"
    
    # 执行备份命令
    subprocess.run(dump_cmd, shell=True)
    
    print(f"数据库已备份到 {backup_file}")
    time.sleep(backup_interval)

解释：

os.makedirs(backup_dir) 创建备份目录。
timestamp 获取当前时间戳。
dump_cmd 构建 mysqldump 命令。
subprocess.run(dump_cmd, shell=True) 执行备份命令。
time.sleep(backup_interval) 每隔一段时间备份一次数据库。

总结

本文介绍了如何结合 while 循环和 time 模块实现15个创意应用，包括倒计时器、进度条、简易闹钟、自动刷新网页、数据采集、自动发送邮件、自动备份文件、实时监控系统资源、自动下载文件、自动重启服务、自动更新软件、自动清理日志文件、自动同步文件夹、自动发送短信、自动记录系统事件，以及一个实战案例：自动备份数据库。