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

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

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

ソースコード： ：source： `Lib / datetime.py`


datetime モジュールは、日付と時刻を操作するためのクラスを提供します。

日付と時刻の計算はサポートされていますが、実装の焦点は、出力のフォーマットと操作のための効率的な属性抽出にあります。

も参照してください

モジュールカレンダー
一般的なカレンダー関連の機能。
モジュール時間
時間アクセスと変換。
パッケージ dateutil
拡張されたタイムゾーンと解析サポートを備えたサードパーティライブラリ。


認識している素朴なオブジェクト

日付と時刻のオブジェクトは、タイムゾーン情報が含まれているかどうかに応じて、「認識」または「ナイーブ」に分類されます。

認識オブジェクトは、タイムゾーンや夏時間情報など、適用可能なアルゴリズムおよび政治的な時間調整に関する十分な知識があれば、他の認識オブジェクトと比較して自分自身を見つけることができます。 認識オブジェクトは、解釈の余地がない特定の瞬間を表します。 1

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

認識オブジェクトを必要とするアプリケーションの場合、 datetime および time オブジェクトには、抽象のサブクラスのインスタンスに設定できるオプションのタイムゾーン情報属性tzinfoがあります。 tzinfo クラス。 これらの tzinfo オブジェクトは、UTC時間からのオフセット、タイムゾーン名、および夏時間が有効かどうかに関する情報をキャプチャします。

datetime モジュールによって提供されるのは、1つの具体的な tzinfo クラス timezone クラスのみです。 timezone クラスは、UTC自体、北米のESTおよびEDTタイムゾーンなど、UTCからのオフセットが固定された単純なタイムゾーンを表すことができます。 より詳細なレベルでタイムゾーンをサポートするかどうかは、アプリケーション次第です。 世界中の時間調整のルールは合理的というよりも政治的であり、頻繁に変更され、UTC以外のすべてのアプリケーションに適した標準はありません。


定数

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

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


利用可能なタイプ

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

tzinfo 抽象基本クラスをUTCからの固定オフセットとして実装するクラス。

バージョン3.2の新機能。

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

サブクラスの関係： 

object
    timedelta
    tzinfo
        timezone
    time
    date
        datetime

共通のプロパティ

date 、 datetime 、 time 、および timezone タイプは、次の共通機能を共有しています。

  • これらのタイプのオブジェクトは不変です。
  • これらのタイプのオブジェクトはハッシュ可能です。つまり、辞書キーとして使用できます。
  • これらのタイプのオブジェクトは、 pickle モジュールを介した効率的なピクルスをサポートします。


オブジェクトが認識されているかナイーブであるかを判断する

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

タイプ time または datetime のオブジェクトは、認識しているか、ナイーブである可能性があります。

datetime オブジェクト d は、次の両方が成立するかどうかを認識します。

  1. d.tzinfoはNoneではありません
  2. d.tzinfo.utcoffset(d)はNoneを返しません

それ以外の場合、 d はナイーブです。

time オブジェクト t は、次の両方が成立するかどうかを認識します。

  1. t.tzinfoはNoneではありません
  2. t.tzinfo.utcoffset(None)はNoneを返しません。

それ以外の場合、 t はナイーブです。

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


timedelta オブジェクト

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

class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)

すべての引数はオプションであり、デフォルトは0です。 引数は整数または浮動小数点数であり、正または負の場合があります。

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

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

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

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

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

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

  • 0 <= microseconds < 1000000

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

  • -999999999 <= days <= 999999999

次の例は、日、秒、マイクロ秒以外の引数がどのように「マージ」され、これらの3つの結果属性に正規化されるかを示しています。

>>> from datetime import timedelta
>>> delta = timedelta(
...     days=50,
...     seconds=27,
...     microseconds=10,
...     milliseconds=29000,
...     minutes=5,
...     hours=8,
...     weeks=2
... )
>>> # Only days, seconds, and microseconds remain
>>> delta
datetime.timedelta(days=64, seconds=29156, microseconds=10)

いずれかの引数が浮動小数点数であり、マイクロ秒の小数部がある場合、すべての引数から残ったマイクロ秒の小数部が結合され、それらの合計は、1/2から偶数のタイブレーカーを使用して最も近いマイクロ秒に丸められます。 引数が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)(6)
t1 = t2 * i or t1 = i * t2 デルタに整数を掛けたもの。 その後、 t1 // i == t2 は、i != 0の場合に真になります。
一般に、 t1 * i == t1 *（i-1）+ t1 は真です。 (1)
t1 = t2 * f or t1 = f * t2 デルタにフロートを掛けたもの。 結果は、半から偶数に丸めて、timedelta.resolutionの最も近い倍数に丸められます。
f = t2 / t3 間隔単位 t3 による全体の持続時間 t2 の除算（3）。 float オブジェクトを返します。
t1 = t2 / f or t1 = t2 / i デルタをfloatまたはintで割った値。 結果は、半から偶数に丸めて、timedelta.resolutionの最も近い倍数に丸められます。
t1 = t2 // iまたはt1 = t2 // t3 フロアが計算され、残り（存在する場合）は破棄されます。 2番目のケースでは、整数が返されます。 (3)
t1 = t2 % t3 余りは timedelta オブジェクトとして計算されます。 (3)
q, r = divmod(t1, t2) 商と剰余を計算します：q = t1 // t2（3）とr = t1 % t2。 qは整数で、rは timedelta オブジェクトです。
+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) timedelta オブジェクトの文字列表現を、正規の属性値を持つコンストラクター呼び出しとして返します。

ノート：

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

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

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

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

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

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

  6. 式t2 - t3は、t3がtimedelta.maxに等しい場合を除いて、常に式t2 + (-t3)に等しくなります。 その場合、前者は結果を生成し、後者はオーバーフローします。

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

バージョン3.2での変更：フロア分割と timedelta オブジェクトの別の timedelta オブジェクトによる実際の分割がサポートされ、剰余演算と divmodもサポートされるようになりました。 （）関数。 timedelta オブジェクトの float オブジェクトによる真の除算と乗算がサポートされるようになりました。


timedelta オブジェクトの比較がサポートされていますが、いくつかの注意点があります。

比較==または!= 常には、比較対象のオブジェクトのタイプに関係なく、ブールを返します。 

>>> from datetime import timedelta
>>> delta1 = timedelta(seconds=57)
>>> delta2 = timedelta(hours=25, seconds=2)
>>> delta2 != delta1
True
>>> delta2 == 5
False

他のすべての比較（<や>など）の場合、 timedelta オブジェクトを別のタイプのオブジェクトと比較すると、 TypeError は次のようになります。上げられた： 

>>> delta2 > delta1
True
>>> delta2 > 5
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: '>' not supported between instances of 'datetime.timedelta' and 'int'

ブールコンテキストでは、 timedelta オブジェクトは、timedelta(0)と等しくない場合にのみ、真であると見なされます。

インスタンスメソッド：

timedelta.total_seconds()

