8.1. datetime —基本的な日付と時刻のタイプ—Pythonドキュメント

提供：Dev Guides
< PythonPython/docs/2.7/library/datetime
移動先:案内、検索

8.1。 日付時刻 —基本的な日付と時刻のタイプ

バージョン2.3の新機能。


datetime モジュールは、単純な方法と複雑な方法の両方で日付と時刻を操作するためのクラスを提供します。 日付と時刻の計算はサポートされていますが、実装の焦点は、出力のフォーマットと操作のための効率的な属性抽出にあります。 関連する機能については、 time および calendar モジュールも参照してください。

日付と時刻のオブジェクトには、「ナイーブ」と「認識」の2種類があります。

認識オブジェクトは、タイムゾーンや夏時間情報など、適用可能なアルゴリズム的および政治的な時間調整について十分な知識を持っており、他の認識オブジェクトとの相対的な位置を特定します。 認識オブジェクトは、解釈 1 に開かれていない特定の瞬間を表すために使用されます。

ナイーブオブジェクトには、他の日付/時刻オブジェクトとの相対的な位置を明確に示すのに十分な情報が含まれていません。 ナイーブオブジェクトが協定世界時（UTC）、現地時間、または他のタイムゾーンの時間を表すかどうかは、特定の数値がメートル、マイル、または質量を表すかどうかがプログラム次第であるのと同様に、純粋にプログラム次第です。 ナイーブなオブジェクトは、現実のいくつかの側面を無視するという犠牲を払って、理解しやすく、操作しやすいものです。

認識オブジェクトを必要とするアプリケーションの場合、 datetime および time オブジェクトには、抽象のサブクラスのインスタンスに設定できるオプションのタイムゾーン情報属性tzinfoがあります。 tzinfo クラス。 これらの tzinfo オブジェクトは、UTC時間からのオフセット、タイムゾーン名、および夏時間が有効かどうかに関する情報をキャプチャします。 datetime モジュールによって提供される具体的な tzinfo クラスはないことに注意してください。 必要な詳細レベルでタイムゾーンをサポートするかどうかは、アプリケーション次第です。 世界中の時間調整のルールは合理的というよりも政治的であり、すべてのアプリケーションに適した基準はありません。

datetime モジュールは、次の定数をエクスポートします。

datetime.MINYEAR
date または datetime オブジェクトで許可される最小の年番号。 MINYEAR は1です。
datetime.MAXYEAR
date または datetime オブジェクトで許可される最大の年番号。 MAXYEAR は9999です。

も参照してください

モジュールカレンダー
一般的なカレンダー関連の機能。
モジュール時間
時間アクセスと変換。


8.1.1。 利用可能なタイプ

class datetime.date
現在のグレゴリオ暦が常に有効であり、今後も有効であると仮定すると、理想的なナイーブな日付です。 属性：年、月、および日。
class datetime.time
毎日が正確に24 * 60 * 60秒であると仮定した場合の、特定の日とは関係のない理想的な時間（ここでは「うるう秒」の概念はありません）。 属性：時間、分、秒、マイクロ秒、および tzinfo 。
class datetime.datetime
日付と時刻の組み合わせ。 属性：年、月、日、時間、分、秒、 マイクロ秒、および tzinfo 。
class datetime.timedelta
2つの date 、 time 、または datetime インスタンス間の差をマイクロ秒の解像度で表す期間。
class datetime.tzinfo
タイムゾーン情報オブジェクトの抽象基本クラス。 これらは、 datetime および time クラスによって使用され、時間調整のカスタマイズ可能な概念を提供します（たとえば、タイムゾーンや夏時間を考慮するため）。

これらのタイプのオブジェクトは不変です。

date タイプのオブジェクトは常にナイーブです。

タイプ time または datetime のオブジェクトは、ナイーブまたは認識している可能性があります。 datetime オブジェクト d は、d.tzinfoがNoneでなく、d.tzinfo.utcoffset(d)がNoneを返さないかどうかを認識します。 d.tzinfoがNoneの場合、またはd.tzinfoがNoneではなく、d.tzinfo.utcoffset(d)がNoneを返す場合、 d はナイーブです。 time オブジェクト t は、t.tzinfoがNoneでなく、t.tzinfo.utcoffset(None)がNoneを返さないかどうかを認識します。 それ以外の場合、 t はナイーブです。

ナイーブとアウェアの区別は、 timedelta オブジェクトには適用されません。

サブクラスの関係： 

object
    timedelta
    tzinfo
    time
    date
        datetime

8.1.2。 タイムデルタオブジェクト

timedelta オブジェクトは、期間、つまり2つの日付または時刻の差を表します。

class datetime.timedelta([days[, seconds[, microseconds[, milliseconds[, minutes[, hours[, weeks]]]]]]])

すべての引数はオプションであり、デフォルトは0です。 引数は、int、long、またはfloatの場合があり、正または負の場合があります。

日、秒、マイクロ秒のみが内部に保存されます。 引数は次の単位に変換されます。

  • ミリ秒は1000マイクロ秒に変換されます。

  • 1分は60秒に変換されます。

  • 1時間は3600秒に変換されます。

  • 1週間は7日に変換されます。

そして、日、秒、マイクロ秒は、表現が一意になるように正規化されます。

  • 0 <= microseconds < 1000000

  • 0 <= seconds < 3600*24（1日の秒数）

  • -999999999 <= days <= 999999999

いずれかの引数が浮動小数点であり、マイクロ秒の小数部がある場合、すべての引数から残ったマイクロ秒の小数部が結合され、それらの合計が最も近いマイクロ秒に丸められます。 引数がfloatでない場合、変換と正規化のプロセスは正確です（情報が失われることはありません）。

日の正規化された値が指定された範囲外にある場合、OverflowErrorが発生します。

負の値の正規化は、最初は意外かもしれないことに注意してください。 例えば、

>>> from datetime import timedelta
>>> d = timedelta(microseconds=-1)
>>> (d.days, d.seconds, d.microseconds)
(-1, 86399, 999999)

クラス属性は次のとおりです。

timedelta.min
最もネガティブな timedelta オブジェクトtimedelta(-999999999)。
timedelta.max
最もポジティブな timedelta オブジェクトtimedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)。
timedelta.resolution
等しくない timedelta オブジェクト間の可能な最小の違いtimedelta(microseconds=1)。

正規化のため、timedelta.max> -timedelta.minであることに注意してください。 -timedelta.maxは timedelta オブジェクトとして表現できません。

インスタンス属性（読み取り専用）：

属性 価値
days -999999999から999999999まで
seconds 0から86399まで
microseconds 0から999999まで

サポートされている操作：

手術 結果
t1 = t2 + t3 t2 と t3 の合計。 その後、 t1 - t2 == t3 および t1 - t3 == t2 本当です。 (1)
t1 = t2 - t3 t2 と t3 の違い。 その後、 t1 == t2 - t3 および t2 == t1 + t3 本当です。 (1)
t1 = t2 * i or t1 = i * t2 デルタに整数またはlongを掛けたもの。 その後、 t1 // i == t2 は、i != 0の場合、trueになります。
一般に、 t1 * i == t1 *（i-1）+ t1 は真です。 (1)
t1 = t2 // i フロアが計算され、残り（存在する場合）は破棄されます。 (3)
+t1 同じ値の timedelta オブジェクトを返します。 (2)
-t1 timedelta （- t1.days 、- t1.seconds 、- t1.microseconds ）、および t1と同等 * -1。 (1)(4)
abs(t) t.days >= 0の場合は+ t に相当し、t.days < 0の場合は- t に相当します。 (2)
str(t) [D day[s], ][H]H:MM:SS[.UUUUUU]の形式で文字列を返します。ここで、Dは負のtに対して負です。 (5)
repr(t) datetime.timedelta(D[, S[, U]])の形式で文字列を返します。ここで、Dは負のtに対して負です。 (5)

ノート：

  1. これは正確ですが、オーバーフローする可能性があります。

  2. これは正確であり、オーバーフローすることはできません。

  3. 0で除算すると、ZeroDivisionErrorが発生します。

  4. - timedelta.max は timedelta オブジェクトとして表現できません。

  5. timedelta オブジェクトの文字列表現は、内部表現と同様に正規化されます。 これは、負のタイムデルタに対してやや異常な結果につながります。 例えば：

    >>> timedelta(hours=-5)
datetime.timedelta(-1, 68400)
>>> print(_)
-1 day, 19:00:00

