`datetime` — 기본 날짜 및 시간 유형¶

소스 코드: Lib/datetime.py

datetime 모듈은 날짜와 시간을 조작하기 위한 클래스들을 제공합니다.

날짜와 시간 산술이 지원되지만, 구현의 초점은 출력 포매팅과 조작을 위한 효율적인 어트리뷰트 추출입니다.

팁

포맷 코드 섹션으로 건너뜁니다.

모듈 calendar: 일반 달력 관련 함수들.
모듈 time: 시간 액세스와 변환.
zoneinfo 모듈: IANA 시간대 데이터베이스를 나타내는 구상 시간대입니다.
패키지 dateutil: 시간대와 구문 분석 지원이 확장된 제삼자 라이브러리.
DateType 패키지: 예를 들어, 정적 형 검사기 가 나이브(naive)와 어웨어(aware) 날짜/시간을 구분할 수 있도록 별도의 정적 타입을 도입하는 서드파티 라이브러리입니다.

어웨어 및 나이브 객체¶

날짜와 시간 객체는 시간대 정보 포함 여부에 따라 “어웨어(aware)” 또는 “나이브(naive)”로 분류될 수 있습니다.

시간대와 일광 절약 시간 정보와 같은 적용 가능한 알고리즘과 정치적 시간 조정에 대한 충분한 지식을 통해, 어웨어 객체는 다른 어웨어 객체와의 상대적인 위치를 파악할 수 있습니다. 어웨어 객체는 자의적으로 해석할 여지 없는 특정 시간을 나타냅니다. [1]

나이브 객체는 다른 날짜/시간 객체와 비교하여 자신의 위치를 명확하게 파악할 수 있는 충분한 정보를 포함하지 않습니다. 나이브 객체가 협정 세계시(UTC), 현지 시간 또는 다른 시간대의 시간을 나타내는지 여부는 프로그램의 판단에 달려 있습니다. 이는 특정 숫자가 미터, 마일 또는 질량을 나타내는지가 프로그램의 결정에 달린 것과 같습니다. 나이프 객체는 현실의 일부 측면을 무시하는 대신 이해하고 다루기 쉽습니다.

어웨어 객체가 필요한 응용 프로그램의 경우, datetime 및 time 객체는 추상 tzinfo 클래스의 서브클래스 인스턴스로 설정할 수 있는 선택적 시간대 정보 어트리뷰트인 tzinfo 를 가집니다. 이러한 tzinfo 객체는 UTC로부터의 오프셋, 시간대 이름, 일광 절약 시간 적용 여부에 대한 정보를 포함합니다.

datetime 모듈에서는 유일한 구상 tzinfo 클래스인 timezone 클래스만 제공됩니다. timezone 클래스는 UTC 자체 또는 북미 EST 및 EDT 시간대와 같이 고정된 오프셋을 가진 단순한 시간대를 나타낼 수 있습니다. 더 상세한 수준의 시간대를 지원하는 것은 응용 프로그램의 몫입니다. 전 세계의 시간 조정 규칙은 논리적이기보다 정치적인 경우가 많으며 빈번하게 변경되므로, UTC를 제외하고 모든 애플리케이션에 적합한 표준이 없습니다.

상수¶

datetime 모듈은 다음 상수를 내보냅니다:

datetime.MINYEAR¶: date 또는 datetime 객체에서 허용되는 가장 작은 연도 숫자입니다. MINYEAR 은 1입니다.

datetime.MAXYEAR¶: date 또는 datetime 객체에서 허용되는 가장 큰 연도 숫자입니다. MAXYEAR 은 9999입니다.

datetime.UTC¶: datetime.timezone.utc 인 UTC 시간대 싱글톤의 별칭입니다.

Added in version 3.11.

사용 가능한 유형¶

class datetime.date: 현재의 그레고리력이 언제나 적용되어왔고, 앞으로도 그럴 것이라는 가정하에 이상적인 나이브 날짜. 어트리뷰트: year, month 및 day.

class datetime.time: 특정 날짜와 관계없이, 하루가 정확히 24*60*60초를 갖는다는 가정하에 이상적인 시간. (여기에는 “윤초”라는 개념이 없습니다.) 어트리뷰트: hour, minute, second, microsecond 및 tzinfo.

class datetime.datetime: 날짜와 시간의 조합. 어트리뷰트: year, month, day, hour, minute, second, microsecond 및 tzinfo.

class datetime.timedelta: 마이크로초 단위로 두 개의 datetime 또는 date 인스턴스 사이의 차이를 나타내는 기간입니다.

class datetime.tzinfo: 시간대 정보 객체의 추상 베이스 클래스. 이것들은 datetime과 time 클래스에서 사용자 정의할 수 있는 시간 조정 개념(예를 들어, 시간대와/나 일광 절약 시간을 다루는 것)을 제공하기 위해 사용됩니다.

class datetime.timezone: tzinfo 추상 베이스 클래스를 구현하는 클래스로, UTC로부터의 고정 오프셋을 나타냅니다.

Added in version 3.2.

이러한 형의 객체는 불변입니다.

서브클래스 관계:

timedelta, tzinfo, time, date는 object를 상속받으며, timezone은 tzinfo로부터, datetime은 date로부터 상속받습니다.

공통 속성¶

date, datetime, time 및 timezone 형은 다음과 같은 공통 기능을 공유합니다:

이러한 형의 객체는 불변입니다.
이러한 유형의 객체는 해시 가능 하므로 딕셔너리 키로 사용할 수 있습니다.
이러한 형의 객체는 pickle 모듈을 통한 효율적인 피클링을 지원합니다.

객체가 어웨어인지 나이브인지 판단하기¶

date 형의 객체는 항상 나이브합니다.

time이나 datetime 형의 객체는 어웨어할 수도 나이브할 수도 있습니다.

datetime 객체 d 가 다음 두 조건을 모두 만족하면 어웨어(aware)입니다.

d.tzinfo가 None이 아닙니다
d.tzinfo.utcoffset(d)가 None을 반환하지 않습니다

그렇지 않으면, d 는 나이브(naive)입니다.

time 객체 t 가 다음 두 조건을 모두 만족하면 어웨어(aware)입니다.

t.tzinfo가 None이 아닙니다
t.tzinfo.utcoffset(None)이 None을 반환하지 않습니다

그렇지 않으면, t 는 나이브(naive)입니다.

어웨어와 나이브 간의 차이점은 timedelta 객체에는 적용되지 않습니다.

`timedelta` 객체¶

timedelta 객체는 두 개의 datetime 또는 date 인스턴스 사이의 차이인 기간을 나타냅니다.

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

모든 인수는 선택 사항이며 기본값은 0입니다. 인수는 정수 또는 부동 소수점 수일 수 있으며 양수 또는 음수일 수 있습니다.

days, seconds 및 microseconds만 내부적으로 저장됩니다. 인자는 이 단위로 변환됩니다:

밀리 초는 1000마이크로초로 변환됩니다.
분은 60초로 변환됩니다.
시간은 3600초로 변환됩니다.
주는 7일로 변환됩니다.

그런 다음 days, seconds 및 microseconds를 다음처럼 정규화하여 표현이 고유하도록 만듭니다

0 <= microseconds < 1000000
0 <= seconds < 3600*24 (하루 내의 초 수)
-999999999 <= days <= 999999999

다음 예는 days, seconds 및 microseconds 이외의 인자가 어떻게 “병합” 되어 세 개의 결과 어트리뷰트로 정규화되는지를 보여줍니다:

>>> import datetime as dt
>>> delta = dt.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)

팁

모듈과 클래스 사이의 혼동을 피하기 위해 import datetime 또는 from datetime import datetime 대신 import datetime as dt 를 사용하십시오. 자세한 내용은 How I Import Python’s datetime Module <https://adamj.eu/tech/2019/09/12/how-i-import-pythons-datetime-module/> 을(를) 참조하십시오.

인자가 float이고 부분 마이크로초가 있으면, 모든 인자의 남은 부분 마이크로초가 합쳐지고, 그 합은 동률일 때 짝수로 반올림하는 방식으로 가장 가까운 마이크로초로 반올림됩니다. float 인자가 없으면, 변환과 정규화 프로세스는 정확합니다 (정보가 손실되지 않습니다).

정규화된 days 값이 표시된 범위를 벗어나면, OverflowError가 발생합니다.

음수 값의 정규화는 처음 보면 놀라울 수 있습니다. 예를 들어:

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

timedelta 객체의 문자열 표현이 혼동을 줄 수 있으므로, 더 읽기 쉬운 형식을 만들기 위해 다음 방식을 사용하십시오.

>>> def pretty_timedelta(td):
...     if td.days >= 0:
...         return str(td)
...     return f'-({-td!s})'
...
>>> d = timedelta(hours=-1)
>>> str(d)  # not human-friendly
'-1 day, 23:00:00'
>>> pretty_timedelta(d)
'-(1:00:00)'

클래스 어트리뷰트:

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 객체로 표현할 수 없습니다.

인스턴스 어트리뷰트 (읽기 전용):

timedelta.days¶: -999,999,999에서 999,999,999 사이(경계 포함).

timedelta.seconds¶

0에서 86,399 사이(경계 포함).

조심

코드가 실제로는 total_seconds() 값을 가져오려는 의도였음에도 불구하고 실수로 이 속성을 사용하는 경우가 종종 발생합니다.

>>> import datetime as dt
>>> duration = dt.timedelta(seconds=11235813)
>>> duration.days, duration.seconds
(130, 3813)
>>> duration.total_seconds()
11235813.0

timedelta.microseconds¶: 0에서 999,999 사이(경계 포함).

지원되는 연산:

연산	결과
`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 또는 t1 = i * t2`	정수를 곱한 Delta입니다. `i != 0` 인 경우, 이후에 `t1 // i == t2` 가 참이 됩니다.
	일반적으로 `t1 * i == t1 * (i-1) + t1` 이 참입니다. (1)