期間に含まれる合計秒数を返します。 td / timedelta(seconds=1)と同等です。 秒以外の間隔の単位については、除算フォームを直接使用してください（例： td / timedelta(microseconds=1)）。

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

バージョン3.2の新機能。

使用例： timedelta

正規化の追加の例： 

>>> # Components of another_year add up to exactly 365 days
>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> another_year = timedelta(weeks=40, days=84, hours=23,
...                          minutes=50, seconds=600)
>>> year == another_year
True
>>> year.total_seconds()
31536000.0

timedelta 演算の例： 

>>> from datetime import timedelta
>>> year = timedelta(days=365)
>>> ten_years = 10 * year
>>> ten_years
datetime.timedelta(days=3650)
>>> ten_years.days // 365
10
>>> nine_years = ten_years - year
>>> nine_years
datetime.timedelta(days=3285)
>>> three_years = nine_years // 3
>>> three_years, three_years.days // 365
(datetime.timedelta(days=1095), 3)

日付オブジェクト

date オブジェクトは、理想化されたカレンダーの日付（年、月、日）を表し、現在のグレゴリオ暦は両方向に無期限に拡張されます。

1年目の1月1日は1日目と呼ばれ、1年目の1月2日は2日目と呼ばれます。 2

class datetime.date(year, month, day)

すべての引数が必要です。 引数は、次の範囲の整数である必要があります。

  • 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()関数でサポートされている値の範囲外である場合、 OverflowError が発生し、localtime()エラーで OSError が発生する可能性があります。 。 これは1970年から2038年までの年に制限されるのが一般的です。 タイムスタンプの概念にうるう秒が含まれる非POSIXシステムでは、うるう秒は fromtimestamp（）によって無視されることに注意してください。

バージョン3.3で変更：タイムスタンプがプラットフォームC localtime()関数でサポートされている値の範囲外の場合、 ValueError ではなく Raise OverflowError 。 localtime()の失敗時に、 ValueError ではなく OSError を発生させます。

classmethod date.fromordinal(ordinal)

1年目の1月1日が序数1である、先発グレゴリオ暦の序数に対応する日付を返します。

ValueError は、1 <= ordinal <= date.max.toordinal()でない限り発生します。 任意の日付 d 、date.fromordinal(d.toordinal()) == d。

classmethod date.fromisoformat(date_string)

YYYY-MM-DDの形式で指定された date_string に対応する date を返します。

>>> from datetime import date
>>> date.fromisoformat('2019-12-04')
datetime.date(2019, 12, 4)

これは、 date.isoformat（）の逆です。 YYYY-MM-DDの形式のみをサポートします。

バージョン3.7の新機能。

classmethod date.fromisocalendar(year, week, day)

年、週、日で指定されたISOカレンダーの日付に対応する date を返します。 これは、関数 date.isocalendar（）の逆です。

バージョン3.8の新機能。

クラス属性：

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は無視されます。 date2.yearが MINYEAR より小さいか、 MAXYEAR より大きい場合、 OverflowError が発生します。
  2. timedelta.secondsとtimedelta.microsecondsは無視されます。
  3. これは正確であり、オーバーフローすることはありません。 timedelta.secondsとtimedelta.microsecondsは0で、date2 + timedelta == date1以降です。
  4. つまり、date1 < date2は、date1.toordinal() < date2.toordinal()の場合に限ります。 他の比較対象が date オブジェクトでもない場合、日付比較では[X23X] TypeError が発生します。 ただし、他の比較対象にtimetuple()属性がある場合は、代わりにNotImplementedが返されます。 このフックは、他の種類の日付オブジェクトに混合タイプの比較を実装する機会を与えます。 そうでない場合、 date オブジェクトを別のタイプのオブジェクトと比較すると、比較が==または!=でない限り、 TypeError が発生します。 後者の場合は、それぞれ False または True を返します。

ブールコンテキストでは、すべての date オブジェクトがtrueと見なされます。

インスタンスメソッド：

date.replace(year=self.year, month=self.month, day=self.day)

キーワード引数が指定された場合に新しい値が指定されたパラメーターを除いて、同じ値の日付を返します。

例：

>>> from datetime import date
>>> d = date(2002, 12, 31)
>>> d.replace(day=26)
datetime.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カレンダーは、グレゴリオ暦の広く使用されているバリアントです。 3

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

たとえば、2004年は木曜日に始まるため、ISO 2004年の最初の週は2003年12月29日月曜日に始まり、2004年1月4日日曜日に終わります。

>>> from datetime import date
>>> date(2003, 12, 29).isocalendar()
(2004, 1, 1)
>>> date(2004, 1, 4).isocalendar()
(2004, 1, 7)
date.isoformat()

日付を表す文字列をISO8601形式YYYY-MM-DDで返します。

>>> from datetime import date
>>> date(2002, 12, 4).isoformat()
'2002-12-04'

これは、 date.fromisoformat（）の逆です。

date.__str__()
日付 d の場合、str(d)はd.isoformat()と同等です。
date.ctime()

日付を表す文字列を返します。

>>> from datetime import date
>>> date(2002, 12, 4).ctime()
'Wed Dec  4 00:00:00 2002'

d.ctime()は次と同等です。

time.ctime(time.mktime(d.timetuple()))

ネイティブC ctime()関数（ time.ctime（）は呼び出すが、 date.ctime（）は呼び出さない）がC標準に準拠しているプラットフォーム。

date.strftime(format)
明示的なフォーマット文字列によって制御される、日付を表す文字列を返します。 時間、分、または秒を参照するフォーマットコードには、0の値が表示されます。 フォーマットディレクティブの完全なリストについては、 strftime（）およびstrptime（）の動作を参照してください。
date.__format__(format)
date.strftime（）と同じです。 これにより、フォーマット済み文字列リテラルおよび str.format（）を使用する場合に、 date オブジェクトのフォーマット文字列を指定できます。 フォーマットディレクティブの完全なリストについては、 strftime（）およびstrptime（）の動作を参照してください。

使用例： date

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

>>> 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)

>>> # Methods related to formatting string output
>>> d.isoformat()
'2002-03-11'
>>> d.strftime("%d/%m/%y")
'11/03/02'
>>> d.strftime("%A %d. %B %Y")
'Monday 11. March 2002'
>>> d.ctime()
'Mon Mar 11 00:00:00 2002'
>>> 'The {1} is {0:%d}, the {2} is {0:%B}.'.format(d, "day", "month")
'The day is 11, the month is March.'

>>> # Methods for to extracting 'components' under different calendars
>>> 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 )

>>> # A date object is immutable; all operations produce a new object
>>> d.replace(year=2005)
datetime.date(2005, 3, 11)

datetime オブジェクト

datetime オブジェクトは、 date オブジェクトと time オブジェクトからのすべての情報を含む単一のオブジェクトです。

date オブジェクトと同様に、 datetime は、現在のグレゴリオ暦が両方向に拡張されていることを前提としています。 time オブジェクトと同様に、 datetime は、毎日正確に3600 * 24秒あると想定しています。

