`datetime` — 기본 날짜와 시간 형¶

소스 코드: Lib/datetime.py

datetime 모듈은 날짜와 시간을 간단하거나 복잡한 방법으로 조작하는 클래스를 제공합니다. 날짜와 시간 산술이 지원되지만, 구현의 초점은 출력 포매팅과 조작을 위한 효율적인 어트리뷰트 추출입니다. 관련 기능에 대해서는, time과 calendar 모듈도 참조하십시오.

날짜와 시간 객체에는 두 가지 종류가 있습니다: “나이브(naive)”와 “어웨어(aware)”.

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

나이브 객체는 모호하지 않게 자신과 다른 날짜/시간 객체의 상대적인 위치를 파악할 수 있는 충분한 정보를 포함하지 않습니다. 나이브 객체가 UTC(Coordinated Universal Time), 지역 시간 또는 다른 시간대의 시간 중 어느 것을 나타내는지는 순전히 프로그램에 달려있습니다. 특정 숫자가 미터, 마일 또는 질량 중 어는 것을 나타내는지가 프로그램에 달린 것과 마찬가지입니다. 나이브 객체는 이해하기 쉽고 작업하기 쉽지만, 현실의 일부 측면을 무시하는 대가를 치릅니다.

어웨어 객체가 필요한 응용 프로그램을 위해, datetime 과 time 객체에는 추상 tzinfo 클래스의 서브 클래스 인스턴스로 설정할 수 있는 선택적 시간대 정보 어트리뷰트인 tzinfo가 있습니다. 이러한 tzinfo 객체는 UTC 시간으로부터의 오프셋, 시간대 이름 및 일광 절약 시간이 적용되는지에 대한 정보를 보관합니다. datetime 모듈에서는 오직 하나의 구상 tzinfo 클래스, timezone 클래스만 제공됨에 유의하십시오. timezone 클래스는 UTC 자체나 북미 EST와 EDT 시간대와 같은 UTC로부터 고정 오프셋을 갖는 간단한 시간대를 나타낼 수 있습니다. 더욱 세부적인 수준의 시간대 지원은 응용 프로그램에 달려 있습니다. 전 세계의 시간 조정에 대한 규칙은 합리적이라기보다 정치적이고, 자주 변경되며, UTC 이외에 모든 응용 프로그램에 적합한 표준은 없습니다.

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

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

datetime.MAXYEAR¶: date나 datetime 객체에서 허용되는 가장 큰 연도 번호. MAXYEAR는 9999입니다.

모듈 calendar: 일반 달력 관련 함수들.
모듈 time: 시간 액세스와 변환.

사용 가능한 형¶

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: 두 date, time 또는 datetime 인스턴스 간의 차이를 마이크로초 해상도로 나타내는 기간.

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

`timedelta` 객체¶

timedelta 객체는 두 날짜나 시간의 차이인 기간을 나타냅니다.

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

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

정규화된 days 값이 표시된 범위를 벗어나면, 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 또는 t1 = i * t2`	델타에 정수를 곱합니다. 이후에는 `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에서 변경: 나머지 연산과 divmod() 함수와 마찬가지로, timedelta 객체를 다른 timedelta 객체로 정수 나누기(floor division)와 실수 나누기(true division)가 이제 지원됩니다. timedelta 객체를 float 객체로 실수 나누기와 곱셈도 이제 이제 지원됩니다.

timedelta 객체의 비교가 지원되는데, 더 짧은 기간을 나타내는 timedelta 객체를 더 작은 것으로 간주합니다. 혼합형 비교가 객체 주소 기반의 기본 비교로 떨어지는 것을 막기 위해, timedelta 객체가 다른 형의 객체와 비교될 때, 비교가 == 이나 !=가 아니면 TypeError가 발생합니다. 두 상황에 해당하면 각각 False 나 True를 반환합니다.

timedelta 객체는 해시 가능(딕셔너리 키로 사용 가능)하고, 효율적인 피클링을 지원하며, 불리언 문맥에서 timedelta 객체는 timedelta(0)와 같지 않을 때만 참으로 간주합니다.

인스턴스 메서드:

timedelta.total_seconds()¶