`t1 = t2 * f 또는 t1 = f * t2`	델타에 float를 곱합니다. 결과는 동률일 때 짝수로 반올림하는 방식으로 timedelta.resolution의 가장 가까운 배수로 자리 올림 됩니다.
`f = t2 / t3`	전체 기간 `t2` 를 구간 단위 `t3` 로 나눈 값입니다. (3) 결과는 `float` 객체로 반환됩니다.
`t1 = t2 / f 또는 t1 = t2 / i`	델타를 float나 int로 나눈 값. 결과는 동률일 때 짝수로 반올림하는 방식으로 timedelta.resolution의 가장 가까운 배수로 자리 올림 됩니다.
`t1 = t2 // i` 또는 `t1 = t2 // t3`	floor가 계산되고 나머지(있다면)를 버립니다. 두 번째 경우에는, 정수가 반환됩니다. (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` 객체의 문자열 표현을 반환합니다.

노트:

이것은 정확하지만, 오버플로 할 수 있습니다.
이것은 정확하고, 오버플로 할 수 없습니다.
0으로 나누면 ZeroDivisionError 가 발생합니다.
-timedelta.max 은(는) timedelta 객체로 표현할 수 없습니다.
timedelta 객체의 문자열 표현은 내부 표현과 유사하게 정규화됩니다. 이것은 음의 timedelta가 다소 이상하게 표현되는 결과로 이어집니다. 예를 들어:
```
>>> timedelta(hours=-5)
datetime.timedelta(days=-1, seconds=68400)
>>> print(_)
-1 day, 19:00:00
```
t2 - t3 표현식은 항상 t2 + (-t3) 표현식과 같아지는데, t3이 timedelta.max일 때만 예외입니다; 이때는 앞에 있는 것은 결과를 만들지만, 뒤에 있는 것은 오버플로를 일으킵니다.

위에 나열된 연산 외에도, timedelta 객체는 date와 datetime 객체와의 어떤 합과 차를 지원합니다 (아래를 참조하세요).

버전 3.2에서 변경: 이제 다른 timedelta 객체로 한 timedelta 객체를 나누는 정수 나눗셈과 실수 나눗셈이 지원되며, 나머지 연산 및 divmod() 함수도 사용 가능합니다. 또한 timedelta 객체를 float 객체로 나누거나 곱하는 것도 이제 지원됩니다.

timedelta 객체는 동등성 및 순서 비교를 지원합니다.

불리언 문맥에서 timedelta 객체는 timedelta(0)와 같지 않을 때만 참으로 간주합니다.

인스턴스 메서드:

timedelta.total_seconds()¶

기간에 포함된 총 초(seconds) 수를 반환합니다. td / timedelta(seconds=1)``와 동일합니다. 초 이외의 단위인 경우, 나눗셈 형태를 직접 사용하십시오 (예: ``td / timedelta(microseconds=1)).

매우 큰 시간 구간에서는 (대부분 플랫폼에서 270년 이상), 이 메서드는 마이크로초의 정확도를 잃게 됩니다.

Added in version 3.2.

사용 예: `timedelta`¶

정규화의 추가 예:

>>> # another_year의 구성 요소들을 합하면 정확히 365일이 됩니다
>>> import datetime as dt
>>> year = dt.timedelta(days=365)
>>> another_year = dt.timedelta(weeks=40, days=84, hours=23,
...                             minutes=50, seconds=600)
>>> year == another_year
True
>>> year.total_seconds()
31536000.0

timedelta 산술의 예:

>>> import datetime as dt
>>> year = dt.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` 객체¶

date 객체는 현재의 그레고리력을 무한히 양방향으로 확장한, 이상적인 달력에서의 날짜(년, 월, 일)를 나타냅니다.

1년 1월 1일을 날 번호 1, 1년 1월 2일을 날 번호 2라고 부르고, 이런 식으로 계속됩니다. [2]

class datetime.date(year, month, day)¶

모든 인자가 필수입니다. 인자는 다음 범위에 있는 정수이어야 합니다:

MINYEAR <= year <= MAXYEAR
1 <= month <= 12
1 <= day <= 주어진 month와 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에서 변경: timestamp가 플랫폼 C localtime() 함수에서 지원하는 값 범위를 벗어나면 ValueError 대신 OverflowError를 발생시킵니다. localtime() 실패 시 ValueError 대신 OSError를 발생시킵니다.

버전 3.15에서 변경: 정수나 실수뿐만 아니라 모든 실수를 타임스탬프 로 수용합니다.

classmethod date.fromordinal(ordinal)¶

역산 그레고리력(proleptic Gregorian) 서수에 해당하는 날짜를 반환하며, 1년 1월 1일이 서수 1입니다.

1 <= ordinal <= date.max.toordinal() 이 아니면 ValueError 가 발생합니다. 모든 날짜 d 에 대해 date.fromordinal(d.toordinal()) == d 입니다.

classmethod date.fromisoformat(date_string)¶

다음 예외 사항을 제외하고, 유효한 ISO 8601 형식의 date_string 에 해당하는 date 를 반환합니다.

정밀도가 낮은 날짜(YYYY-MM, YYYY)는 현재 지원되지 않습니다.
확장된 날짜 표현(±YYYYYY-MM-DD)은 현재 지원되지 않습니다.
서수 날짜(YYYY-OOO)는 현재 지원되지 않습니다.

예제:

>>> import datetime as dt
>>> dt.date.fromisoformat('2019-12-04')
datetime.date(2019, 12, 4)
>>> dt.date.fromisoformat('20191204')
datetime.date(2019, 12, 4)
>>> dt.date.fromisoformat('2021-W01-1')
datetime.date(2021, 1, 4)

Added in version 3.7.

버전 3.11에서 변경: 이전에는 이 메서드가 YYYY-MM-DD 형식만 지원했습니다.

classmethod date.fromisocalendar(year, week, day)¶: year, week, day 로 지정된 ISO 달력 날짜에 해당하는 date 를 반환합니다. 이는 함수 date.isocalendar() 의 역함수입니다.

Added in version 3.8.

classmethod date.strptime(date_string, format)¶

format 에 따라 구문 분석된 date_string 에 해당하는 date 를 반환합니다. 이는 다음과 동일합니다:

date(*(time.strptime(date_string, format)[0:3]))

date_string과 format을 time.strptime() 으로 구문 분석할 수 없거나, 결과가 타임 튜플이 아닌 경우에 ValueError 가 발생합니다. 또한 strftime() 및 strptime() 동작 및 date.fromisoformat() 을 참조하십시오.

참고

format 에 연도가 포함되지 않은 월의 일(%d)만 지정된 경우 ValueError 가 발생합니다. 이는 형식에 연도가 없을 때 기본값으로 사용되는 연도가 윤년이 아님으로써 발생하는 4년 주기 윤년 오류를 방지하기 위함입니다. 해결 방법은 format 에 항상 연도를 포함하는 것입니다. 연도가 없는 date_string 값을 구문 분석할 경우, 구문 분석 전에 명시적으로 윤도이해임을 보장하는 연도를 추가하십시오:

>>> import datetime as dt
>>> date_string = "02/29"
>>> when = dt.date.strptime(f"{date_string};1984", "%m/%d;%Y")  # 윤년 오류 방지
>>> when.strftime("%B %d")
'February 29'

Added in version 3.14.

클래스 어트리뷰트:

date.min¶: 표현 가능한 가장 이른 date, date(MINYEAR, 1, 1).

date.max¶: 표현 가능한 가장 늦은 date, date(MAXYEAR, 12, 31).

date.resolution¶: 같지 않은 date 객체 간의 가능한 가장 작은 차이, timedelta(days=1).

인스턴스 어트리뷰트 (읽기 전용):

date.year¶: MINYEAR와 MAXYEAR 사이, 경계 포함.

date.month¶: 1과 12 사이, 경계 포함.

date.day¶: 1과 주어진 year의 주어진 month의 날 수 사이.

지원되는 연산:

연산	결과
`date2 = date1 + timedelta`	`date2` 는 `date1` 으로부터 `timedelta.days` 일 후의 날짜입니다. (1)
`date2 = date1 - timedelta`	`date2 + timedelta == date1` 이 성립하는 `date2` 를 계산합니다. (2)
`timedelta = date1 - date2`	(3)
`date1 == date2` `date1 != date2`	동등성 비교. (4)
`date1 < date2` `date1 > date2` `date1 <= date2` `date1 >= date2`	순서 비교. (5)

노트:

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 이 성립합니다.
date 객체가 동일한 날짜를 나타내는 경우 서로 같다고 판단합니다.

date 객체가 datetime 인스턴스가 아니면, 동일한 날짜를 나타내더라도 datetime 객체와 결코 같지 않습니다.
date1 이 시간상으로 date2 보다 앞설 때 date1 을 더 작은 값으로 간주합니다. 다시 말해, date1.toordinal() < date2.toordinal() 인 경우에만 date1 < date2 가 성립합니다.

datetime 객체와 datetime 인스턴스가 아닌 date 객체 간의 순서 비교 시 TypeError 가 발생합니다.

버전 3.13에서 변경: datetime 객체와 datetime 하위 클래스가 아닌 date`의 인스턴스 간 비교 시, 더 이상 후자를 시간 부분과 시간대를 무시하고 :class:!date`로 변환하지 않습니다. 기본 동작은 하위 클래스에서 특별 비교 메서드를 재정의하여 변경할 수 있습니다.

불리언 문맥에서, 모든 date 객체는 참으로 간주합니다.

인스턴스 메서드:

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

동일한 값을 가지되, 지정된 매개변수만 업데이트된 새로운 date 객체를 반환합니다.

예제:

>>> import datetime as dt
>>> d = dt.date(2002, 12, 31)
>>> d.replace(day=26)
datetime.date(2002, 12, 26)

범용 함수인 copy.replace() 도 date 객체를 지원합니다.

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일부터 시작하여 현재 연도 내의 날짜 번호입니다.

date.toordinal()¶: 날짜의 역산 그레고리력 서수를 반환하며, 1년 1월 1일은 서수 1입니다. 모든 date 객체 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()¶

세 개의 구성 요소가 있는 네임드 튜플 객체를 반환합니다: year, week 및 weekday.

ISO 달력은 널리 사용되는 그레고리력의 변형입니다. [3]

ISO 연도는 52나 53개의 완전한 주로 구성되고, 주는 월요일에 시작하여 일요일에 끝납니다. ISO 연도의 첫 번째 주는 그 해의 (그레고리) 달력에서 목요일이 들어있는 첫 번째 주입니다. 이것을 주 번호 1이라고 하며, 그 목요일의 ISO 연도는 그레고리 연도와 같습니다.

예를 들어, 2004년은 목요일에 시작되므로, ISO 연도 2004의 첫 주는 월요일, 2003년 12월 29일에 시작하고, 일요일, 2004년 1월 4일에 끝납니다:

>>> import datetime as dt
>>> dt.date(2003, 12, 29).isocalendar()
datetime.IsoCalendarDate(year=2004, week=1, weekday=1)
>>> dt.date(2004, 1, 4).isocalendar()
datetime.IsoCalendarDate(year=2004, week=1, weekday=7)

버전 3.9에서 변경: 결과가 튜플에서 네임드 튜플로 변경되었습니다.

date.isoformat()¶

ISO 8601 형식으로 날짜를 나타내는 문자열을 반환합니다, YYYY-MM-DD:

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

date.__str__()¶: 날짜 d 에 대해 str(d) 는 d.isoformat() 과 동일합니다.

date.ctime()¶

날짜를 나타내는 문자열을 반환합니다:

>>> import datetime as dt
>>> dt.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.isoformat() 을 참조하십시오.

date.__format__(format)¶: date.strftime() 과 동일합니다. 이를 통해 formatted string literals 나 str.format() 을 사용할 때 date 객체에 대한 포맷 문자열을 지정할 수 있습니다. 또한 strftime() 및 strptime() 동작 및 date.isoformat() 을 참조하십시오.

사용 예시: `date`¶

이벤트까지 남은 날 수 계산 예:

>>> import time
>>> import datetime as dt
>>> today = dt.date.today()
>>> today
datetime.date(2007, 12, 5)
>>> today == dt.date.fromtimestamp(time.time())
True
>>> my_birthday = dt.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로 작업하는 추가 예:

>>> import datetime as dt
>>> d = dt.date.fromordinal(730920) # 1. 1. 0001 이후 730920일째
>>> d
datetime.date(2002, 3, 11)

>>> # 문자열 출력 포맷팅 관련 메서드
>>> 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.'

>>> # 다양한 달력에서 '구성 요소'를 추출하는 메서드
>>> 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 )

>>> # 날짜 객체는 불변(immutable)입니다. 모든 연산은 새로운 객체를 생성합니다.
>>> 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)¶

year, month, day 인자는 필수입니다. tzinfo는 None이거나 tzinfo 서브 클래스의 인스턴스일 수 있습니다. 나머지 인자는 다음 범위의 정수이어야 합니다:

MINYEAR <= year <= MAXYEAR,
1 <= month <= 12,
1 <= day <= 주어진 month와 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()보다 선호됩니다.

참고

기본 클록의 정밀도에 따라 datetime.now() 를 연속으로 호출할 때 동일한 시각이 반환될 수 있습니다.

classmethod datetime.utcnow()¶

tzinfo가 None인 현재 UTC 날짜와 시간을 반환합니다.