コンストラクタ：

class datetime.datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

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

  • 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、

  • fold in [0, 1]。

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

バージョン3.6の新機能： fold引数を追加しました。

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

classmethod datetime.today()

tzinfo Noneを使用して、現在のローカル日時を返します。

に相当：

datetime.fromtimestamp(time.time())

now（）、 fromtimestamp（）も参照してください。

このメソッドは、機能的には now（）と同等ですが、tzパラメーターはありません。

classmethod datetime.now(tz=None)

現在の現地の日付と時刻を返します。

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

tz がNoneでない場合は、 tzinfo サブクラスのインスタンスである必要があり、現在の日付と時刻は tz 'に変換されます。 ■タイムゾーン。

この関数は、 today（）および utcnow（）よりも優先されます。

classmethod datetime.utcnow()

tzinfo Noneを使用して、現在のUTC日付と時刻を返します。

これは now（）に似ていますが、現在のUTC日付と時刻を単純な datetime オブジェクトとして返します。 datetime.now(timezone.utc)を呼び出すことにより、現在のUTC日時を知ることができます。 now（）も参照してください。

警告

ナイーブなdatetimeオブジェクトは、多くのdatetimeメソッドによって現地時間として扱われるため、UTCで時間を表すために認識された日時を使用することをお勧めします。 そのため、UTCで現在の時刻を表すオブジェクトを作成するための推奨される方法は、datetime.now(timezone.utc)を呼び出すことです。

classmethod datetime.fromtimestamp(timestamp, tz=None)

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

tz がNoneでない場合は、 tzinfo サブクラスのインスタンスである必要があり、タイムスタンプは tz のタイムゾーンに変換されます。 。

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

バージョン3.3で変更：タイムスタンプがプラットフォームC localtime()でサポートされている値の範囲外の場合、 ValueError ではなく Raise OverflowError またはgmtime()機能。 localtime()またはgmtime()の失敗時に、 ValueError ではなく OSError を発生させます。

バージョン3.6で変更： fromtimestamp（）は、 fold が1に設定されたインスタンスを返す場合があります。

classmethod datetime.utcfromtimestamp(timestamp)

tzinfo Noneを使用して、POSIXタイムスタンプに対応するUTC datetime を返します。 （結果のオブジェクトはナイーブです。）

タイムスタンプがプラットフォームCのgmtime()関数でサポートされている値の範囲外である場合、 OverflowError が発生し、gmtime()エラーで OSError が発生する可能性があります。 。 これは1970年から2038年までの年に制限されるのが一般的です。

認識している datetime オブジェクトを取得するには、 fromtimestamp（）を呼び出します。

datetime.fromtimestamp(timestamp, timezone.utc)

POSIX準拠のプラットフォームでは、次の式と同等です。

datetime(1970, 1, 1, tzinfo=timezone.utc) + timedelta(seconds=timestamp)

ただし、後者の式は常に全年の範囲をサポートします： MINYEAR から MAXYEAR まで。

警告

ナイーブなdatetimeオブジェクトは、多くのdatetimeメソッドによって現地時間として扱われるため、UTCで時間を表すために認識された日時を使用することをお勧めします。 そのため、UTCで特定のタイムスタンプを表すオブジェクトを作成するための推奨される方法は、datetime.fromtimestamp(timestamp, tz=timezone.utc)を呼び出すことです。

バージョン3.3で変更：タイムスタンプがプラットフォームC gmtime()関数でサポートされている値の範囲外の場合、 ValueError ではなく Raise OverflowError 。 gmtime()の失敗時に、 ValueError ではなく OSError を発生させます。

classmethod datetime.fromordinal(ordinal)
1年目の1月1日が序数1である、先発グレゴリオ暦の序数に対応する datetime を返します。 ValueError は、1 <= ordinal <= datetime.max.toordinal()でない限り発生します。 結果の時、分、秒、マイクロ秒はすべて0であり、 tzinfo はNoneです。
classmethod datetime.combine(date, time, tzinfo=self.tzinfo)

日付コンポーネントが指定された date オブジェクトと等しく、時間コンポーネントが指定された time オブジェクトと等しい新しい datetime オブジェクトを返します。 tzinfo 引数が指定されている場合、その値は結果の tzinfo 属性を設定するために使用されます。それ以外の場合は、 time の tzinfo 属性が設定されます。 ]引数が使用されます。

datetime オブジェクト d 、d == datetime.combine(d.date(), d.time(), d.tzinfo)の場合。 dateが datetime オブジェクトの場合、その時間コンポーネントと tzinfo 属性は無視されます。

バージョン3.6で変更： tzinfo 引数を追加しました。

classmethod datetime.fromisoformat(date_string)

date.isoformat（）および datetime.isoformat（）によって発行された形式のいずれかで、 date_string に対応する datetime を返します。

具体的には、この関数は次の形式の文字列をサポートします。

YYYY-MM-DD[*HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]]

ここで、*は任意の1文字に一致します。

注意

これは、任意のISO8601文字列の解析をサポートしません。 datetime.isoformat（）の逆演算としてのみ意図されています。 よりフル機能のISO8601パーサーであるdateutil.parser.isoparseは、サードパーティパッケージ dateutil で入手できます。

例：

>>> from datetime import datetime
>>> datetime.fromisoformat('2011-11-04')
datetime.datetime(2011, 11, 4, 0, 0)
>>> datetime.fromisoformat('2011-11-04T00:05:23')
datetime.datetime(2011, 11, 4, 0, 5, 23)
>>> datetime.fromisoformat('2011-11-04 00:05:23.283')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000)
>>> datetime.fromisoformat('2011-11-04 00:05:23.283+00:00')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000, tzinfo=datetime.timezone.utc)
>>> datetime.fromisoformat('2011-11-04T00:05:23+04:00')   
datetime.datetime(2011, 11, 4, 0, 5, 23,
    tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))

バージョン3.7の新機能。

classmethod datetime.fromisocalendar(year, week, day)

年、週、日で指定されたISOカレンダーの日付に対応する datetime を返します。 日時の非日付コンポーネントには、通常のデフォルト値が入力されます。 これは、関数 datetime.isocalendar（）の逆です。

バージョン3.8の新機能。

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（）の動作を参照してください。

クラス属性：

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。
datetime.fold

[0, 1]で。 繰り返される間隔の間に壁の時間を明確にするために使用されます。 （夏時間の終了時に時計がロールバックされるか、政治的な理由で現在のゾーンのUTCオフセットが減少すると、間隔が繰り返されます。）値0（1）は、次の2つの瞬間の早い方（遅い方）を表します。同じ実時間表現。

バージョン3.6の新機能。

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