上記の操作に加えて、 timedelta オブジェクトは、 date および datetime オブジェクトによる特定の加算および減算をサポートします（以下を参照）。

timedelta オブジェクトの比較は、小さいtimedeltaと見なされる短い期間を表す timedelta オブジェクトでサポートされます。 混合タイプの比較がオブジェクトアドレスによるデフォルトの比較にフォールバックするのを防ぐために、 timedelta オブジェクトを別のタイプのオブジェクトと比較すると、比較しない限りTypeErrorが発生します。 ==または!=です。 後者の場合は、それぞれ False または True を返します。

timedelta オブジェクトは hashable （辞書キーとして使用可能）であり、効率的なピクルス化をサポートし、ブールコンテキストでは、 timedelta オブジェクトは次の場合にのみtrueと見なされます。 timedelta(0)と同じではありません。

インスタンスメソッド：

timedelta.total_seconds()

期間に含まれる合計秒数を返します。 真の除算を有効にして計算された(td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6と同等です。

非常に長い時間間隔（ほとんどのプラットフォームで270年を超える）の場合、この方法ではマイクロ秒の精度が失われることに注意してください。

バージョン2.7の新機能。

使用例： 

>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> another_year = timedelta(weeks=40, days=84, hours=23,
...                          minutes=50, seconds=600)  # adds up to 365 days
>>> year.total_seconds()
31536000.0
>>> year == another_year
True
>>> ten_years = 10 * year
>>> ten_years, ten_years.days // 365
(datetime.timedelta(3650), 10)
>>> nine_years = ten_years - year
>>> nine_years, nine_years.days // 365
(datetime.timedelta(3285), 9)
>>> three_years = nine_years // 3;
>>> three_years, three_years.days // 365
(datetime.timedelta(1095), 3)
>>> abs(three_years - ten_years) == 2 * three_years + year
True

8.1.3。 日にちオブジェクト

date オブジェクトは、理想化されたカレンダーの日付（年、月、日）を表し、現在のグレゴリオ暦は両方向に無期限に拡張されます。 1年目の1月1日は1日目と呼ばれ、1年目の1月2日は2日目と呼ばれます。 これは、ダーショウィッツとレインゴールドの著書「カレンダー計算」の「先発グレゴリオ暦」の定義と一致します。このカレンダーは、すべての計算の基本カレンダーです。 先発グレゴリオ暦の序数と他の多くのカレンダーシステムとの間で変換するためのアルゴリズムについては、本を参照してください。

class datetime.date(year, month, day)

すべての引数が必要です。 引数は、次の範囲のintまたはlongの場合があります。

  • MINYEAR <= year <= MAXYEAR

  • 1 <= month <= 12

  • 1 <= day <= number of days in the given month and year

これらの範囲外の引数を指定すると、ValueErrorが発生します。

他のコンストラクター、すべてのクラスメソッド：

classmethod date.today()
現在の現地の日付を返します。 これはdate.fromtimestamp(time.time())と同等です。
classmethod date.fromtimestamp(timestamp)
time.time（）によって返されるような、POSIXタイムスタンプに対応するローカル日付を返します。 タイムスタンプがプラットフォームCのlocaltime()関数でサポートされている値の範囲外の場合、これによりValueErrorが発生する可能性があります。 これは1970年から2038年までの年に制限されるのが一般的です。 タイムスタンプの概念にうるう秒が含まれる非POSIXシステムでは、うるう秒は fromtimestamp（）によって無視されることに注意してください。
classmethod date.fromordinal(ordinal)
1年目の1月1日が序数1である、先発グレゴリオ暦の序数に対応する日付を返します。 ValueErrorは、1 <= ordinal <= date.max.toordinal()でない限り発生します。 任意の日付 d 、date.fromordinal(d.toordinal()) == d。

クラス属性：

date.min
最も早い表現可能な日付、date(MINYEAR, 1, 1)。
date.max
最新の表現可能な日付、date(MAXYEAR, 12, 31)。
date.resolution
等しくない日付オブジェクト間の可能な最小の差、timedelta(days=1)。

インスタンス属性（読み取り専用）：

date.year
MINYEAR と MAXYEAR の間。
date.month
1から12まで。
date.day
1から特定の年の特定の月の日数まで。

サポートされている操作：

手術 結果
date2 = date1 + timedelta date2 は、 date1 からtimedelta.days日削除されます。 (1)
date2 = date1 - timedelta date2 をdate2 + timedelta == date1となるように計算します。 (2)
timedelta = date1 - date2 (3)
date1 < date2 date1 は、 date1 が date2 よりも時間的に先行している場合、 date2 よりも小さいと見なされます。 (4)

ノート：

  1. date2 は、timedelta.days > 0の場合は時間的に前方に移動し、timedelta.days < 0の場合は後方に移動します。 その後date2 - date1 == timedelta.days。 timedelta.secondsとtimedelta.microsecondsは無視されます。 OverflowErrorは、date2.yearが MINYEAR よりも小さいか、 MAXYEAR よりも大きい場合に発生します。
  2. これは、date1 +（-timedelta）とまったく同じではありません。これは、date1-timedeltaがオーバーフローしない場合に、-timedeltaが単独でオーバーフローする可能性があるためです。 timedelta.secondsとtimedelta.microsecondsは無視されます。
  3. これは正確であり、オーバーフローすることはありません。 timedelta.secondsとtimedelta.microsecondsは0で、date2 + timedelta == date1以降です。
  4. つまり、date1 < date2は、date1.toordinal() < date2.toordinal()の場合に限ります。 比較がオブジェクトアドレスを比較するデフォルトのスキームにフォールバックするのを防ぐために、他の比較対象が date オブジェクトでもない場合、日付比較は通常TypeErrorを発生させます。 ただし、他の比較対象にtimetuple()属性がある場合は、代わりにNotImplementedが返されます。 このフックは、他の種類の日付オブジェクトに混合タイプの比較を実装する機会を与えます。 そうでない場合、 date オブジェクトを別のタイプのオブジェクトと比較すると、比較が==または!=でない限り、TypeErrorが発生します。 後者の場合は、それぞれ False または True を返します。

日付は辞書のキーとして使用できます。 ブールコンテキストでは、すべての date オブジェクトがtrueと見なされます。

インスタンスメソッド：

date.replace(year, month, day)
キーワード引数が指定された場合に新しい値が指定されたパラメーターを除いて、同じ値の日付を返します。 たとえば、d == date(2002, 12, 31)の場合、d.replace(day=26) == date(2002, 12, 26)です。
date.timetuple()
time.localtime（）によって返されるような time.struct_time を返します。 時間、分、秒は0で、DSTフラグは-1です。 d.timetuple()はtime.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))と同等です。ここで、yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1は、1月1日の1から始まる今年の日数です。
date.toordinal()
1年目の1月1日が序数1である、日付の先発グレゴリオ暦の序数を返します。 日付オブジェクト d 、date.fromordinal(d.toordinal()) == dの場合。
date.weekday()
曜日を整数として返します。月曜日は0、日曜日は6です。 たとえば、水曜日のdate(2002, 12, 4).weekday() == 2。 isoweekday（）も参照してください。
date.isoweekday()
曜日を整数として返します。月曜日は1、日曜日は7です。 たとえば、水曜日のdate(2002, 12, 4).isoweekday() == 3。 weekday（）、 isocalendar（）も参照してください。
date.isocalendar()

3タプル（ISO年、ISO週番号、ISO平日）を返します。

ISOカレンダーは、グレゴリオ暦の広く使用されているバリアントです。 適切な説明については、 https://www.staff.science.uu.nl/~gent0113/calendar/isocalendar.htmを参照してください。

ISO年は、52週または53週で構成され、週は月曜日に始まり、日曜日に終わります。 ISO年の最初の週は、木曜日を含む年の最初の（グレゴリオ暦）暦週です。 これは第1週と呼ばれ、その木曜日のISO年はグレゴリオ暦の年と同じです。

たとえば、2004年は木曜日に始まるため、ISO 2004年の最初の週は2003年12月29日月曜日に始まり、2004年1月4日日曜日に終わり、date(2003, 12, 29).isocalendar() == (2004, 1, 1)とdate(2004, 1, 4).isocalendar() == (2004, 1, 7)になります。

