Pythonでの日時フォーマット完全ガイド｜strftime・strptime・タイムゾーンの使い方

Pythonでプログラムを作っていると、「今の時間を表示したい」「日付の形式を変えたい」「文字で書かれた日付をプログラムで使えるようにしたい」といった場面がよく出てきます。

そんなときに活躍するのが、Pythonの日時フォーマット機能です。これを使えば、日付や時刻を自由自在に操作できるようになります。

この記事では、Pythonで日時を扱うための基本的な方法から、実際のプロジェクトで使える応用テクニックまで、初心者の方にもわかりやすく説明します。

この記事で学べること

• 現在の日時を取得する方法
• 日時を好きな形式で表示する方法（strftime）
• 文字列を日時データに変換する方法（strptime）
• 世界各地の時刻を扱う方法（タイムゾーン）
• 実際の開発で使える応用テクニック

現在の日時を取得してみよう

datetimeモジュールの基本

Pythonで日時を扱うときは、datetimeというモジュールを使います。これは最初から用意されているので、特別なインストールは必要ありません。

現在の日時を取得する

from datetime import datetime

# 今の時刻を取得
now = datetime.now()
print(now)

実行結果の例

2024-06-01 14:25:30.123456

コードの説明

• from datetime import datetime：datetimeモジュールからdatetimeクラスを読み込みます
• datetime.now()：現在の日時を取得します
• 結果は「年-月-日 時:分:秒.マイクロ秒」の形式で表示されます

日付だけ、時刻だけを取得する

現在の日時から、日付や時刻の部分だけを取り出すこともできます：

from datetime import datetime, date, time

# 現在の日時
now = datetime.now()

# 日付部分だけを取得
today = now.date()
print(f"今日の日付：{today}")

# 時刻部分だけを取得
current_time = now.time()
print(f"現在の時刻：{current_time}")

# 個別の要素を取得
print(f"年：{now.year}")
print(f"月：{now.month}")
print(f"日：{now.day}")
print(f"時：{now.hour}")
print(f"分：{now.minute}")
print(f"秒：{now.second}")

実行結果の例

今日の日付：2024-06-01
現在の時刻：14:25:30.123456
年：2024
月：6
日：1
時：14
分：25
秒：30

特定の日時を作成する

現在の時刻だけでなく、指定した日時も作成できます：

from datetime import datetime

# 指定した日時を作成
specific_date = datetime(2024, 12, 25, 9, 30, 0)
print(f"クリスマスの朝：{specific_date}")

# 誕生日を作成
birthday = datetime(1990, 5, 15)
print(f"誕生日：{birthday}")

実行結果の例

クリスマスの朝：2024-12-25 09:30:00
誕生日：1990-05-15 00:00:00

datetime.now()で現在の日時が簡単に取得できます。これが日時操作の出発点になります。

strftimeで日時を好きな形式に変換しよう

strftimeの基本的な使い方

strftime（ストリングフロムタイム）は、日時データを文字列に変換するための機能です。これを使えば、日時を好きな形式で表示できます。

基本的な書き方

日時データ.strftime("表示したい形式")

簡単な例

from datetime import datetime

now = datetime.now()

# 日本でよく使われる形式
japanese_format = now.strftime("%Y年%m月%d日")
print(japanese_format)

# アメリカでよく使われる形式
american_format = now.strftime("%m/%d/%Y")
print(american_format)

# ファイル名に使いやすい形式
filename_format = now.strftime("%Y%m%d_%H%M%S")
print(filename_format)

実行結果の例

2024年06月01日
06/01/2024
20240601_142530

よく使う書式記号一覧

日時の各部分を表現するために、特別な記号を使います：

年・月・日関連

• %Y：年（4桁）例：2024
• %y：年（2桁）例：24
• %m：月（2桁、01-12）例：06
• %B：月名（英語、フル）例：June
• %b：月名（英語、短縮）例：Jun
• %d：日（2桁、01-31）例：01

時・分・秒関連