手術 結果
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があります。 datetime2.yearが MINYEAR より小さいか、 MAXYEAR より大きい場合、 OverflowError が発生します。 入力が認識オブジェクトであっても、タイムゾーンの調整は行われないことに注意してください。

  2. datetime2 + timedelta == datetime1となるようにdatetime2を計算します。 さらに、結果には入力日時と同じ tzinfo 属性があり、入力が認識されていてもタイムゾーンの調整は行われません。

  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()から取得）を差し引くことによって調整されます。

    バージョン3.3で変更：認識インスタンスとナイーブ datetime インスタンス間の同等性の比較では、 TypeError は発生しません。

    ノート

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

インスタンスメソッド：

datetime.date()
同じ年、月、日で date オブジェクトを返します。
datetime.time()

time オブジェクトを同じ時間、分、秒、マイクロ秒、およびフォールドで返します。 tzinfo はNoneです。 メソッド timetz（）も参照してください。

バージョン3.6で変更： fold値が返された time オブジェクトにコピーされます。

datetime.timetz()

同じ時、分、秒、マイクロ秒、fold、およびtzinfo属性を持つ time オブジェクトを返します。 メソッド time（）も参照してください。

バージョン3.6で変更： fold値が返された time オブジェクトにコピーされます。

datetime.replace(year=self.year, month=self.month, day=self.day, hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)

キーワード引数が指定された方によって新しい値が与えられた属性を除いて、同じ属性を持つ日時を返します。 tzinfo=Noneを指定すると、日付と時刻のデータを変換せずに、認識されている日時から単純な日時を作成できることに注意してください。

バージョン3.6の新機能： fold引数を追加しました。

datetime.astimezone(tz=None)

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

指定する場合、 tz は tzinfo サブクラスのインスタンスである必要があり、その utcoffset（）および dst（）メソッドは返さないようにする必要がありますNone。 self がナイーブである場合、システムタイムゾーンの時間を表すと推定されます。

引数なしで（またはtz=Noneを使用して）呼び出された場合、システムのローカルタイムゾーンがターゲットタイムゾーンとして想定されます。 変換された日時インスタンスの.tzinfo属性は、OSから取得したゾーン名とオフセットを使用して timezone のインスタンスに設定されます。

self.tzinfoが tz の場合、self.astimezone(tz)は self と等しくなります。日付または時刻データの調整は実行されません。 それ以外の場合、結果はタイムゾーン tz の現地時間であり、 self と同じUTC時間を表します。astz = dt.astimezone(tz)の後、astz - astz.utcoffset()は同じ日付になりますdt - dt.utcoffset()としての時間データ。

日付と時刻のデータを調整せずに、単にタイムゾーンオブジェクト 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)

バージョン3.3で変更： tz を省略できるようになりました。

バージョン3.6で変更： astimezone（）メソッドは、システムの現地時間を表すと推定されるナイーブインスタンスで呼び出すことができるようになりました。

datetime.utcoffset()

tzinfo がNoneの場合、Noneを返し、それ以外の場合はself.tzinfo.utcoffset(self)を返し、後者がNoneを返さない場合は例外を発生させます。または、マグニチュードが1日未満の timedelta オブジェクト。

バージョン3.7で変更： UTCオフセットは整数分に制限されていません。

datetime.dst()

tzinfo がNoneの場合、Noneを返し、それ以外の場合はself.tzinfo.dst(self)を返し、後者がNoneを返さない場合は例外を発生させます。または、マグニチュードが1日未満の timedelta オブジェクト。

バージョン3.7で変更： DSTオフセットは整数分に制限されていません。

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またはMAXYEARであり、UTC調整が年の境界を超えて流出した場合、 OverflowError が発生する可能性があることに注意してください。

警告

ナイーブなdatetimeオブジェクトは、多くのdatetimeメソッドによって現地時間として扱われるため、UTCで時間を表すために認識された日時を使用することをお勧めします。 その結果、utcfromtimetupleを使用すると誤解を招く結果が生じる可能性があります。 UTCを表すナイーブなdatetimeがある場合は、datetime.replace(tzinfo=timezone.utc)を使用して認識させます。その時点で、 datetime.timetuple（）を使用できます。

datetime.toordinal()
日付の先発グレゴリオ暦の序数を返します。 self.date().toordinal()と同じです。
datetime.timestamp()

datetime インスタンスに対応するPOSIXタイムスタンプを返します。 戻り値は、 time.time（）によって返されるものと同様の float です。

ナイーブ datetime インスタンスは現地時間を表すと想定され、このメソッドはプラットフォームC mktime()関数に依存して変換を実行します。 datetime は、多くのプラットフォームでmktime()よりも広い範囲の値をサポートするため、このメソッドは、過去または将来の時間に OverflowError を発生させる可能性があります。

認識している datetime インスタンスの場合、戻り値は次のように計算されます。

(dt - datetime(1970, 1, 1, tzinfo=timezone.utc)).total_seconds()

バージョン3.3の新機能。

バージョン3.6で変更： timestamp（）メソッドは、 fold 属性を使用して、繰り返される間隔の時間を明確にします。

ノート

UTC時間を表すナイーブな datetime インスタンスからPOSIXタイムスタンプを直接取得する方法はありません。 アプリケーションがこの規則を使用していて、システムのタイムゾーンがUTCに設定されていない場合は、tzinfo=timezone.utcを指定してPOSIXタイムスタンプを取得できます。

timestamp = dt.replace(tzinfo=timezone.utc).timestamp()

またはタイムスタンプを直接計算することによって：

timestamp = (dt - datetime(1970, 1, 1)) / timedelta(seconds=1)
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='T', timespec='auto')

日付と時刻を表す文字列をISO8601形式で返します。

utcoffset（）がNoneを返さない場合は、文字列が追加され、UTCオフセットが示されます。

  • YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]]、マイクロ秒が0でない場合

  • YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]]、マイクロ秒が0の場合

例：

>>> from datetime import datetime, timezone
>>> datetime(2019, 5, 18, 15, 17, 8, 132263).isoformat()
'2019-05-18T15:17:08.132263'
>>> datetime(2019, 5, 18, 15, 17, tzinfo=timezone.utc).isoformat()
'2019-05-18T15:17:00+00:00'

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

>>> from datetime import tzinfo, timedelta, datetime
>>> class TZ(tzinfo):
...     """A time zone with an arbitrary, constant -06:39 offset."""
...     def utcoffset(self, dt):
...         return timedelta(hours=-6, minutes=-39)
...
>>> datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
'2002-12-25 00:00:00-06:39'
>>> datetime(2009, 11, 27, microsecond=100, tzinfo=TZ()).isoformat()
'2009-11-27T00:00:00.000100-06:39'

オプションの引数 timespec は、含める時間の追加コンポーネントの数を指定します（デフォルトは'auto'です）。 次のいずれかになります。

  • 'auto'：マイクロ秒が0の場合は'seconds'と同じ、それ以外の場合は'microseconds'と同じ。

  • 'hours'：時間を2桁のHH形式で含めます。

  • 'minutes'：時間と分をHH:MM形式で含めます。

  • 'seconds'：時間、分、および秒をHH:MM:SS形式で含めます。

  • 'milliseconds'：フルタイムを含みますが、小数秒の部分をミリ秒に切り捨てます。 HH:MM:SS.sssフォーマット。

  • 'microseconds'：フルタイムをHH:MM:SS.ffffff形式で含めます。