date.isoformat()
ISO8601形式の日付を表す文字列「YYYY-MM-DD」を返します。 たとえば、date(2002, 12, 4).isoformat() == '2002-12-04'です。
date.__str__()
日付 d の場合、str(d)はd.isoformat()と同等です。
date.ctime()
日付を表す文字列を返します（例：date(2002, 12, 4).ctime() == 'Wed Dec 4 00:00:00 2002'）。 d.ctime()は、ネイティブC ctime()関数（ time.ctime（）が呼び出すが、日付）が呼び出されるプラットフォームのtime.ctime(time.mktime(d.timetuple()))と同等です。 ctime（）は呼び出さない）はC標準に準拠しています。
date.strftime(format)
明示的なフォーマット文字列によって制御される、日付を表す文字列を返します。 時間、分、または秒を参照するフォーマットコードには、0の値が表示されます。 フォーマットディレクティブの完全なリストについては、セクション strftime（）およびstrptime（）の動作を参照してください。
date.__format__(format)
date.strftime（）と同じです。 これにより、 str.format（）を使用するときに、 date オブジェクトのフォーマット文字列を指定できます。 セクション strftime（）およびstrptime（）の動作を参照してください。

イベントまでの日数を数える例： 

>>> import time
>>> from datetime import date
>>> today = date.today()
>>> today
datetime.date(2007, 12, 5)
>>> today == date.fromtimestamp(time.time())
True
>>> my_birthday = date(today.year, 6, 24)
>>> if my_birthday < today:
...     my_birthday = my_birthday.replace(year=today.year + 1)
>>> my_birthday
datetime.date(2008, 6, 24)
>>> time_to_birthday = abs(my_birthday - today)
>>> time_to_birthday.days
202

date の操作例： 

>>> from datetime import date
>>> d = date.fromordinal(730920) # 730920th day after 1. 1. 0001
>>> d
datetime.date(2002, 3, 11)
>>> t = d.timetuple()
>>> for i in t:     
...     print i
2002                # year
3                   # month
11                  # day
0
0
0
0                   # weekday (0 = Monday)
70                  # 70th day in the year
-1
>>> ic = d.isocalendar()
>>> for i in ic:    
...     print i
2002                # ISO year
11                  # ISO week number
1                   # ISO day number ( 1 = Monday )
>>> d.isoformat()
'2002-03-11'
>>> d.strftime("%d/%m/%y")
'11/03/02'
>>> d.strftime("%A %d. %B %Y")
'Monday 11. March 2002'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
'The day is 11, the month is March.'

8.1.4。 日付時刻オブジェクト

datetime オブジェクトは、 date オブジェクトと time オブジェクトからのすべての情報を含む単一のオブジェクトです。 date オブジェクトと同様に、 datetime は、現在のグレゴリオ暦が両方向に拡張されていることを前提としています。 時間オブジェクトのように、 datetime は、毎日正確に3600 * 24秒あると想定しています。

コンストラクタ：

class datetime.datetime(year, month, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]])

年、月、日の引数が必要です。 tzinfo は、None、または tzinfo サブクラスのインスタンスである可能性があります。 残りの引数は、次の範囲のintまたはlongです。

  • MINYEAR <= year <= MAXYEAR

  • 1 <= month <= 12

  • 1 <= day <= number of days in the given month and year

  • 0 <= hour < 24

  • 0 <= minute < 60

  • 0 <= second < 60

  • 0 <= microsecond < 1000000

これらの範囲外の引数を指定すると、ValueErrorが発生します。

他のコンストラクター、すべてのクラスメソッド：

classmethod datetime.today()
tzinfo Noneを使用して、現在のローカル日時を返します。 これはdatetime.fromtimestamp(time.time())と同等です。 now（）、 fromtimestamp（）も参照してください。
classmethod datetime.now([tz])

現在の現地の日付と時刻を返します。 オプションの引数 tz がNoneであるか指定されていない場合、これは today（）のようになりますが、可能であれば、 time.time（）タイムスタンプ（たとえば、これはC gettimeofday()関数を提供するプラットフォームで可能かもしれません）。

tz がNoneでない場合は、 tzinfo サブクラスのインスタンスである必要があり、現在の日付と時刻は tz 'に変換されます。 ■タイムゾーン。 この場合、結果はtz.fromutc(datetime.utcnow().replace(tzinfo=tz))と同等です。 today（）、 utcnow（）も参照してください。

classmethod datetime.utcnow()
tzinfo Noneを使用して、現在のUTC日付と時刻を返します。 これは now（）に似ていますが、現在のUTC日付と時刻を単純な datetime オブジェクトとして返します。 now（）も参照してください。
classmethod datetime.fromtimestamp(timestamp[, tz])

time.time（）によって返されるような、POSIXタイムスタンプに対応するローカルの日付と時刻を返します。 オプションの引数 tz がNoneであるか指定されていない場合、タイムスタンプはプラットフォームのローカル日時に変換され、返される datetime オブジェクトはナイーブです。

tz がNoneでない場合は、 tzinfo サブクラスのインスタンスである必要があり、タイムスタンプは tz のタイムゾーンに変換されます。 。 この場合、結果はtz.fromutc(datetime.utcfromtimestamp(timestamp).replace(tzinfo=tz))と同等です。

fromtimestamp（）は、タイムスタンプがプラットフォームCのlocaltime()またはgmtime()関数でサポートされている値の範囲外の場合、ValueErrorを発生させる可能性があります。 これは1970年から2038年までの年に制限されるのが一般的です。 タイムスタンプの概念にうるう秒が含まれる非POSIXシステムでは、うるう秒は fromtimestamp（）によって無視され、同じ[X232X ] datetime オブジェクト。 utcfromtimestamp（）も参照してください。

classmethod datetime.utcfromtimestamp(timestamp)
tzinfo Noneを使用して、POSIXタイムスタンプに対応するUTC datetime を返します。 タイムスタンプがプラットフォームCのgmtime()関数でサポートされている値の範囲外の場合、これによりValueErrorが発生する可能性があります。 これは1970年から2038年までの年に制限されるのが一般的です。 fromtimestamp（）も参照してください。
classmethod datetime.fromordinal(ordinal)
1年目の1月1日が序数1である、先発グレゴリオ暦の序数に対応する datetime を返します。 ValueErrorは、1 <= ordinal <= datetime.max.toordinal()でない限り発生します。 結果の時、分、秒、マイクロ秒はすべて0であり、 tzinfo はNoneです。
classmethod datetime.combine(date, time)
日付コンポーネントが指定された date オブジェクトと等しく、時間コンポーネントと tzinfo 属性が指定された timeと等しい新しい datetime オブジェクトを返します。 オブジェクトの。 datetime オブジェクト d 、d == datetime.combine(d.date(), d.timetz())の場合。 dateが datetime オブジェクトの場合、その時間コンポーネントと tzinfo 属性は無視されます。
classmethod datetime.strptime(date_string, format)

format に従って解析された date_string に対応する datetime を返します。 これはdatetime(*(time.strptime(date_string, format)[0:6]))と同等です。 ValueErrorは、date_stringとformatが time.strptime（）で解析できない場合、または時間タプルではない値を返す場合に発生します。 フォーマットディレクティブの完全なリストについては、セクション strftime（）およびstrptime（）の動作を参照してください。

バージョン2.5の新機能。

クラス属性：

datetime.min
最も早い表現可能な datetime 、datetime(MINYEAR, 1, 1, tzinfo=None)。
datetime.max
最新の表現可能な datetime 、datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None)。
datetime.resolution
等しくない datetime オブジェクト間の可能な最小の違いtimedelta(microseconds=1)。

インスタンス属性（読み取り専用）：

datetime.year
MINYEAR と MAXYEAR の間。
datetime.month
1から12まで。
datetime.day
1から特定の年の特定の月の日数まで。
datetime.hour
range(24)で。
datetime.minute
range(60)で。
datetime.second
range(60)で。
datetime.microsecond
range(1000000)で。
datetime.tzinfo
tzinfo 引数として datetime コンストラクターに渡されたオブジェクト、または渡されなかった場合はNone。

サポートされている操作：