• %H：時（24時間形式、00-23）例：14
• %I：時（12時間形式、01-12）例：02
• %M：分（00-59）例：25
• %S：秒（00-59）例：30
• %p：AM/PM（12時間形式で使用）例：PM

曜日関連

• %A：曜日名（英語、フル）例：Saturday
• %a：曜日名（英語、短縮）例：Sat
• %w：曜日（数字、0=日曜日）例：6

実用的なフォーマット例

実際のプロジェクトでよく使われる形式をご紹介します：

from datetime import datetime

now = datetime.now()

# ログファイル用（詳細な時刻）
log_format = now.strftime("%Y-%m-%d %H:%M:%S")
print(f"ログ用：{log_format}")

# ユーザー向け表示（読みやすい形式）
user_format = now.strftime("%Y年%m月%d日 %H時%M分")
print(f"ユーザー向け：{user_format}")

# バックアップファイル名用
backup_format = now.strftime("backup_%Y%m%d_%H%M%S.sql")
print(f"バックアップファイル：{backup_format}")

# 英語での表示
english_format = now.strftime("%B %d, %Y at %I:%M %p")
print(f"英語表示：{english_format}")

# 曜日付きの表示
weekday_format = now.strftime("%A, %Y年%m月%d日")
print(f"曜日付き：{weekday_format}")

実行結果の例

ログ用：2024-06-01 14:25:30
ユーザー向け：2024年06月01日 14時25分
バックアップファイル：backup_20240601_142530.sql
英語表示：June 01, 2024 at 02:25 PM
曜日付き：Saturday, 2024年06月01日

時刻の計算と表示

日時の計算を行って、結果を表示することもできます：

from datetime import datetime, timedelta

now = datetime.now()

# 1週間後
one_week_later = now + timedelta(weeks=1)
print(f"1週間後：{one_week_later.strftime('%Y年%m月%d日 %A')}")

# 30日前
thirty_days_ago = now - timedelta(days=30)
print(f"30日前：{thirty_days_ago.strftime('%Y年%m月%d日')}")

# 3時間後
three_hours_later = now + timedelta(hours=3)
print(f"3時間後：{three_hours_later.strftime('%H時%M分')}")

実行結果の例

1週間後：2024年06月08日 Saturday
30日前：2024年05月02日
3時間後：17時25分

strftimeを使えば、日時を自由な形式で表示できます。用途に応じて適切な形式を選びましょう。

strptimeで文字列を日時データに変換しよう

strptimeの基本的な使い方

strptime（ストリングパーズタイム）は、文字列で書かれた日時を、Pythonが計算に使える日時データに変換するための機能です。

基本的な書き方

datetime.strptime("日時の文字列", "文字列の形式")

簡単な例

from datetime import datetime

# 文字列から日時データを作成
date_string = "2024-06-01"
date_object = datetime.strptime(date_string, "%Y-%m-%d")
print(f"変換結果：{date_object}")
print(f"データ型：{type(date_object)}")

# 時刻も含む場合
datetime_string = "2024-06-01 14:25:30"
datetime_object = datetime.strptime(datetime_string, "%Y-%m-%d %H:%M:%S")
print(f"時刻付き：{datetime_object}")

実行結果の例

変換結果：2024-06-01 00:00:00
データ型：<class 'datetime.datetime'>
時刻付き：2024-06-01 14:25:30

様々な形式の文字列を変換する

実際のデータでは、日時がいろいろな形式で書かれていることがあります：

from datetime import datetime

# 日本語形式
japanese_date = "2024年06月01日"
converted1 = datetime.strptime(japanese_date, "%Y年%m月%d日")
print(f"日本語形式：{converted1}")

# アメリカ形式
american_date = "06/01/2024"
converted2 = datetime.strptime(american_date, "%m/%d/%Y")
print(f"アメリカ形式：{converted2}")

# ヨーロッパ形式
european_date = "01.06.2024"
converted3 = datetime.strptime(european_date, "%d.%m.%Y")
print(f"ヨーロッパ形式：{converted3}")