ノート

除外された時間コンポーネントは、丸められるのではなく、切り捨てられます。

ValueError は、無効な timespec 引数で発生します。

>>> from datetime import datetime
>>> datetime.now().isoformat(timespec='minutes')   
'2002-12-25T00:00'
>>> dt = datetime(2015, 1, 1, 12, 30, 59, 0)
>>> dt.isoformat(timespec='microseconds')
'2015-01-01T12:30:59.000000'

バージョン3.6の新機能： timespec 引数が追加されました。

datetime.__str__()
datetime インスタンス d の場合、str(d)はd.isoformat(' ')と同等です。
datetime.ctime()

日付と時刻を表す文字列を返します。

>>> from datetime import datetime
>>> datetime(2002, 12, 4, 20, 30, 40).ctime()
'Wed Dec  4 20:30:40 2002'

出力文字列には、入力が認識されているかどうかに関係なく、タイムゾーン情報が含まれませんされます。

d.ctime()は次と同等です。

time.ctime(time.mktime(d.timetuple()))

ネイティブC ctime()関数（ time.ctime（）は呼び出すが、 datetime.ctime（）は呼び出さない）がC標準に準拠しているプラットフォーム。

datetime.strftime(format)
明示的なフォーマット文字列によって制御される、日付と時刻を表す文字列を返します。 フォーマットディレクティブの完全なリストについては、 strftime（）およびstrptime（）の動作を参照してください。
datetime.__format__(format)
datetime.strftime（）と同じです。 これにより、フォーマット済み文字列リテラルおよび str.format（）を使用する場合に、 datetime オブジェクトのフォーマット文字列を指定できます。 フォーマットディレクティブの完全なリストについては、 strftime（）およびstrptime（）の動作を参照してください。

使用例： datetime

datetime オブジェクトの操作例： 

>>> from datetime import datetime, date, time, timezone

>>> # 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()
>>> datetime.now()   
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
>>> datetime.now(timezone.utc)   
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060, tzinfo=datetime.timezone.utc)

>>> # 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 a 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 サブクラスを定義しています。これは、1945年まで+4 UTCを使用し、その後+4：30UTCを使用しました。 

from datetime import timedelta, datetime, tzinfo, timezone

class KabulTz(tzinfo):
    # Kabul used +4 until 1945, when they moved to +4:30
    UTC_MOVE_DATE = datetime(1944, 12, 31, 20, tzinfo=timezone.utc)

    def utcoffset(self, dt):
        if dt.year < 1945:
            return timedelta(hours=4)
        elif (1945, 1, 1, 0, 0) <= dt.timetuple()[:5] < (1945, 1, 1, 0, 30):
            # An ambiguous ("imaginary") half-hour range representing
            # a 'fold' in time due to the shift from +4 to +4:30.
            # If dt falls in the imaginary range, use fold to decide how
            # to resolve. See PEP495.
            return timedelta(hours=4, minutes=(30 if dt.fold else 0))
        else:
            return timedelta(hours=4, minutes=30)

    def fromutc(self, dt):
        # Follow same validations as in datetime.tzinfo
        if not isinstance(dt, datetime):
            raise TypeError("fromutc() requires a datetime argument")
        if dt.tzinfo is not self:
            raise ValueError("dt.tzinfo is not self")

        # A custom implementation is required for fromutc as
        # the input to this function is a datetime with utc values
        # but with a tzinfo set to self.
        # See datetime.astimezone or fromtimestamp.
        if dt.replace(tzinfo=timezone.utc) >= self.UTC_MOVE_DATE:
            return dt + timedelta(hours=4, minutes=30)
        else:
            return dt + timedelta(hours=4)

    def dst(self, dt):
        # Kabul does not observe daylight saving time.
        return timedelta(0)

    def tzname(self, dt):
        if dt >= self.UTC_MOVE_DATE:
            return "+04:30"
        return "+04"

上からのKabulTzの使用法： 

>>> tz1 = KabulTz()

>>> # Datetime before the change
>>> dt1 = datetime(1900, 11, 21, 16, 30, tzinfo=tz1)
>>> print(dt1.utcoffset())
4:00:00

>>> # Datetime after the change
>>> dt2 = datetime(2006, 6, 14, 13, 0, tzinfo=tz1)
>>> print(dt2.utcoffset())
4:30:00

>>> # Convert datetime to another time zone
>>> dt3 = dt2.astimezone(timezone.utc)
>>> dt3
datetime.datetime(2006, 6, 14, 8, 30, tzinfo=datetime.timezone.utc)
>>> dt2
datetime.datetime(2006, 6, 14, 13, 0, tzinfo=KabulTz())
>>> dt2 == dt3
True

時間オブジェクト

time オブジェクトは、特定の曜日に依存せず、 tzinfo オブジェクトを介して調整される（ローカル）時刻を表します。

class datetime.time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)

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

  • 0 <= hour < 24、

  • 0 <= minute < 60、

  • 0 <= second < 60、

  • 0 <= microsecond < 1000000、

  • fold in [0, 1]。

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

クラス属性：

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

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

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

[0, 1]で。 繰り返される間隔の間に壁の時間を明確にするために使用されます。 （夏時間の終了時に時計がロールバックされるか、政治的な理由で現在のゾーンのUTCオフセットが減少すると、間隔が繰り返されます。）値0（1）は、次の2つの瞬間の早い方（遅い方）を表します。同じ実時間表現。

バージョン3.6の新機能。

time オブジェクトは、 time と time の比較をサポートします。ここで、 a はの場合 b よりも小さいと見なされます。 a は b よりも時間的に先行しています。 一方の比較対象がナイーブでもう一方が認識している場合、順序比較が試行されると TypeError が発生します。 同等性の比較では、ナイーブインスタンスがアウェアインスタンスと等しくなることはありません。

両方の比較対象が認識していて、同じ tzinfo 属性を持っている場合、共通の tzinfo 属性は無視され、基準時間が比較されます。 両方の比較対象が認識していて、異なる tzinfo 属性を持っている場合、比較対象は最初にUTCオフセット（self.utcoffset()から取得）を差し引くことによって調整されます。 混合タイプの比較がオブジェクトアドレスによるデフォルトの比較にフォールバックするのを防ぐために、 time オブジェクトが別のタイプのオブジェクトと比較されると、 TypeError が発生します。比較は==または!=です。 後者の場合は、それぞれ False または True を返します。

バージョン3.3で変更：認識インスタンスとナイーブ時間インスタンス間の同等性の比較では、 TypeError は発生しません。


ブールコンテキストでは、 time オブジェクトは常にtrueと見なされます。