手術 結果
datetime2 = datetime1 + timedelta (1)
datetime2 = datetime1 - timedelta (2)
timedelta = datetime1 - datetime2 (3)
datetime1 < datetime2 datetime を datetime と比較します。 (4)

  1. datetime2は、datetime1から削除されたtimedeltaの期間であり、次の場合に時間的に進みます。timedelta.days > 0、または後方の場合timedelta.days <0。 結果には、入力日時と同じ tzinfo 属性があり、datetime2-datetime1 == timedeltaafterがあります。 OverflowErrorは、datetime2.yearが MINYEAR よりも小さいか、 MAXYEAR よりも大きい場合に発生します。 入力が認識オブジェクトであっても、タイムゾーンの調整は行われないことに注意してください。

  2. datetime2 + timedelta == datetime1となるようにdatetime2を計算します。 さらに、結果には入力日時と同じ tzinfo 属性があり、入力が認識されていてもタイムゾーンの調整は行われません。 これは、datetime1 +（-timedelta）とまったく同じではありません。これは、datetime1-timedeltaがオーバーフローしない場合に、-timedeltaが単独でオーバーフローする可能性があるためです。

  3. datetime からの datetime の減算は、両方のオペランドがナイーブである場合、または両方が認識している場合にのみ定義されます。 一方が認識していて、もう一方がナイーブである場合、TypeErrorが発生します。

    両方がナイーブであるか、両方が認識していて同じ tzinfo 属性を持っている場合、 tzinfo 属性は無視され、結果は timedelta オブジェクトになります。 datetime2 + t == datetime1のようなt 。 この場合、タイムゾーンの調整は行われません。

    両方が認識していて、 tzinfo 属性が異なる場合、a-bは、 a と b が最初にナイーブUTC日時に最初に変換されたかのように動作します。 結果は(a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset())ですが、実装がオーバーフローすることはありません。

  4. datetime1 は、 datetime1 が datetime2 よりも時間的に先行している場合、 datetime2 よりも小さいと見なされます。

    一方の比較対象がナイーブで、もう一方が認識している場合、TypeErrorが発生します。 両方の比較対象が認識していて、同じ tzinfo 属性を持っている場合、共通の tzinfo 属性は無視され、基準日時が比較されます。 両方の比較対象が認識していて、異なる tzinfo 属性を持っている場合、比較対象は最初にUTCオフセット（self.utcoffset()から取得）を差し引くことによって調整されます。

    ノート

    比較がオブジェクトアドレスを比較するデフォルトのスキームにフォールバックするのを防ぐために、他の比較対象が datetime オブジェクトでもない場合、日時比較は通常TypeErrorを発生させます。 ただし、他の比較対象にtimetuple()属性がある場合は、代わりにNotImplementedが返されます。 このフックは、他の種類の日付オブジェクトに混合タイプの比較を実装する機会を与えます。 そうでない場合、 datetime オブジェクトを別のタイプのオブジェクトと比較すると、比較が==または!=でない限り、TypeErrorが発生します。 後者の場合は、それぞれ False または True を返します。

datetime オブジェクトは辞書キーとして使用できます。 ブールコンテキストでは、すべての datetime オブジェクトがtrueと見なされます。

インスタンスメソッド：

datetime.date()
同じ年、月、日で date オブジェクトを返します。
datetime.time()
time オブジェクトを同じ時間、分、秒、マイクロ秒で返します。 tzinfo はNoneです。 メソッド timetz（）も参照してください。
datetime.timetz()
同じ時、分、秒、マイクロ秒、およびtzinfo属性を持つ time オブジェクトを返します。 メソッド time（）も参照してください。
datetime.replace([year[, month[, day[, hour[, minute[, second[, microsecond[, tzinfo]]]]]]]])
キーワード引数が指定された方によって新しい値が与えられた属性を除いて、同じ属性を持つ日時を返します。 tzinfo=Noneを指定すると、日付と時刻のデータを変換せずに、認識されている日時から単純な日時を作成できることに注意してください。
datetime.astimezone(tz)

新しい tzinfo 属性 tz を持つ datetime オブジェクトを返し、結果が self と同じUTC時刻になるように日付と時刻のデータを調整します。 、ただし tz の現地時間。

tz は tzinfo サブクラスのインスタンスである必要があり、その utcoffset（）および dst（）メソッドはNone。 self は認識している必要があります（self.tzinfoはNoneであってはならず、self.utcoffset()はNoneを返していてはなりません）。

self.tzinfoが tz の場合、self.astimezone(tz)は self と等しくなります。日付または時刻データの調整は実行されません。 それ以外の場合、結果はタイムゾーン tz の現地時間であり、 self と同じUTC時間を表します。astz = dt.astimezone(tz)の後、astz - astz.utcoffset()は通常同じになりますdt - dt.utcoffset()としての日付と時刻のデータ。 クラス tzinfo の説明では、これを達成できない夏時間の移行境界でのケースについて説明しています（ tz が標準時間と夏時間の両方をモデル化する場合にのみ問題になります）。

日付と時刻のデータを調整せずに、単にタイムゾーンオブジェクト tz を日時 dt にアタッチする場合は、dt.replace(tzinfo=tz)を使用します。 日付と時刻のデータを変換せずに、認識されている日時 dt からタイムゾーンオブジェクトを削除するだけの場合は、dt.replace(tzinfo=None)を使用します。

デフォルトの tzinfo.fromutc（）メソッドを tzinfo サブクラスでオーバーライドして、 astimezone（）によって返される結果に影響を与えることができることに注意してください。 エラーケースを無視すると、 astimezone（）は次のように動作します。

def astimezone(self, tz):
    if self.tzinfo is tz:
        return self
    # Convert self to UTC, and attach the new time zone object.
    utc = (self - self.utcoffset()).replace(tzinfo=tz)
    # Convert from UTC to tz's local time.
    return tz.fromutc(utc)
datetime.utcoffset()
tzinfo がNoneの場合、Noneを返し、それ以外の場合はself.tzinfo.utcoffset(self)を返し、後者がNoneを返さない場合は例外を発生させます。 、または timedelta オブジェクトは、1日未満の大きさの整数を表します。
datetime.dst()
tzinfo がNoneの場合、Noneを返し、それ以外の場合はself.tzinfo.dst(self)を返し、後者がNoneを返さない場合は例外を発生させます。 、または timedelta オブジェクトは、1日未満の大きさの整数を表します。
datetime.tzname()
tzinfo がNoneの場合、Noneを返し、それ以外の場合はself.tzinfo.tzname(self)を返し、後者がNoneを返さない場合、または文字列オブジェクト、
datetime.timetuple()
time.localtime（）によって返されるような time.struct_time を返します。 d.timetuple()はtime.struct_time((d.year, d.month, d.day, d.hour, d.minute, d.second, d.weekday(), yday, dst))と同等です。ここで、yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1は、1月1日の1から始まる今年の日数です。 結果のtm_isdstフラグは、 dst（）メソッドに従って設定されます。 tzinfo はNoneまたは dst（）です。 ]はNoneを返し、tm_isdstは-1に設定されます。 それ以外の場合、 dst（）がゼロ以外の値を返す場合、tm_isdstは1に設定されます。 それ以外の場合、tm_isdstは0に設定されます。
datetime.utctimetuple()

datetime インスタンス d がナイーブである場合、これはd.timetuple()と同じですが、tm_isdstがd.dst()に関係なく強制的に0になる点が異なります。 ] 戻り値。 DSTがUTC時間に有効になることはありません。

d が認識している場合、 d はd.utcoffset()を減算することにより、UTC時間に正規化され、正規化された時間の time.struct_time が返されます。 。 tm_isdstは強制的に0になります。 d .yearがMINYEARの場合、結果のtm_yearメンバーは MINYEAR -1または MAXYEAR +1である可能性があることに注意してください。またはMAXYEARおよびUTC調整が1年の境界を超えて流出します。

datetime.toordinal()
日付の先発グレゴリオ暦の序数を返します。 self.date().toordinal()と同じです。
datetime.weekday()
曜日を整数として返します。月曜日は0、日曜日は6です。 self.date().weekday()と同じです。 isoweekday（）も参照してください。
datetime.isoweekday()
曜日を整数として返します。月曜日は1、日曜日は7です。 self.date().isoweekday()と同じです。 weekday（）、 isocalendar（）も参照してください。
datetime.isocalendar()
3タプル（ISO年、ISO週番号、ISO平日）を返します。 self.date().isocalendar()と同じです。
datetime.isoformat([sep])

日付と時刻をISO8601形式で表す文字列YYYY-MM-DDTHH：MM：SS.mmmmmmを返します。マイクロ秒が0の場合は、YYYY-MM-DDTHH：MM：SSを返します。

utcoffset（）がNoneを返さない場合、6文字の文字列が追加され、UTCオフセットが（符号付き）時間と分で示されます：YYYY-MM-DDTHH：MM：SS。 mmmmmm + HH：MM、またはマイクロ秒が0の場合YYYY-MM-DDTHH：MM：SS + HH：MM

オプションの引数 sep （デフォルトは'T'）は、結果の日付部分と時刻部分の間に配置される1文字の区切り文字です。 例えば、

