Pythonでプログラムを一時停止｜sleep関数の基礎

みなさん、プログラムを書いているとき「ちょっと待機させたい」「時間を空けて処理したい」と思ったことはありませんか？

「プログラムを数秒止めるにはどうすればいい？」「待機時間を自由に設定できるの？」こんな疑問を感じたことはないでしょうか？

実は、sleep関数を使うことで、プログラムを好きな時間だけ一時停止できます。この記事を読めば、sleep関数の基本から実践的な活用法まで理解できるようになります。

今回は、Pythonのsleep関数について、基本的な使い方から実際のプロジェクトでの活用例まで詳しく解説します。一緒にsleep関数をマスターしていきましょう！

sleep関数って何？

Pythonでプログラムの実行を制御するための基本的な機能を学びましょう。

基本的な概念

sleep関数は、指定した時間だけプログラムの実行を一時停止する関数です。

簡単に言うと、「プログラムを○秒間眠らせる」機能なんです。例えば、処理の間に3秒待機させたり、0.5秒の短い間隔を作ったりできます。

基本的な使い方を見てみましょう。

import time

print("処理開始")
time.sleep(3)  # 3秒間一時停止
print("3秒後に実行されます")

この例では、「処理開始」が表示された後、3秒間プログラムが停止します。その後、「3秒後に実行されます」が表示されます。

timeモジュールのインポート

sleep関数を使用するには、timeモジュールをインポートする必要があります。

# timeモジュールをインポート
import time

# これでsleep関数が使用可能
time.sleep(秒数)

import timeと書くだけで、sleep関数が使えるようになります。とても簡単ですよね！

基本的な使い方

様々な時間指定でsleep関数を使ってみましょう。

秒単位での一時停止

整数で秒数を指定する基本的な使い方です。

import time