バージョン3.5での変更： Python 3.5より前では、 time オブジェクトは、UTCで深夜を表す場合はfalseと見なされていました。 この動作はあいまいでエラーが発生しやすいと見なされ、Python3.5で削除されました。 詳細については、：issue： `13936` を参照してください。


その他のコンストラクター：

classmethod time.fromisoformat(time_string)

time.isoformat（）によって発行された形式の1つで、 time_string に対応する time を返します。 具体的には、この関数は次の形式の文字列をサポートします。

HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]

注意

これは、任意のISO8601文字列の解析をサポートしません。 time.isoformat（）の逆演算としてのみ意図されています。

例：

>>> from datetime import time
>>> time.fromisoformat('04:23:01')
datetime.time(4, 23, 1)
>>> time.fromisoformat('04:23:01.000384')
datetime.time(4, 23, 1, 384)
>>> time.fromisoformat('04:23:01+04:00')
datetime.time(4, 23, 1, tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))

バージョン3.7の新機能。

インスタンスメソッド：

time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, *, fold=0)

同じ値の time を返します。ただし、キーワード引数が指定されている場合は、新しい値が指定された属性を除きます。 tzinfo=Noneを指定すると、時間データを変換せずに、認識されている時間からナイーブな時間を作成できます。

バージョン3.6の新機能： fold引数を追加しました。

time.isoformat(timespec='auto')

時刻を表す文字列をISO8601形式で返します。次のいずれかです。

オプションの引数 timespec は、含める時間の追加コンポーネントの数を指定します（デフォルトは'auto'です）。 次のいずれかになります。

  • 'auto'：マイクロ秒が0の場合は'seconds'と同じ、それ以外の場合は'microseconds'と同じ。

  • 'hours'：時間を2桁のHH形式で含めます。

  • 'minutes'：時間と分をHH:MM形式で含めます。

  • 'seconds'：時間、分、および秒をHH:MM:SS形式で含めます。

  • 'milliseconds'：フルタイムを含みますが、小数秒の部分をミリ秒に切り捨てます。 HH:MM:SS.sssフォーマット。

  • 'microseconds'：フルタイムをHH:MM:SS.ffffff形式で含めます。

ノート

除外された時間コンポーネントは、丸められるのではなく、切り捨てられます。

ValueError は、無効な timespec 引数で発生します。

例：

>>> from datetime import time
>>> time(hour=12, minute=34, second=56, microsecond=123456).isoformat(timespec='minutes')
'12:34'
>>> dt = time(hour=12, minute=34, second=56, microsecond=0)
>>> dt.isoformat(timespec='microseconds')
'12:34:56.000000'
>>> dt.isoformat(timespec='auto')
'12:34:56'

バージョン3.6の新機能： timespec 引数が追加されました。

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を返さない場合は例外を発生させます。または、マグニチュードが1日未満の timedelta オブジェクト。

バージョン3.7で変更： UTCオフセットは整数分に制限されていません。

time.dst()

tzinfo がNoneの場合、Noneを返し、それ以外の場合はself.tzinfo.dst(None)を返し、後者がNoneを返さない場合は例外を発生させます。 、またはマグニチュードが1日未満の timedelta オブジェクト。

バージョン3.7で変更： DSTオフセットは整数分に制限されていません。

time.tzname()
tzinfo がNoneの場合、Noneを返すか、self.tzinfo.tzname(None)を返すか、後者がNoneを返さない場合は例外を発生させます。または文字列オブジェクト。

使用例： time

time オブジェクトの操作例： 

>>> from datetime import time, tzinfo, timedelta
>>> class TZ1(tzinfo):
...     def utcoffset(self, dt):
...         return timedelta(hours=1)
...     def dst(self, dt):
...         return timedelta(0)
...     def tzname(self,dt):
...         return "+01:00"
...     def  __repr__(self):
...         return f"{self.__class__.__name__}()"
...
>>> t = time(12, 10, 30, tzinfo=TZ1())
>>> t
datetime.time(12, 10, 30, tzinfo=TZ1())
>>> t.isoformat()
'12:10:30+01:00'
>>> t.dst()
datetime.timedelta(0)
>>> t.tzname()
'+01:00'
>>> t.strftime("%H:%M:%S %Z")
'12:10:30 +01:00'
>>> 'The {} is {:%H:%M}.'.format("time", t)
'The time is 12:10.'

tzinfo オブジェクト

class datetime.tzinfo

これは抽象基本クラスです。つまり、このクラスを直接インスタンス化しないでください。 tzinfo のサブクラスを定義して、特定のタイムゾーンに関する情報を取得します。

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

具体的なサブクラスを導出し、（少なくとも）使用する datetime メソッドに必要な標準の tzinfo メソッドの実装を提供する必要があります。 datetime モジュールは、 timezone を提供します。これは、 tzinfo の単純な具体的なサブクラスであり、UTC自体や北米のESTやEDTなどのUTCからの固定オフセットを持つタイムゾーンを表すことができます。

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

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

tzinfo.utcoffset(dt)

UTCから正の東にある timedelta オブジェクトとして、UTCからの現地時間のオフセットを返します。 現地時間がUTCの西にある場合、これは負の値になります。

これは、UTCからの合計オフセットを表します。 たとえば、 tzinfo オブジェクトがタイムゾーンとDSTの両方の調整を表す場合、 utcoffset（）はそれらの合計を返す必要があります。 UTCオフセットがわからない場合は、Noneを返します。 それ以外の場合、返される値は、厳密に-timedelta(hours=24)とtimedelta(hours=24)の間の timedelta オブジェクトである必要があります（オフセットの大きさは1日未満である必要があります）。 utcoffset（）のほとんどの実装は、おそらく次の2つのいずれかのようになります。

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

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

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

バージョン3.7で変更： UTCオフセットは整数分に制限されていません。

tzinfo.dst(dt)

timedelta オブジェクトとして、またはDST情報が不明な場合はNoneとして、夏時間（DST）調整を返します。

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.

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

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

バージョン3.7で変更： DSTオフセットは整数分に制限されていません。

