Pythonのtime.sleep関数を使って秒単位で処理を一時停止する7つの方法

import time

print("こんにちは")
time.sleep(2)
print("さようなら")

import time

print("プログラムを開始します")
time.sleep(3)  # 3秒間処理を停止
print("3秒経過しました")

プログラムを開始します
(3秒間の待機)
3秒経過しました

import time

print("0.5秒ごとにカウントダウンします")
for i in range(3, 0, -1):
    print(i)
    time.sleep(0.5)  # 0.5秒間処理を停止
print("カウントダウン終了")

0.5秒ごとにカウントダウンします
3
(0.5秒待機)
2
(0.5秒待機)
1
(0.5秒待機)
カウントダウン終了

import time

print("5秒間、1秒ごとに経過時間を表示します")
start_time = time.time()
for i in range(5):
    current_time = time.time()
    elapsed_time = current_time - start_time
    print(f"{elapsed_time:.2f}秒経過")
    time.sleep(1)  # 1秒間処理を停止
print("処理が終了しました")

5秒間、1秒ごとに経過時間を表示します
0.00秒経過
(1秒待機)
1.00秒経過
(1秒待機)
2.00秒経過
(1秒待機)
3.00秒経過
(1秒待機)
4.00秒経過
(1秒待機)
処理が終了しました

import time
import random

print("ランダムな間隔でメッセージを表示します")
for i in range(5):
    wait_time = random.uniform(0.5, 2.0)  # 0.5秒から2.0秒の間でランダムな待機時間を生成
    print(f"メッセージ {i+1}: {wait_time:.2f}秒待機します")
    time.sleep(wait_time)
print("処理が終了しました")

ランダムな間隔でメッセージを表示します
メッセージ 1: 1.23秒待機します
(1.23秒待機)
メッセージ 2: 0.87秒待機します
(0.87秒待機)
メッセージ 3: 1.56秒待機します
(1.56秒待機)
メッセージ 4: 0.62秒待機します
(0.62秒待機)
メッセージ 5: 1.91秒待機します
(1.91秒待機)
処理が終了しました

import time

print("プログラムを開始します")
print("5秒間待機しますが、Enterキーを押すと即座に再開します")

start_time = time.time()
while time.time() - start_time < 5:
    if input() == "":  # Enterキーが押されたかチェック
        break
    time.sleep(0.1)  # 0.1秒ごとにチェック

print("処理を再開しました")

プログラムを開始します
5秒間待機しますが、Enterキーを押すと即座に再開します
(ユーザーがEnterキーを押す)
処理を再開しました

import asyncio

async def task(name, delay):
    print(f"タスク {name} を開始します")
    await asyncio.sleep(delay)  # 非同期環境での待機
    print(f"タスク {name} が完了しました")

async def main():
    print("非同期処理を開始します")
    await asyncio.gather(
        task("A", 2),
        task("B", 1),
        task("C", 3)
    )
    print("すべての非同期処理が完了しました")

asyncio.run(main())

非同期処理を開始します
タスク A を開始します
タスク B を開始します
タスク C を開始します
タスク B が完了しました
タスク A が完了しました
タスク C が完了しました
すべての非同期処理が完了しました

import threading
import time

def worker(event):
    print("ワーカーが待機を開始します")
    event.wait(timeout=5)  # 最大5秒間待機
    if event.is_set():
        print("イベントが発生しました")
    else:
        print("タイムアウトしました")

def trigger(event):
    print("3秒後にイベントを発生させます")
    time.sleep(3)
    event.set()

event = threading.Event()
worker_thread = threading.Thread(target=worker, args=(event,))
trigger_thread = threading.Thread(target=trigger, args=(event,))

worker_thread.start()
trigger_thread.start()

worker_thread.join()
trigger_thread.join()

print("すべての処理が完了しました")

ワーカーが待機を開始します
3秒後にイベントを発生させます
イベントが発生しました
すべての処理が完了しました

import time
import psutil

def cpu_usage_test():
    print("CPU使用率テストを開始します")
    start_time = time.time()
    while time.time() - start_time < 5:
        time.sleep(0.001)  # 1ミリ秒の待機
    print(f"CPU使用率: {psutil.cpu_percent()}%")

cpu_usage_test()

CPU使用率テストを開始します
CPU使用率: 12.5%

import threading
import time

def worker(name, delay):
    print(f"{name} スレッドが開始しました")
    time.sleep(delay)
    print(f"{name} スレッドが終了しました")

# 2つのスレッドを作成
thread1 = threading.Thread(target=worker, args=("スレッド1", 2))
thread2 = threading.Thread(target=worker, args=("スレッド2", 1))

# スレッドを開始
thread1.start()
thread2.start()

# メインスレッドは両方のスレッドが終了するまで待機
thread1.join()
thread2.join()

print("全てのスレッドが終了しました")

スレッド1 スレッドが開始しました
スレッド2 スレッドが開始しました
スレッド2 スレッドが終了しました
スレッド1 スレッドが終了しました
全てのスレッドが終了しました

import time

def improved_long_wait(total_wait_time, check_interval=1):
    print(f"{total_wait_time}秒間の待機を開始します")
    start_time = time.time()
    elapsed_time = 0

    while elapsed_time < total_wait_time:
        time.sleep(min(check_interval, total_wait_time - elapsed_time))
        elapsed_time = time.time() - start_time
        print(f"経過時間: {elapsed_time:.2f}秒")

        # ここで必要な処理や条件チェックを行うことができます
        # 例: if some_condition(): break

    print("待機が完了しました")

# 10秒間の待機を1秒ごとにチェック
improved_long_wait(10)