# 12時間形式
twelve_hour = "06/01/2024 2:25 PM"
converted4 = datetime.strptime(twelve_hour, "%m/%d/%Y %I:%M %p")
print(f"12時間形式：{converted4}")

# 英語の月名
english_month = "June 01, 2024"
converted5 = datetime.strptime(english_month, "%B %d, %Y")
print(f"英語月名：{converted5}")

実行結果の例

日本語形式：2024-06-01 00:00:00
アメリカ形式：2024-06-01 00:00:00
ヨーロッパ形式：2024-06-01 00:00:00
12時間形式：2024-06-01 14:25:00
英語月名：2024-06-01 00:00:00

エラー処理と実用的な使い方

文字列の形式が間違っていると、エラーが発生します。安全に処理するためのテクニックをご紹介します：

from datetime import datetime

def safe_parse_date(date_string, format_string):
    """安全に日時文字列を変換する関数"""
    try:
        return datetime.strptime(date_string, format_string)
    except ValueError as e:
        print(f"エラー：{date_string} を {format_string} で変換できません")
        print(f"詳細：{e}")
        return None

# 正しい形式
correct_date = safe_parse_date("2024-06-01", "%Y-%m-%d")
print(f"成功：{correct_date}")

# 間違った形式
wrong_date = safe_parse_date("2024/06/01", "%Y-%m-%d")
print(f"失敗：{wrong_date}")

# 複数の形式を試す関数
def parse_date_multiple_formats(date_string):
    """複数の形式を試して日時を変換する"""
    formats = [
        "%Y-%m-%d",
        "%Y/%m/%d",
        "%m/%d/%Y",
        "%Y年%m月%d日",
        "%B %d, %Y"
    ]
    
    for fmt in formats:
        try:
            return datetime.strptime(date_string, fmt)
        except ValueError:
            continue
    
    print(f"どの形式でも変換できませんでした：{date_string}")
    return None

# 様々な形式をテスト
test_dates = [
    "2024-06-01",
    "2024/06/01", 
    "06/01/2024",
    "2024年06月01日",
    "June 01, 2024"
]

for date_str in test_dates:
    result = parse_date_multiple_formats(date_str)
    print(f"{date_str} → {result}")

CSVファイルやログファイルでの活用例

実際のプロジェクトでは、ファイルから日時データを読み込むことがよくあります：

from datetime import datetime

# ログファイルの例（文字列として仮定）
log_lines = [
    "2024-06-01 10:30:15 INFO ユーザーがログインしました",
    "2024-06-01 10:31:22 ERROR データベース接続エラー",
    "2024-06-01 10:32:45 INFO ユーザーがログアウトしました"
]

def parse_log_line(line):
    """ログ行から日時を抽出して変換する"""
    # 最初の19文字が日時部分
    date_part = line[:19]
    message_part = line[20:]
    
    # 日時を変換
    log_datetime = datetime.strptime(date_part, "%Y-%m-%d %H:%M:%S")
    
    return log_datetime, message_part

# ログを解析
for line in log_lines:
    log_time, message = parse_log_line(line)
    print(f"時刻：{log_time.strftime('%H時%M分%S秒')} メッセージ：{message}")

実行結果の例

時刻：10時30分15秒 メッセージ：INFO ユーザーがログインしました
時刻：10時31分22秒 メッセージ：ERROR データベース接続エラー
時刻：10時32分45秒 メッセージ：INFO ユーザーがログアウトしました

strptimeを使えば、文字列で書かれた日時を計算可能なデータに変換できます。これにより、日時の比較や計算が可能になります。

タイムゾーンを正しく扱おう

タイムゾーンとは？

タイムゾーンとは、地球上の各地域で使われている時刻の基準のことです。日本は「JST（日本標準時）」、イギリスは「GMT（グリニッジ標準時）」、アメリカ東部は「EST（東部標準時）」などがあります。

世界中で使われるシステムを作るときは、タイムゾーンを正しく扱うことがとても重要です。