기간에 포함된 총 시간을 초(seconds)로 반환합니다. td / timedelta(seconds=1)와 동등합니다. 초 이외의 구간 단위에는, 나누기 형식을 직접 사용하십시오 (예를 들어, td / timedelta(microseconds=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(days=3650), 10)
>>> nine_years = ten_years - year
>>> nine_years, nine_years.days // 365
(datetime.timedelta(days=3285), 9)
>>> three_years = nine_years // 3
>>> three_years, three_years.days // 365
(datetime.timedelta(days=1095), 3)
>>> abs(three_years - ten_years) == 2 * three_years + year
True

`date` 객체¶

date 객체는 현재의 그레고리력을 무한히 양방향으로 확장한, 이상적인 달력에서의 날짜(년, 월, 일)를 나타냅니다. 1년 1월 1일을 날 번호 1, 1년 1월 2일을 날 번호 2라고 부릅니다. 이것은 Dershowitz와 Reingold의 책 Calendrical Calculations에 나오는 “역산 그레고리(proleptic Gregorian)” 달력의 정의와 일치합니다. 이 달력은 모든 계산의 기본 달력입니다. 역산 그레고리력 서수(ordinal)와 다른 많은 달력 시스템 사이의 변환을 위한 알고리즘에 관해서는 이 책을 참조하십시오.

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

All arguments are required. Arguments must be integers in the following ranges:

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를 발생시킵니다.

classmethod date.fromordinal(ordinal)¶: 역산 그레고리력 서수에 해당하는 date를 반환합니다. 1년 1월 1일이 서수 1입니다. 1 <= ordinal <= date.max.toordinal()이 아니면 ValueError가 발생합니다. 모든 date d에 대해, date.fromordinal(d.toordinal()) == d입니다.

classmethod date.fromisoformat(date_string)¶: date.isoformat()으로 만든 형식의 date_string에 해당하는 date를 반환합니다. 구체적으로, 이 함수는 YYYY-MM-DD 형식의 문자열을 지원합니다.

조심

이것은 임의의 ISO 8601 문자열을 구문 분석하는 것을 지원하지 않습니다 - 이것은 date.isoformat()의 역연산이고자 할 뿐입니다.

버전 3.7에 추가.

클래스 어트리뷰트:

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에 앞서면 date1는 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.toordinal() < date2.toordinal()일 때만 date1 < date2입니다. 비교 대상이 date 객체가 아니면 날짜 비교는 TypeError를 발생시킵니다. 그러나, 비교 대상에 timetuple() 어트리뷰트가 있으면, 대신 NotImplemented가 반환됩니다. 이 훅은 다른 형의 날짜 객체가 혼합형 비교를 구현할 기회를 제공합니다. 그렇지 않으면, date 객체가 다른 형의 객체와 비교될 때, 비교가 ==나 !=가 아니면 TypeError가 발생합니다. 두 상황에 해당하면 각각 False 나 True를 반환합니다

날짜는 딕셔너리 키로 사용할 수 있습니다. 불리언 문맥에서, 모든 date 객체는 참으로 간주합니다.

인스턴스 메서드:

date.replace(year=self.year, month=self.month, day=self.day)¶: 키워드 인자로 새로운 값이 주어진 매개 변수들을 제외하고, 같은 값을 가진 date를 반환합니다. 예를 들어, 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입니다. 임의의 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()¶

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()¶: ISO 8601 형식으로 날짜를 나타내는 문자열을 반환합니다, ‘YYYY-MM-DD’. 예를 들어, date(2002, 12, 4).isoformat() == '2002-12-04'.

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

date.ctime()¶: 날짜를 나타내는 문자열을 반환합니다, 예를 들어 date(2002, 12, 4).ctime() == 'Wed Dec 4 00:00:00 2002'. d.ctime()은 네이티브 C ctime() 함수(time.ctime()은 호출하지만 date.ctime()은 호출하지 않습니다)가 C 표준을 준수하는 플랫폼에서 time.ctime(time.mktime(d.timetuple()))와 동등합니다.

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.'

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

The year, month and day arguments are required. tzinfo may be None, or an instance of a tzinfo subclass. The remaining arguments must be integers in the following ranges:

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을 반환합니다. 이것은 datetime.fromtimestamp(time.time())과 동등합니다. now(), fromtimestamp()를 참조하십시오.

classmethod datetime.now(tz=None)¶

현재의 지역 날짜와 시간을 반환합니다. 선택적 인자 tz가 None이거나 지정되지 않으면, today()와 유사합니다. 하지만, 가능하면 time.time() 타임스탬프를 통해 얻을 수 있는 것보다 더 높은 정밀도를 제공합니다 (예를 들어, C gettimeofday() 함수를 제공하는 플랫폼에서 가능합니다).

tz가 None이 아니면, tzinfo 서브 클래스의 인스턴스여야 하며, 현재 날짜와 시간이 tz의 시간대로 변환됩니다. 이때 결과는 tz.fromutc(datetime.utcnow().replace(tzinfo=tz))와 동등합니다. today(), utcnow()도 참조하십시오.

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

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

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

tz가 None이 아니면, tzinfo 서브 클래스의 인스턴스여야 하며, timestamp는 tz의 시간대로 변환됩니다. 이때 결과는 tz.fromutc(datetime.utcfromtimestamp(timestamp).replace(tzinfo=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로 설정된 인스턴스를 반환할 수 있습니다.

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 사이, 경계 포함.

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

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=self.tzinfo)¶

지정된 date 객체와 같은 날짜 구성 요소와 지정된 time 객체와 같은 시간 구성 요소를 갖는 새 datetime 객체를 반환합니다. tzinfo 인자가 제공되면, 그 값은 결과의 tzinfo 어트리뷰트를 설정하는 데 사용되며, 그렇지 않으면 time 인자의 tzinfo 어트리뷰트가 사용됩니다.

모든 datetime 객체 d에 대해, d == datetime.combine(d.date(), d.time(), d.tzinfo)가 성립합니다. date가 datetime 객체면, 그것의 시간 구성 요소와 tzinfo 어트리뷰트가 무시됩니다.

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

classmethod datetime.fromisoformat(date_string)¶: date.isoformat()과 datetime.isoformat()이 출력하는 형식 중 하나인 date_string에 해당하는 datetime을 반환합니다. 구체적으로, 이 함수는 YYYY-MM-DD[*HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]]] 형식의 문자열을 지원합니다. 여기서 *는 임의의 단일 문자와 일치 할 수 있습니다.

조심