이것은 now()와 비슷하지만, 현재의 UTC 날짜와 시간을 나이브 datetime 객체로 반환합니다. 현재 어웨어 UTC datetime은 datetime.now(timezone.utc)를 호출하여 얻을 수 있습니다. now()도 참조하십시오.

경고

나이브 datetime 객체는 많은 datetime 메서드에 의해 지역 시간으로 취급되므로, UTC로 시간을 나타내는 어웨어 datetime을 사용하는 것이 좋습니다. 따라서 UTC로 현재 시간을 나타내는 객체를 만드는 권장 방법은 datetime.now(timezone.utc)를 호출하는 것입니다.

버전 3.12부터 폐지됨: 대신 UTC 와 함께 datetime.now() 를 사용하십시오.

classmethod datetime.fromtimestamp(timestamp, tz=None)¶

time.time()가 반환하는 것과 같은, POSIX timestamp에 해당하는 지역 날짜와 시간을 반환합니다. 선택적 인자 tz가 None이거나 지정되지 않으면 timestamp는 플랫폼의 지역 날짜와 시간으로 변환되며, 반환된 datetime 객체는 나이브합니다.

tz가 None이 아니면, tzinfo 서브 클래스의 인스턴스여야 하며, timestamp는 tz의 시간대로 변환됩니다.

timestamp가 플랫폼 C localtime() 이나 gmtime() 함수에서 지원하는 값 범위를 벗어나면 fromtimestamp()가 OverflowError를 발생시킬 수 있고, localtime() 이나 gmtime()이 실패하면 OSError를 발생시킬 수 있습니다. 1970년에서 2038년까지로 제한되는 것이 일반적입니다. 타임스탬프에 윤초 개념을 포함하는 비 POSIX 시스템에서, fromtimestamp()는 윤초를 무시하므로, 1초 차이가 나는 두 개의 타임스탬프가 같은 datetime 객체를 산출할 수 있습니다. 이 방법은 utcfromtimestamp()보다 선호됩니다.

버전 3.3에서 변경: timestamp가 플랫폼 C localtime() 이나 gmtime() 함수에서 지원하는 값 범위를 벗어나면 ValueError 대신 OverflowError를 발생시킵니다. localtime() 이나 gmtime()이 실패하면 ValueError 대신 OSError를 발생시킵니다.

버전 3.6에서 변경: fromtimestamp()는 fold가 1로 설정된 인스턴스를 반환할 수 있습니다.

버전 3.15에서 변경: 정수나 실수뿐만 아니라 모든 실수를 타임스탬프 로 수용합니다.

classmethod datetime.utcfromtimestamp(timestamp)¶

tzinfo가 None인 POSIX timestamp에 해당하는 UTC datetime을 반환합니다. (결과 객체는 나이브합니다.)

timestamp가 플랫폼 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로 시간을 나타내는 어웨어 datetime을 사용하는 것이 좋습니다. 따라서 UTC로 특정 timestamp를 나타내는 객체를 만드는 권장 방법은 datetime.fromtimestamp(timestamp, tz=timezone.utc)를 호출하는 것입니다.

버전 3.3에서 변경: timestamp가 플랫폼 C gmtime() 함수에서 지원하는 값 범위를 벗어나면 ValueError 대신 OverflowError를 발생시킵니다. gmtime()이 실패하면 ValueError 대신 OSError를 발생시킵니다.

버전 3.15에서 변경: 정수나 실수뿐만 아니라 모든 실수를 타임스탬프 로 수용합니다.

버전 3.12부터 폐지됨: 대신 UTC 와 함께 datetime.fromtimestamp() 를 사용하십시오.

classmethod datetime.fromordinal(ordinal)¶: 역산 그레고리력 서수(ordinal)에 해당하는 datetime을 반환합니다. 1년 1월 1일이 서수 1입니다. 1 <= ordinal <= datetime.max.toordinal()이 아니면 ValueError가 발생합니다. 결과의 hour, minute, second 및 microsecond는 모두 0이고, tzinfo는 None입니다.

classmethod datetime.combine(date, time, tzinfo=time.tzinfo)¶

날짜 구성 요소가 주어진 date 객체와 같고, 시간 구성 요소가 주어진 time 객체와 같은 새로운 datetime 객체를 반환합니다. tzinfo 인자가 제공되면 결과의 tzinfo 속성을 설정하는 데 해당 값이 사용되며, 그렇지 않으면 time 인자의 tzinfo 속성이 사용됩니다. 만약 date 인자가 datetime 객체인 경우, 시간 구성 요소와 tzinfo 속성은 무시됩니다.

모든 datetime 객체 d 에 대하여, d == datetime.combine(d.date(), d.time(), d.tzinfo) 가 성립합니다.

버전 3.6에서 변경: tzinfo 인자가 추가되었습니다.

classmethod datetime.fromisoformat(date_string)¶

다음 예외를 제외하고 유효한 ISO 8601 형식의 date_string 에 해당하는 datetime 을 반환합니다.

시간대 오프셋은 소수점 이하 초를 포함할 수 있습니다.
T 구분자는 임의의 단일 유니코드 문자로 대체될 수 있습니다.
소수점 단위의 시와 분은 지원되지 않습니다.
정밀도가 낮은 날짜(YYYY-MM, YYYY)는 현재 지원되지 않습니다.
확장된 날짜 표현(±YYYYYY-MM-DD)은 현재 지원되지 않습니다.
서수 날짜(YYYY-OOO)는 현재 지원되지 않습니다.

예제:

>>> import datetime as dt
>>> dt.datetime.fromisoformat('2011-11-04')
datetime.datetime(2011, 11, 4, 0, 0)
>>> dt.datetime.fromisoformat('20111104')
datetime.datetime(2011, 11, 4, 0, 0)
>>> dt.datetime.fromisoformat('2011-11-04T00:05:23')
datetime.datetime(2011, 11, 4, 0, 5, 23)
>>> dt.datetime.fromisoformat('2011-11-04T00:05:23Z')
datetime.datetime(2011, 11, 4, 0, 5, 23, tzinfo=datetime.timezone.utc)
>>> dt.datetime.fromisoformat('20111104T000523')
datetime.datetime(2011, 11, 4, 0, 5, 23)
>>> dt.datetime.fromisoformat('2011-W01-2T00:05:23.283')
datetime.datetime(2011, 1, 4, 0, 5, 23, 283000)
>>> dt.datetime.fromisoformat('2011-11-04 00:05:23.283')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000)
>>> dt.datetime.fromisoformat('2011-11-04 00:05:23.283+00:00')
datetime.datetime(2011, 11, 4, 0, 5, 23, 283000, tzinfo=datetime.timezone.utc)
>>> dt.datetime.fromisoformat('2011-11-04T00:05:23+04:00')
datetime.datetime(2011, 11, 4, 0, 5, 23,
    tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))

Added in version 3.7.

버전 3.11에서 변경: 이전에는 이 메서드가 date.isoformat() 또는 datetime.isoformat() 에 의해 출력될 수 있는 형식만 지원했습니다.

classmethod datetime.fromisocalendar(year, week, day)¶: year, week, day 로 지정된 ISO 달력 날짜에 해당하는 datetime 을 반환합니다. datetime의 날짜 이외 구성 요소는 일반적인 기본값으로 채워집니다. 이는 datetime.isocalendar() 함수의 역함수입니다.

Added in version 3.8.

classmethod datetime.strptime(date_string, format)¶

format에 따라 구문 분석된, date_string에 해당하는 datetime를 반환합니다.

format 에 마이크로초 또는 시간대 정보가 포함되지 않은 경우, 이는 다음과 동일합니다:

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

ValueError 는 date_string과 format이 time.strptime() 으로 파싱될 수 없거나, 파싱 결과가 타임 튜플이 아닐 때 발생합니다. 또한 strftime() 및 strptime() 동작 및 datetime.fromisoformat() 을 참조하십시오.

버전 3.15에서 변경: format 에 연도가 포함되지 않은 월의 일(%d)만 지정된 경우 ValueError 가 발생합니다. 이는 형식에 연도가 없을 때 기본값으로 사용되는 연도가 윤년이 아님으로써 발생하는 4년 주기 윤년 오류를 방지하기 위함입니다. 해결 방법은 format 에 항상 연도를 포함하는 것입니다. 연도가 없는 date_string 값을 구문 분석할 경우, 구문 분석 전에 명시적으로 윤도이해임을 보장하는 연도를 추가하십시오:

>>> import datetime as dt
>>> date_string = "02/29"
>>> when = dt.datetime.strptime(f"{date_string};1984", "%m/%d;%Y")  # 윤년 버그를 방지합니다.
>>> when.strftime("%B %d")
'February 29'

클래스 어트리뷰트:

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과 주어진 year의 주어진 month의 날 수 사이.

datetime.hour¶: 범위 range(24).

datetime.minute¶: 범위 range(60).

datetime.second¶: 범위 range(60).

datetime.microsecond¶: 범위 range(1000000).

datetime.tzinfo¶: datetime 생성자에 tzinfo 인자로 전달된 객체이거나, 전달되지 않았으면 None입니다.

datetime.fold¶: [0, 1]. 반복되는 구간 동안 벽면 시간(wall times)을 구분하는 데 사용됩니다. (반복 구간은 일광 절약 시간제 종료 시 시계가 뒤로 돌아가거나 현재 지역의 UTC 오프셋이 정치적 이유로 감소할 때 발생합니다.) 값 0과 1은 각각 동일한 벽면 시간 표현을 가진 두 시점 중 앞선 시점과 나중 시점을 나타냅니다.

Added in version 3.6.

지원되는 연산:

연산	결과
`datetime2 = datetime1 + timedelta`	(1)
`datetime2 = datetime1 - timedelta`	(2)
`timedelta = datetime1 - datetime2`	(3)
`datetime1 == datetime2` `datetime1 != datetime2`	동등성 비교. (4)
`datetime1 < datetime2` `datetime1 > datetime2` `datetime1 <= datetime2` `datetime1 >= datetime2`	순서 비교. (5)

datetime2 는 datetime1 에서 timedelta 만큼의 기간을 제거한 결과로, timedelta.days > 0 이면 시간이 앞으로 이동하고, timedelta.days < 0 이면 뒤로 이동합니다. 결과는 입력된 datetime과 동일한 tzinfo 속성을 가지며, 이후 datetime2 - datetime1 == timedelta 가 성립합니다. datetime2.year 가 MINYEAR 보다 작거나 MAXYEAR 보다 크면 OverflowError 가 발생합니다. 입력이 어웨어(aware) 객체인 경우에도 타임존 조정은 수행되지 않음에 주의하십시오.
datetime2 + timedelta == datetime1 이 성립하는 datetime2 를 계산합니다. 더하기 연산과 마찬가지로, 결과는 입력된 datetime과 동일한 tzinfo 속성을 가지며, 입력이 어웨어인 경우에도 타임존 조정은 수행되지 않습니다.
datetime 에서 datetime 을 빼는 것은 두 피연산자가 모두 나이브(naive)하거나 또는 둘 다 어웨어(aware)할 때만 정의됩니다. 하나가 어웨어이고 다른 하나가 나이브인 경우, TypeError 가 발생합니다.

두 객체가 모두 나이프거나, 모두 어웨어이면서 동일한 tzinfo 속성을 가지는 경우, tzinfo 속성은 무시되며 결과는 datetime2 + t == datetime1 을 만족하는 timedelta 객체 t 가 됩니다. 이 경우 타임존 조정은 수행되지 않습니다.