>>> from datetime import tzinfo, timedelta, datetime
>>> class TZ(tzinfo):
...     def utcoffset(self, dt): return timedelta(minutes=-399)
...
>>> datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
'2002-12-25 00:00:00-06:39'
datetime.__str__()
datetime インスタンス d の場合、str(d)はd.isoformat(' ')と同等です。
datetime.ctime()
datetime(2002, 12, 4, 20, 30, 40).ctime() == 'Wed Dec  4 20:30:40 2002'のように、日付と時刻を表す文字列を返します。 d.ctime()は、ネイティブC ctime()関数（ time.ctime（）が呼び出すが、 datetime）が呼び出されるプラットフォームのtime.ctime(time.mktime(d.timetuple()))と同等です。 ctime（）は呼び出さない）はC標準に準拠しています。
datetime.strftime(format)
明示的なフォーマット文字列によって制御される、日付と時刻を表す文字列を返します。 フォーマットディレクティブの完全なリストについては、セクション strftime（）およびstrptime（）の動作を参照してください。
datetime.__format__(format)
datetime.strftime（）と同じです。 これにより、 str.format（）を使用するときに、 datetime オブジェクトのフォーマット文字列を指定できます。 セクション strftime（）およびstrptime（）の動作を参照してください。

日時オブジェクトの操作例： 

>>> from datetime import datetime, date, time
>>> # Using datetime.combine()
>>> d = date(2005, 7, 14)
>>> t = time(12, 30)
>>> datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)
>>> # Using datetime.now() or datetime.utcnow()
>>> datetime.now()   
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
>>> datetime.utcnow()   
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060)
>>> # Using datetime.strptime()
>>> dt = datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> dt
datetime.datetime(2006, 11, 21, 16, 30)
>>> # Using datetime.timetuple() to get tuple of all attributes
>>> tt = dt.timetuple()
>>> for it in tt:   
...     print it
...
2006    # year
11      # month
21      # day
16      # hour
30      # minute
0       # second
1       # weekday (0 = Monday)
325     # number of days since 1st January
-1      # dst - method tzinfo.dst() returned None
>>> # Date in ISO format
>>> ic = dt.isocalendar()
>>> for it in ic:   
...     print it
...
2006    # ISO year
47      # ISO week
2       # ISO weekday
>>> # Formatting datetime
>>> dt.strftime("%A, %d. %B %Y %I:%M%p")
'Tuesday, 21. November 2006 04:30PM'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, "day", "month", "time")
'The day is 21, the month is November, the time is 04:30PM.'

tzinfoでdatetimeを使用する： 

>>> from datetime import timedelta, datetime, tzinfo
>>> class GMT1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1) + self.dst(dt)
...     def dst(self, dt):
...         # DST starts last Sunday in March
...         d = datetime(dt.year, 4, 1)   # ends last Sunday in October
...         self.dston = d - timedelta(days=d.weekday() + 1)
...         d = datetime(dt.year, 11, 1)
...         self.dstoff = d - timedelta(days=d.weekday() + 1)
...         if self.dston <=  dt.replace(tzinfo=None) < self.dstoff:
...             return timedelta(hours=1)
...         else:
...             return timedelta(0)
...     def tzname(self,dt):
...          return "GMT +1"
...
>>> class GMT2(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=2) + self.dst(dt)
...     def dst(self, dt):
...         d = datetime(dt.year, 4, 1)
...         self.dston = d - timedelta(days=d.weekday() + 1)
...         d = datetime(dt.year, 11, 1)
...         self.dstoff = d - timedelta(days=d.weekday() + 1)
...         if self.dston <=  dt.replace(tzinfo=None) < self.dstoff:
...             return timedelta(hours=1)
...         else:
...             return timedelta(0)
...     def tzname(self,dt):
...         return "GMT +2"
...
>>> gmt1 = GMT1()
>>> # Daylight Saving Time
>>> dt1 = datetime(2006, 11, 21, 16, 30, tzinfo=gmt1)
>>> dt1.dst()
datetime.timedelta(0)
>>> dt1.utcoffset()
datetime.timedelta(0, 3600)
>>> dt2 = datetime(2006, 6, 14, 13, 0, tzinfo=gmt1)
>>> dt2.dst()
datetime.timedelta(0, 3600)
>>> dt2.utcoffset()
datetime.timedelta(0, 7200)
>>> # Convert datetime to another time zone
>>> dt3 = dt2.astimezone(GMT2())
>>> dt3     
datetime.datetime(2006, 6, 14, 14, 0, tzinfo=<GMT2 object at 0x...>)
>>> dt2     
datetime.datetime(2006, 6, 14, 13, 0, tzinfo=<GMT1 object at 0x...>)
>>> dt2.utctimetuple() == dt3.utctimetuple()
True

8.1.5。 時間オブジェクト

時間オブジェクトは、特定の日とは関係なく、 tzinfo オブジェクトを介して調整される（ローカル）時刻を表します。

class datetime.time([hour[, minute[, second[, microsecond[, tzinfo]]]]])

すべての引数はオプションです。 tzinfo は、None、または tzinfo サブクラスのインスタンスである可能性があります。 残りの引数は、次の範囲のintまたはlongです。

  • 0 <= hour < 24

  • 0 <= minute < 60

  • 0 <= second < 60

  • 0 <= microsecond < 1000000。

これらの範囲外の引数を指定すると、ValueErrorが発生します。 tzinfo を除くすべてのデフォルトは0で、デフォルトは None です。

クラス属性：

time.min
最も早い表現可能な時間、time(0, 0, 0, 0)。
time.max
最新の表現可能な時間、time(23, 59, 59, 999999)。
time.resolution
等しくない time オブジェクト間の可能な最小の違いtimedelta(microseconds=1)。ただし、 time オブジェクトの演算はサポートされていないことに注意してください。

インスタンス属性（読み取り専用）：

time.hour
range(24)で。
time.minute
range(60)で。
time.second
range(60)で。
time.microsecond
range(1000000)で。
time.tzinfo
オブジェクトはtzinfo引数として time コンストラクターに渡され、何も渡されなかった場合はNoneに渡されました。

サポートされている操作：

  • time と time の比較。ここで、 a が bに先行する場合、 a は b よりも小さいと見なされます。 時間内に。 一方の比較対象がナイーブで、もう一方が認識している場合、TypeErrorが発生します。 両方の比較対象が認識していて、同じ tzinfo 属性を持っている場合、共通の tzinfo 属性は無視され、基準時間が比較されます。 両方の比較対象が認識していて、異なる tzinfo 属性を持っている場合、比較対象は最初にUTCオフセット（self.utcoffset()から取得）を差し引くことによって調整されます。 混合タイプの比較がオブジェクトアドレスによるデフォルトの比較にフォールバックするのを防ぐために、 time オブジェクトを別のタイプのオブジェクトと比較すると、比較しない限りTypeErrorが発生します。 ==または!=です。 後者の場合は、それぞれ False または True を返します。
  • ハッシュ、dictキーとして使用
  • 効率的な酸洗い
  • ブールコンテキストでは、 time オブジェクトは、分に変換してutcoffset()（または0が [ X170X]）、結果はゼロ以外です。

インスタンスメソッド：

time.replace([hour[, minute[, second[, microsecond[, tzinfo]]]]])
同じ値の time を返します。ただし、キーワード引数が指定されている場合は、新しい値が指定された属性を除きます。 tzinfo=Noneを指定すると、時間データを変換せずに、認識されている時間からナイーブな時間を作成できます。
time.isoformat()
ISO 8601形式で時刻を表す文字列を返します。HH：MM：SS.mmmmmm、またはself.microsecondが0の場合、HH：MM：SS utcoffset（）がNoneを返さない場合]、6文字の文字列が追加され、UTCオフセットが（符号付き）時間と分で示されます：HH：MM：SS.mmmmmm + HH：MM、またはself.microsecondが0の場合、HH：MM：SS + HH：んん
time.__str__()
しばらくの間、 t 、str(t)はt.isoformat()と同等です。
time.strftime(format)
明示的なフォーマット文字列によって制御される、時間を表す文字列を返します。 フォーマットディレクティブの完全なリストについては、セクション strftime（）およびstrptime（）の動作を参照してください。
time.__format__(format)
time.strftime（）と同じです。 これにより、 str.format（）を使用するときに、 time オブジェクトのフォーマット文字列を指定できます。 セクション strftime（）およびstrptime（）の動作を参照してください。
time.utcoffset()
tzinfo がNoneの場合、Noneを返し、それ以外の場合はself.tzinfo.utcoffset(None)を返し、後者がNoneを返さない場合は例外を発生させます。または、 timedelta オブジェクトは、1日未満の大きさの整数を表します。
time.dst()
tzinfo がNoneの場合、Noneを返し、それ以外の場合はself.tzinfo.dst(None)を返し、後者がNoneを返さない場合は例外を発生させます。 、または timedelta オブジェクトは、1日未満の大きさの整数を表します。
time.tzname()
tzinfo がNoneの場合、Noneを返すか、self.tzinfo.tzname(None)を返すか、後者がNoneを返さない場合は例外を発生させます。または文字列オブジェクト。