This does not support parsing arbitrary ISO 8601 strings - it is only intended as the inverse operation of datetime.isoformat(). A more full-featured ISO 8601 parser, dateutil.parser.isoparse is available in the third-party package dateutil.

버전 3.7에 추가.

classmethod datetime.strptime(date_string, format)¶: format에 따라 구문 분석된, date_string에 해당하는 datetime를 반환합니다. 이것은 datetime(*(time.strptime(date_string, format)[0:6]))과 동등합니다. date_string과 format을 time.strptime()로 구문 분석할 수 없거나, 시간 튜플이 아닌 값을 반환하면 ValueError가 발생합니다. 포매팅 지시자의 전체 목록은 strftime()과 strptime() 동작을 참조하십시오.

클래스 어트리뷰트:

datetime.min¶: 표현 가능한 가장 이른 datetime, datetime(MINYEAR, 1, 1, tzinfo=None).

datetime.max¶: 표현 가능한 가장 늦은 datetime, datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None).

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

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

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

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

datetime.day¶: 1과 주어진 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 time)의 모호함을 제거하는 데 사용됩니다. 반복되는 구간은 일광 절약 시간이 끝날 때나 현재 지역의 UTC 오프셋이 정치적인 이유로 줄어들어 시계를 되돌릴 때 발생합니다. 값 0(1)은 같은 벽 시간을 나타내는 두 순간 중 이전(이후)을 나타냅니다.

버전 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이면 과거로 이동합니다. 결과는 입력 datetime과 같은 tzinfo 어트리뷰트를 가지고, 이후에 datetime2 - datetime1 == timedelta 입니다. datetime2.year가 MINYEAR보다 작거나 MAXYEAR보다 커지려고 하면 OverflowError가 발생합니다. 입력이 어웨어 객체일 때도 시간대 조정이 수행되지 않음에 유의하십시오.
datetime2 + timedelta == datetime1 을 만족하는 datetime2를 계산합니다. 덧셈과 마찬가지로, 결과는 입력 datetime과 같은 tzinfo 어트리뷰트를 가지며 입력이 어웨어일 때도 시간대 조정이 수행되지 않습니다.
datetime에서 datetime을 빼는 것은 두 피연산자 모두 나이브하거나, 모두 어웨어할 때만 정의됩니다. 하나가 어웨어이고 다른 하나가 나이브면, 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())입니다.
datetime1이 datetime2에 앞서면 datetime1은 datetime2보다 작은 것으로 간주합니다.

하나의 비교 피연산자가 나이브하고 다른 하나는 어웨어하면, 순서 비교가 시도될 때 TypeError가 발생합니다. 동등(equality) 비교에서는, 나이브 인스턴스는 절대 어웨어 인스턴스와 같지 않습니다.

비교 피연산자가 모두 어웨어하고, 같은 tzinfo 어트리뷰트를 가지면, 공통 tzinfo 어트리뷰트가 무시되고 기본 datetime이 비교됩니다. 두 비교 피연산자가 모두 어웨어하고 다른 tzinfo 어트리뷰트를 가지면, 비교 피연산자들은 먼저 그들의 UTC 오프셋 (self.utcoffset() 에서 얻습니다)을 뺀 값으로 조정됩니다.

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

참고

비교가 객체 주소 기반의 기본 비교 체계로 떨어지는 것을 막기 위해, datetime 비교는 다른 비교 피연산자가 datetime 객체가 아니면 일반적으로 TypeError를 발생시킵니다. 그러나, 다른 비교 피연산자에 timetuple() 어트리뷰트가 있으면 NotImplemented가 대신 반환됩니다. 이 훅은 다른 형의 날짜 객체에 혼합형 비교를 구현할 기회를 제공합니다. 그렇지 않으면, datetime 객체가 다른 형의 객체와 비교될 때, 비교가 == 나 !=가 아니면 TypeError가 발생합니다. 두 상황에 해당하면 각각 False 나 True를 반환합니다.

datetime 객체는 딕셔너리 키로 사용할 수 있습니다. 불리언 문맥에서, 모든 datetime 객체는 참으로 간주합니다.

인스턴스 메서드:

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을 만들 수 있습니다.

버전 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와 같습니다: 날짜나 시간 데이터 조정이 수행되지 않습니다. 그렇지 않으면 결과는 self와 같은 UTC 시간을 나타내는 tz 시간대의 지역 시간입니다: astz = dt.astimezone(tz) 후에, astz - astz.utcoffset()는 dt - dt.utcoffset()과 같은 날짜와 시간 데이터를 갖습니다.

날짜와 시간 데이터를 조정하지 않고 시간대 객체 tz를 datetime dt에 연결하기만 하려면, dt.replace(tzinfo=tz)를 사용하십시오. 날짜와 시간 데이터를 변환하지 않고 어웨어 datetime dt에서 시간대 객체를 제거하려면, dt.replace(tzinfo=None)를 사용하십시오.

기본 tzinfo.fromutc() 메서드는 astimezone()에 의해 반환된 결과에 영향을 주도록 tzinfo 서브 클래스에서 재정의할 수 있습니다. 에러가 발생하는 경우를 무시하고, 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 객체를 반환하지 않으면 예외를 발생시킵니다.

버전 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.dst()가 무엇을 반환하는지와 관계없이 tm_isdst가 강제로 0이 된다는 점만 제외하면, d.timetuple()과 같습니다. 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')¶