pytzライブラリを使った基本操作

pytzは、Pythonでタイムゾーンを扱うための便利なライブラリです。

pytzのインストール

pip install pytz

基本的な使い方

from datetime import datetime
import pytz

# 現在のUTC時刻を取得
utc_now = datetime.now(pytz.UTC)
print(f"UTC時刻：{utc_now}")

# 日本時刻に変換
japan_tz = pytz.timezone("Asia/Tokyo")
japan_time = utc_now.astimezone(japan_tz)
print(f"日本時刻：{japan_time}")

# アメリカ東部時刻に変換
eastern_tz = pytz.timezone("US/Eastern")
eastern_time = utc_now.astimezone(eastern_tz)
print(f"アメリカ東部：{eastern_time}")

# イギリス時刻に変換
uk_tz = pytz.timezone("Europe/London")
uk_time = utc_now.astimezone(uk_tz)
print(f"イギリス時刻：{uk_time}")

実行結果の例

UTC時刻：2024-06-01 05:25:30+00:00
日本時刻：2024-06-01 14:25:30+09:00
アメリカ東部：2024-06-01 01:25:30-04:00
イギリス時刻：2024-06-01 06:25:30+01:00

よく使われるタイムゾーン

世界の主要なタイムゾーンをご紹介します：

import pytz
from datetime import datetime

# よく使われるタイムゾーン
timezones = {
    "日本": "Asia/Tokyo",
    "韓国": "Asia/Seoul", 
    "中国": "Asia/Shanghai",
    "インド": "Asia/Kolkata",
    "イギリス": "Europe/London",
    "ドイツ": "Europe/Berlin",
    "アメリカ東部": "US/Eastern",
    "アメリカ西部": "US/Pacific",
    "オーストラリア": "Australia/Sydney"
}

# 現在のUTC時刻
utc_now = datetime.now(pytz.UTC)
print(f"基準時刻（UTC）：{utc_now.strftime('%Y-%m-%d %H:%M:%S')}")
print("=" * 50)

# 各地域の時刻を表示
for region, tz_name in timezones.items():
    tz = pytz.timezone(tz_name)
    local_time = utc_now.astimezone(tz)
    print(f"{region}：{local_time.strftime('%Y-%m-%d %H:%M:%S %Z')}")

zoneinfo（Python 3.9以降の推奨方法）

Python 3.9以降では、標準ライブラリのzoneinfoを使うことが推奨されています：

from datetime import datetime
from zoneinfo import ZoneInfo

# 現在の日本時刻を取得
japan_now = datetime.now(ZoneInfo("Asia/Tokyo"))
print(f"日本時刻：{japan_now}")

# 異なるタイムゾーンに変換
utc_time = japan_now.astimezone(ZoneInfo("UTC"))
print(f"UTC時刻：{utc_time}")

ny_time = japan_now.astimezone(ZoneInfo("America/New_York"))
print(f"ニューヨーク：{ny_time}")

実用的なタイムゾーン処理の例

実際の開発でよく使われるパターンをご紹介します：

from datetime import datetime
import pytz

class TimeConverter:
    """タイムゾーン変換を簡単にするクラス"""
    
    def __init__(self):
        self.utc = pytz.UTC
        self.jst = pytz.timezone("Asia/Tokyo")
        self.est = pytz.timezone("US/Eastern")
        self.pst = pytz.timezone("US/Pacific")
    
    def to_jst(self, dt):
        """任意の日時を日本時刻に変換"""
        if dt.tzinfo is None:
            # タイムゾーンが設定されていない場合はUTCとして扱う
            dt = self.utc.localize(dt)
        return dt.astimezone(self.jst)
    
    def to_utc(self, dt):
        """任意の日時をUTCに変換"""
        if dt.tzinfo is None:
            # タイムゾーンが設定されていない場合はJSTとして扱う
            dt = self.jst.localize(dt)
        return dt.astimezone(self.utc)
    
    def format_multiple_zones(self, dt):
        """複数のタイムゾーンで時刻を表示"""
        if dt.tzinfo is None:
            dt = self.utc.localize(dt)
        
        zones = [
            ("UTC", self.utc),
            ("日本", self.jst),
            ("アメリカ東部", self.est),
            ("アメリカ西部", self.pst)
        ]
        
        result = []
        for name, tz in zones:
            local_time = dt.astimezone(tz)
            formatted = local_time.strftime("%Y-%m-%d %H:%M:%S %Z")
            result.append(f"{name}: {formatted}")
        
        return "\n".join(result)