tzinfo.tzname(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(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_examples.py ファイルには、 tzinfo クラスの例がいくつかあります。 

from datetime import tzinfo, timedelta, datetime

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

# A class capturing the platform's idea of local time.
# (May result in wrong values on historical times in
#  timezones where UTC offset and/or the DST rules had
#  changed in the past.)
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 fromutc(self, dt):
        assert dt.tzinfo is self
        stamp = (dt - datetime(1970, 1, 1, tzinfo=self)) // SECOND
        args = _time.localtime(stamp)[:6]
        dst_diff = DSTDIFF // SECOND
        # Detect fold
        fold = (args == _time.localtime(stamp - dst_diff))
        return datetime(*args, microsecond=dt.microsecond,
                        tzinfo=self, fold=fold)

    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) on the first Sunday of Nov.
DSTEND_2007 = datetime(1, 11, 1, 2)
# 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) 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, 2)
# 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)
# 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

def us_dst_range(year):
    # Find start and end times for US DST. For years before 1967, return
    # start = end for no DST.
    if 2006 < year:
        dststart, dstend = DSTSTART_2007, DSTEND_2007
    elif 1986 < year < 2007:
        dststart, dstend = DSTSTART_1987_2006, DSTEND_1987_2006
    elif 1966 < year < 1987:
        dststart, dstend = DSTSTART_1967_1986, DSTEND_1967_1986
    else:
        return (datetime(year, 1, 1), ) * 2

    start = first_sunday_on_or_after(dststart.replace(year=year))
    end = first_sunday_on_or_after(dstend.replace(year=year))
    return start, end


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
        start, end = us_dst_range(dt.year)
        # Can't compare naive to aware objects, so strip the timezone from
        # dt first.
        dt = dt.replace(tzinfo=None)
        if start + HOUR <= dt < end - HOUR:
            # DST is in effect.
            return HOUR
        if end - HOUR <= dt < end:
            # Fold (an ambiguous hour): use dt.fold to disambiguate.
            return ZERO if dt.fold else HOUR
        if start <= dt < start + HOUR:
            # Gap (a non-existent hour): reverse the fold rule.
            return HOUR if dt.fold else ZERO
        # DST is off.
        return ZERO

    def fromutc(self, dt):
        assert dt.tzinfo is self
        start, end = us_dst_range(dt.year)
        start = start.replace(tzinfo=self)
        end = end.replace(tzinfo=self)
        std_time = dt + self.stdoffset
        dst_time = std_time + HOUR
        if end <= dst_time < end + HOUR:
            # Repeated hour
            return std_time.replace(fold=1)
        if std_time < start or dst_time >= end:
            # Standard time
            return std_time
        if start <= std_time < end - HOUR:
            # Daylight saving time
            return dst_time


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で結果を提供しません。 たとえば、2016年の春のフォワードトランジションでは、次のようになります。 

>>> from datetime import datetime, timezone
>>> from tzinfo_examples import HOUR, Eastern
>>> u0 = datetime(2016, 3, 13, 5, tzinfo=timezone.utc)
>>> for i in range(4):
...     u = u0 + i*HOUR
...     t = u.astimezone(Eastern)
...     print(u.time(), 'UTC =', t.time(), t.tzname())
...
05:00:00 UTC = 00:00:00 EST
06:00:00 UTC = 01:00:00 EST
07:00:00 UTC = 03:00:00 EDT
08:00:00 UTC = 04:00:00 EDT

DSTが終了すると（「終了」行）、さらに悪い問題が発生する可能性があります。ローカルの壁時間では明確に綴ることができない時間、つまり夏時間の最後の1時間です。 東部では、夏時間が終了する日の5：MMUTCの形式の時間です。 ローカルの掛け時計は、1：59（夏時間）から1:00（標準時間）に戻ります。 1：MMの形式の現地時間はあいまいです。 astimezone()は、隣接する2つのUTC時間を同じローカル時間にマッピングすることにより、ローカルクロックの動作を模倣します。 東部標準時の例では、5：MMと6：MMの形式のUTC時間は、東部標準時に変換すると両方とも1：MMにマップされますが、それ以前の時間では fold 属性が0に設定され、後の時間ではそれが設定されます。 1に設定します。 たとえば、2016年のフォールバック移行では、次のようになります。 

>>> u0 = datetime(2016, 11, 6, 4, tzinfo=timezone.utc)
>>> for i in range(4):
...     u = u0 + i*HOUR
...     t = u.astimezone(Eastern)
...     print(u.time(), 'UTC =', t.time(), t.tzname(), t.fold)
...
04:00:00 UTC = 00:00:00 EDT 0
05:00:00 UTC = 01:00:00 EDT 0
06:00:00 UTC = 01:00:00 EST 1
07:00:00 UTC = 02:00:00 EST 0

fold 属性の値のみが異なる datetime インスタンスは、比較では等しいと見なされることに注意してください。

実時間のあいまいさに耐えられないアプリケーションは、 fold 属性の値を明示的にチェックするか、ハイブリッド tzinfo サブクラスの使用を避ける必要があります。 timezone 、またはその他の固定オフセット tzinfo サブクラス（EST（固定オフセット-5時間）のみを表すクラス、またはEDT（固定オフセット）のみを表すクラスなど）を使用する場合、あいまいさはありません。 -4時間））。

も参照してください

dateutil.tz

datetime モジュールには、基本的な timezone クラス（UTCからの任意の固定オフセットを処理するため）とその timezone.utc 属性（UTCタイムゾーンインスタンス）があります。

dateutil.tz ライブラリは、 IANAタイムゾーンデータベース（Olsonデータベースとも呼ばれます）をPythonに提供するため、その使用をお勧めします。

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

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


タイムゾーンオブジェクト

timezone クラスは tzinfo のサブクラスであり、各インスタンスはUTCからの固定オフセットによって定義されたタイムゾーンを表します。

このクラスのオブジェクトを使用して、1年のさまざまな曜日にさまざまなオフセットが使用されている場所、または常用時に履歴が変更されている場所のタイムゾーン情報を表すことはできません。

class datetime.timezone(offset, name=None)

offset 引数は、現地時間とUTCの差を表す timedelta オブジェクトとして指定する必要があります。 厳密には-timedelta(hours=24)とtimedelta(hours=24)の間にある必要があります。そうでない場合、 ValueError が発生します。

name 引数はオプションです。 指定する場合は、 datetime.tzname（）メソッドによって返される値として使用される文字列である必要があります。

バージョン3.2の新機能。

バージョン3.7で変更： UTCオフセットは整数分に制限されていません。

timezone.utcoffset(dt)

timezone インスタンスの構築時に指定された固定値を返します。

dt 引数は無視されます。 戻り値は、現地時間とUTCの差に等しい timedelta インスタンスです。

バージョン3.7で変更： UTCオフセットは整数分に制限されていません。

timezone.tzname(dt)

timezone インスタンスの構築時に指定された固定値を返します。

name がコンストラクターで指定されていない場合、tzname(dt)によって返される名前は、offsetの値から次のように生成されます。 offset がtimedelta(0)の場合、名前は「UTC」です。それ以外の場合は、UTC±HH:MM形式の文字列です。ここで、±はoffsetの符号です。 、HHおよびMMは、それぞれoffset.hoursおよびoffset.minutesの2桁です。

バージョン3.6で変更： offset=timedelta(0)から生成された名前は、'UTC+00:00'ではなく、プレーン 'UTC' になりました。

timezone.dst(dt)
常にNoneを返します。
timezone.fromutc(dt)
dt + offsetを返します。 dt 引数は、tzinfoがselfに設定された、認識可能な datetime インスタンスである必要があります。

クラス属性：

timezone.utc
UTCタイムゾーンtimezone(timedelta(0))。


strftime()およびstrptime()の動作

date 、 datetime 、および time オブジェクトはすべて、strftime(format)メソッドをサポートし、明示的な形式の制御下で時間を表す文字列を作成しますストリング。

逆に、 datetime.strptime（）クラスメソッドは、日付と時刻を表す文字列と対応するフォーマット文字列から datetime オブジェクトを作成します。

次の表は、strftime()とstrptime()の高レベルの比較を示しています。

strftime strptime
使用法 指定された形式に従ってオブジェクトを文字列に変換します 対応する形式を指定して、文字列を datetime オブジェクトに解析します
メソッドのタイプ インスタンスメソッド クラスメソッド
の方法 日付; datetime ; 時間 datetime
サイン strftime(format) strptime(date_string, format)

strftime()およびstrptime()フォーマットコード

以下は、1989 C標準が必要とするすべてのフォーマットコードのリストであり、これらは標準C実装のすべてのプラットフォームで機能します。

指令 意味 例 ノート
%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 (9)
%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 (9)
%y ゼロが埋め込まれた10進数としての世紀のない年。 00、01、…、99 (9)
%Y 10進数として世紀を持つ年。 0001、0002、…、2013、2014、…、9998、9999 (2)
%H ゼロが埋め込まれた10進数としての時間（24時間制）。 00、01、…、23 (9)
%I ゼロが埋め込まれた10進数としての時間（12時間制）。 01、02、…、12 (9)
%p ロケールのAMまたはPMに相当します。

午前、午後（en_US）;

午前、午後（de_DE）

(1), (3)
%M ゼロが埋め込まれた10進数としての分。 00、01、…、59 (9)
%S ゼロが埋め込まれた10進数として2番目。 00、01、…、59 (4), (9)
%f 10進数としてのマイクロ秒。左側にゼロが埋め込まれます。 000000、000001、…、999999 (5)
%z ±HHMM[SS[.ffffff]]の形式のUTCオフセット（オブジェクトがナイーブの場合は空の文字列）。 （空）、+ 0000、-0400、+ 1030、+ 063415、-030712.345216 (6)
%Z タイムゾーン名（オブジェクトがナイーブの場合は空の文字列）。 （空）、UTC、EST、CST
%j ゼロが埋め込まれた10進数としての年の日。 001、002、…、366 (9)
%U ゼロが埋め込まれた10進数としての年の週番号（週の最初の日としての日曜日）。 最初の日曜日に先行する新年のすべての日は、第0週と見なされます。 00、01、…、53 (7), (9)
%W 10進数としての年の週番号（週の最初の日としての月曜日）。 最初の月曜日より前の新年のすべての日は、第0週と見なされます。 00、01、…、53 (7), (9)
%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)
%% リテラル'%'文字。 %