ISO 8601 형식으로 날짜와 시간을 나타내는 문자열을 반환합니다, YYYY-MM-DDTHH:MM:SS.ffffff, 또는 microsecond가 0이면, YYYY-MM-DDTHH:MM:SS

utcoffset()이 None을 반환하지 않으면, UTC 오프셋을 제공하는 문자열을 덧붙입니다: YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]], 또는 microsecond가 0이면, YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]].

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

>>> 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': 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를 발생시킵니다.

>>> 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()은 네이티브 C ctime() 함수(time.ctime()이 호출하지만, datetime.ctime()은 호출하지 않습니다)가 C 표준을 준수하는 플랫폼에서 time.ctime(time.mktime(d.timetuple()))과 동등합니다.

datetime.strftime(format)¶: 명시적인 포맷 문자열에 의해 제어되는 날짜와 시간을 나타내는 문자열을 반환합니다. 포매팅 지시자의 전체 목록은 strftime()과 strptime() 동작을 참조하십시오.

datetime.__format__(format)¶: datetime.strftime()과 같습니다. 이것이 포맷 문자열 리터럴과 str.format()을 사용할 때 datetime 객체를 위한 포맷 문자열을 지정할 수 있도록 합니다. 포매팅 지시자의 전체 목록은 strftime()과 strptime() 동작을 참조하십시오.

datetime 객체로 작업하는 예제:

>>> 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, timezone
>>> class KabulTz(tzinfo):
...     # Kabul used +4 until 1945, when they moved to +4:30
...     UTC_MOVE_DATE = datetime(1944, 12, 31, 20, tzinfo=timezone.utc)
...     def utcoffset(self, dt):
...         if dt.year < 1945:
...             return timedelta(hours=4)
...         elif (1945, 1, 1, 0, 0) <= dt.timetuple()[:5] < (1945, 1, 1, 0, 30):
...             # If dt falls in the imaginary range, use fold to decide how
...             # to resolve. See PEP495
...             return timedelta(hours=4, minutes=(30 if dt.fold else 0))
...         else:
...             return timedelta(hours=4, minutes=30)
...
...     def fromutc(self, dt):
...         # 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
...
...         # Follow same validations as in datetime.tzinfo
...         if not isinstance(dt, datetime):
...             raise TypeError("fromutc() requires a datetime argument")
...         if dt.tzinfo is not self:
...             raise ValueError("dt.tzinfo is not self")
...
...         if dt.replace(tzinfo=timezone.utc) >= self.UTC_MOVE_DATE:
...             return dt + timedelta(hours=4, minutes=30)
...         else:
...             return dt + timedelta(hours=4)
...
...     def dst(self, dt):
...         return timedelta(0)
...
...     def tzname(self, dt):
...         if dt >= self.UTC_MOVE_DATE:
...             return "+04:30"
...         else:
...             return "+04"
...
...     def  __repr__(self):
...         return f"{self.__class__.__name__}()"
...
>>> tz1 = KabulTz()
>>> # Datetime before the change
>>> dt1 = datetime(1900, 11, 21, 16, 30, tzinfo=tz1)
>>> print(dt1.utcoffset())
4:00:00
>>> # Datetime after the change
>>> dt2 = datetime(2006, 6, 14, 13, 0, tzinfo=tz1)
>>> print(dt2.utcoffset())
4:30:00
>>> # Convert datetime to another time zone
>>> dt3 = dt2.astimezone(timezone.utc)
>>> dt3
datetime.datetime(2006, 6, 14, 8, 30, tzinfo=datetime.timezone.utc)
>>> dt2
datetime.datetime(2006, 6, 14, 13, 0, tzinfo=KabulTz())
>>> dt2.utctimetuple() == dt3.utctimetuple()
True

`time` 객체¶

time 객체는 특정 날짜와 관계없는 (지역) 시간을 나타내며, tzinfo 객체를 통해 조정할 수 있습니다.

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

All arguments are optional. tzinfo may be None, or an instance of a tzinfo subclass. The remaining arguments must be integers in the following ranges:

0 <= hour < 24,
0 <= minute < 60,
0 <= second < 60,
0 <= microsecond < 1000000,
fold in [0, 1].

이 범위를 벗어나는 인자가 주어지면, ValueError가 발생합니다. tzinfo의 기본값은 None이고, 그 외의 모든 기본값은 0입니다.

클래스 어트리뷰트:

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 time)의 모호함을 제거하는 데 사용됩니다. 반복되는 구간은 일광 절약 시간이 끝날 때나 현재 지역의 UTC 오프셋이 정치적인 이유로 줄어들어 시계를 되돌릴 때 발생합니다. 값 0(1)은 같은 벽 시간을 나타내는 두 순간 중 이전(이후)을 나타냅니다.

버전 3.6에 추가.

지원되는 연산:

time과 time의 비교, 이때 a가 b에 앞서면 a가 b보다 작은 것으로 간주합니다. 하나의 비교 피연산자가 나이브하고 다른 하나는 어웨어하면, 순서 비교가 시도될 때 TypeError가 발생합니다. 동등(equality) 비교에서는, 나이브 인스턴스는 절대 어웨어 인스턴스와 같지 않습니다.