# 使用例
converter = TimeConverter()

# 現在時刻を複数のタイムゾーンで表示
now = datetime.now(pytz.UTC)
print("現在時刻を各地域で表示：")
print(converter.format_multiple_zones(now))

print("\n" + "=" * 40 + "\n")

# 日本時刻からUTCに変換
japan_time = datetime(2024, 6, 1, 14, 25, 30)
utc_converted = converter.to_utc(japan_time)
print(f"日本時刻 {japan_time} は")
print(f"UTC時刻では {utc_converted.strftime('%Y-%m-%d %H:%M:%S %Z')} です")

ログ記録でのタイムゾーン活用

システムのログを記録するときの実用例：

from datetime import datetime
import pytz

def log_with_timezone(message, timezone="Asia/Tokyo"):
    """タイムゾーン付きでログを記録する"""
    tz = pytz.timezone(timezone)
    current_time = datetime.now(tz)
    
    # UTC時刻も併記
    utc_time = current_time.astimezone(pytz.UTC)
    
    log_entry = (
        f"[{current_time.strftime('%Y-%m-%d %H:%M:%S %Z')}] "
        f"(UTC: {utc_time.strftime('%H:%M:%S')}) "
        f"{message}"
    )
    
    print(log_entry)
    return log_entry

# 使用例
log_with_timezone("アプリケーションが開始されました")
log_with_timezone("データベースに接続しました")
log_with_timezone("ユーザーがログインしました")

実行結果の例

[2024-06-01 14:25:30 JST] (UTC: 05:25:30) アプリケーションが開始されました
[2024-06-01 14:25:30 JST] (UTC: 05:25:30) データベースに接続しました
[2024-06-01 14:25:30 JST] (UTC: 05:25:30) ユーザーがログインしました

タイムゾーンを正しく扱うことで、世界中で使われるシステムでも時刻の混乱を防げます。pytzやzoneinfoを活用して、国際的なアプリケーションを作りましょう。

実践的な活用テクニック

ファイル名に日時を含める

バックアップファイルやログファイルの名前に日時を含める方法：

from datetime import datetime

def create_backup_filename(base_name):
    """バックアップファイル名を生成する"""
    now = datetime.now()
    timestamp = now.strftime("%Y%m%d_%H%M%S")
    return f"{base_name}_backup_{timestamp}.sql"

def create_log_filename():
    """ログファイル名を生成する"""
    today = datetime.now()
    date_str = today.strftime("%Y%m%d")
    return f"app_log_{date_str}.log"

# 使用例
backup_file = create_backup_filename("user_database")
log_file = create_log_filename()

print(f"バックアップファイル：{backup_file}")
print(f"ログファイル：{log_file}")

日付の計算と比較

日付の差を計算したり、期限をチェックしたりする方法：

from datetime import datetime, timedelta

def calculate_age(birth_date_str):
    """誕生日から年齢を計算する"""
    birth_date = datetime.strptime(birth_date_str, "%Y-%m-%d")
    today = datetime.now()
    age = today.year - birth_date.year
    
    # 今年の誕生日がまだ来ていない場合は1歳引く
    if today.month < birth_date.month or \
       (today.month == birth_date.month and today.day < birth_date.day):
        age -= 1
    
    return age

def days_until_deadline(deadline_str):
    """締切日までの日数を計算する"""
    deadline = datetime.strptime(deadline_str, "%Y-%m-%d")
    today = datetime.now()
    diff = deadline - today
    return diff.days