例： 

>>> from datetime import time, tzinfo, timedelta
>>> class GMT1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1)
...     def dst(self, dt):
...         return timedelta(0)
...     def tzname(self,dt):
...         return "Europe/Prague"
...
>>> t = time(12, 10, 30, tzinfo=GMT1())
>>> t                               
datetime.time(12, 10, 30, tzinfo=<GMT1 object at 0x...>)
>>> gmt = GMT1()
>>> t.isoformat()
'12:10:30+01:00'
>>> t.dst()
datetime.timedelta(0)
>>> t.tzname()
'Europe/Prague'
>>> t.strftime("%H:%M:%S %Z")
'12:10:30 Europe/Prague'
>>> 'The {} is {:%H:%M}.'.format("time", t)
'The time is 12:10.'

8.1.6。 tzinfo オブジェクト

class datetime.tzinfo

これは抽象基本クラスです。つまり、このクラスを直接インスタンス化しないでください。 具体的なサブクラスを導出し、（少なくとも）使用する datetime メソッドに必要な標準の tzinfo メソッドの実装を提供する必要があります。 datetime モジュールは、 tzinfo の具体的なサブクラスを提供しません。

tzinfo （の具体的なサブクラス）のインスタンスは、 datetime および time オブジェクトのコンストラクターに渡すことができます。 後者のオブジェクトは、属性を現地時間であると見なし、 tzinfo オブジェクトは、UTCからの現地時間のオフセット、タイムゾーンの名前、およびDSTオフセットを、すべて日付または時刻に関連して明らかにするメソッドをサポートします。それらに渡されたオブジェクト。

ピクルス化の特別な要件： tzinfo サブクラスには、引数なしで呼び出すことができる__init__()メソッドが必要です。そうでない場合、ピクルス化できますが、再度ピクルス解除することはできません。 これは、将来緩和される可能性のある技術要件です。

tzinfo の具体的なサブクラスは、次のメソッドを実装する必要がある場合があります。 正確にどのメソッドが必要かは、認識されている datetime オブジェクトの用途によって異なります。 疑わしい場合は、それらすべてを実装するだけです。

tzinfo.utcoffset(self, dt)

UTCからの現地時間のオフセットをUTCの東の分単位で返します。 現地時間がUTCの西にある場合、これは負の値になります。 これはUTCからの合計オフセットであることが意図されていることに注意してください。 たとえば、 tzinfo オブジェクトがタイムゾーンとDSTの両方の調整を表す場合、 utcoffset（）はそれらの合計を返す必要があります。 UTCオフセットがわからない場合は、Noneを返します。 それ以外の場合、返される値は、-1439から1439までの範囲の整数を指定する timedelta オブジェクトである必要があります（1440 = 24 * 60;オフセットの大きさは1日未満である必要があります）。 utcoffset（）のほとんどの実装は、おそらく次の2つのいずれかのようになります。

return CONSTANT                 # fixed-offset class
return CONSTANT + self.dst(dt)  # daylight-aware class

utcoffset（）がNoneを返さない場合、 dst（）もNoneを返さないはずです。

utcoffset（）のデフォルトの実装では、NotImplementedErrorが発生します。

tzinfo.dst(self, dt)

UTCの東の分単位で夏時間（DST）調整を返すか、DST情報が不明な場合はNoneを返します。 DSTが有効でない場合は、timedelta(0)を返します。 DSTが有効な場合は、オフセットを timedelta オブジェクトとして返します（詳細については、 utcoffset（）を参照してください）。 DSTオフセットは、該当する場合、 utcoffset（）によって返されるUTCオフセットにすでに追加されているため、取得することに興味がない限り、 dst（）を参照する必要はありません。 DST情報は別途。 たとえば、 datetime.timetuple（）は、 tzinfo 属性の dst（）メソッドを呼び出して、tm_isdstフラグの設定方法を決定します。 tzinfo.fromutc（）は、 dst（）を呼び出して、タイムゾーンをまたぐときのDSTの変更を考慮します。

標準時間と日照時間の両方をモデル化する tzinfo サブクラスのインスタンス tz は、この意味で一貫している必要があります。

tz.utcoffset(dt) - tz.dst(dt)

datetime dt とdt.tzinfo == tzのすべてで同じ結果を返す必要があります。正常な tzinfo サブクラスの場合、この式はタイムゾーンの「標準オフセット」を生成します。これは、日付や時刻に依存するのではなく、地理的な場所にのみ依存する必要があります。 datetime.astimezone（）の実装はこれに依存していますが、違反を検出することはできません。 それを確実にするのはプログラマーの責任です。 tzinfo サブクラスがこれを保証できない場合は、 tzinfo.fromutc（）のデフォルトの実装をオーバーライドして、astimezone()で正しく機能するようにすることができます。

dst（）のほとんどの実装は、おそらく次の2つのいずれかのようになります。

def dst(self, dt):
    # a fixed-offset class:  doesn't account for DST
    return timedelta(0)

また

def dst(self, dt):
    # Code to set dston and dstoff to the time zone's DST
    # transition times based on the input dt.year, and expressed
    # in standard local time.  Then

    if dston <= dt.replace(tzinfo=None) < dstoff:
        return timedelta(hours=1)
    else:
        return timedelta(0)

dst（）のデフォルトの実装では、NotImplementedErrorが発生します。

tzinfo.tzname(self, dt)

datetime オブジェクト dt に対応するタイムゾーン名を文字列として返します。 datetime モジュールでは文字列名については何も定義されておらず、特に何かを意味する必要はありません。 たとえば、「GMT」、「UTC」、「-500」、「-5：00」、「EDT」、「US / Eastern」、「America / NewYork」はすべて有効な返信です。 文字列名がわからない場合は、Noneを返します。 これは固定文字列ではなくメソッドであることに注意してください。これは主に、一部の tzinfo サブクラスが、渡された dt の特定の値に応じて、特に tzinfoの場合に、異なる名前を返したいためです。 クラスは夏時間を考慮しています。

tzname（）のデフォルトの実装では、NotImplementedErrorが発生します。

これらのメソッドは、同じ名前のメソッドに応答して、 datetime または time オブジェクトによって呼び出されます。 datetime オブジェクトはそれ自体を引数として渡し、 time オブジェクトはNoneを引数として渡します。 したがって、 tzinfo サブクラスのメソッドは、Noneまたはクラス datetime の dt 引数を受け入れるように準備する必要があります。

Noneが渡された場合、最適な応答を決定するのはクラス設計者の責任です。 たとえば、クラスが時間オブジェクトが tzinfo プロトコルに参加しないことを伝えたい場合は、Noneを返すことが適切です。 utcoffset(None)は、標準のUTCオフセットを返す方が便利な場合があります。これは、標準のオフセットを検出するための他の規則がないためです。

datetime オブジェクトが datetime メソッドに応答して渡される場合、dt.tzinfoは self と同じオブジェクトです。 tzinfo メソッドは、ユーザーコードが tzinfo メソッドを直接呼び出さない限り、これに依存できます。 tzinfo メソッドは、 dt を現地時間であると解釈し、他のタイムゾーンのオブジェクトについて心配する必要がないことを目的としています。

サブクラスがオーバーライドしたい tzinfo メソッドがもう1つあります。

tzinfo.fromutc(self, dt)

これは、デフォルトの datetime.astimezone（）実装から呼び出されます。 そこから呼び出されると、dt.tzinfoは self であり、 dt の日付と時刻のデータはUTC時刻を表すものと見なされます。 fromutc（）の目的は、日付と時刻のデータを調整し、 self の現地時間で同等の日時を返すことです。