비교 피연산자가 모두 어웨어하고, 같은 tzinfo 어트리뷰트를 가지면, 공통 tzinfo 어트리뷰트가 무시되고 기본 time이 비교됩니다. 두 비교 피연산자가 모두 어웨어하고 다른 tzinfo 어트리뷰트를 가지면, 비교 피연산자들은 먼저 그들의 UTC 오프셋 (self.utcoffset()에서 얻습니다)을 뺀 값으로 조정됩니다. 혼합형 비교가 객체 주소 기반의 기본 비교로 떨어지는 것을 막기 위해, time 객체가 다른 형의 객체와 비교될 때, 비교가 == 이나 !=가 아니면 TypeError가 발생합니다. 두 상황에 해당하면 각각 False 나 True를 반환합니다.

버전 3.3에서 변경: 나이브와 어웨어 time 인스턴스 간의 동등 비교는 TypeError를 발생시키지 않습니다.
hash, 딕셔너리 키로 사용
효율적인 피클링

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

버전 3.5에서 변경: 파이썬 3.5 이전에, time 객체는 UTC 자정을 나타낼 때 거짓으로 간주했습니다. 이 동작은 애매하고 에러가 발생하기 쉬운 것으로 간주하여 파이썬 3.5에서 제거되었습니다. 자세한 내용은 bpo-13936을 참조하십시오.

기타 생성자:

classmethod time.fromisoformat(time_string)¶: time.isoformat()이 출력하는 형식 중 하나인 time_string에 해당하는 time을 반환합니다. 구체적으로, 이 함수는 HH[:MM[:SS[.fff[fff]]]][+HH:MM[:SS[.ffffff]]] 형식의 문자열을 지원합니다.

조심

이것은 임의의 ISO 8601 문자열을 구문 분석하는 것을 지원하지 않습니다 - 이것은 time.isoformat()의 역연산이고자 할 뿐입니다.

버전 3.7에 추가.

인스턴스 메서드:

time.replace(hour=self.hour, minute=self.minute, second=self.second, microsecond=self.microsecond, tzinfo=self.tzinfo, * fold=0)¶: 키워드 인자로 새로운 값이 주어진 어트리뷰트를 제외하고, 같은 값을 가진 time을 반환합니다. tzinfo=None을 지정하면 시간 데이터의 변환 없이 어웨어 time에서 나이브 time을 만들 수 있습니다.

버전 3.6에 추가: fold 인자가 추가되었습니다.

time.isoformat(timespec='auto')¶

ISO 8601 형식으로 시간을 나타내는 문자열을 반환합니다, HH:MM:SS.ffffff, 또는 microsecond가 0이면, HH:MM:SS utcoffset()이 None을 반환하지 않으면, UTC 오프셋을 제공하는 문자열을 덧붙입니다: HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]], 또는 self.microsecond가 0이면, HH:MM:SS+HH:MM[:SS[.ffffff]].

선택적 인자 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를 발생시킵니다.

>>> 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__()¶: time 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 객체를 반환하지 않으면 예외를 발생시킵니다.

버전 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이나 문자열 객체를 반환하지 않으면 예외를 발생시킵니다.

예제:

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

`tzinfo` 객체¶

class datetime.tzinfo¶

이것은 추상 베이스 클래스입니다. 즉, 이 클래스를 직접 인스턴스로 만들면 안 됩니다. 여러분은 구상(concrete) 서브 클래스를 파생시킬 필요가 있고, (적어도) 여러분이 사용하는 datetime 메서드에 필요한 표준 tzinfo 메서드의 구현을 제공해야 합니다. datetime 모듈은 간단한 tzinfo의 구상 서브 클래스 timezone를 제공하는데, UTC 자체나 북미 EST, EDT와 같은 UTC로부터의 고정 오프셋을 갖는 시간대를 나타낼 수 있습니다.

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

피클링을 위한 특별한 요구 사항: tzinfo 서브 클래스는 인자 없이 호출할 수 있는 __init__() 메서드를 가져야 합니다. 그렇지 않으면 피클 될 수는 있지만, 다시 역 피클 될 수는 없습니다. 이것은 기술적 요구사항으로, 미래에 완화될 수 있습니다.

tzinfo의 구상 서브 클래스는 다음 메서드를 구현해야 할 수도 있습니다. 정확히 어떤 메서드가 필요한지는 어웨어 datetime 객체를 사용하는 방법에 따라 다릅니다. 확실하지 않으면, 그냥 모두 구현하십시오.

tzinfo.utcoffset(dt)¶

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

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

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

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

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

tzinfo.dst(dt)¶