def is_business_day(date_str):
    """平日かどうかを判定する（土日を休日とする）"""
    date_obj = datetime.strptime(date_str, "%Y-%m-%d")
    # weekday(): 月曜=0, 日曜=6
    return date_obj.weekday() < 5

# 使用例
print(f"年齢：{calculate_age('1990-05-15')}歳")
print(f"締切まで：{days_until_deadline('2024-12-31')}日")
print(f"平日判定：{is_business_day('2024-06-01')}")

期間の集計と分析

データ分析でよく使われる期間集計の例：

from datetime import datetime, timedelta
from collections import defaultdict

# サンプルデータ（アクセスログのイメージ）
access_logs = [
    "2024-06-01 09:15:30 user_001 login",
    "2024-06-01 09:18:45 user_002 login", 
    "2024-06-01 14:22:10 user_001 logout",
    "2024-06-02 08:30:15 user_003 login",
    "2024-06-02 10:45:20 user_002 logout",
    "2024-06-03 11:12:05 user_001 login"
]

def analyze_daily_access(logs):
    """日別のアクセス数を集計する"""
    daily_count = defaultdict(int)
    
    for log in logs:
        # ログから日時部分を抽出
        date_str = log.split()[0]
        date_obj = datetime.strptime(date_str, "%Y-%m-%d")
        
        # 日付をキーとして集計
        date_key = date_obj.strftime("%Y-%m-%d")
        daily_count[date_key] += 1
    
    return dict(daily_count)

def analyze_hourly_access(logs):
    """時間帯別のアクセス数を集計する"""
    hourly_count = defaultdict(int)
    
    for log in logs:
        # ログから日時部分を抽出
        datetime_str = " ".join(log.split()[:2])
        datetime_obj = datetime.strptime(datetime_str, "%Y-%m-%d %H:%M:%S")
        
        # 時間をキーとして集計
        hour_key = datetime_obj.hour
        hourly_count[hour_key] += 1
    
    return dict(hourly_count)

# 分析実行
daily_stats = analyze_daily_access(access_logs)
hourly_stats = analyze_hourly_access(access_logs)

print("日別アクセス数：")
for date, count in sorted(daily_stats.items()):
    print(f"  {date}: {count}件")

print("\n時間帯別アクセス数：")
for hour in sorted(hourly_stats.keys()):
    print(f"  {hour:02d}時台: {hourly_stats[hour]}件")

実行結果の例

日別アクセス数：
  2024-06-01: 3件
  2024-06-02: 2件
  2024-06-03: 1件

時間帯別アクセス数：
  08時台: 1件
  09時台: 2件
  10時台: 1件
  11時台: 1件
  14時台: 1件

営業日の計算

ビジネスシステムでよく必要になる営業日計算の例：

from datetime import datetime, timedelta

def get_business_days(start_date_str, end_date_str):
    """指定期間の営業日数を計算する（土日を除く）"""
    start_date = datetime.strptime(start_date_str, "%Y-%m-%d")
    end_date = datetime.strptime(end_date_str, "%Y-%m-%d")
    
    business_days = []
    current_date = start_date
    
    while current_date <= end_date:
        # 平日（月曜=0から金曜=4）の場合のみ追加
        if current_date.weekday() < 5:
            business_days.append(current_date.strftime("%Y-%m-%d"))
        current_date += timedelta(days=1)
    
    return business_days

def add_business_days(start_date_str, days_to_add):
    """指定日から営業日を加算した日付を取得する"""
    current_date = datetime.strptime(start_date_str, "%Y-%m-%d")
    added_days = 0
    
    while added_days < days_to_add:
        current_date += timedelta(days=1)
        # 平日の場合のみカウント
        if current_date.weekday() < 5:
            added_days += 1
    
    return current_date.strftime("%Y-%m-%d")