두 객체가 모두 어웨어이나 서로 다른 tzinfo 속성을 가지는 경우, a-b 는 a 와 b 가 먼저 나이브한 UTC datetime으로 변환된 것처럼 작동합니다. 결과는 (a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset()) 과 같으나, 구현상 절대 오버플로가 발생하지 않습니다.
datetime 객체는 타임존을 고려했을 때 동일한 날짜와 시간을 나타내면 서로 같은 것으로 간주됩니다.

나이브 및 어웨어 datetime 객체는 결코 같지 않습니다.

두 비교 대상이 모두 어웨어이고 동일한 tzinfo 속성을 가지면, tzinfo 와 fold 속성은 무시되고 기본 datetime이 비교됩니다. 두 비교 대상이 모두 어웨어이지만 서로 다른 tzinfo 속성을 가지는 경우, 구현상 오버플로가 발생하지 않는 범위 내에서 비교 대상들이 먼저 UTC datetime으로 변환된 것처럼 작동합니다. 반복되는 구간에 있는 datetime 인스턴스는 다른 타임존의 datetime 인스턴스와 결코 같지 않습니다.
datetime1 이 타임존을 고려했을 때 시간상으로 datetime2 보다 앞선다면, datetime1 은 datetime2 보다 작은 것으로 간주됩니다.

나이브와 어웨어 datetime 객체 간의 순서 비교는 TypeError 를 발생시킵니다.

두 비교 대상이 모두 어웨어이고 동일한 tzinfo 속성을 가지면, tzinfo 와 fold 속성은 무시되고 기본 datetime이 비교됩니다. 두 비교 대상이 모두 어웨어이나 서로 다른 tzinfo 속성을 가지는 경우, 구현상 오버플로가 발생하지 않는 범위 내에서 비교 대상들이 먼저 UTC datetime으로 변환된 것처럼 작동합니다.

버전 3.3에서 변경: 어웨어와 나이브 datetime 인스턴스 간의 동등 비교는 TypeError를 발생시키지 않습니다.

인스턴스 메서드:

datetime.date()¶: 같은 year, month, day의 date 객체를 반환합니다.

datetime.time()¶: 같은 hour, minute, second, microsecond 및 fold의 time 객체를 반환합니다. tzinfo는 None입니다. 메서드 timetz()도 참조하십시오.

버전 3.6에서 변경: fold 값은 반환된 time 객체에 복사됩니다.

datetime.timetz()¶: 같은 hour, minute, second, microsecond, 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)¶

동일한 속성을 유지하되 지정된 매개변수만 업데이트된 새로운 datetime 객체를 반환합니다. tzinfo=None 을 지정하면 날짜와 시간 데이터의 변환 없이 어웨어 datetime으로부터 나이브 datetime을 생성할 수 있습니다.

datetime 객체는 일반 함수인 copy.replace() 에서도 지원됩니다.

버전 3.6에서 변경: fold 매개변수가 추가되었습니다.

datetime.astimezone(tz=None)¶

새로운 tzinfo 어트리뷰트 tz를 갖는 datetime 객체를 반환하는데, 결과가 self와 같은 UTC 시간이지만 tz의 지역 시간이 되도록 날짜와 시간 데이터를 조정합니다.

제공될 경우, tz 는 반드시 tzinfo 의 서브클래스 인스턴스여야 하며, 그 utcoffset() 및 dst() 메서드는 None 을 반환해서는 안 됩니다. self 가 나이브인 경우 시스템 타임존의 시간을 나타내는 것으로 간주됩니다.

인자 없이(또는 tz=None``으로) 호출하면 대상 타임존에 시스템 로컬 타임존이 적용됩니다. 변환된 datetime 인스턴스의 ``.tzinfo 속성은 OS에서 얻은 존 이름과 오프셋을 가진 timezone 인스턴스로 설정됩니다.

self.tzinfo 가 tz 인 경우, self.astimezone(tz) 는 self 와 동일합니다. 즉, 날짜나 시간 데이터의 조정이 수행되지 않습니다. 그렇지 않은 경우 결과는 tz 타임존에서의 로컬 시간이며, self 와 동일한 UTC 시간을 나타냅니다. 즉, astz = dt.astimezone(tz) 이후 astz - astz.utcoffset() 은 dt - dt.utcoffset() 과 동일한 날짜 및 시간 데이터를 갖게 됩니다.

날짜와 시간 데이터의 조정 없이 datetime dt 에 timezone 객체 tz 를 붙이려면 dt.replace(tzinfo=tz) 를 사용하십시오. 날짜와 시간 데이터의 변환 없이 어웨어 datetime dt 에서 timezone 객체를 제거하려면 dt.replace(tzinfo=None) 을 사용하십시오.

기본 tzinfo.fromutc() 메서드는 astimezone()에 의해 반환된 결과에 영향을 주도록 tzinfo 서브 클래스에서 재정의할 수 있습니다. 에러가 발생하는 경우를 무시하고, astimezone()는 다음과 같이 작동합니다:

def astimezone(self, tz):
    if self.tzinfo is tz:
        return self
    # self를 UTC로 변환하고 새로운 타임존 객체를 연결합니다.
    utc = (self - self.utcoffset()).replace(tzinfo=tz)
    # UTC에서 tz의 로컬 시간으로 변환합니다.
    return tz.fromutc(utc)

버전 3.3에서 변경: 이제 tz를 생략할 수 있습니다.

버전 3.6에서 변경: 이제 astimezone() 메서드는 이제 나이브 인스턴스에서 호출될 수 있는데, 시스템 지역 시간을 나타내는 것으로 간주합니다.

datetime.utcoffset()¶: tzinfo가 None이면, None을 반환하고, 그렇지 않으면 self.tzinfo.utcoffset(self)를 반환하고, 후자가 None이나 하루 미만의 크기를 가진 timedelta 객체를 반환하지 않으면 예외를 발생시킵니다.

버전 3.7에서 변경: UTC 오프셋은 분 단위로 제한되지 않습니다.

datetime.dst()¶: tzinfo가 None이면, None을 반환하고, 그렇지 않으면 self.tzinfo.dst(self)를 반환하고, 후자가 None이나 하루 미만의 크기를 가진 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() 가 0이 아닌 값을 반환하면, tm_isdst 는 1로 설정되며, 그 외의 경우 tm_isdst 은 0으로 설정됩니다.

datetime.utctimetuple()¶

datetime 인스턴스 d 가 나이브인 경우, 이는 d.timetuple() 과 동일하지만, d.dst() 의 반환 값에 관계없이 tm_isdst 이 0으로 강제됩니다. UTC 시간에는 DST가 적용되지 않습니다.

d 가 어웨어인 경우, d 는 d.utcoffset() 을 빼서 UTC 시간으로 정규화되며, 정규화된 시간에 대한 time.struct_time 이 반환됩니다. tm_isdst 는 0으로 강제됩니다. 주의: d.year 가 MINYEAR 또는 MAXYEAR 이고 UTC 조정 시 연도 경계를 넘어가는 경우 OverflowError 가 발생할 수 있습니다.

경고

나이브 `datetime 객체는 많은 datetime 메서드에서 로컬 시간으로 취급되므로, UTC 시간을 나타낼 때는 어웨어 datetime을 사용하는 것이 권장됩니다. 결과적으로 datetime.utctimetuple() 을 사용하면 잘못된 결과를 얻을 수 있습니다. UTC를 나타내는 나이브 `datetime 객체가 있는 경우, datetime.replace(tzinfo=timezone.utc) 를 사용하여 이를 어웨어로 만든 후 datetime.timetuple() 을 사용할 수 있습니다.

datetime.toordinal()¶: 날짜의 역산 그레고리력 서수를 반환합니다. self.date().toordinal()과 같습니다.

datetime.timestamp()¶

datetime 인스턴스에 해당하는 POSIX 타임스탬프를 반환합니다. 반환 값은 time.time()이 반환하는 것과 비슷한 float입니다.

나이브 datetime 인스턴스는 로컬 시간을 나타내는 것으로 간주되며, 이 메서드는 변환을 수행하기 위해 플랫폼 C 함수에 의존합니다. 많은 플랫폼에서 datetime 이 플랫폼 C 함수보다 더 넓은 범위의 값을 지원하므로, 아주 먼 과거나 미래의 시간에 대해서는 이 메서드가 OverflowError 또는 OSError 를 발생시킬 수 있습니다.

어웨어 datetime 인스턴스의 경우, 반환 값은 다음과 같이 계산됩니다:

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

참고

UTC 시간을 나타내는 나이브 datetime 인스턴스로부터 POSIX 타임스탬프를 직접 얻는 메서드는 없습니다. 애플리케이션에서 이 방식을 사용하고 시스템 타임존이 UTC로 설정되어 있지 않은 경우, tzinfo=timezone.utc 를 제공하여 POSIX 타임스탬프를 얻을 수 있습니다.

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

또는 직접 타임스탬프를 계산할 수 있습니다:

timestamp = (dt - datetime(1970, 1, 1)) / timedelta(seconds=1)

Added in version 3.3.

버전 3.6에서 변경: timestamp() 메서드는 fold 어트리뷰트를 사용하여 반복되는 구간의 시간을 구분합니다.

버전 3.6에서 변경: 이 메서드는 더 이상 변환을 수행하기 위해 플랫폼 C mktime() 함수에 의존하지 않습니다.

datetime.weekday()¶: 정수로 요일을 반환합니다. 월요일은 0이고 일요일은 6입니다. self.date().weekday()와 같습니다. isoweekday()도 참조하십시오.

datetime.isoweekday()¶: 정수로 요일을 반환합니다. 월요일은 1이고 일요일은 7입니다. self.date().isoweekday() 와 같습니다. weekday(), isocalendar()도 참조하십시오.

datetime.isocalendar()¶: 세 개의 컴포넌트를 가진 네임드 튜플을 반환합니다: year, week 및 weekday. self.date().isocalendar()와 같습니다.

datetime.isoformat(sep='T', timespec='auto')¶

ISO 8601 형식으로 날짜와 시간을 나타내는 문자열을 반환합니다:

YYYY-MM-DDTHH:MM:SS.ffffff, microsecond가 0이 아니면
YYYY-MM-DDTHH:MM:SS, microsecond가 0이면

utcoffset()이 None을 반환하지 않으면, UTC 오프셋을 제공하는 문자열을 덧붙입니다:

YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]], microsecond가 0이 아니면
YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]], microsecond가 0이면

예제:

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

선택적 인자 sep(기본값 'T')은 한 문자 구분자로, 결과의 날짜와 시간 부분 사이에 배치됩니다. 예를 들어:

>>> import datetime as dt
>>> class TZ(dt.tzinfo):
...     """임의의 고정된 -06:39 오프셋을 가진 타임존."""
...     def utcoffset(self, when):
...         return dt.timedelta(hours=-6, minutes=-39)
...
>>> dt.datetime(2002, 12, 25, tzinfo=TZ()).isoformat(' ')
'2002-12-25 00:00:00-06:39'
>>> dt.datetime(2009, 11, 27, microsecond=100, tzinfo=TZ()).isoformat()
'2009-11-27T00:00:00.000100-06:39'

선택적 인자 timespec은 포함할 시간의 추가 구성 요소 수를 지정합니다 (기본값은 'auto'입니다). 다음 중 하나일 수 있습니다:

'auto': microsecond가 0이면 'seconds'와 같고, 그렇지 않으면 'microseconds'와 같습니다.
'hours': hour를 두 자리 숫자 HH 형식으로 포함합니다.
'minutes': hour와 minute를 HH:MM 형식으로 포함합니다.
'seconds': hour, minute 및 second를 HH:MM:SS 형식으로 포함합니다.
'milliseconds': 전체 시간을 포함하지만, 초 미만은 밀리초 단위로 자릅니다. HH:MM:SS.sss 형식입니다.
'microseconds': 전체 시간을 HH:MM:SS.ffffff 형식으로 포함합니다.