일광 절약 시간 (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 서브 클래스가 이를 보장 할 수 없으면, astimezone()와 상관없이 올바르게 작동하도록 tzinfo.fromutc()의 기본 구현을 재정의할 수 있습니다.

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

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를 발생시킵니다.

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

tzinfo.tzname(dt)¶

datetime 객체 dt에 해당하는 시간대 이름을 문자열로 반환합니다. 문자열 이름에 관한 어떤 것도 datetime 모듈에 의해 정의되지 않으며, 특별히 어떤 것을 의미해야 한다는 요구 사항이 없습니다. 예를 들어, “GMT”, “UTC”, “-500”, “-5:00”, “EDT”, “US/Eastern”, “America/New York”은 모두 유효한 응답입니다. 문자열 이름을 모르면 None을 반환합니다. 이것은 고정된 문자열이기보다 메서드인데, 주로 어떤 tzinfo 서브 클래스가 전달된 dt의 특정 값에 따라 다른 이름을 반환하기를 원하기 때문입니다. 특히 tzinfo 클래스가 일광 절약 시간을 고려할 때 그렇습니다.

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() 구현은 다음과 같이 동작합니다:

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

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

from datetime import tzinfo, timedelta, datetime

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

# A class capturing the platform's idea of local time.
# (May result in wrong values on historical times in
#  timezones where UTC offset and/or the DST rules had
#  changed in the past.)
import time as _time

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

DSTDIFF = DSTOFFSET - STDOFFSET

class LocalTimezone(tzinfo):

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

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

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

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

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

Local = LocalTimezone()


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

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


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

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

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


class USTimeZone(tzinfo):

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

    def __repr__(self):
        return self.reprname

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

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

    def dst(self, dt):
        if dt is None or dt.tzinfo is None:
            # An exception may be sensible here, in one or both cases.
            # It depends on how you want to treat them.  The default
            # fromutc() implementation (called by the default astimezone()
            # implementation) passes a datetime with dt.tzinfo is self.
            return ZERO
        assert dt.tzinfo is self
        start, end = us_dst_range(dt.year)
        # Can't compare naive to aware objects, so strip the timezone from
        # dt first.
        dt = dt.replace(tzinfo=None)
        if start + HOUR <= dt < end - HOUR:
            # DST is in effect.
            return HOUR
        if end - HOUR <= dt < end:
            # Fold (an ambiguous hour): use dt.fold to disambiguate.
            return ZERO if dt.fold else HOUR
        if start <= dt < start + HOUR:
            # Gap (a non-existent hour): reverse the fold rule.
            return HOUR if dt.fold else ZERO
        # DST is off.
        return ZERO

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


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

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)에서, 다음과 같은 결과를 얻습니다

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

DST가 끝날 때 (“end” 줄), 잠재적으로 더 나쁜 문제가 있습니다: 지역 시간으로 명확하게 말할 수 없는 시(hour)가 있습니다: 일광 절약 시간의 마지막 한 시간. Eastern에서, 이것은 일광 절약 시간제가 끝나는 날의 5:MM UTC 형식의 시간입니다. 지역 벽시계는 1:59(일광 절약 시간)에서 다시 1:00(표준 시간)으로 도약합니다. 1:MM 형식의 지역 시간은 모호합니다. astimezone()은 두 개의 인접한 UTC 시(hour)를 같은 지역 시(hour)로 매핑하여 지역 시계 동작을 모방합니다. Eastern 예제에서, 5:MM과 6:MM 형식의 UTC 시간은 모두 Eastern으로 변환될 때 1:MM으로 매핑되지만, 이전 시간은 fold 어트리뷰트가 0으로 설정되고 이후 시간은 1로 설정됩니다. 예를 들어, 2016년 가을의 역 전환( back transition)에서, 다음과 같은 결과를 얻습니다

>>> 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 인스턴스로 timezone.utc가 있습니다.

dateutil.tz 라이브러리는 IANA 시간대 데이터베이스 (Olson 데이터베이스라고도 합니다)를 파이썬으로 가져옵니다. 사용을 권장합니다.

IANA timezone database

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

`timezone` 객체¶

timezone 클래스는 tzinfo의 서브 클래스이며, 각 인스턴스는 UTC로부터의 고정 오프셋으로 정의된 시간대를 나타냅니다. 이 클래스의 객체는 일 년 중 어떤 날에는 다른 오프셋이 사용되거나 민간 시간이 역사적으로 변해온 지역의 시간대 정보를 나타내는데 사용할 수 없음에 유의하십시오.

class datetime.timezone(offset, name=None)¶

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

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

버전 3.2에 추가.

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

timezone.utcoffset(dt)¶: timezone 인스턴스가 구축될 때 지정된 고정값을 반환합니다. dt 인자는 무시됩니다. 반환 값은 지역 시간과 UTC 간의 차이와 같은 timedelta 인스턴스입니다.

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

timezone.tzname(dt)¶: timezone 인스턴스가 구축될 때 지정된 고정값을 반환합니다. name을 생성자에 제공하지 않았으면, tzname(dt)에 의해 반환되는 이름은 다음과 같이 offset 값으로부터 생성됩니다. offset이 timedelta(0)이면, 이름은 “UTC”이고, 그렇지 않으면 문자열 ‘UTC±HH:MM’입니다. 여기서 ±는 offset의 부호이고, HH와 MM은 각각 offset.hours와 offset.minutes의 두 자리 숫자입니다.

버전 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) 메서드를 지원하여, 명시적 포맷 문자열로 제어된 시간을 나타내는 문자열을 만듭니다. 대체로 말하자면, 모든 객체가 timetuple() 메서드를 지원하는 것은 아니지만, d.strftime(fmt)는 time 모듈의 time.strftime(fmt, d.timetuple())처럼 작동합니다.

반대로, datetime.strptime() 클래스 메서드는 날짜와 시간을 나타내는 문자열과 해당 포맷 문자열로 datetime 객체를 만듭니다. datetime.strptime(date_string, format)은 format에 초 미만의 성분이나 시간대 오프셋 정보가 포함된 경우를 제외하고는 datetime(*(time.strptime(date_string, format)[0:6]))과 동등합니다. 이것들은 datetime.strptime에서는 지원되지만 time.strptime에서는 버려집니다.