def is_deadline_approaching(deadline_str, warning_days=3):
    """締切日が近づいているかチェックする"""
    deadline = datetime.strptime(deadline_str, "%Y-%m-%d")
    today = datetime.now().date()
    
    # 営業日ベースで警告日数を計算
    business_days = get_business_days(
        today.strftime("%Y-%m-%d"), 
        deadline.strftime("%Y-%m-%d")
    )
    
    remaining_business_days = len(business_days)
    
    return {
        "is_approaching": remaining_business_days <= warning_days,
        "remaining_days": remaining_business_days,
        "deadline": deadline_str
    }

# 使用例
print("営業日計算の例：")
business_days = get_business_days("2024-06-01", "2024-06-15")
print(f"6月1日〜15日の営業日数：{len(business_days)}日")

next_business_day = add_business_days("2024-06-01", 5)
print(f"6月1日から営業日5日後：{next_business_day}")

deadline_check = is_deadline_approaching("2024-06-10")
print(f"締切チェック：{deadline_check}")

データベースとの連携

実際のプロジェクトでよく使われる、データベースとの日時データ連携：

from datetime import datetime, timedelta
import json

# データベースから取得したデータのサンプル（JSON形式）
sample_data = [
    {"id": 1, "name": "田中", "created_at": "2024-06-01T09:15:30"},
    {"id": 2, "name": "佐藤", "created_at": "2024-06-01T14:22:10"},
    {"id": 3, "name": "山田", "created_at": "2024-06-02T08:30:15"}
]

class DataProcessor:
    """データベースの日時データを処理するクラス"""
    
    def __init__(self):
        self.datetime_format = "%Y-%m-%dT%H:%M:%S"
    
    def parse_database_datetime(self, datetime_str):
        """データベースの日時文字列を解析する"""
        return datetime.strptime(datetime_str, self.datetime_format)
    
    def format_for_display(self, datetime_str):
        """表示用の日時形式に変換する"""
        dt = self.parse_database_datetime(datetime_str)
        return dt.strftime("%Y年%m月%d日 %H時%M分")
    
    def filter_by_date_range(self, data, start_date_str, end_date_str):
        """指定期間のデータをフィルタリングする"""
        start_date = datetime.strptime(start_date_str, "%Y-%m-%d")
        end_date = datetime.strptime(end_date_str, "%Y-%m-%d") + timedelta(days=1)
        
        filtered_data = []
        for item in data:
            created_at = self.parse_database_datetime(item["created_at"])
            if start_date <= created_at < end_date:
                filtered_data.append(item)
        
        return filtered_data
    
    def get_recent_data(self, data, hours=24):
        """指定時間以内のデータを取得する"""
        cutoff_time = datetime.now() - timedelta(hours=hours)
        
        recent_data = []
        for item in data:
            created_at = self.parse_database_datetime(item["created_at"])
            if created_at >= cutoff_time:
                recent_data.append(item)
        
        return recent_data
    
    def create_summary_report(self, data):
        """データのサマリーレポートを作成する"""
        if not data:
            return "データがありません"
        
        # 最新と最古のデータを取得
        sorted_data = sorted(data, key=lambda x: x["created_at"])
        oldest = self.parse_database_datetime(sorted_data[0]["created_at"])
        newest = self.parse_database_datetime(sorted_data[-1]["created_at"])
        
        # 期間を計算
        period = newest - oldest
        
        report = f"""
データサマリーレポート
==================
総件数: {len(data)}件
期間: {oldest.strftime('%Y年%m月%d日')} 〜 {newest.strftime('%Y年%m月%d日')}
日数: {period.days + 1}日
平均件数/日: {len(data) / (period.days + 1):.1f}件

詳細データ:
"""
        
        for item in sorted_data:
            display_time = self.format_for_display(item["created_at"])
            report += f"- {item['name']} ({display_time})\n"
        
        return report

# 使用例
processor = DataProcessor()

print("サンプルデータの処理例：")
print("=" * 40)

# 期間フィルタリング
filtered = processor.filter_by_date_range(sample_data, "2024-06-01", "2024-06-01")
print(f"6月1日のデータ: {len(filtered)}件")