ほとんどの tzinfo サブクラスは、デフォルトの fromutc（）実装を問題なく継承できるはずです。 固定オフセットのタイムゾーン、および標準時間と夏時間の両方を占めるタイムゾーンを処理するのに十分な強度があり、夏時間の移行時間が異なる年であっても後者を処理できます。 デフォルトの fromutc（）実装がすべての場合に正しく処理されない可能性があるタイムゾーンの例は、（UTCからの）標準オフセットが経過した特定の日時に依存する場合です。これは政治的な理由で発生する可能性があります。 。 astimezone()および fromutc（）のデフォルトの実装では、結果が標準オフセットが変更された瞬間にまたがる時間の1つである場合、目的の結果が生成されない場合があります。

エラーの場合のコードをスキップすると、デフォルトの fromutc（）実装は次のように動作します。

def fromutc(self, dt):
    # raise ValueError error if dt.tzinfo is not self
    dtoff = dt.utcoffset()
    dtdst = dt.dst()
    # raise ValueError if dtoff is None or dtdst is None
    delta = dtoff - dtdst  # this is self's standard offset
    if delta:
        dt += delta   # convert to standard local time
        dtdst = dt.dst()
        # raise ValueError if dtdst is None
    if dtdst:
        return dt + dtdst
    else:
        return dt

tzinfo クラスの例： 

from datetime import tzinfo, timedelta, datetime

ZERO = timedelta(0)
HOUR = timedelta(hours=1)

# A UTC class.

class UTC(tzinfo):
    """UTC"""

    def utcoffset(self, dt):
        return ZERO

    def tzname(self, dt):
        return "UTC"

    def dst(self, dt):
        return ZERO

utc = UTC()

# A class building tzinfo objects for fixed-offset time zones.
# Note that FixedOffset(0, "UTC") is a different way to build a
# UTC tzinfo object.

class FixedOffset(tzinfo):
    """Fixed offset in minutes east from UTC."""

    def __init__(self, offset, name):
        self.__offset = timedelta(minutes = offset)
        self.__name = name

    def utcoffset(self, dt):
        return self.__offset

    def tzname(self, dt):
        return self.__name

    def dst(self, dt):
        return ZERO

# A class capturing the platform's idea of local time.

import time as _time

STDOFFSET = timedelta(seconds = -_time.timezone)
if _time.daylight:
    DSTOFFSET = timedelta(seconds = -_time.altzone)
else:
    DSTOFFSET = STDOFFSET

DSTDIFF = DSTOFFSET - STDOFFSET

class LocalTimezone(tzinfo):

    def utcoffset(self, dt):
        if self._isdst(dt):
            return DSTOFFSET
        else:
            return STDOFFSET

    def dst(self, dt):
        if self._isdst(dt):
            return DSTDIFF
        else:
            return ZERO

    def tzname(self, dt):
        return _time.tzname[self._isdst(dt)]

    def _isdst(self, dt):
        tt = (dt.year, dt.month, dt.day,
              dt.hour, dt.minute, dt.second,
              dt.weekday(), 0, 0)
        stamp = _time.mktime(tt)
        tt = _time.localtime(stamp)
        return tt.tm_isdst > 0

Local = LocalTimezone()


# A complete implementation of current DST rules for major US time zones.

def first_sunday_on_or_after(dt):
    days_to_go = 6 - dt.weekday()
    if days_to_go:
        dt += timedelta(days_to_go)
    return dt


# US DST Rules
#
# This is a simplified (i.e., wrong for a few cases) set of rules for US
# DST start and end times. For a complete and up-to-date set of DST rules
# and timezone definitions, visit the Olson Database (or try pytz):
# http://www.twinsun.com/tz/tz-link.htm
# http://sourceforge.net/projects/pytz/ (might not be up-to-date)
#
# In the US, since 2007, DST starts at 2am (standard time) on the second
# Sunday in March, which is the first Sunday on or after Mar 8.
DSTSTART_2007 = datetime(1, 3, 8, 2)
# and ends at 2am (DST time; 1am standard time) on the first Sunday of Nov.
DSTEND_2007 = datetime(1, 11, 1, 1)
# From 1987 to 2006, DST used to start at 2am (standard time) on the first
# Sunday in April and to end at 2am (DST time; 1am standard time) on the last
# Sunday of October, which is the first Sunday on or after Oct 25.
DSTSTART_1987_2006 = datetime(1, 4, 1, 2)
DSTEND_1987_2006 = datetime(1, 10, 25, 1)
# From 1967 to 1986, DST used to start at 2am (standard time) on the last
# Sunday in April (the one on or after April 24) and to end at 2am (DST time;
# 1am standard time) on the last Sunday of October, which is the first Sunday
# on or after Oct 25.
DSTSTART_1967_1986 = datetime(1, 4, 24, 2)
DSTEND_1967_1986 = DSTEND_1987_2006

class USTimeZone(tzinfo):

    def __init__(self, hours, reprname, stdname, dstname):
        self.stdoffset = timedelta(hours=hours)
        self.reprname = reprname
        self.stdname = stdname
        self.dstname = dstname

    def __repr__(self):
        return self.reprname

    def tzname(self, dt):
        if self.dst(dt):
            return self.dstname
        else:
            return self.stdname

    def utcoffset(self, dt):
        return self.stdoffset + self.dst(dt)

    def dst(self, dt):
        if dt is None or dt.tzinfo is None:
            # An exception may be sensible here, in one or both cases.
            # It depends on how you want to treat them.  The default
            # fromutc() implementation (called by the default astimezone()
            # implementation) passes a datetime with dt.tzinfo is self.
            return ZERO
        assert dt.tzinfo is self

        # Find start and end times for US DST. For years before 1967, return
        # ZERO for no DST.
        if 2006 < dt.year:
            dststart, dstend = DSTSTART_2007, DSTEND_2007
        elif 1986 < dt.year < 2007:
            dststart, dstend = DSTSTART_1987_2006, DSTEND_1987_2006
        elif 1966 < dt.year < 1987:
            dststart, dstend = DSTSTART_1967_1986, DSTEND_1967_1986
        else:
            return ZERO

        start = first_sunday_on_or_after(dststart.replace(year=dt.year))
        end = first_sunday_on_or_after(dstend.replace(year=dt.year))

        # Can't compare naive to aware objects, so strip the timezone from
        # dt first.
        if start <= dt.replace(tzinfo=None) < end:
            return HOUR
        else:
            return ZERO

Eastern  = USTimeZone(-5, "Eastern",  "EST", "EDT")
Central  = USTimeZone(-6, "Central",  "CST", "CDT")
Mountain = USTimeZone(-7, "Mountain", "MST", "MDT")
Pacific  = USTimeZone(-8, "Pacific",  "PST", "PDT")

tzinfo サブクラスには、DST移行ポイントで、標準時間と夏時間の両方を考慮した、避けられない微妙な問題が年に2回あることに注意してください。 具体的には、米国東部標準時（UTC -0500）について考えてみます。ここで、EDTは3月の第2日曜日の1:59（EST）の直後に始まり、11月の第1日曜日の1:59（EDT）の直後に終わります。 

  UTC   3:MM  4:MM  5:MM  6:MM  7:MM  8:MM
  EST  22:MM 23:MM  0:MM  1:MM  2:MM  3:MM
  EDT  23:MM  0:MM  1:MM  2:MM  3:MM  4:MM

start  22:MM 23:MM  0:MM  1:MM  3:MM  4:MM

  end  23:MM  0:MM  1:MM  1:MM  2:MM  3:MM

DSTが開始すると（「開始」ライン）、ローカルウォールクロックは1:59から3:00に跳ね上がります。 2：MMの形式の実時間は、その日にはあまり意味がないため、astimezone(Eastern)は、DSTの開始日にhour == 2で結果を提供しません。 astimezone()がこの保証を行うためには、rzinfo.dst()メソッドは、「欠落時間」（東部の場合は2：MM）の時間を夏時間と見なす必要があります。

DSTが終了すると（「終了」行）、さらに悪い問題が発生する可能性があります。ローカルの壁時間では明確に綴ることができない時間、つまり夏時間の最後の1時間です。 東部では、夏時間が終了する日の5：MMUTCの形式の時間です。 ローカルの掛け時計は、1：59（夏時間）から1:00（標準時間）に戻ります。 1：MMの形式の現地時間はあいまいです。 astimezone()は、隣接する2つのUTC時間を同じローカル時間にマッピングすることにより、ローカルクロックの動作を模倣します。 東部標準時の例では、5：MMと6：MMの形式のUTC時間は、東部標準時に変換されると両方とも1：MMにマップされます。 astimezone()がこの保証を行うためには、 tzinfo.dst（）メソッドは、「繰り返し時間」の時間を標準時間と見なす必要があります。 これは、例のように、タイムゾーンの標準現地時間でDST切り替え時間を表すことで簡単に調整できます。