10秒間の待機を開始します
経過時間: 1.00秒
経過時間: 2.00秒
経過時間: 3.00秒
経過時間: 4.00秒
経過時間: 5.00秒
経過時間: 6.00秒
経過時間: 7.00秒
経過時間: 8.00秒
経過時間: 9.00秒
経過時間: 10.00秒
待機が完了しました

import sys
print(sys.executable)
print(sys.version)

/usr/local/bin/python3
3.8.5 (default, Jul 21 2020, 10:48:26) 
[Clang 11.0.3 (clang-1103.0.32.62)]

import time
time.sleep(0.5)

import time
import math

# 方法1: 整数を使用
time.sleep(1)

# 方法2: math.floorを使用して浮動小数点数を整数に変換
sleep_time = 0.5
time.sleep(math.floor(sleep_time))

import time

try:
    print("5秒間の待機を開始します。Ctrl+Cで中断できます。")
    time.sleep(5)
    print("待機が完了しました。")
except KeyboardInterrupt:
    print("\n待機が中断されました。")
finally:
    print("プログラムを終了します。")

5秒間の待機を開始します。Ctrl+Cで中断できます。
^C
待機が中断されました。
プログラムを終了します。

import time
import requests

def rate_limited_api_call(url, max_calls, period):
    """
    指定された期間内にAPIコールの回数を制限する関数

    :param url: APIのURL
    :param max_calls: 期間内の最大呼び出し回数
    :param period: 制限を適用する期間（秒）
    """
    for i in range(max_calls + 5):  # 制限を超えるリクエストを試みる
        start_time = time.time()

        # APIリクエストを送信
        response = requests.get(url)
        print(f"リクエスト {i+1}: ステータスコード {response.status_code}")

        # 制限に達した場合、エラーメッセージを表示
        if response.status_code == 429:
            print("APIリクエスト制限に達しました。しばらく待機します。")
            time.sleep(period)  # 指定された期間待機

        # リクエスト間隔を調整
        elapsed_time = time.time() - start_time
        wait_time = max(0, (period / max_calls) - elapsed_time)
        time.sleep(wait_time)

# 使用例
api_url = "https://api.example.com/data"
rate_limited_api_call(api_url, max_calls=5, period=60)

リクエスト 1: ステータスコード 200
リクエスト 2: ステータスコード 200
リクエスト 3: ステータスコード 200
リクエスト 4: ステータスコード 200
リクエスト 5: ステータスコード 200
リクエスト 6: ステータスコード 429
APIリクエスト制限に達しました。しばらく待機します。
リクエスト 7: ステータスコード 200
...

import time
import sys

def loading_animation(duration):
    """
    指定された時間だけローディングアニメーションを表示する関数

    :param duration: アニメーションの継続時間（秒）
    """
    animation = "|/-\\"
    start_time = time.time()
    i = 0
    while time.time() - start_time < duration:
        sys.stdout.write("\r" + "Loading " + animation[i % len(animation)])
        sys.stdout.flush()
        time.sleep(0.1)
        i += 1
    sys.stdout.write("\rComplete!     \n")

# 使用例
print("処理を開始します...")
loading_animation(5)
print("処理が完了しました。")

処理を開始します...
Loading |
Loading /
Loading -
Loading \
...
Complete!     
処理が完了しました。

import time
import threading

def long_running_task():
    """時間のかかるタスクをシミュレートする関数"""
    print("長時間の処理を開始します...")
    time.sleep(10)  # 10秒間スリープして長時間の処理をシミュレート
    print("長時間の処理が完了しました。")

def run_with_timeout(task, timeout):
    """
    指定された時間内にタスクを実行する関数

    :param task: 実行するタスク（関数）
    :param timeout: タイムアウトまでの時間（秒）
    """
    thread = threading.Thread(target=task)
    thread.start()
    thread.join(timeout)
    if thread.is_alive():
        print(f"タイムアウト: {timeout}秒を超えました。")
        return False
    return True

# 使用例
print("タイムアウトありで処理を実行")
result = run_with_timeout(long_running_task, 5)
if not result:
    print("処理は中断されました。")

print("\nタイムアウトなしで処理を実行")
result = run_with_timeout(long_running_task, 15)
if result:
    print("処理は正常に完了しました。")

タイムアウトありで処理を実行
長時間の処理を開始します...
タイムアウト: 5秒を超えました。
処理は中断されました。

タイムアウトなしで処理を実行
長時間の処理を開始します...
長時間の処理が完了しました。
処理は正常に完了しました。

import time
import datetime

def periodic_task():
    """定期的に実行されるタスク"""
    current_time = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    print(f"タスクを実行しました。現在時刻: {current_time}")

def run_periodic_task(interval, duration):
    """
    指定された間隔で定期的にタスクを実行する関数

    :param interval: タスクを実行する間隔（秒）
    :param duration: 全体の実行時間（秒）
    """
    start_time = time.time()
    while time.time() - start_time < duration:
        periodic_task()
        time.sleep(interval)

# 使用例
print("1分間、10秒ごとにタスクを実行します。")
run_periodic_task(interval=10, duration=60)
print("定期実行が完了しました。")

1分間、10秒ごとにタスクを実行します。
タスクを実行しました。現在時刻: 2023-04-18 15:30:00
タスクを実行しました。現在時刻: 2023-04-18 15:30:10
タスクを実行しました。現在時刻: 2023-04-18 15:30:20
タスクを実行しました。現在時刻: 2023-04-18 15:30:30
タスクを実行しました。現在時刻: 2023-04-18 15:30:40
タスクを実行しました。現在時刻: 2023-04-18 15:30:50
定期実行が完了しました。