# 表示形式変換
for item in sample_data:
    display_time = processor.format_for_display(item["created_at"])
    print(f"{item['name']}: {display_time}")

print("\n" + "=" * 40)

# サマリーレポート
report = processor.create_summary_report(sample_data)
print(report)

国際化対応の日時表示

多言語対応のアプリケーションで使える日時表示：

from datetime import datetime
import locale

class InternationalDateFormatter:
    """国際化対応の日時フォーマッター"""
    
    def __init__(self):
        self.formats = {
            "ja": {
                "date": "%Y年%m月%d日",
                "time": "%H時%M分",
                "datetime": "%Y年%m月%d日 %H時%M分",
                "weekday": ["月", "火", "水", "木", "金", "土", "日"]
            },
            "en": {
                "date": "%B %d, %Y",
                "time": "%I:%M %p", 
                "datetime": "%B %d, %Y at %I:%M %p",
                "weekday": ["Mon", "Tue", "Wed", "Thu", "Fri", "Sat", "Sun"]
            },
            "de": {
                "date": "%d. %B %Y",
                "time": "%H:%M",
                "datetime": "%d. %B %Y um %H:%M",
                "weekday": ["Mo", "Di", "Mi", "Do", "Fr", "Sa", "So"]
            }
        }
    
    def format_date(self, dt, lang="ja", include_weekday=False):
        """指定言語で日付をフォーマットする"""
        if isinstance(dt, str):
            dt = datetime.strptime(dt, "%Y-%m-%d %H:%M:%S")
        
        fmt = self.formats.get(lang, self.formats["ja"])
        
        if lang == "ja":
            formatted = dt.strftime(fmt["date"])
            if include_weekday:
                weekday = fmt["weekday"][dt.weekday()]
                formatted += f"（{weekday}）"
        else:
            formatted = dt.strftime(fmt["date"])
            if include_weekday:
                weekday = fmt["weekday"][dt.weekday()]
                formatted = f"{weekday}, {formatted}"
        
        return formatted
    
    def format_datetime(self, dt, lang="ja"):
        """指定言語で日時をフォーマットする"""
        if isinstance(dt, str):
            dt = datetime.strptime(dt, "%Y-%m-%d %H:%M:%S")
        
        fmt = self.formats.get(lang, self.formats["ja"])
        return dt.strftime(fmt["datetime"])
    
    def create_multilingual_display(self, dt):
        """多言語で同時表示する"""
        if isinstance(dt, str):
            dt = datetime.strptime(dt, "%Y-%m-%d %H:%M:%S")
        
        display = "多言語表示:\n"
        display += f"日本語: {self.format_datetime(dt, 'ja')}\n"
        display += f"English: {self.format_datetime(dt, 'en')}\n"
        display += f"Deutsch: {self.format_datetime(dt, 'de')}\n"
        
        return display

# 使用例
formatter = InternationalDateFormatter()
sample_datetime = datetime(2024, 6, 1, 14, 25, 30)

print("国際化対応の日時表示：")
print("=" * 40)

print(formatter.create_multilingual_display(sample_datetime))

print("曜日付きの日付表示：")
print(f"日本語: {formatter.format_date(sample_datetime, 'ja', True)}")
print(f"英語: {formatter.format_date(sample_datetime, 'en', True)}")
print(f"ドイツ語: {formatter.format_date(sample_datetime, 'de', True)}")

まとめ

Pythonでの日時フォーマットは、strftime、strptime、そしてタイムゾーン管理の3つが基本となります。

学習のポイント

• strftime：日時データを文字列に変換（表示用）
• strptime：文字列を日時データに変換（計算用）
• タイムゾーン：国際的なシステムでは必須の知識
• 実践活用：ファイル名生成、ログ解析、期間計算など

よく使う場面

• ログファイルの解析と整形
• バックアップファイル名の自動生成
• 締切日の管理と通知システム
• アクセス解析と統計レポート
• 国際化対応のウェブアプリケーション