참고

제외된 시간 구성 요소는 반올림되지 않고 잘립니다.

잘못된 timespec 인자는 ValueError를 발생시킵니다:

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

버전 3.6에서 변경: timespec 파라미터가 추가되었습니다.

datetime.__str__()¶: datetime 인스턴스 d 에 대해, str(d) 는 d.isoformat(' ') 와 동일합니다.

datetime.ctime()¶

날짜와 시간을 나타내는 문자열을 반환합니다:

>>> import datetime as dt
>>> dt.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.isoformat() 를 참조하십시오.

datetime.__format__(format)¶: datetime.strftime() 과 동일합니다. 이를 통해 formatted string literals 및 str.format() 을 사용할 때 datetime 객체에 대한 포맷 문자열을 지정할 수 있습니다. 또한 strftime() 및 strptime() 동작 및 datetime.isoformat() 를 참조하십시오.

사용 예: `datetime`¶

datetime 객체를 사용하는 예제:

>>> import datetime as dt

>>> # Using datetime.combine()
>>> d = dt.date(2005, 7, 14)
>>> t = dt.time(12, 30)
>>> dt.datetime.combine(d, t)
datetime.datetime(2005, 7, 14, 12, 30)

>>> # Using datetime.now()
>>> dt.datetime.now()
datetime.datetime(2007, 12, 6, 16, 29, 43, 79043)   # GMT +1
>>> dt.datetime.now(dt.timezone.utc)
datetime.datetime(2007, 12, 6, 15, 29, 43, 79060, tzinfo=datetime.timezone.utc)

>>> # Using datetime.strptime()
>>> my_datetime = dt.datetime.strptime("21/11/06 16:30", "%d/%m/%y %H:%M")
>>> my_datetime
datetime.datetime(2006, 11, 21, 16, 30)

>>> # Using datetime.timetuple() to get tuple of all attributes
>>> tt = my_datetime.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 = my_datetime.isocalendar()
>>> for it in ic:
...     print(it)
...
2006    # ISO year
47      # ISO week
2       # ISO weekday

>>> # Formatting a datetime
>>> my_datetime.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(my_datetime, "day", "month", "time")
'The day is 21, the month is November, the time is 04:30PM.'

아래 예제는 1945년까지 +4 UTC를 사용한 후 +4:30 UTC로 변경한 아프가니스탄 카불의 시간대 정보를 캡처하는 tzinfo 서브 클래스를 정의합니다:

import datetime as dt

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

    def utcoffset(self, when):
        if when.year < 1945:
            return dt.timedelta(hours=4)
        elif (1945, 1, 1, 0, 0) <= when.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 when falls in the imaginary range, use fold to decide how
            # to resolve. See PEP 495.
            return dt.timedelta(hours=4, minutes=(30 if when.fold else 0))
        else:
            return dt.timedelta(hours=4, minutes=30)

    def fromutc(self, when):
        # Follow same validations as in datetime.tzinfo
        if not isinstance(when, dt.datetime):
            raise TypeError("fromutc() requires a datetime argument")
        if when.tzinfo is not self:
            raise ValueError("when.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 when.replace(tzinfo=dt.timezone.utc) >= self.UTC_MOVE_DATE:
            return when + dt.timedelta(hours=4, minutes=30)
        else:
            return when + dt.timedelta(hours=4)

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

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

위의 KabulTz 사용법:

>>> tz1 = KabulTz()

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

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

>>> # Convert datetime to another time zone
>>> dt3 = dt2.astimezone(dt.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` 객체¶

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이며, tzinfo 는 None 을 기본값으로 합니다.

클래스 어트리뷰트:

time.min¶: 표현 가능한 가장 이른 time, time(0, 0, 0, 0).

time.max¶: 표현 가능한 가장 늦은 time, 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¶: time 생성자에 tzinfo 인자로 전달된 객체이거나, 전달되지 않았으면 None입니다.

time.fold¶: [0, 1]. 반복되는 구간 동안 벽면 시간(wall times)을 구분하는 데 사용됩니다. (반복 구간은 일광 절약 시간제 종료 시 시계가 뒤로 돌아가거나 현재 지역의 UTC 오프셋이 정치적 이유로 감소할 때 발생합니다.) 값 0과 1은 각각 동일한 벽면 시간 표현을 가진 두 시점 중 앞선 시점과 나중 시점을 나타냅니다.

Added in version 3.6.

time 객체는 동등성 및 순서 비교를 지원하며, 시간상 a 가 b 보다 앞설 때 a 가 b 보다 작은 것으로 간주합니다.

나이브(naive)와 어웨어(aware) time 객체는 결코 같을 수 없습니다. 나이브와 어웨어 time 객체 간의 순서 비교를 시도하면 TypeError 가 발생합니다.

비교 피연산자가 모두 어웨어하고 동일한 tzinfo 속성을 가지는 경우, tzinfo 및 fold 속성은 무시되고 기본 시간이 비교됩니다. 두 피연산자가 모두 어웨어하지만 다른 tzinfo 속성을 가지는 경우, 먼저 UTC 오프셋(self.utcoffset() 에서 획득)을 차감하여 조정한 후 비교합니다.

버전 3.3에서 변경: 어웨어와 나이브 time 인스턴스 간의 동등성 비교는 TypeError 를 발생시키지 않습니다.

불리언 문맥에서, time 객체는 항상 참으로 간주합니다.

버전 3.5에서 변경: Python 3.5 이전에는 UTC 자정을 나타내는 time 객체가 False로 간주되었습니다. 이 동작은 모호하고 오류가 발생하기 쉬운 것으로 판단되어 Python 3.5에서 제거되었습니다. 자세한 내용은 bpo-13936 을 참조하십시오.

기타 생성자:

classmethod time.fromisoformat(time_string)¶

다음의 예외 사항을 제외하고, 유효한 ISO 8601 형식의 time_string 에 해당하는 time 객체를 반환합니다.

시간대 오프셋은 소수점 이하 초를 포함할 수 있습니다.
날짜와 시간 사이에 모호성이 발생할 수 있는 경우 보통 필요한 앞부분의 T 는 필수 사항이 아닙니다.
소수점 이하 초는 어떤 수의 자리수를 가질 수 있습니다(6자리를 넘어가는 부분은 잘립니다).
소수점 단위의 시와 분은 지원되지 않습니다.

예제

>>> import datetime as dt
>>> dt.time.fromisoformat('04:23:01')
datetime.time(4, 23, 1)
>>> dt.time.fromisoformat('T04:23:01')
datetime.time(4, 23, 1)
>>> dt.time.fromisoformat('T042301')
datetime.time(4, 23, 1)
>>> dt.time.fromisoformat('04:23:01.000384')
datetime.time(4, 23, 1, 384)
>>> dt.time.fromisoformat('04:23:01,000384')
datetime.time(4, 23, 1, 384)
>>> dt.time.fromisoformat('04:23:01+04:00')
datetime.time(4, 23, 1, tzinfo=datetime.timezone(datetime.timedelta(seconds=14400)))
>>> dt.time.fromisoformat('04:23:01Z')
datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)
>>> dt.time.fromisoformat('04:23:01+00:00')
datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)

Added in version 3.7.

버전 3.11에서 변경: 이전에는 이 메서드가 time.isoformat() 에서 출력될 수 있는 형식만 지원했습니다.

classmethod time.strptime(date_string, format)¶

format 에 따라 구문 분석된 date_string 에 해당하는 time 객체를 반환합니다.

format 에 마이크로초나 시간대 정보가 포함되어 있지 않은 경우, 이는 다음과 동일합니다:

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

date_string 과 format 을 time.strptime() 으로 구문 분석할 수 없거나, 결과가 시간 튜플이 아닌 경우 ValueError 가 발생합니다. 또한 strftime() 및 strptime() 동작 및 time.fromisoformat() 를 참조하십시오.

Added in version 3.14.

인스턴스 메서드:

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

동일한 값을 가지되 지정된 파라미터가 업데이트된 새로운 time 객체를 반환합니다. 시간 데이터의 변환 없이 어웨어(aware) time 에서 나이브(naive) time 을 생성하려면 tzinfo=None 을 지정할 수 있습니다.

time 객체는 일반 함수인 copy.replace() 에서도 지원됩니다.

버전 3.6에서 변경: fold 매개변수가 추가되었습니다.

time.isoformat(timespec='auto')¶

ISO 8601 형식으로 시간을 나타내는 문자열을 반환합니다, 다음 중 한가지입니다:

HH:MM:SS.ffffff, microsecond가 0이 아니면
HH:MM:SS, microsecond가 0이면
HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]], utcoffset()이 None을 반환하지 않으면
HH:MM:SS+HH:MM[:SS[.ffffff]], microsecond가 0이고 utcoffset()이 None을 반환하지 않으면

선택적 인자 timespec은 포함할 시간의 추가 구성 요소 수를 지정합니다 (기본값은 'auto'입니다). 다음 중 하나일 수 있습니다:

'auto': microsecond가 0이면 'seconds'와 같고, 그렇지 않으면 'microseconds'와 같습니다.
'hours': hour를 두 자리 숫자 HH 형식으로 포함합니다.
'minutes': hour와 minute를 HH:MM 형식으로 포함합니다.
'seconds': hour, minute 및 second를 HH:MM:SS 형식으로 포함합니다.
'milliseconds': 전체 시간을 포함하지만, 초 미만은 밀리초 단위로 자릅니다. HH:MM:SS.sss 형식입니다.
'microseconds': 전체 시간을 HH:MM:SS.ffffff 형식으로 포함합니다.

참고

제외된 시간 구성 요소는 반올림되지 않고 잘립니다.

잘못된 timespec 인자는 ValueError를 발생시킵니다.

예제:

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

버전 3.6에서 변경: timespec 파라미터가 추가되었습니다.

time.__str__()¶: 시간 t 에 대해, str(t) 는 t.isoformat() 와 동일합니다.

time.strftime(format)¶: 명시적인 포맷 문자열에 의해 제어되는 시간을 나타내는 문자열을 반환합니다. 또한 strftime() 및 strptime() 동작 및 time.isoformat() 를 참조하십시오.

time.__format__(format)¶: time.strftime() 과 동일합니다. 이를 통해 formatted string literals 및 str.format() 을 사용할 때 time 객체에 대한 포맷 문자열을 지정할 수 있습니다. 또한 strftime() 및 strptime() 동작 및 time.isoformat() 를 참조하십시오.

time.utcoffset()¶: tzinfo가 None이면, None을 반환하고, 그렇지 않으면 self.tzinfo.utcoffset(None)를 반환하고, 후자가 None이나 하루 미만의 크기를 가진 timedelta 객체를 반환하지 않으면 예외를 발생시킵니다.

버전 3.7에서 변경: UTC 오프셋은 분 단위로 제한되지 않습니다.

time.dst()¶: tzinfo가 None이면, None을 반환하고, 그렇지 않으면 self.tzinfo.dst(None)를 반환하고, 후자가 None이나 하루 미만의 크기를 가진 timedelta 객체를 반환하지 않으면 예외를 발생시킵니다.

버전 3.7에서 변경: DST 오프셋은 분 단위로 제한되지 않습니다.

time.tzname()¶: tzinfo가 None이면, None을 반환하고, 그렇지 않으면 self.tzinfo.tzname(None)를 반환하고, 후자가 None이나 문자열 객체를 반환하지 않으면 예외를 발생시킵니다.

사용 예: `time`¶

time 객체로 작업하는 예제:

>>> import datetime as dt
>>> class TZ1(dt.tzinfo):
...     def utcoffset(self, when):
...         return dt.timedelta(hours=1)
...     def dst(self, when):
...         return dt.timedelta(0)
...     def tzname(self, when):
...         return "+01:00"
...     def  __repr__(self):
...         return f"{self.__class__.__name__}()"
...
>>> t = dt.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¶

This is an abstract base class, meaning that this class should not be instantiated directly. Define a subclass of tzinfo to capture information about a particular time zone.

tzinfo 의 (구체적인 서브 클래스인) 인스턴스를 datetime 및 time 객체의 생성자에 전달할 수 있습니다. 후자의 객체들은 자신의 속성을 지역 시간으로 간주하며, tzinfo 객체는 자신에게 전달된 날짜 또는 시간 객체에 상대적으로 UTC로부터의 지역 시간 오프셋, 시간대 이름 및 DST 오프셋을 나타내는 메서드를 지원합니다.

You need to derive a concrete subclass, and (at least) supply implementations of the standard tzinfo methods needed by the datetime methods you use. The datetime module provides timezone, a simple concrete subclass of tzinfo which can represent time zones with fixed offset from UTC such as UTC itself or North American EST and EDT.

피클링(Pickling)에 대한 특별한 요구 사항: tzinfo 서브 클래스는 인자가 없는 상태에서 호출 가능한 __init__() 메서드를 가져야 합니다. 그렇지 않으면 피클링은 가능하지만 다시 언피클링(Unpickling)이 되지 않을 수 있습니다. 이는 향후 완화될 수 있는 기술적인 요구 사항입니다.

tzinfo`의 구체적 서브 클래스는 다음 메서드들을 구현해야 할 수도 있습니다. 정확히 어떤 메서드가 필요한지는 어웨어(aware) :mod:!datetime` 객체를 어떻게 사용하는지에 따라 달라집니다. 확실하지 않다면 모든 메서드를 구현하십시오.

tzinfo.utcoffset(dt)¶

지역 시간의 UTC로부터의 오프셋을 UTC의 동쪽에 있을 때 양의 값을 갖는 timedelta 객체로 반환합니다. 지역 시간이 UTC의 서쪽이면 이 값은 음수여야 합니다.

이것은 UTC로부터의 총 오프셋을 나타냅니다; 예를 들어, tzinfo 객체가 시간대와 DST 조정을 모두 나타내면, utcoffset()은 그들의 합계를 반환해야 합니다. UTC 오프셋을 알 수 없으면, None을 반환합니다. 그렇지 않으면 반환되는 값은 반드시 -timedelta(hours=24)와 timedelta(hours=24) 사이의 timedelta 객체여야 합니다 (오프셋의 크기는 하루 미만이어야 합니다). utcoffset()의 대부분 구현은 아마도 이 두 가지 중 하나일 것입니다:

return CONST                 # 고정 오프셋 클래스
return CONST + self.dst(dt)  # 일광 절약 시간 인지 클래스

utcoffset()이 None을 반환하지 않으면, dst()도 None을 반환하지 않아야 합니다.

utcoffset()의 기본 구현은 NotImplementedError를 발생시킵니다.

버전 3.7에서 변경: UTC 오프셋은 분 단위로 제한되지 않습니다.

tzinfo.dst(dt)¶

일광 절약 시간 (DST) 조정을 timedelta 객체로, 또는 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)

dt.tzinfo == tz 인 모든 datetime dt 에 대해 동일한 결과를 반환해야 합니다. 적절한 tzinfo 서브 클래스의 경우, 이 표현식은 날짜나 시간에 의존하지 않고 오직 지리적 위치에만 기반한 시간대의 “표준 오프셋”을 생성합니다. datetime.astimezone() 의 구현은 이를 기반으로 하지만 위반 사항을 감지할 수는 없으므로, 이를 보장하는 것은 프로그래머의 책임입니다. 만약 tzinfo 서브 클래스가 이를 보장할 수 없다면, tzinfo.fromutc() 의 기본 구현을 재정의하여 astimezone() 과 상관없이 올바르게 작동하게 할 수 있습니다.

dst()의 대부분 구현은 아마도 이 두 가지 중 하나일 것입니다:

import datetime as dt

def dst(self, when):
    # 고정 오프셋 클래스: DST를 고려하지 않음
    return dt.timedelta(0)

또는:

import datetime as dt

def dst(self, when):
    # 입력된 when.year를 기반으로 시간대의 DST 전환 시간을 설정하며,
    # 표준 지역 시간으로 표현됩니다.

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

dst()의 기본 구현은 NotImplementedError를 발생시킵니다.

버전 3.7에서 변경: DST 오프셋은 분 단위로 제한되지 않습니다.

tzinfo.tzname(dt)¶

Return the time zone name corresponding to the datetime object dt, as a string. Nothing about string names is defined by the datetime module, and there’s no requirement that it mean anything in particular. For example, "GMT", "UTC", "-500", "-5:00", "EDT", "US/Eastern", "America/New York" are all valid replies. Return None if a string name isn’t known. Note that this is a method rather than a fixed string primarily because some tzinfo subclasses will wish to return different names depending on the specific value of dt passed, especially if the tzinfo class is accounting for daylight time.

tzname()의 기본 구현은 NotImplementedError를 발생시킵니다.

이 메서드들은 datetime 또는 time 객체에서 동일한 이름의 메서드에 대한 응답으로 호출됩니다. datetime 객체는 자신을 인자로 전달하고, time 객체는 None 을 인자로 전달합니다. 따라서 tzinfo 서브 클래스의 메서드는 None 또는 datetime 클래스 타입의 dt 인자를 수용할 준비가 되어 있어야 합니다.

None이 전달되면, 최선의 응답을 결정하는 것은 클래스 설계자에게 달려있습니다. 예를 들어, 클래스가 tzinfo 프로토콜에 time 객체가 참여하지 않는다고 말하고 싶다면 None을 반환하는 것이 적절합니다. 표준 오프셋을 발견하는 다른 규칙이 없으므로, utcoffset(None)이 표준 UTC 오프셋을 반환하는 것이 더 유용할 수 있습니다.

datetime 메서드에 응답하여 datetime 객체가 전달될 때, dt.tzinfo 는 self 와 동일한 객체입니다. 사용자 코드가 tzinfo 메서드를 직접 호출하는 경우가 아니라면, tzinfo 메서드는 이를 신뢰할 수 있습니다. 이는 tzinfo 메서드가 dt 를 지역 시간으로 해석하고 다른 시간대의 객체에 대해 걱정할 필요가 없도록 하기 위함입니다.

서브 클래스가 재정의할 수 있는 tzinfo 메서드가 하나 더 있습니다:

tzinfo.fromutc(dt)¶

이 메서드는 기본 datetime.astimezone() 구현에서 호출됩니다. 해당 경우, dt.tzinfo 는 self 이며, dt 의 날짜와 시간 데이터는 UTC 시간을 나타내는 것으로 간주됩니다. fromutc() 의 목적은 날짜 및 시간 데이터를 조정하여 self 의 로컬 시간과 동일한 datetime을 반환하는 것입니다.

대부분의 tzinfo 서브 클래스는 기본 fromutc() 구현을 문제없이 상속할 수 있습니다. 이 구현은 고정 오프셋 시간대는 물론, 표준 및 일광 절약 시간을 모두 고려하는 시간대를 처리하기에 충분히 강력하며, 후자의 경우 연도별로 DST 전환 시간이 다른 경우도 처리합니다. 기본 fromutc() 구현이 모든 경우에 올바르게 처리하지 못할 수도 있는 예는 정치적 이유로 특정 날짜와 시간에 따라 표준 오프셋(UTC 기준)이 달라지는 경우입니다. astimezone() 및 fromutc() 의 기본 구현은 결과가 표준 오프셋이 바뀌는 시점을 걸쳐 있는 시간대 중 하나인 경우 사용자가 원하는 결과를 생성하지 못할 수 있습니다.

에러가 발생하는 경우를 위한 코드를 생략하면, 기본 fromutc() 구현은 다음과 같이 동작합니다:

import datetime as dt

def fromutc(self, when):
    # when.tzinfo가 self가 아니면 ValueError 발생
    dtoff = when.utcoffset()
    dtdst = when.dst()
    # dtoff 또는 dtdst가 None이면 ValueError 발생
    delta = dtoff - dtdst  # 이것은 self의 표준 오프셋임
    if delta:
        when += delta   # 표준 로컬 시간으로 변환
        dtdst = when.dst()
        # dtdst가 None이면 ValueError 발생
    if dtdst:
        return when + dtdst
    else:
        return when

다음 tzinfo_examples.py 파일에는 tzinfo 클래스의 몇 가지 예가 나와 있습니다:

import datetime as dt

# 플랫폼의 지역 시간 개념을 캡처하는 클래스.
# (과거에 UTC 오프셋 및/또는 DST 규칙이 변경된 시간대의
#  과거 시간에 대해서는 잘못된 값이 나올 수 있습니다.)
import time

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

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

DSTDIFF = DSTOFFSET - STDOFFSET


class LocalTimezone(dt.tzinfo):

    def fromutc(self, when):
        assert when.tzinfo is self
        stamp = (when - dt.datetime(1970, 1, 1, tzinfo=self)) // SECOND
        args = time.localtime(stamp)[:6]
        dst_diff = DSTDIFF // SECOND
        # fold 감지
        fold = (args == time.localtime(stamp - dst_diff))
        return dt.datetime(*args, microsecond=when.microsecond,
                           tzinfo=self, fold=fold)

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

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

    def tzname(self, when):
        return time.tzname[self._isdst(when)]

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


Local = LocalTimezone()


# 주요 미국 시간대에 대한 현재 DST 규칙의 완전한 구현.

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


# 미국 DST 규칙
#
# 이것은 미국 DST 시작 및 종료 시간에 대한 단순화된(즉, 일부 사례에서 틀린)
# 규칙 세트입니다. 완전하고 최신인 DST 규칙 및 시간대 정의를 보려면
# Olson Database를 방문하거나 pytz를 시도해 보세요:
# http://www.twinsun.com/tz/tz-link.htm
# https://sourceforge.net/projects/pytz/ (최신이 아닐 수 있음)
#
# 미국에서는 2007년부터 DST가 3월 두 번째 일요일 오전 2시(표준시)에 시작하며,
# 이는 3월 8일 또는 그 이후의 첫 번째 일요일입니다.
DSTSTART_2007 = dt.datetime(1, 3, 8, 2)
# 그리고 11월 첫 번째 일요일 오전 2시(DST 시간)에 종료됩니다.
DSTEND_2007 = dt.datetime(1, 11, 1, 2)
# 1987년부터 2006년까지 DST는 4월 첫 번째 일요일 오전 2시(표준시)에 시작하여
# 10월 마지막 일요일 오전 2시(DST 시간)에 종료되었으며,
# 이는 10월 25일 또는 그 이후의 첫 번째 일요일입니다.
DSTSTART_1987_2006 = dt.datetime(1, 4, 1, 2)
DSTEND_1987_2006 = dt.datetime(1, 10, 25, 2)
# 1967년부터 1986년까지 DST는 4월 마지막 일요일 오전 2시(표준시)에 시작하여
# (4월 24일 또는 그 이후의 일요일) 10월 마지막 일요일 오전 2시(DST 시간)에
# 종료되었으며, 이는 10월 25일 또는 그 이후의 첫 번째 일요일입니다.
DSTSTART_1967_1986 = dt.datetime(1, 4, 24, 2)
DSTEND_1967_1986 = DSTEND_1987_2006


def us_dst_range(year):
    # 미국 DST의 시작 및 종료 시간을 찾습니다. 1967년 이전 연도에 대해서는
    # DST가 없음을 나타내기 위해 start = end를 반환합니다.
    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 (dt.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(dt.tzinfo):

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

    def __repr__(self):
        return self.reprname

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

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

    def dst(self, when):
        if when is None or when.tzinfo is None:
            # 하나 또는 두 경우 모두에서 여기서 예외를 발생시키는 것이 합리적일 수 있습니다.
            # 그것은 당신이 그것들을 어떻게 처리하고 싶은지에 달려 있습니다. 기본
            # fromutc() 구현(기본 astimezone() 구현에 의해 호출됨)은
            # when.tzinfo가 self인 datetime을 전달합니다.
            return ZERO
        assert when.tzinfo is self
        start, end = us_dst_range(when.year)
        # 나이브(naive) 객체와 어웨어(aware) 객체를 비교할 수 없으므로,
        # 먼저 when에서 시간대를 제거합니다.
        when = when.replace(tzinfo=None)
        if start + HOUR <= when < end - HOUR:
            # DST가 적용 중입니다.
            return HOUR
        if end - HOUR <= when < end:
            # Fold (모호한 시간): when.fold를 사용하여 모호성을 해제합니다.
            return ZERO if when.fold else HOUR
        if start <= when < start + HOUR:
            # Gap (존재하지 않는 시간): fold 규칙을 반대로 적용합니다.
            return HOUR if when.fold else ZERO
        # DST가 꺼져 있습니다.
        return ZERO

    def fromutc(self, when):
        assert when.tzinfo is self
        start, end = us_dst_range(when.year)
        start = start.replace(tzinfo=self)
        end = end.replace(tzinfo=self)
        std_time = when + self.stdoffset
        dst_time = std_time + HOUR
        if end <= dst_time < end + HOUR:
            # 반복되는 시간
            return std_time.replace(fold=1)
        if std_time < start or dst_time >= end:
            # 표준시
            return std_time
        if start <= std_time < end - HOUR:
            # 일광 절약 시간
            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")

DST 전환점에서 표준 시간과 일광 절약 시간을 모두 고려하는 tzinfo 서브 클래스에는 일 년에 두 번 불가피한 미묘함이 있음에 유의하십시오. 구체적으로, 3월 두 번째 일요일의 1:59 (EST) 다음 분에 시작하고, 11월 첫 번째 일요일 1:59 (EDT) 다음 분에 끝나는 미국 Eastern(UTC -0500)을 고려하십시오:

  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가 시작할 때 (“start” 줄), 지역 벽시계는 1:59에서 3:00로 도약합니다. 그날에는 2:MM 형식의 벽 시간은 실질적인 의미가 없으므로, astimezone(Eastern)은 DST가 시작하는 날에 hour == 2인 결과를 전달하지 않습니다. 예를 들어, 2016년 봄의 전진 전환(forward transition)에서, 다음과 같은 결과를 얻습니다:

>>> import datetime as dt
>>> from tzinfo_examples import HOUR, Eastern
>>> u0 = dt.datetime(2016, 3, 13, 5, tzinfo=dt.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가 종료될 때(“end” 라인), 더 심각한 문제가 발생할 수 있습니다. 로컬 시간으로 모호함 없이 표현할 수 없는 시간이 존재하는데, 바로 일광 절약 시간의 마지막 시간입니다. Eastern의 경우, 이는 DST가 끝나는 날 UTC 기준 5:MM 형태의 시간들입니다. 로컬 벽시계는 1:59(일광 절약 시간)에서 1:00(표준 시간)으로 다시 거꾸로 도약합니다. 1:MM 형식의 로컬 시간은 모호합니다. astimezone() 은 인접한 두 UTC 시간을 동일한 로컬 시간으로 매핑함으로써 로컬 시계의 동작을 모방합니다. Eastern 예시에서, UTC 기준 5:MM과 6:MM 형태의 시간들은 모두 Eastern으로 변환될 때 1:MM으로 매핑되지만, 이전 시간은 fold 어트리뷰트가 0으로 설정되고 나중 시간은 1로 설정됩니다. 예를 들어, 2016년 Fall back 전환 시점에서 다음과 같은 결과를 얻습니다:

>>> import datetime as dt
>>> from tzinfo_examples import HOUR, Eastern
>>> u0 = dt.datetime(2016, 11, 6, 4, tzinfo=dt.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`이나 다른 고정 오프셋 :class:!tzinfo` 서브 클래스(예를 들어 EST 전용 또는 EDT 전용을 나타내는 클래스)를 사용하는 경우에는 모호함이 없습니다.

zoneinfo
datetime 모듈은 기본적인 timezone 클래스(임의의 고정 오프셋을 처리하기 위함)와 그 어트리뷰트인 timezone.utc`(UTC :class:!timezone` 인스턴스)를 제공합니다.

zoneinfo 는 *IANA 시간대 데이터베이스*(Olson 데이터베이스로도 알려짐)를 Python에 도입하며, 사용이 권장됩니다.

IANA 시간대 데이터베이스 <https://www.iana.org/time-zones>_: 시간대 데이터베이스 (종종 tz, tzdata 또는 zoneinfo라고 합니다)에는 전 세계 여러 지역에서 지역 시간의 히스토리를 표현하는 코드와 데이터가 포함되어 있습니다. 정치 단체가 변경 한 시간대 경계, UTC 오프셋 및 일광 절약 시간 규칙을 반영하기 위해 주기적으로 갱신됩니다.

`timezone` 객체¶

timezone 클래스는 tzinfo 의 서브 클래스이며, 각 인스턴스는 UTC로부터 고정된 오프셋에 의해 정의되는 시간대를 나타냅니다.

이 클래스의 객체는 연중 다른 날에 서로 다른 오프셋이 사용되거나 민간 시간(civil time)에 역사적 변화가 있었던 지역의 시간대 정보를 표현하는 데 사용할 수 없습니다.

class datetime.timezone(offset[, name])¶

offset 인자는 지역 시간과 UTC 간의 차이를 나타내는 timedelta 객체로 지정해야 합니다. 엄격히(경계를 포함하지 않는) -timedelta(hours=24)와 timedelta(hours=24) 사이여야 합니다. 그렇지 않으면 ValueError가 발생합니다.

name 인자는 선택적입니다. 지정되면 datetime.tzname() 메서드가 반환하는 값으로 사용될 문자열이어야 합니다.

Added in version 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의 두 자리 숫자입니다.

버전 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) 메서드를 지원하여, 명시적 포맷 문자열로 제어된 시간을 나타내는 문자열을 만듭니다.

반대로, date.strptime(), datetime.strptime(), 그리고 time.strptime() 클래스 메서드는 시간을 나타내는 문자열과 그에 대응하는 포맷 문자열로부터 객체를 생성합니다.

아래 표는 strftime() 과 strptime() 의 고수준 비교를 제공합니다:

	`strftime`	`strptime`
용도	주어진 포맷에 따라 객체를 문자열로 변환합니다	상응하는 포맷을 사용하여 문자열을 객체로 파싱
메서드의 형	인스턴스 메서드	클래스 메서드
서명	`strftime(format)`	`strptime(date_string, format)`

`strftime()` 및 `strptime()` 포맷 코드¶

이 메서드들은 날짜를 파싱하고 포맷하는 데 사용할 수 있는 포맷 코드를 수용합니다:

>>> import datetime as dt
>>> dt.datetime.strptime('31/01/22 23:59:59.999999',
...                      '%d/%m/%y %H:%M:%S.%f')
datetime.datetime(2022, 1, 31, 23, 59, 59, 999999)
>>> _.strftime('%a %d %b %Y, %I:%M%p')
'Mon 31 Jan 2022, 11:59PM'

다음은 2011 C 표준이 요구하는 모든 포맷 코드 목록이며, 지원되는 모든 플랫폼에서 작동합니다.

지시자	의미	예	노트
`%a`	요일을 로케일의 축약된 이름으로.	Sun, Mon, …, Sat (en_US); So, Mo, …, Sa (de_DE)	(1)
`%A`	요일을 로케일의 전체 이름으로.	Sunday, Monday, …, Saturday (en_US); Sonntag, Montag, …, Samstag (de_DE)	(1)
`%b`	월을 로케일의 축약된 이름으로.	Jan, Feb, …, Dec (en_US); Jan, Feb, …, Dez (de_DE)	(1)
`%B`	월을 로케일의 전체 이름으로.	January, February, …, December (en_US); Januar, Februar, …, Dezember (de_DE)	(1)
`%c`	로케일의 적절한 날짜와 시간 표현.	Tue Aug 16 21:30:00 1988 (en_US); Di 16 Aug 21:30:00 1988 (de_DE)	(1)
`%C`	연도를 100으로 나누고 0이 채워진 10진수 형태로 소수점을 버려 정수로 표현한 값.	01, 02, …, 99	(0)
`%d`	월중 일(day of the month)을 0으로 채워진 10진수로.	01, 02, …, 31	(9), (10)
`%D`	`%m/%d/%y` 와 동일합니다.	11/28/25	(9)
`%e`	공백이 채워진 10진수 형태의 월중 일.	␣1, ␣2, …, 31	(10)
`%F`	ISO 8601 형식인 `%Y-%m-%d` 와 동일합니다.	2025-10-11, 1001-12-30
`%g`	ISO 주(`%V`)의 더 큰 부분을 포함하는 연도를 나타내는 ISO 8601 연도의 마지막 두 자리.	00, 01, …, 99	(0)
`%G`	ISO 주(`%V`)의 더 큰 부분을 포함하는 연도를 나타내는 세기가 있는 ISO 8601 연도.	0001, 0002, …, 2013, 2014, …, 9998, 9999	(8)
`%h`	`%b` 와 동일합니다.	`%b` 를 참조하십시오.	(0)
`%H`	시(24시간제)를 0으로 채워진 십진수로.	00, 01, …, 23	(9)
`%I`	시(12시간제)를 0으로 채워진 십진수로.	01, 02, …, 12	(9)
`%j`	연중 일(day of the year)을 0으로 채워진 십진수로.	001, 002, …, 366	(9)
`%m`	월을 0으로 채워진 10진수로.	01, 02, …, 12	(9)
`%M`	분을 0으로 채워진 십진수로.	00, 01, …, 59	(9)
`%n`	줄 바꿈 문자(`'\n'`). `strptime()` 의 경우, 하나 이상의 공백.	`\n`
`%p`	로케일의 오전이나 오후에 해당하는 것.	AM, PM (en_US); am, pm (de_DE)	(1), (3)
`%r`	로케일의 12시간 시계 시간.	12:00:00 AM	(1), (0)
`%R`	`%H:%M` 와 동일합니다.	10:01
`%S`	초를 0으로 채워진 10진수로.	00, 01, …, 59	(4), (9)
`%t`	탭 문자(`'\t'`). `strptime()` 의 경우, 하나 이상의 공백.	`\t`
`%T`	ISO 8601 시간 형식으로, `%H:%M:%S` 와 동일합니다.	10:01:59
`%u`	ISO 8601 요일을 10진수로, 1은 월요일입니다.	1, 2, …, 7
`%U`	연중 주 번호(일요일을 주의 첫 번째 날로 간주)를 0이 채워진 10진수로 표현합니다. 새해의 첫 번째 일요일 이전의 모든 날은 주 0으로 간주됩니다.	00, 01, …, 53	(7), (9)
`%V`	ISO 8601 주를 월요일을 주의 시작으로 하는 십진수로. 주 01은 1월 4일을 포함하는 주입니다.	01, 02, …, 53	(8), (9)
`%w`	요일을 10진수로, 0은 일요일이고 6은 토요일입니다.	0, 1, …, 6
`%W`	연중 주 번호(월요일을 주의 첫 번째 날로 간주)를 0이 채워진 10진수로 표현합니다. 새해의 첫 번째 월요일 이전의 모든 날은 주 0으로 간주됩니다.	00, 01, …, 53	(7), (9)
`%x`	로케일의 적절한 날짜 표현.	08/16/88 (None); 08/16/1988 (en_US); 16.08.1988 (de_DE)	(1)
`%X`	로케일의 적절한 시간 표현.	21:30:00 (en_US); 21:30:00 (de_DE)	(1)
`%y`	세기가 없는 해(year)를 0으로 채워진 10진수로.	00, 01, …, 99	(9)
`%Y`	세기가 있는 해(year)를 10진수로.	0001, 0002, …, 2013, 2014, …, 9998, 9999	(2)
`%z`	`±HHMM[SS[.ffffff]]` 형태의 UTC 오프셋 (객체가 나이브하면 빈 문자열).	(비어 있음), +0000, -0400, +1030, +063415, -030712.345216	(6)
`%Z`	시간대 이름 (객체가 나이브하면 빈 문자열).	(비어 있음), UTC, GMT	(6)
`%%`	리터럴 `'%'` 문자.	%

ISO 8601 연도 및 ISO 8601 주 지시자는 위에서 언급한 연도 및 주 번호 지시자와 상호 대체 가능하지 않습니다. 불완전하거나 모호한 ISO 8601 지시어로 strptime() 을 호출하면 ValueError 가 발생합니다.

편의를 위해 C11 표준에서 요구하지 않는 몇 가지 추가 지시자가 포함되어 있습니다.

지시자	의미	예	노트
`%f`	마이크로초를 0이 6개 채워진 10진수로 표현합니다.	000000, 000001, …, 999999	(5)
`%:z`	`±HH:MM[:SS[.ffffff]]` 형태의 UTC 오프셋(객체가 나이브한 경우 빈 문자열).	(비어 있음), +00:00, -04:00, +10:30, +06:34:15, -03:07:12.345216	(6)

지원되는 전체 포맷 코드 세트는 플랫폼마다 다릅니다. 이는 Python이 플랫폼 C 라이브러리의 strftime() 함수를 호출하며, 플랫폼 간 차이가 흔하기 때문입니다. 사용 중인 플랫폼에서 지원하는 전체 포맷 코드를 확인하려면 strftime(3) 문서를 참조하십시오. 지원되지 않는 포맷 지정자를 처리하는 방식도 플랫폼에 따라 다릅니다.

Added in version 3.6: %G, %u 및 %V가 추가되었습니다.

Added in version 3.12: %:z 가 strftime() 을 위해 추가되었습니다.

Added in version 3.15: %D, %F, %n, %t, 그리고 %:z 가 strptime() 을 위해 추가되었습니다.

기술적 상세 정보¶

일반적으로 말하면, d.strftime(fmt) 은 모든 객체가 timetuple() 메서드를 지원하지는 않지만, time 모듈의 time.strftime(fmt, d.timetuple()) 와 유사하게 작동합니다.

datetime.strptime() 및 date.strptime() 클래스 메서드의 경우, 기본값은 1900-01-01T00:00:00.000 입니다. 포맷 문자열에 지정되지 않은 구성 요소는 이 기본값에서 가져옵니다.

참고

구분자가 없는 포맷 문자열은 파싱할 때 모호할 수 있습니다. 예를 들어, %Y%m%d 를 사용할 경우 2026111 이라는 문자열이 2026-11-01 또는 2026-01-11 로 해석될 수 있습니다. 입력값이 의도한 대로 파싱되도록 구분자를 사용하십시오.

참고

연도가 없는 불완전한 날짜를 파싱할 때, datetime.strptime() 및 date.strptime() 은 기본 연도인 1900년이 윤년이 아니기 때문에 2월 29일을 만나면 예외를 발생시킵니다. 파싱하기 전에 항상 불완전한 날짜 문자열에 기본 윤년을 추가하십시오.

>>> import datetime as dt
>>> value = "2/29"
>>> dt.datetime.strptime(value, "%m/%d")
Traceback (most recent call last):
...
ValueError: day 29 must be in range 1..28 for month 2 in year 1900
>>> dt.datetime.strptime(f"1904 {value}", "%Y %m/%d")
datetime.datetime(1904, 2, 29, 0, 0)

datetime.strptime(date_string, format)은 다음과 동등합니다:

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

단, 포맷에 소수점 이하 초 구성 요소나 시간대 오프셋 정보가 포함된 경우는 제외됩니다. 이들은 datetime.strptime 에서는 지원되지만 time.strptime 에서는 무시됩니다.

time 객체의 경우 연도, 월, 일에 대한 포맷 코드를 사용해서는 안 됩니다. time 객체에는 해당 값이 없기 때문입니다. 그럼에도 사용될 경우, 연도는 1900으로, 월과 일은 1로 대체됩니다.

date 객체의 경우 시간(hour), 분(minute), 초(second), 마이크로초(microsecond)에 대한 포맷 코드를 사용해서는 안 됩니다. date 객체에는 해당 값이 없기 때문입니다. 그럼에도 사용될 경우 0으로 대체됩니다.

같은 이유로, 현재 로케일의 문자 집합으로는 표현할 수 없는 유니코드 코드 포인트를 포함하는 포맷 문자열의 처리도 플랫폼에 따라 다릅니다. 일부 플랫폼에서는 이러한 코드 포인트가 그대로 출력에 보존되지만, 다른 곳에서는 strftime이 UnicodeError를 발생시키거나 대신 빈 문자열을 반환할 수 있습니다.

노트:

이 포맷 코드는 현재 strptime() 에서 지원되지 않습니다.
포맷이 현재 로케일에 따라 달라지므로 출력값에 대해 예측할 때 주의가 필요합니다. 필드 순서가 다를 수 있으며(예: “월/일/년” 대 “일/월/년”), 출력 결과에 비 ASCII 문자가 포함될 수 있습니다.
strptime() 메서드는 [1, 9999] 범위의 연도를 파싱할 수 있지만, 1000 미만의 연도는 4자리 너비로 채워진 형태여야 합니다.

버전 3.2에서 변경: 이전 버전에서 strftime() 메서드는 1900 이상의 연도로 제한되었습니다.

버전 3.3에서 변경: 버전 3.2에서 strftime() 메서드는 1000 이상의 연도로 제한되었습니다.
strptime() 메서드와 함께 사용할 때, 시(hour)를 파싱하기 위해 %I 지시자를 사용하는 경우에만 %p 지시자가 출력 시 필드에 영향을 줍니다.
time 모듈과 달리, datetime 모듈은 윤초를 지원하지 않습니다.
strptime() 메서드와 함께 사용할 때, %f 지시자는 1개에서 6개의 숫자를 허용하며 오른쪽에 0을 채웁니다. %f 는 C 표준의 포맷 문자 집합에 대한 확장 기능입니다(단, datetime 객체에서는 별도로 구현되어 항상 사용 가능합니다).
단순(naive) 객체에 대해 %z, %: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에서 변경: strptime() 메서드에 %z 지시어를 사용할 때, UTC 오프셋의 시간, 분, 초 사이에는 콜론(:)이 구분 기호로 포함될 수 있습니다. 예를 들어, '+010000' 과 '+01:00:00' 은 모두 한 시간의 오프셋으로 해석됩니다. 또한, 'Z' 를 제공하는 것은 '+00:00' 을 제공하는 것과 동일합니다.
%:z
strftime() 과 함께 사용할 때, 시간, 분, 초 사이에 콜론 구분 기호가 추가되는 것을 제외하고는 %z 와 동일하게 동작합니다.

strptime() 과 함께 사용할 때, UTC 오프셋은 반드시 시간, 분, 초 사이에 콜론(:)을 구분 기호로 포함해야 합니다. 예를 들어, '+01:00:00' 은 한 시간의 오프셋으로 해석되지만('+010000' 은 제외), 'Z' 를 제공하는 것은 '+00:00' 과 동일합니다.

%Z
strftime() 에서 tzname() 이 None 을 반환하면 %Z 는 빈 문자열로 대체되며, 그렇지 않으면 %Z 는 문자열이어야 하는 반환 값으로 대체됩니다.

strptime() 은 %Z 에 대해 특정 값만 허용합니다:
1. 컴퓨터의 로케일에 대한 time.tzname의 모든 값
2. 하드 코딩된 값 UTC와 GMT
따라서 일본에 거주하는 사람은 JST, UTC 및 GMT를 유효한 값으로 가질 수 있지만, 아마도 EST는 아닙니다. 유효하지 않은 값에 대해서는 ValueError가 발생합니다.
버전 3.2에서 변경: strptime() 메서드에 %z 지시어를 제공하면 aware된 datetime 객체가 생성됩니다. 결과의 tzinfo 는 timezone 인스턴스로 설정됩니다.
strptime() 메서드와 함께 사용할 때, %U 및 %W``는 요일과 달력 연도(``%Y)가 지정된 경우에만 계산에 사용됩니다.
%U 및 %W 와 유사하게, %V 는 strptime() 포맷 문자열에서 요일과 ISO 연도(%G)가 지정된 경우에만 계산에 사용됩니다. 또한 %G 와 %Y 는 서로 대체될 수 없음에 유의하십시오.
strptime() 메서드와 함께 사용할 때, %d, %m, %H, %I, %M, %S, %j, %U, %W 및 %V 형식의 앞자리에 오는 0은 생략 가능합니다. %y 형식은 앞에 오는 0이 반드시 필요합니다.
strptime() 를 사용하여 월과 일을 파싱할 때는 항상 포맷에 연도를 포함하십시오. 파싱하려는 값에 연도가 없는 경우, 명시적인 가짜 윤년(dummy leap year)을 추가하십시오. 그렇지 않으면 파서가 사용하는 기본 연도(1900)가 윤년이 아니기 때문에 윤일(leap day)을 만날 때 코드가 예외를 발생시킵니다. 사용자들은 매 윤년마다 이 버그를 경험하게 됩니다.
```
>>> month_day = "02/29"
>>> dt.datetime.strptime(f"{month_day};1984", "%m/%d;%Y")  # 윤년 버그 발생 안 함.
datetime.datetime(1984, 2, 29, 0, 0)
```
버전 3.15에서 변경: 연도 없이 %d 를 사용하는 경우 이제 ValueError 가 발생합니다.

버전 3.15부터 사용 지원 중단(deprecated), 버전 3.17에서 제거 예정: 연도 없이 %e 를 포함하는 포맷 문자열을 사용하는 strptime() 호출은 이제 DeprecationWarning 을 발생시킵니다.

각주

datetime — 기본 날짜 및 시간 유형¶

어웨어 및 나이브 객체¶

상수¶

사용 가능한 유형¶

공통 속성¶

객체가 어웨어인지 나이브인지 판단하기¶

timedelta 객체¶

사용 예: timedelta¶

date 객체¶

사용 예시: date¶

datetime 객체¶

사용 예: datetime¶

time 객체¶

사용 예: time¶

tzinfo 객체¶

timezone 객체¶

strftime() 및 strptime() 동작¶

strftime() 및 strptime() 포맷 코드¶

기술적 상세 정보¶

분실물 보관소

`datetime` — 기본 날짜 및 시간 유형¶

`timedelta` 객체¶

사용 예: `timedelta`¶

`date` 객체¶

사용 예시: `date`¶

`datetime` 객체¶

사용 예: `datetime`¶

`time` 객체¶

사용 예: `time`¶

`tzinfo` 객체¶

`timezone` 객체¶

`strftime()` 및 `strptime()` 동작¶

`strftime()` 및 `strptime()` 포맷 코드¶