time 객체의 경우, time 객체에 해당 값이 없으므로, 연(year), 월(month) 및 일(day)의 포맷 코드는 사용하지 않아야 합니다. 어쨌든 사용되면, 1900이 해당 연도로, 1이 해당 월과 일로 대체됩니다.

date 객체의 경우, date 객체에 해당 값이 없으므로, 시(hour), 분(minute), 초(second) 및 마이크로초(microsecond)의 포맷 코드는 사용하지 않아야 합니다. 어쨌든 사용되면, 0으로 대체됩니다.

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

파이썬이 플랫폼 C 라이브러리의 strftime() 함수를 호출하고, 플랫폼 변형이 일반적이기 때문에, 지원되는 전체 포맷 코드 집합은 플랫폼에 따라 다릅니다. 여러분의 플랫폼에서 지원되는 모든 포맷 코드를 보려면, strftime(3) 설명서를 참조하십시오.

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

다음은 C 표준(1989 버전)이 요구하는 모든 포맷 코드 목록이며, 표준 C 구현이 있는 모든 플랫폼에서 작동합니다. C 표준의 1999 버전에는 추가 형식 코드가 추가되었음에 유의하십시오.

지시자	의미	예	노트
`%a`	요일을 로케일의 축약된 이름으로.	Sun, Mon, …, Sat (en_US); So, Mo, …, Sa (de_DE)	(1)
`%A`	요일을 로케일의 전체 이름으로.	Sunday, Monday, …, Saturday (en_US); Sonntag, Montag, …, Samstag (de_DE)	(1)
`%w`	요일을 10진수로, 0은 일요일이고 6은 토요일입니다.	0, 1, …, 6
`%d`	월중 일(day of the month)을 0으로 채워진 10진수로.	01, 02, …, 31	(9)
`%b`	월을 로케일의 축약된 이름으로.	Jan, Feb, …, Dec (en_US); Jan, Feb, …, Dez (de_DE)	(1)
`%B`	월을 로케일의 전체 이름으로.	January, February, …, December (en_US); Januar, Februar, …, Dezember (de_DE)	(1)
`%m`	월을 0으로 채워진 10진수로.	01, 02, …, 12	(9)
`%y`	세기가 없는 해(year)를 0으로 채워진 10진수로.	00, 01, …, 99	(9)
`%Y`	세기가 있는 해(year)를 10진수로.	0001, 0002, …, 2013, 2014, …, 9998, 9999	(2)
`%H`	시(24시간제)를 0으로 채워진 십진수로.	00, 01, …, 23	(9)
`%I`	시(12시간제)를 0으로 채워진 십진수로.	01, 02, …, 12	(9)
`%p`	로케일의 오전이나 오후에 해당하는 것.	AM, PM (en_US); am, pm (de_DE)	(1), (3)
`%M`	분을 0으로 채워진 십진수로.	00, 01, …, 59	(9)
`%S`	초를 0으로 채워진 10진수로.	00, 01, …, 59	(4), (9)
`%f`	마이크로초를 왼쪽에 0으로 채워진 십진수로.	000000, 000001, …, 999999	(5)
`%z`	±HHMM[SS[.ffffff]] 형태의 UTC 오프셋 (객체가 나이브하면 빈 문자열).	(비어 있음), +0000, -0400, +1030, +063415, -030712.345216	(6)
`%Z`	시간대 이름 (객체가 나이브하면 빈 문자열).	(비어 있음), UTC, EST, CST
`%j`	연중 일(day of the year)을 0으로 채워진 십진수로.	001, 002, …, 366	(9)
`%U`	연중 주 번호(일요일이 주의 시작)를 0으로 채워진 10진수로. 첫 번째 일요일에 선행하는 새해의 모든 날은 주 0으로 간주합니다.	00, 01, …, 53	(7), (9)
`%W`	연중 주 번호(월요일이 주의 시작)를 십진수로. 첫 번째 월요일에 선행하는 새해의 모든 말은 주 0으로 간주합니다.	00, 01, …, 53	(7), (9)
`%c`	로케일의 적절한 날짜와 시간 표현.	Tue Aug 16 21:30:00 1988 (en_US); Di 16 Aug 21:30:00 1988 (de_DE)	(1)
`%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)
`%%`	리터럴 `'%'` 문자.	%

C89 표준에서 요구하지 않는 몇 가지 추가 지시자가 편의상 포함되어 있습니다. 이 파라미터들은 모두 ISO 8601 날짜 값에 해당합니다. strftime() 메서드와 함께 사용될 때 모든 플랫폼에서 사용할 수 있는 것은 아닙니다. ISO 8601 연도와 ISO 8601 주 지시자는 위의 연도 및 주 번호 지시자와 교환할 수 없습니다. 불완전하거나 모호한 ISO 8601 지시자로 strptime()을 호출하면 ValueError가 발생합니다.

지시자	의미	예	노트
`%G`	ISO 주(`%V`)의 더 큰 부분을 포함하는 연도를 나타내는 세기가 있는 ISO 8601 연도.	0001, 0002, …, 2013, 2014, …, 9998, 9999	(8)
`%u`	ISO 8601 요일을 10진수로, 1은 월요일입니다.	1, 2, …, 7
`%V`	ISO 8601 주를 월요일을 주의 시작으로 하는 십진수로. 주 01은 1월 4일을 포함하는 주입니다.	01, 02, …, 53	(8), (9)

버전 3.6에 추가: %G, %u 및 %V가 추가되었습니다.

노트:

포맷이 현재 로케일에 따라 다르므로, 출력값에 대해 가정을 할 때 주의해야 합니다. 필드 순서가 달라지며 (예를 들어, “월/일/년” 과 “일/월/년”), 출력에는 로케일의 기본 인코딩을 사용하여 인코딩된 유니코드 문자가 포함될 수 있습니다 (예를 들어, 현재 로케일이 ja_JP이면, 기본 인코딩은 eucJP, SJIS 또는 utf-8 중 하나일 수 있습니다; 현재 로케일의 인코딩을 결정하려면 locale.getlocale()을 사용하십시오).
strptime() 메서드는 전체 [1, 9999] 범위에서 연도를 구문 분석할 수 있지만, 1000보다 작은 연도는 4자리 너비가 되도록 0으로 채워야 합니다.

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

버전 3.3에서 변경: 버전 3.2에서, strftime() 메서드는 연도를 1000 이상으로 제한했습니다.
strptime() 메서드와 함께 사용할 때, %p 지시자는 시간을 구문 분석하는 데 %I 지시문을 사용할 때만 출력 시간 필드에 영향을 줍니다.
time 모듈과 달리, datetime 모듈은 윤초를 지원하지 않습니다.
strptime() 메서드와 함께 사용할 때, %f 지시자는 하나에서 여섯 자리 숫자와 오른쪽의 0-채움을 받아들입니다. %f는 C 표준의 포맷 문자 집합에 대한 확장입니다 (하지만 datetime 객체에서 별도로 구현되므로 항상 사용할 수 있습니다).
나이브 객체의 경우, %z 와 %Z 포맷 코드는 빈 문자열로 치환됩니다.

어웨어 객체의 경우:

%z
utcoffset()이 ±HHMM[SS[.ffffff]] 형식의 문자열로 변환됩니다. 여기서 HH는 UTC 오프셋 시간(hour)의 수를 나타내는 두 자리 숫자 문자열이고, MM은 UTC 오프셋 분의 수를 나타내는 두 자리 숫자 문자열이며, SS는 UTC 오프셋 초의 수를 나타내는 두 자리 숫자 문자열이며, ffffff는 UTC 오프셋 마이크로초의 수를 나타내는 6자리 숫자 문자열입니다. 오프셋이 딱 떨어지는 초면 ffffff 부분은 생략되며, offset이 딱 떨어지는 분이면 ffffff와 SS 부분이 모두 생략됩니다. 예를 들어, utcoffset()이 timedelta(hours=-3, minutes=-30)를 반환하면, %z는 '-0330' 문자열로 치환됩니다.

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

버전 3.7에서 변경: %z 지시자가 strptime() 메서드에 제공될 때, UTC 오프셋에는 콜론이 시, 분 및 초 사이의 구분 기호로 사용될 수 있습니다. 예를 들어, '+01:00:00'은 1시간의 오프셋으로 구문 분석됩니다. 또한, 'Z'를 제공하는 것은 '+00:00'과 같습니다.

%Z
tzname()이 None을 반환하면, %Z는 빈 문자열로 치환됩니다. 그렇지 않으면 %Z는 문자열이어야 하는 반환 값으로 치환됩니다.

버전 3.2에서 변경: %z 지시자가 strptime() 메서드에 제공될 때, 어웨어 datetime 객체가 생성됩니다. 결과의 tzinfo는 timezone 인스턴스로 설정됩니다.
strptime() 메서드와 함께 사용될 때, %U 와 %W는 요일과 달력 연도(%Y)가 지정되었을 때만 계산에 사용됩니다.
%U 와 %W와 비슷하게, %V는 요일과 ISO 연도(%G)가 strptime() 포맷 문자열에 지정되었을 때만 계산에 사용됩니다. 또한 %G와 %Y를 상호 교환할 수 없음에 유의하십시오.
strptime() 메서드와 함께 사용할 때, 선행 0은 %d, %m, %H, %I, %M, %S, %J, %U, %W 및 %V 포맷에서 선택적입니다. 포맷 %y에는 선행 0이 필요합니다.

각주

1: 즉, 상대론적 효과를 무시한다면
2: 1900이 윤년이 아니므로 datetime.strptime('Feb 29', '%b %d')를 전달하는 것은 실패합니다.

`datetime` — 기본 날짜와 시간 형¶

사용 가능한 형¶

`timedelta` 객체¶

`date` 객체¶

`datetime` 객체¶

`time` 객체¶

`tzinfo` 객체¶

`timezone` 객체¶

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

목차

이전 항목

다음 항목

현재 문서

datetime — 기본 날짜와 시간 형¶

사용 가능한 형¶

timedelta 객체¶

date 객체¶

datetime 객체¶

time 객체¶

tzinfo 객체¶

timezone 객체¶

strftime()과 strptime() 동작¶

`datetime` — 기본 날짜와 시간 형¶

`timedelta` 객체¶

`date` 객체¶

`datetime` 객체¶

`time` 객체¶

`tzinfo` 객체¶

`timezone` 객체¶

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