便宜上、C89標準で必要とされていないいくつかの追加のディレクティブが含まれています。 これらのパラメータはすべて、ISO8601の日付値に対応しています。

指令 意味 例 ノート
%G ISO 8601年。世紀は、ISO週の大部分を含む年を表します（%V）。 0001、0002、…、2013、2014、…、9998、9999 (8)
%u 10進数としてのISO8601平日（1は月曜日）。 1、2、…、7
%V ISO 8601週を10進数として、月曜日を週の最初の日とします。 01週目は、1月4日を含む週です。 01、02、…、53 (8), (9)

strftime()方式で使用した場合、これらはすべてのプラットフォームで使用できるとは限りません。 ISO 8601年およびISO8601週ディレクティブは、上記の年および週番号ディレクティブと互換性がありません。 不完全またはあいまいなISO8601ディレクティブを使用してstrptime()を呼び出すと、 ValueError が発生します。

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

バージョン3.6の新機能： %G、%u、%Vが追加されました。


技術詳細

大まかに言えば、d.strftime(fmt)は time モジュールのtime.strftime(fmt, d.timetuple())のように機能しますが、すべてのオブジェクトがtimetuple()メソッドをサポートしているわけではありません。

datetime.strptime（）クラスメソッドの場合、デフォルト値は1900-01-01T00:00:00.000です。フォーマット文字列で指定されていないコンポーネントは、デフォルト値からプルされます。 4

datetime.strptime(date_string, format)を使用することは、次と同等です。 

datetime(*(time.strptime(date_string, format)[0:6]))

ただし、フォーマットに1秒未満のコンポーネントまたはタイムゾーンオフセット情報が含まれている場合を除きます。これらはdatetime.strptimeでサポートされていますが、time.strptimeによって破棄されます。

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

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

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

ノート：

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

  2. NSstrptime() メソッドは[1、9999]の全範囲の年を解析できますが、1000未満の年は4桁の幅にゼロで埋める必要があります。

    バージョン3.2で変更：以前のバージョンでは、strftime()メソッドは1900年以上に制限されていました。

    バージョン3.3で変更：バージョン3.2では、strftime()メソッドは1000年以上に制限されていました。

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

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

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

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

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

    %z

    utcoffset()は±HHMM[SS[.ffffff]]の形式の文字列に変換されます。ここで、HHはUTCオフセット時間数を示す2桁の文字列、MMはUTCオフセットの分数を示す2桁の文字列、SSはUTCオフセットの秒数を示す2桁の文字列、ffffffはUTCオフセットの数を示す6桁の文字列です。マイクロ秒。 ffffffの部分は、オフセットが整数の場合は省略され、ffffffとSSの部分は、オフセットが整数の場合は省略されます。 たとえば、utcoffset()がtimedelta(hours=-3, minutes=-30)を返す場合、%zは文字列'-0330'に置き換えられます。

    バージョン3.7で変更： UTCオフセットは整数分に制限されていません。

    バージョン3.7で変更： %zディレクティブがstrptime()メソッドに提供されている場合、UTCオフセットには、時間、分、秒の間の区切り文字としてコロンを含めることができます。 たとえば、'+01:00:00'は1時間のオフセットとして解析されます。 また、'Z'の提供は'+00:00'と同じです。

    %Z

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

    バージョン3.2で変更： %zディレクティブがstrptime()メソッドに提供されると、認識される datetime オブジェクトが生成されます。 結果のtzinfoはタイムゾーンインスタンスに設定されます。

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

  8. %Uおよび%Wと同様に、%Vは、曜日とISO年（%G）が[ X148X] フォーマット文字列。 また、%Gと%Yは互換性がないことに注意してください。

  9. strptime()メソッドで使用する場合、%d、%m、%H、%I、%M、%S、%J、%U、%W、および%V。 形式%yには、先行ゼロが必要です。

脚注

1
つまり、相対性理論の影響を無視する場合
2
これは、ダーショウィッツとレインゴールドの著書カレンダー計算の「先発グレゴリオ暦」カレンダーの定義と一致します。ここでは、すべての計算の基本カレンダーです。 先発グレゴリオ暦の序数と他の多くのカレンダーシステムとの間で変換するためのアルゴリズムについては、本を参照してください。
3
Rを参照してください。 NS。 良い説明については、vanGentの ISO8601カレンダーの数学ガイド。
4
1900はうるう年ではないため、datetime.strptime('Feb 29', '%b %d')の合格は失敗します。



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