def basic_sleep_examples():
    print("1秒待機の例")
    print("開始...")
    time.sleep(1)  # 1秒停止
    print("1秒経過しました")
    
    print("
3秒待機の例")
    print("開始...")
    time.sleep(3)  # 3秒停止
    print("3秒経過しました")
    
    print("
5秒待機の例")
    print("開始...")
    time.sleep(5)  # 5秒停止
    print("5秒経過しました")

basic_sleep_examples()

実行結果はこちらです。

1秒待機の例
開始...
（1秒待機）
1秒経過しました

3秒待機の例
開始...
（3秒待機）
3秒経過しました

5秒待機の例
開始...
（5秒待機）
5秒経過しました

time.sleep(数字)で、指定した秒数だけプログラムが停止します。とても分かりやすいですね。

小数点以下の指定

より細かい時間制御も可能です。

import time

def precise_sleep_examples():
    print("0.5秒（500ミリ秒）待機")
    print("開始...")
    time.sleep(0.5)  # 0.5秒停止
    print("0.5秒経過")
    
    print("
0.1秒（100ミリ秒）待機")
    print("開始...")
    time.sleep(0.1)  # 0.1秒停止
    print("0.1秒経過")
    
    print("
2.5秒待機")
    print("開始...")
    time.sleep(2.5)  # 2.5秒停止
    print("2.5秒経過")

precise_sleep_examples()

実行結果はこちらです。

0.5秒（500ミリ秒）待機
開始...
（0.5秒待機）
0.5秒経過

0.1秒（100ミリ秒）待機
開始...
（0.1秒待機）
0.1秒経過

2.5秒待機
開始...
（2.5秒待機）
2.5秒経過

小数点を使うことで、1秒未満の細かい制御ができます。リアルタイムな処理に便利ですね。

実用的な活用例

実際のプログラムでよく使われる場面を見てみましょう。

カウントダウンタイマー

数字を数えながら時間を表示するプログラムです。

import time

def countdown_timer(seconds):
    print(f"{seconds}秒のカウントダウンを開始します")
    
    for i in range(seconds, 0, -1):
        print(f"{i}...")
        time.sleep(1)  # 1秒ずつ待機
    
    print("🎉 時間です！")

# 5秒のカウントダウン
countdown_timer(5)

実行結果はこちらです。

5秒のカウントダウンを開始します
5...
（1秒待機）
4...
（1秒待機）
3...
（1秒待機）
2...
（1秒待機）
1...
（1秒待機）
🎉 時間です！

forループとsleepを組み合わせることで、自然なカウントダウンが作れます。

デジタル時計

現在時刻を1秒ごとに更新表示するプログラムです。

import time
from datetime import datetime

def digital_clock(duration=60):
    print("デジタル時計開始（Ctrl+Cで停止）")
    
    try:
        for _ in range(duration):
            current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
            print(f"\r{current_time}", end="", flush=True)
            time.sleep(1)  # 1秒ごとに更新
    except KeyboardInterrupt:
        print("
時計を停止しました")

# 10秒間時計を表示
digital_clock(10)

この長いコードは時計機能の全体像です。一つずつ見ていきましょう。

まず、現在時刻の取得部分です。

current_time = datetime.now().strftime("%Y-%m-%d %H:%M:%S")

datetime.now()で現在時刻を取得して、見やすい形式に整えています。

次に、表示の更新部分です。

print(f"\r{current_time}", end="", flush=True)
time.sleep(1)

\rで行の先頭に戻り、同じ場所に新しい時刻を表示します。 1秒待機してから次の更新を行います。

プログレスバー

処理の進行状況を視覚的に表示するツールです。

import time

def progress_bar(total_steps=10):
    print("処理開始...")
    
    for i in range(total_steps + 1):
        # プログレスバーの作成
        progress = int(50 * i / total_steps)  # 50文字のバー
        bar = "=" * progress + "-" * (50 - progress)
        percentage = int(100 * i / total_steps)
        
        print(f"\r[{bar}] {percentage}%", end="", flush=True)
        
        if i < total_steps:
            time.sleep(0.5)  # 0.5秒ずつ進行
    
    print("
✅ 処理完了！")

progress_bar(10)

実行結果はこちらです。

処理開始...
[--------------------------------------------------] 0%
[=====---------------------------------------------] 10%
[==========------------------------------------] 20%
...
[==================================================] 100%
✅ 処理完了！

プログレスバーでは、処理の進捗を視覚的に表現できます。ユーザーにとって分かりやすい表示ですね。

APIリクエストの間隔調整

Webサービスに負荷をかけないよう、適切な間隔でリクエストを送る例です。

import time
import requests

def fetch_data_with_delay(urls, delay=1):
    results = []
    
    for i, url in enumerate(urls):
        print(f"リクエスト {i+1}/{len(urls)}: {url}")
        
        try:
            response = requests.get(url)
            results.append({
                'url': url,
                'status': response.status_code,
                'success': response.status_code == 200
            })
            print(f"✅ 成功: ステータスコード {response.status_code}")
            
        except Exception as e:
            print(f"❌ エラー: {e}")
            results.append({
                'url': url,
                'status': None,
                'success': False
            })
        
        # 最後のリクエスト以外で待機
        if i < len(urls) - 1:
            print(f"{delay}秒待機中...")
            time.sleep(delay)
    
    return results

# 各リクエスト間に2秒の間隔
urls = [
    "https://httpbin.org/delay/1",
    "https://httpbin.org/status/200",
    "https://httpbin.org/json"
]

results = fetch_data_with_delay(urls, delay=2)

このコードでは、各APIリクエストの間に指定した秒数の待機時間を設けています。 サーバーに負荷をかけない礼儀正しいプログラムの実装例です。

高度な時間制御

より柔軟な時間制御の方法を学びましょう。

ランダムな待機時間

毎回異なる待機時間を設定する方法です。

import time
import random

def random_sleep_example():
    print("ランダムな間隔で処理を実行")
    
    for i in range(5):
        # 1秒から3秒のランダムな待機
        wait_time = random.uniform(1, 3)
        print(f"処理 {i+1}: {wait_time:.2f}秒待機")
        time.sleep(wait_time)
        print(f"処理 {i+1} 完了")

random_sleep_example()

実行結果はこちらです。

ランダムな間隔で処理を実行
処理 1: 2.34秒待機
（2.34秒待機）
処理 1 完了
処理 2: 1.67秒待機
（1.67秒待機）
処理 2 完了
...

random.uniform()を使うことで、毎回異なる待機時間を設定できます。自然な動作を演出したい場合に便利です。

条件付き待機

処理の内容に応じて待機時間を調整する方法です。

import time

def conditional_sleep_example():
    tasks = [
        {"name": "軽い処理", "complexity": 1},
        {"name": "普通の処理", "complexity": 2},
        {"name": "重い処理", "complexity": 3}
    ]
    
    for task in tasks:
        print(f"実行中: {task['name']}")
        
        # 複雑さに応じて待機時間を調整
        wait_time = task['complexity'] * 0.5
        time.sleep(wait_time)
        
        print(f"✅ {task['name']} 完了（{wait_time}秒）")

conditional_sleep_example()

実行結果はこちらです。

実行中: 軽い処理
✅ 軽い処理 完了（0.5秒）
実行中: 普通の処理
✅ 普通の処理 完了（1.0秒）
実行中: 重い処理
✅ 重い処理 完了（1.5秒）

処理の重さに応じて待機時間を動的に調整できます。より現実的なシミュレーションが可能ですね。

時間の測定と組み合わせ

処理時間を測定しながらsleepを使う例です。

import time

def measure_with_sleep():
    def simulate_work(work_name, work_time):
        print(f"開始: {work_name}")
        start_time = time.time()
        
        # 作業のシミュレーション（sleep）
        time.sleep(work_time)
        
        end_time = time.time()
        elapsed_time = end_time - start_time
        
        print(f"完了: {work_name} ({elapsed_time:.2f}秒)")
        return elapsed_time
    
    # 複数の作業を順次実行
    works = [
        ("データ取得", 1.5),
        ("データ処理", 2.0),
        ("結果保存", 1.0)
    ]
    
    total_time = 0
    for work_name, work_time in works:
        elapsed = simulate_work(work_name, work_time)
        total_time += elapsed
        
        # 作業間に少し間隔を空ける
        time.sleep(0.5)
    
    print(f"
📊 総実行時間: {total_time:.2f}秒")

measure_with_sleep()

実行結果はこちらです。

開始: データ取得
完了: データ取得 (1.50秒)
開始: データ処理
完了: データ処理 (2.00秒)
開始: 結果保存
完了: 結果保存 (1.00秒)

📊 総実行時間: 4.50秒

time.time()と組み合わせることで、処理時間の測定も同時に行えます。

sleepの注意点と制限

sleep関数を使用する際に知っておくべき重要なポイントです。

正確性について

sleep関数の時間精度には限界があります。

import time

def sleep_accuracy_test():
    print("sleep関数の正確性テスト")
    
    for sleep_duration in [0.1, 0.5, 1.0, 2.0]:
        print(f"
{sleep_duration}秒のsleepテスト:")
        
        # 5回測定して平均を計算
        total_diff = 0
        for i in range(5):
            start = time.time()
            time.sleep(sleep_duration)
            end = time.time()
            
            actual_duration = end - start
            difference = actual_duration - sleep_duration
            total_diff += difference
            
            print(f"  試行{i+1}: 予定{sleep_duration}秒 → 実際{actual_duration:.4f}秒 (差:{difference:.4f}秒)")
        
        avg_diff = total_diff / 5
        print(f"  平均誤差: {avg_diff:.4f}秒")

sleep_accuracy_test()

実行結果はこちらです。

sleep関数の正確性テスト

0.1秒のsleepテスト:
  試行1: 予定0.1秒 → 実際0.1015秒 (差:0.0015秒)
  試行2: 予定0.1秒 → 実際0.1012秒 (差:0.0012秒)
  ...
  平均誤差: 0.0013秒

sleep関数は完全に正確ではないことが分かります。微小な誤差があることを理解しておきましょう。

プラットフォームによる違い

WindowsやMac、Linuxで動作が異なる場合があります。

import time
import platform

def platform_sleep_info():
    print(f"実行環境: {platform.system()} {platform.release()}")
    print(f"Pythonバージョン: {platform.python_version()}")
    
    # 最小sleep時間のテスト
    print("
最小sleep時間のテスト:")
    
    min_times = [0.001, 0.01, 0.1]
    for min_time in min_times:
        start = time.time()
        time.sleep(min_time)
        end = time.time()
        
        actual = end - start
        print(f"sleep({min_time}): 実際は{actual:.4f}秒")

platform_sleep_info()

実行結果はこちらです。

実行環境: Darwin 20.6.0
Pythonバージョン: 3.9.7

最小sleep時間のテスト:
sleep(0.001): 実際は0.0015秒
sleep(0.01): 実際は0.0105秒
sleep(0.1): 実際は0.1008秒

環境によって精度が変わることを覚えておきましょう。

CPUリソースの使用

sleepを使うことでCPUリソースを効率的に使えます。

import time

def cpu_usage_comparison():
    print("CPU使用率の比較")
    
    def busy_wait(duration):
        """ビジーウェイト（CPU使用率高）"""
        start = time.time()
        while time.time() - start < duration:
            pass  # 何もしないが、CPUを使い続ける
    
    def sleep_wait(duration):
        """sleep使用（CPU使用率低）"""
        time.sleep(duration)
    
    print("1. ビジーウェイト（CPU使用率が高い）")
    start = time.time()
    busy_wait(1)
    print(f"実行時間: {time.time() - start:.2f}秒")
    
    print("
2. sleep使用（CPU使用率が低い）")
    start = time.time()
    sleep_wait(1)
    print(f"実行時間: {time.time() - start:.2f}秒")
    
    print("
💡 sleepを使うとCPUリソースを他の処理に回せます")

cpu_usage_comparison()

実行結果はこちらです。

CPU使用率の比較
1. ビジーウェイト（CPU使用率が高い）
実行時間: 1.00秒

2. sleep使用（CPU使用率が低い）
実行時間: 1.00秒

💡 sleepを使うとCPUリソースを他の処理に回せます

sleepを使うとCPUに優しいプログラムが作れます。

代替手段と応用

sleep以外の時間制御方法も知っておきましょう。

threading.Timerを使った遅延実行

指定時間後に関数を実行する方法です。

import threading
import time

def delayed_execution_example():
    def delayed_function(message):
        print(f"遅延実行: {message}")
    
    print("メイン処理開始")
    
    # 3秒後に関数を実行
    timer = threading.Timer(3.0, delayed_function, args=["3秒後のメッセージ"])
    timer.start()
    
    # メイン処理は続行
    for i in range(5):
        print(f"メイン処理 {i+1}")
        time.sleep(1)
    
    print("メイン処理終了")
    
    # タイマーの完了を待つ
    timer.join()

delayed_execution_example()

実行結果はこちらです。

メイン処理開始
メイン処理 1
メイン処理 2
メイン処理 3
遅延実行: 3秒後のメッセージ
メイン処理 4
メイン処理 5
メイン処理終了

threading.Timerを使うと、メイン処理と並行して時間待ちができます。

asyncioを使った非同期待機

複数の処理を同時に実行しながら待機する方法です。

import asyncio
import time

async def async_sleep_example():
    async def async_task(name, duration):
        print(f"{name} 開始")
        await asyncio.sleep(duration)  # 非同期sleep
        print(f"{name} 完了 ({duration}秒)")
    
    print("非同期処理開始")
    start_time = time.time()
    
    # 複数のタスクを並行実行
    await asyncio.gather(
        async_task("タスク1", 2),
        async_task("タスク2", 3),
        async_task("タスク3", 1)
    )
    
    end_time = time.time()
    print(f"全体実行時間: {end_time - start_time:.2f}秒")

# 実行方法（Jupyter notebookなどでは直接実行可能）
# asyncio.run(async_sleep_example())

非同期処理では、複数のタスクを同時に実行できます。より効率的な時間制御が可能になります。

実際のプロジェクトでの活用

実務でよく使われる具体例を見てみましょう。

Webスクレイピングでの使用

サーバーに負荷をかけないよう、適切な間隔でデータを取得する例です。

import time
import requests
from bs4 import BeautifulSoup

def polite_web_scraper(urls, delay=2):
    print(f"Webスクレイピング開始（間隔: {delay}秒）")
    
    scraped_data = []
    
    for i, url in enumerate(urls):
        print(f"
{i+1}/{len(urls)}: {url}")
        
        try:
            response = requests.get(url)
            soup = BeautifulSoup(response.content, 'html.parser')
            
            # タイトルを取得
            title = soup.find('title')
            title_text = title.text.strip() if title else "タイトルなし"
            
            scraped_data.append({
                'url': url,
                'title': title_text,
                'status': response.status_code
            })
            
            print(f"✅ 取得成功: {title_text}")
            
        except Exception as e:
            print(f"❌ エラー: {e}")
            scraped_data.append({
                'url': url,
                'title': None,
                'status': None
            })
        
        # サーバーに負荷をかけないよう待機
        if i < len(urls) - 1:
            print(f"{delay}秒待機中...")
            time.sleep(delay)
    
    return scraped_data

# 使用例（実際のスクレイピングでは利用規約を確認してください）
test_urls = [
    "https://httpbin.org/html",
    "https://httpbin.org/json"
]

Webスクレイピングでは、サーバーへの配慮が非常に重要です。適切な間隔を設けることで、礼儀正しいプログラムが作れます。

自動化スクリプトでの使用

定期的な処理を自動実行するスクリプトの例です。

import time
import os
from datetime import datetime

def automated_backup_simulation():
    def simulate_backup(backup_name):
        print(f"🔄 {backup_name} 開始...")
        
        # バックアップ処理のシミュレーション
        time.sleep(2)  # 実際の処理時間をシミュレート
        
        print(f"✅ {backup_name} 完了")
        return True
    
    backup_tasks = [
        "データベースバックアップ",
        "ファイルシステムバックアップ",
        "設定ファイルバックアップ"
    ]
    
    print(f"🚀 自動バックアップ開始: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
    
    for i, task in enumerate(backup_tasks):
        print(f"
--- {i+1}/{len(backup_tasks)} ---")
        
        success = simulate_backup(task)
        
        if not success:
            print("❌ バックアップ失敗。処理を中断します。")
            break
        
        # タスク間に少し間隔を空ける
        if i < len(backup_tasks) - 1:
            print("⏳ 次のタスクまで少し待機...")
            time.sleep(1)
    
    print(f"
🎉 すべてのバックアップ完了: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")

# デモ用の短縮バックアップ
def quick_backup_demo():
    tasks = ["DB", "ファイル", "設定"]
    
    for i, task in enumerate(tasks):
        print(f"{task}バックアップ中...")
        time.sleep(1)  # 1秒で短縮
        print(f"✅ {task} 完了")
        
        if i < len(tasks) - 1:
            time.sleep(0.5)  # 短い間隔

quick_backup_demo()

実行結果はこちらです。

DBバックアップ中...
✅ DB 完了
ファイルバックアップ中...
✅ ファイル 完了
設定バックアップ中...
✅ 設定 完了

自動化スクリプトでは、処理間に適切な間隔を設けることで、システムに負荷をかけない安全な動作を実現できます。

まとめ

Pythonのsleep関数について、基本から実践まで詳しく解説しました。

基本的な使い方

import time
time.sleep(秒数)  # 指定した秒数だけ一時停止

主な活用場面

タイマー・カウントダウンの実装
API リクエスト間隔の調整
ユーザーインターフェースの制御
自動化スクリプトでの処理間隔
テスト・デバッグでの動作確認

重要なポイント

小数点以下の時間も指定可能（例：time.sleep(0.5)）
プラットフォームにより正確性が異なる場合がある
CPU リソースを効率的に使用できる
礼儀正しいプログラムの実装に必須

注意事項

長時間のsleepはユーザビリティを損なう可能性がある
Webスクレイピングでは適切な間隔を設定する
非同期処理ではasyncio.sleep()の使用を検討する

sleep関数を適切に使うことで、より自然で効率的なプログラムを作成できます。処理のタイミング制御は、実用的なアプリケーション開発において非常に重要な技術です。

ぜひ今回学んだ知識を活用して、様々なプロジェクトでsleep関数を使ってみてください！適切な時間制御により、ユーザーにとって快適なプログラムが作れますよ。

Pythonでプログラムを一時停止｜sleep関数の基礎

Pythonでプログラムを一時停止｜sleep関数の基礎

sleep関数って何？

基本的な概念

timeモジュールのインポート

基本的な使い方

秒単位での一時停止

小数点以下の指定

実用的な活用例

カウントダウンタイマー

デジタル時計

プログレスバー

APIリクエストの間隔調整

高度な時間制御

ランダムな待機時間

条件付き待機

時間の測定と組み合わせ

sleepの注意点と制限

正確性について

プラットフォームによる違い

CPUリソースの使用

代替手段と応用

threading.Timerを使った遅延実行

asyncioを使った非同期待機

実際のプロジェクトでの活用

Webスクレイピングでの使用

自動化スクリプトでの使用

まとめ

関連記事

Python with文とは？ファイル操作を安全に行う方法

Python タプルアンパック｜複数の値を展開する基礎

Python 文字列のreplace()入門｜文字を置き換える方法