このようなあいまいさを許容できないアプリケーションでは、ハイブリッド tzinfo サブクラスの使用を避ける必要があります。 UTC、またはその他の固定オフセット tzinfo サブクラス（EST（固定オフセット-5時間）のみ、またはEDT（固定オフセット-4時間）のみを表すクラスなど）を使用する場合、あいまいさはありません。

も参照してください

pytz

標準ライブラリには tzinfo インスタンスはありませんが、 IANAタイムゾーンデータベース（Olsonデータベースとも呼ばれます）をPythonに取り込むサードパーティライブラリがあります： pytz [ X197X]。

pytz には最新の情報が含まれているため、その使用をお勧めします。

IANAタイムゾーンデータベース

タイムゾーンデータベース（多くの場合、tzまたはzoneinfoと呼ばれます）には、世界中の多くの代表的な場所の現地時間の履歴を表すコードとデータが含まれています。 政治団体がタイムゾーンの境界、UTCオフセット、夏時間のルールに加えた変更を反映するために定期的に更新されます。


8.1.7。 strftime()とstrptime()行動

date 、 datetime 、および time オブジェクトはすべて、strftime(format)メソッドをサポートし、明示的な形式の制御下で時間を表す文字列を作成しますストリング。 大まかに言えば、d.strftime(fmt)は time モジュールのtime.strftime(fmt, d.timetuple())のように機能しますが、すべてのオブジェクトがtimetuple()メソッドをサポートしているわけではありません。

逆に、 datetime.strptime（）クラスメソッドは、日付と時刻を表す文字列と対応するフォーマット文字列から datetime オブジェクトを作成します。 datetime.strptime(date_string, format)はdatetime(*(time.strptime(date_string, format)[0:6]))と同等ですが、フォーマットにサブセカンドコンポーネントまたはタイムゾーンオフセット情報が含まれている場合を除きます。これらはdatetime.strptimeでサポートされていますが、time.strptimeによって破棄されます。 。

time オブジェクトの場合、timeオブジェクトにはそのような値がないため、年、月、日のフォーマットコードは使用しないでください。 とにかく使用する場合は、年を1900に、月と日を1に置き換えます。

date オブジェクトの場合、 date オブジェクトにはそのような値がないため、時間、分、秒、およびマイクロ秒のフォーマットコードは使用しないでください。 とにかく使用する場合は、0に置き換えられます。

PythonはプラットフォームCライブラリのstrftime()関数を呼び出し、プラットフォームのバリエーションが一般的であるため、サポートされるフォーマットコードのフルセットはプラットフォームによって異なります。 ご使用のプラットフォームでサポートされているフォーマットコードの完全なセットを確認するには、 strftime（3）のドキュメントを参照してください。

同じ理由で、現在のロケールの文字セットで表すことができないUnicodeコードポイントを含むフォーマット文字列の処理もプラットフォームに依存します。 一部のプラットフォームでは、このようなコードポイントは出力にそのまま保持されますが、他のプラットフォームでは、strftimeがUnicodeErrorを発生させるか、代わりに空の文字列を返す場合があります。

以下は、C標準（1989バージョン）が必要とするすべてのフォーマットコードのリストであり、これらは標準C実装のすべてのプラットフォームで機能します。 1999バージョンのC標準では、フォーマットコードが追加されていることに注意してください。

strftime()が機能する正確な年の範囲も、プラットフォームによって異なります。 プラットフォームに関係なく、1900年より前の年は使用できません。

指令 意味 例 ノート
%a ロケールの省略名としての平日。

日、月、…、土（en_US）;

だから、Mo、…、Sa（de_DE）

(1)
%A ロケールのフルネームとしての平日。

日曜日、月曜日、…、土曜日（en_US）;

Sonntag、Montag、…、Samstag（de_DE）

(1)
%w 10進数としての平日。0は日曜日、6は土曜日です。 0、1、…、6
%d ゼロが埋め込まれた10進数としての月の日。 01、02、…、31
%b ロケールの省略名としての月。

1月、2月、…、12月（en_US）;

1月、2月、…、Dez（de_DE）

(1)
%B ロケールのフルネームとしての月。

1月、2月、…、12月（en_US）;

Januar、Februar、…、Dezember（de_DE）

(1)
%m ゼロが埋め込まれた10進数としての月。 01、02、…、12
%y ゼロが埋め込まれた10進数としての世紀のない年。 00、01、…、99
%Y 10進数として世紀を持つ年。 1970, 1988, 2001, 2013
%H ゼロが埋め込まれた10進数としての時間（24時間制）。 00、01、…、23
%I ゼロが埋め込まれた10進数としての時間（12時間制）。 01、02、…、12
%p ロケールのAMまたはPMに相当します。

午前、午後（en_US）;

午前、午後（de_DE）

(1), (2)
%M ゼロが埋め込まれた10進数としての分。 00、01、…、59
%S ゼロが埋め込まれた10進数として2番目。 00、01、…、59 (3)
%f 10進数としてのマイクロ秒。左側にゼロが埋め込まれます。 000000、000001、…、999999 (4)
%z + HHMMまたは-HHMMの形式のUTCオフセット（オブジェクトがナイーブの場合は空の文字列）。 （空）、+ 0000、-0400、+ 1030 (5)
%Z タイムゾーン名（オブジェクトがナイーブの場合は空の文字列）。 （空）、UTC、EST、CST
%j ゼロが埋め込まれた10進数としての年の日。 001、002、…、366
%U ゼロが埋め込まれた10進数としての年の週番号（週の最初の日としての日曜日）。 最初の日曜日に先行する新年のすべての日は、第0週と見なされます。 00、01、…、53 (6)
%W 10進数としての年の週番号（週の最初の日としての月曜日）。 最初の月曜日より前の新年のすべての日は、第0週と見なされます。 00、01、…、53 (6)
%c ロケールの適切な日付と時刻の表現。

1988年8月16日火曜日21:30:00（en_US）;

Di 16 Aug 21:30:00 1988（de_DE）

(1)
%x ロケールの適切な日付表現。

88年8月16日（なし）;

1988年8月16日（en_US）;

16.08.1988（de_DE）

(1)
%X ロケールの適切な時間表現。

21:30:00（en_US）;

21:30:00（de_DE）

(1)
%% リテラル'%'文字。 %

ノート：

  1. 形式は現在のロケールに依存するため、出力値について推測する場合は注意が必要です。 フィールドの順序は異なり（たとえば、「月/日/年」と「日/月/年」）、出力には、ロケールのデフォルトエンコーディングを使用してエンコードされたUnicode文字が含まれる場合があります（たとえば、現在のロケールがja_JP、デフォルトのエンコーディングはeucJP、SJIS、またはutf-8のいずれかです。 locale.getlocale（）を使用して現在のエンコーディングを決定しますロケールのエンコーディング）。

  2. strptime()メソッドと一緒に使用すると、%pディレクティブは、%Iディレクティブを使用して時間を解析する場合にのみ、出力時間フィールドに影響します。

  3. time モジュールとは異なり、 datetime モジュールはうるう秒をサポートしていません。

  4. %fは、C標準のフォーマット文字セットの拡張です（ただし、日時オブジェクトに個別に実装されているため、常に使用できます）。 strptime()メソッドと一緒に使用すると、%fディレクティブは1〜6桁で、右側にゼロパッドを受け入れます。

    バージョン2.6の新機能。

  5. ナイーブオブジェクトの場合、%zおよび%Zフォーマットコードは空の文字列に置き換えられます。

    認識オブジェクトの場合：

    %z

    utcoffset()は、+ HHMMまたは-HHMMの形式の5文字の文字列に変換されます。ここで、HHはUTCオフセット時間数を示す2桁の文字列であり、MMは数値を示す2桁の文字列です。 UTCオフセット分の。 たとえば、utcoffset()がtimedelta(hours=-3, minutes=-30)を返す場合、%zは文字列'-0330'に置き換えられます。

    %Z

    tzname()がNoneを返す場合、%Zは空の文字列に置き換えられます。 それ以外の場合、%Zは戻り値に置き換えられます。戻り値は文字列である必要があります。

  6. strptime()方式で使用する場合、%Uおよび%Wは、曜日と年が指定されている場合の計算でのみ使用されます。

脚注

1
つまり、相対性理論の影響を無視する場合



「https://www.finddevguides.com/index.php?title=Python/docs/2.7/library/datetime&oldid=97104」から取得
Powered by MediaWiki