8.1。 日付時刻 —基本的な日付と時刻のタイプ
ソースコード: :source: `Lib / datetime.py`
datetime モジュールは、単純な方法と複雑な方法の両方で日付と時刻を操作するためのクラスを提供します。 日付と時刻の計算はサポートされていますが、実装の焦点は、出力のフォーマットと操作のための効率的な属性抽出にあります。 関連する機能については、 time および calendar モジュールも参照してください。
日付と時刻のオブジェクトには、「ナイーブ」と「認識」の2種類があります。
認識オブジェクトは、タイムゾーンや夏時間情報など、適用可能なアルゴリズム的および政治的な時間調整について十分な知識を持っており、他の認識オブジェクトとの相対的な位置を特定します。 認識オブジェクトは、解釈 1 に開かれていない特定の瞬間を表すために使用されます。
ナイーブオブジェクトには、他の日付/時刻オブジェクトとの相対的な位置を明確に示すのに十分な情報が含まれていません。 ナイーブオブジェクトが協定世界時(UTC)、現地時間、または他のタイムゾーンの時間を表すかどうかは、特定の数値がメートル、マイル、または質量を表すかどうかがプログラム次第であるのと同様に、純粋にプログラム次第です。 ナイーブなオブジェクトは、現実のいくつかの側面を無視するという犠牲を払って、理解しやすく、操作しやすいものです。
認識オブジェクトを必要とするアプリケーションの場合、 datetime および time オブジェクトには、抽象のサブクラスのインスタンスに設定できるオプションのタイムゾーン情報属性tzinfo
があります。 tzinfo クラス。 これらの tzinfo オブジェクトは、UTC時間からのオフセット、タイムゾーン名、および夏時間が有効かどうかに関する情報をキャプチャします。 datetime モジュールによって提供されるのは、1つの具体的な tzinfo クラス timezone クラスのみであることに注意してください。 timezone クラスは、UTC自体、北米のESTおよびEDTタイムゾーンなど、UTCからのオフセットが固定された単純なタイムゾーンを表すことができます。 より詳細なレベルでタイムゾーンをサポートするかどうかは、アプリケーション次第です。 世界中の時間調整のルールは合理的というよりも政治的であり、頻繁に変更され、UTC以外のすべてのアプリケーションに適した標準はありません。
datetime モジュールは、次の定数をエクスポートします。
8.1.1。 利用可能なタイプ
- class datetime.time
- 毎日が正確に24 * 60 * 60秒であると仮定した場合の、特定の日とは関係のない理想的な時間(ここでは「うるう秒」の概念はありません)。 属性:時間、分、秒、マイクロ秒、および tzinfo 。
- class datetime.tzinfo
- タイムゾーン情報オブジェクトの抽象基本クラス。 これらは、 datetime および time クラスによって使用され、時間調整のカスタマイズ可能な概念を提供します(たとえば、タイムゾーンや夏時間を考慮するため)。
- class datetime.timezone
tzinfo 抽象基本クラスをUTCからの固定オフセットとして実装するクラス。
バージョン3.2の新機能。
これらのタイプのオブジェクトは不変です。
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
timezone
time
date
datetime
8.1.2。 タイムデルタオブジェクト
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
いずれかの引数が浮動小数点数であり、マイクロ秒の小数部がある場合、すべての引数から残ったマイクロ秒の小数部が結合され、それらの合計は、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 の場合、trueになります。
|
一般に、 t1 * i == t1 *(i-1)+ t1 は真です。 (1) | |
t1 = t2 * f or t1 = f * t2
|
デルタにフロートを掛けたもの。 結果は、半から偶数に丸めて、timedelta.resolutionの最も近い倍数に丸められます。 |
f = t2 / t3
|
t2 の t3 による除算(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)
|
datetime.timedelta(D[, S[, U]]) の形式で文字列を返します。ここで、Dは負のt に対して負です。 (5)
|
ノート:
これは正確ですが、オーバーフローする可能性があります。
これは正確であり、オーバーフローすることはありません。
0で除算すると、 ZeroDivisionError が発生します。
- timedelta.max は timedelta オブジェクトとして表現できません。
timedelta オブジェクトの文字列表現は、内部表現と同様に正規化されます。 これにより、負のタイムデルタに対してやや異常な結果が生じます。 例えば:
>>> timedelta(hours=-5) datetime.timedelta(-1, 68400) >>> print(_) -1 day, 19:00:00
式
t2 - t3
は、t3がtimedelta.max
に等しい場合を除いて、常に式t2 + (-t3)
に等しくなります。 その場合、前者は結果を生成し、後者はオーバーフローします。
上記の操作に加えて、 timedelta オブジェクトは、 date および datetime オブジェクトによる特定の加算および減算をサポートします(以下を参照)。
バージョン3.2での変更:フロア分割と timedelta オブジェクトの別の timedelta オブジェクトによる実際の分割がサポートされ、剰余演算と divmodもサポートされるようになりました。 ()関数。 timedelta オブジェクトの float オブジェクトによる真の除算と乗算がサポートされるようになりました。
timedelta オブジェクトの比較は、小さいtimedeltaと見なされる短い期間を表す timedelta オブジェクトでサポートされます。 混合タイプの比較がオブジェクトアドレスによるデフォルトの比較にフォールバックするのを防ぐために、 timedelta オブジェクトが別のタイプのオブジェクトと比較されると、 TypeError が発生します。比較は==
または!=
です。 後者の場合は、それぞれ False または True を返します。
timedelta オブジェクトは hashable (辞書キーとして使用可能)であり、効率的なピクルス化をサポートし、ブールコンテキストでは、 timedelta オブジェクトは次の場合にのみtrueと見なされます。 timedelta(0)
と同じではありません。
インスタンスメソッド:
- timedelta.total_seconds()
期間に含まれる合計秒数を返します。
td / timedelta(seconds=1)
と同等です。非常に長い時間間隔(ほとんどのプラットフォームで270年を超える)の場合、この方法ではマイクロ秒の精度が失われることに注意してください。
バージョン3.2の新機能。
使用例:
>>> 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)
すべての引数が必要です。 引数は、次の範囲の整数にすることができます。
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
。
クラス属性:
- date.min
- 最も早い表現可能な日付、
date(MINYEAR, 1, 1)
。
- date.max
- 最新の表現可能な日付、
date(MAXYEAR, 12, 31)
。
- date.resolution
- 等しくない日付オブジェクト間の可能な最小の差、
timedelta(days=1)
。
インスタンス属性(読み取り専用):
- 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) |
ノート:
- date2 は、
timedelta.days > 0
の場合は時間的に前方に移動し、timedelta.days < 0
の場合は後方に移動します。 その後date2 - date1 == timedelta.days
。timedelta.seconds
とtimedelta.microseconds
は無視されます。date2.year
が MINYEAR よりも小さいか、 MAXYEAR よりも大きい場合、 OverflowError が発生します。 timedelta.seconds
とtimedelta.microseconds
は無視されます。- これは正確であり、オーバーフローすることはありません。 timedelta.secondsとtimedelta.microsecondsは0で、date2 + timedelta == date1以降です。
- つまり、
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)
- キーワード引数が指定された場合に新しい値が指定されたパラメーターを除いて、同じ値の日付を返します。 たとえば、
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()
は、ネイティブCctime()
関数( 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=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()も参照してください。
- classmethod datetime.now(tz=None)
現在の現地の日付と時刻を返します。 オプションの引数 tz が
None
であるか指定されていない場合、これは today()のようになりますが、可能であれば、 time.time()タイムスタンプ(たとえば、これはCgettimeofday()
関数を提供するプラットフォームで可能かもしれません)。tz が
None
でない場合は、 tzinfo サブクラスのインスタンスである必要があり、現在の日付と時刻は tz 'に変換されます。 ■タイムゾーン。 この場合、結果はtz.fromutc(datetime.utcnow().replace(tzinfo=tz))
と同等です。 today()、 utcnow()も参照してください。
- classmethod datetime.utcnow()
- tzinfo
None
を使用して、現在のUTC日付と時刻を返します。 これは now()に似ていますが、現在のUTC日付と時刻を単純な datetime オブジェクトとして返します。datetime.now(timezone.utc)
を呼び出すことにより、現在のUTC日時を知ることができます。 now()も参照してください。
- classmethod datetime.fromtimestamp(timestamp, tz=None)
time.time()によって返されるような、POSIXタイムスタンプに対応するローカルの日付と時刻を返します。 オプションの引数 tz が
None
であるか指定されていない場合、タイムスタンプはプラットフォームのローカル日時に変換され、返される datetime オブジェクトはナイーブです。tz が
None
でない場合は、 tzinfo サブクラスのインスタンスである必要があり、タイムスタンプは tz のタイムゾーンに変換されます。 。 この場合、結果はtz.fromutc(datetime.utcfromtimestamp(timestamp).replace(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 まで。
バージョン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.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.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) |
datetime2は、datetime1から削除されたtimedeltaの期間であり、次の場合に時間的に進みます。
timedelta.days
> 0、または後方の場合timedelta.days
<0。 結果には、入力日時と同じ tzinfo 属性があり、datetime2-datetime1 == timedeltaafterがあります。 datetime2.yearが MINYEAR より小さいか、 MAXYEAR より大きい場合、 OverflowError が発生します。 入力が認識オブジェクトであっても、タイムゾーンの調整は行われないことに注意してください。datetime2 + timedelta == datetime1となるようにdatetime2を計算します。 さらに、結果には入力日時と同じ tzinfo 属性があり、入力が認識されていてもタイムゾーンの調整は行われません。
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())
ですが、実装がオーバーフローすることはありません。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()も参照してください。バージョン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
を返さない場合は例外を発生させます。 、または 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
またはMAXYEAR
であり、UTC調整が年の境界を超えて流出した場合、 OverflowError が発生する可能性があることに注意してください。
- 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形式で表す文字列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'
オプションの引数 timespec は、含める時間の追加コンポーネントの数を指定します(デフォルトは
'auto'
です)。 次のいずれかになります。'auto'
:マイクロ秒が0の場合は'seconds'
と同じ、それ以外の場合は'microseconds'
と同じ。'hours'
:時間を2桁のHH形式で含めます。'milliseconds'
:フルタイムを含みますが、小数秒の部分をミリ秒に切り捨てます。 HH:MM:SS.sss形式。'microseconds'
:フルタイムをHH:MM:SS.mmmmmm形式で含めます。
ノート
除外された時間コンポーネントは、丸められるのではなく、切り捨てられます。
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()
datetime(2002, 12, 4, 20, 30, 40).ctime() == 'Wed Dec 4 20:30:40 2002'
のように、日付と時刻を表す文字列を返します。d.ctime()
は、ネイティブCctime()
関数( 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=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 オブジェクト間の可能な最小の違い
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.fold
[0, 1]
で。 繰り返される間隔の間に壁の時間を明確にするために使用されます。 (夏時間の終了時に時計がロールバックされるか、政治的な理由で現在のゾーンのUTCオフセットが減少すると、間隔が繰り返されます。)値0(1)は、次の2つの瞬間の早い方(遅い方)を表します。同じ壁時間表現。バージョン3.6の新機能。
サポートされている操作:
time と time の比較。ここで、 a が bに先行する場合、 a は b よりも小さいと見なされます。 時間内に。 一方の比較対象がナイーブでもう一方が認識している場合、順序比較が試行されると TypeError が発生します。 同等性の比較では、ナイーブインスタンスがアウェアインスタンスと等しくなることはありません。
両方の比較対象が認識していて、同じ tzinfo 属性を持っている場合、共通の tzinfo 属性は無視され、基準時間が比較されます。 両方の比較対象が認識していて、異なる tzinfo 属性を持っている場合、比較対象は最初にUTCオフセット(
self.utcoffset()
から取得)を差し引くことによって調整されます。 混合タイプの比較がオブジェクトアドレスによるデフォルトの比較にフォールバックするのを防ぐために、 time オブジェクトが別のタイプのオブジェクトと比較されると、 TypeError が発生します。比較は==
または!=
です。 後者の場合は、それぞれ False または True を返します。ハッシュ、dictキーとして使用
効率的な酸洗い
ブールコンテキストでは、 time オブジェクトは常にtrueと見なされます。
バージョン3.5での変更: Python 3.5より前では、 time オブジェクトは、UTCで深夜を表す場合はfalseと見なされていました。 この動作はあいまいでエラーが発生しやすいと見なされ、Python3.5で削除されました。 詳細については、:issue: `13936` を参照してください。
インスタンスメソッド:
- 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形式で返します。HH:MM:SS.mmmmmm。 microsecond が0の場合、HH:MM:SS utcoffset()が[ X157X] 、6文字の文字列が追加され、UTCオフセットが(符号付き)時間と分で示されます:HH:MM:SS.mmmmmm + HH:MM、またはself.microsecondが0の場合、HH:MM: SS + HH:MM
オプションの引数 timespec は、含める時間の追加コンポーネントの数を指定します(デフォルトは
'auto'
です)。 次のいずれかになります。'auto'
:マイクロ秒が0の場合は'seconds'
と同じ、それ以外の場合は'microseconds'
と同じ。'hours'
:時間を2桁のHH形式で含めます。'milliseconds'
:フルタイムを含みますが、小数秒の部分をミリ秒に切り捨てます。 HH:MM:SS.sss形式。'microseconds'
:フルタイムをHH:MM:SS.mmmmmm形式で含めます。
ノート
除外された時間コンポーネントは、丸められるのではなく、切り捨てられます。
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
を返さない場合は例外を発生させます。または、 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 、 timezone の単純な具象サブクラスを提供します。これは、UTC自体または北米ESTおよびEDTなどのUTCからの固定オフセットを持つタイムゾーンを表すことができます。 。
tzinfo (の具体的なサブクラス)のインスタンスは、 datetime および time オブジェクトのコンストラクターに渡すことができます。 後者のオブジェクトは、属性を現地時間であると見なし、 tzinfo オブジェクトは、UTCからの現地時間のオフセット、タイムゾーンの名前、およびDSTオフセットを、すべて日付または時刻に関連して明らかにするメソッドをサポートします。それらに渡されたオブジェクト。
ピクルス化の特別な要件: tzinfo サブクラスには、引数なしで呼び出すことができる
__init__()
メソッドが必要です。そうでない場合、ピクルス化できますが、再度ピクルス解除することはできません。 これは、将来緩和される可能性のある技術要件です。tzinfo の具体的なサブクラスは、次のメソッドを実装する必要がある場合があります。 正確にどのメソッドが必要かは、認識されている datetime オブジェクトの用途によって異なります。 疑わしい場合は、それらすべてを実装するだけです。
- tzinfo.utcoffset(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(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(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 クラスの例:
from datetime import tzinfo, timedelta, datetime, timezone
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年の春のフォワードトランジションでは、
>>> 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
標準ライブラリには、UTCからの任意の固定オフセットを処理するための timezone クラスと、UTCタイムゾーンインスタンスとしての timezone.utc があります。
dateutil.tz ライブラリは、 IANAタイムゾーンデータベース(Olsonデータベースとも呼ばれます)をPythonに提供するため、その使用をお勧めします。
- IANAタイムゾーンデータベース
タイムゾーンデータベース(多くの場合、tz、tzdata、zoneinfoと呼ばれます)には、世界中の多くの代表的な場所の現地時間の履歴を表すコードとデータが含まれています。 政治団体がタイムゾーンの境界、UTCオフセット、夏時間のルールに加えた変更を反映するために定期的に更新されます。
8.1.7。 タイムゾーンオブジェクト
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の新機能。
- timezone.utcoffset(dt)
- timezone インスタンスの構築時に指定された固定値を返します。 dt 引数は無視されます。 戻り値は、現地時間とUTCの差に等しい timedelta インスタンスです。
- 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))
。
8.1.8。 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)のドキュメントを参照してください。
以下は、C標準(1989バージョン)が必要とするすべてのフォーマットコードのリストであり、これらは標準C実装のすべてのプラットフォームで機能します。 1999バージョンの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 | |
%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進数として世紀を持つ年。 | 0001、0002、…、2013、2014、…、9998、9999 | (2) |
%H
|
ゼロが埋め込まれた10進数としての時間(24時間制)。 | 00、01、…、23 | |
%I
|
ゼロが埋め込まれた10進数としての時間(12時間制)。 | 01、02、…、12 | |
%p
|
ロケールのAMまたはPMに相当します。 |
午前、午後(en_US); 午前、午後(de_DE) |
(1), (3) |
%M
|
ゼロが埋め込まれた10進数としての分。 | 00、01、…、59 | |
%S
|
ゼロが埋め込まれた10進数として2番目。 | 00、01、…、59 | (4) |
%f
|
10進数としてのマイクロ秒。左側にゼロが埋め込まれます。 | 000000、000001、…、999999 | (5) |
%z
|
+ HHMMまたは-HHMMの形式のUTCオフセット(オブジェクトがナイーブの場合は空の文字列)。 | (空)、+ 0000、-0400、+ 1030 | (6) |
%Z
|
タイムゾーン名(オブジェクトがナイーブの場合は空の文字列)。 | (空)、UTC、EST、CST | |
%j
|
ゼロが埋め込まれた10進数としての年の日。 | 001、002、…、366 | |
%U
|
ゼロが埋め込まれた10進数としての年の週番号(週の最初の日としての日曜日)。 最初の日曜日に先行する新年のすべての日は、第0週と見なされます。 | 00、01、…、53 | (7) |
%W
|
10進数としての年の週番号(週の最初の日としての月曜日)。 最初の月曜日より前の新年のすべての日は、第0週と見なされます。 | 00、01、…、53 | (7) |
%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の日付値に対応しています。 strftime()
メソッドで使用する場合、これらはすべてのプラットフォームで使用できるとは限りません。 ISO 8601年およびISO8601週ディレクティブは、上記の年および週番号ディレクティブと互換性がありません。 不完全またはあいまいなISO8601ディレクティブを使用してstrptime()
を呼び出すと、 ValueError が発生します。
指令 | 意味 | 例 | ノート |
---|---|---|---|
%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) |
バージョン3.6の新機能: %G
、%u
、%V
が追加されました。
ノート:
形式は現在のロケールに依存するため、出力値について推測する場合は注意が必要です。 フィールドの順序は異なり(たとえば、「月/日/年」と「日/月/年」)、出力には、ロケールのデフォルトエンコーディングを使用してエンコードされたUnicode文字が含まれる場合があります(たとえば、現在のロケールが
ja_JP
、デフォルトのエンコーディングはeucJP
、SJIS
、またはutf-8
のいずれかです。 locale.getlocale()を使用して現在のエンコーディングを決定しますロケールのエンコーディング)。NS
strptime()
メソッドは[1、9999]の全範囲の年を解析できますが、1000未満の年は4桁の幅にゼロで埋める必要があります。バージョン3.2で変更:以前のバージョンでは、
strftime()
メソッドは1900年以上に制限されていました。バージョン3.3で変更:バージョン3.2では、
strftime()
メソッドは1000年以上に制限されていました。strptime()
メソッドと一緒に使用すると、%p
ディレクティブは、%I
ディレクティブを使用して時間を解析する場合にのみ、出力時間フィールドに影響します。strptime()
メソッドと一緒に使用すると、%f
ディレクティブは1〜6桁で、右側にゼロパッドを受け入れます。%f
は、C標準のフォーマット文字セットの拡張です(ただし、日時オブジェクトに個別に実装されているため、常に使用できます)。ナイーブオブジェクトの場合、
%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
は戻り値に置き換えられます。戻り値は文字列である必要があります。
strptime()
方式で使用する場合、%U
および%W
は、曜日と暦年(%Y
)が指定されている場合の計算でのみ使用されます。 。%U
および%W
と同様に、%V
は、曜日とISO年(%G
)が[ X148X] フォーマット文字列。 また、%G
と%Y
は互換性がないことに注意してください。
脚注
- 1
- つまり、相対性理論の影響を無視する場合