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

소스 코드: Lib/datetime.py

`datetime` 모듈은 날짜와 시간을 조작하는 클래스를 제공합니다.

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

더 보기

모듈 `calendar`

  일반 달력 관련 함수들.

모듈 `time`

  시간 액세스와 변환.

패키지 dateutil

  시간대와 구문 분석 지원이 확장된 제삼자 라이브러리.

## 어웨어와 나이브 객체

날짜와 시간 객체는 시간대 정보를 포함하는지에 따라 《어웨어(aware)》와 《나이브(naive)》로 분류될 수 있습니다.

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

## 사용 가능한 형

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에 추가.

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

서브 클래스 관계:

    object
        timedelta
        tzinfo
            timezone
        time
        date
            datetime

### 공통 속성

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

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

- 이러한 형의 객체는 해시 가능합니다. 딕셔너리 키로 사용할 수 있다는 뜻입니다.

- 이러한 형의 객체는 `pickle` 모듈을 통한 효율적인 피클링을 지원합니다.

### 객체가 어웨어한지 나이브한지 판단하기

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

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

`datetime` 객체 d는 다음 조건을 모두 만족하면 어웨어합니다:

1. `d.tzinfo`가 `None`이 아닙니다

2. `d.tzinfo.utcoffset(d)`가 `None`을 반환하지 않습니다

그렇지 않으면, d는 나이브합니다.

`time` 객체 t는 다음 조건을 모두 만족하면 어웨어합니다.

1. `t.tzinfo`가 `None`이 아닙니다

2. `t.tzinfo.utcoffset(None)`이 `None`을 반환하지 않습니다

그렇지 않으면, t는 나이브합니다.

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

## `timedelta` 객체

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

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 이외의 인자가 어떻게 《병합》 되어 세 개의 결과 어트리뷰트로 정규화되는지를 보여줍니다:

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

  인자가 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` 객체의 문자열 표현을 반환합니다.

노트:

1. 이것은 정확하지만, 오버플로 할 수 있습니다.

2. 이것은 정확하고, 오버플로 할 수 없습니다.

3. 0으로 나누면 `ZeroDivisionError`가 발생합니다.

4. -timedelta.max는 `timedelta` 객체로 표현할 수 없습니다.

5. `timedelta` 객체의 문자열 표현은 내부 표현과 유사하게 정규화됩니다. 이것은 음의 timedelta가 다소 이상하게 표현되는 결과로 이어집니다. 예를 들어:

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

6. `t2 - t3` 표현식은 항상 `t2 + (-t3)` 표현식과 같아지는데, t3이 `timedelta.max`일 때만 예외입니다; 이때는 앞에 있는 것은 결과를 만들지만, 뒤에 있는 것은 오버플로를 일으킵니다.

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

버전 3.2에서 변경: 나머지 연산과 `divmod()` 함수와 마찬가지로, `timedelta` 객체를 다른 `timedelta` 객체로 정수 나누기(floor division)와 실수 나누기(true division)가 이제 지원됩니다. `timedelta` 객체를 `float` 객체로 실수 나누기와 곱셈도 이제 이제 지원됩니다.

`timedelta` 객체의 비교가 지원되지만, 주의할 점이 있습니다.

비교 `==`나 `!=`은 비교되는 객체의 형과 관계없이 항상 `bool`을 반환합니다.

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

다른 모든 비교의 경우 (가령 `<`와 `>`), `timedelta` 객체가 다른 형의 객체와 비교될 때, `TypeError`가 발생합니다.

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

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

인스턴스 메서드:

`timedelta.``total_seconds`()

  기간에 포함된 총 시간을 초(seconds)로 반환합니다. `td / timedelta(seconds=1)`와 동등합니다. 초 이외의 구간 단위에는, 나누기 형식을 직접 사용하십시오 (예를 들어, `td / timedelta(microseconds=1)`).

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

  버전 3.2에 추가.

### 사용 예: `timedelta`

정규화의 추가 예:

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

`timedelta` 산술의 예:

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

## `date` 객체

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

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)

  `YYYY-MM-DD` 형식으로 제공된 date_string에 해당하는 `date`를 반환합니다:

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

  이것은 `date.isoformat()`의 역연산입니다. 형식 `YYYY-MM-DD`만 지원합니다.

  버전 3.7에 추가.

classmethod `date.``fromisocalendar`(year, week, day)

  년, 주 및 일로 지정된 ISO 달력 날짜에 해당하는 `date`를 반환합니다. 이것은 함수 `date.isocalendar()`의 역입니다.

  버전 3.8에 추가.

클래스 어트리뷰트:

`date.``min`

  표현 가능한 가장 이른 date, `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)

노트:

1. date2는 `timedelta.days > 0`이면 미래로, `timedelta.days < 0`이면 과거로 이동합니다. 결국 `date2 - date1 == timedelta.days`이 됩니다. `timedelta.seconds`와 `timedelta.microseconds`는 무시됩니다. `date2.year`가 `MINYEAR`보다 작거나 `MAXYEAR`보다 크게 되려고 하면 `OverflowError`가 발생합니다.

2. `timedelta.seconds`와 `timedelta.microseconds`는 무시됩니다.

3. 이것은 정확하고, 오버플로 할 수 없습니다. timedelta.seconds와 timedelta.microseconds는 0이고, 이후에 date2 + timedelta == date1 이 됩니다.

4. 즉, 오직 `date1.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를 반환합니다.

  예제:

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

`date.``timetuple`()

  `time.localtime()`이 반환하는 것과 같은 `time.struct_time`을 반환합니다.

  시, 분 및 초는 0이고, DST 플래그는 -1입니다.

  `d.timetuple()`은 다음과 동등합니다:

      time.struct_time((d.year, d.month, d.day, 0, 0, 0, d.weekday(), yday, -1))

  여기서 `yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1`은 1월 1일에 `1`로 시작하는 현재 연도의 날짜 번호입니다.

`date.``toordinal`()

  역산 그레고리력 서수를 돌려줍니다. 1년 1월 1일의 서수는 1입니다. 임의의 `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 달력은 널리 사용되는 그레고리력의 변형입니다. 3

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

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

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

`date.``isoformat`()

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

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

  이것은 `date.fromisoformat()`의 역입니다.

`date.``__str__`()

  날짜 d에 대해, `str(d)`는 `d.isoformat()`와 동등합니다.

`date.``ctime`()

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

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

  `d.ctime()`은 다음과:

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

  네이티브 C `ctime()` 함수(`time.ctime()`은 호출하지만 `date.ctime()`은 호출하지 않습니다)가 C 표준을 준수하는 플랫폼에서 동등합니다.

`date.``strftime`(format)

  명시적인 포맷 문자열로 제어되는, 날짜를 나타내는 문자열을 반환합니다. 시, 분 또는 초를 나타내는 포맷 코드는 0 값을 보게 됩니다. 포매팅 지시자의 전체 목록은, strftime()과 strptime() 동작를 참조하십시오.

`date.``__format__`(format)

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

### 사용 예: `date`

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

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

`date`로 작업하는 추가 예:

    >>> from datetime import date
    >>> d = date.fromordinal(730920) # 730920th day after 1. 1. 0001
    >>> d
    datetime.date(2002, 3, 11)

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

    >>> # Methods for to extracting 'components' under different calendars
    >>> t = d.timetuple()
    >>> for i in t:
    ...     print(i)
    2002                # year
    3                   # month
    11                  # day
    0
    0
    0
    0                   # weekday (0 = Monday)
    70                  # 70th day in the year
    -1
    >>> ic = d.isocalendar()
    >>> for i in ic:
    ...     print(i)
    2002                # ISO year
    11                  # ISO week number
    1                   # ISO day number ( 1 = Monday )

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

## `datetime` 객체

`datetime` 객체는 `date` 객체와 `time` 객체의 모든 정보를 포함하는 단일 객체입니다.

`date` 객체와 마찬가지로, `datetime`은 현재의 그레고리력을 양방향으로 확장한다고 가정합니다; `time` 객체와 마찬가지로, `datetime`은 하루가 정확히 3600*24초인 것으로 가정합니다.

생성자:

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

  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을 반환합니다.

  다음과 동등합니다:

      datetime.fromtimestamp(time.time())

  `now()`, `fromtimestamp()`를 참조하십시오.

  이 메서드는 기능적으로 `now()`와 동등하지만, `tz` 매개 변수는 없습니다.

classmethod `datetime.``now`(tz=None)

  현재의 지역 날짜와 시간을 반환합니다.

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

  tz가 `None`이 아니면, `tzinfo` 서브 클래스의 인스턴스여야 하며, 현재 날짜와 시간이 tz의 시간대로 변환됩니다.

  이 함수는 `today()`와 `utcnow()`보다 선호됩니다.

classmethod `datetime.``utcnow`()

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

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

  경고

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

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로 설정된 인스턴스를 반환할 수 있습니다.

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

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

  여기서 `*`는 임의의 단일 문자와 일치 할 수 있습니다.

  조심

  이것은 임의의 ISO 8601 문자열을 구문 분석하는 것을 지원하지 않습니다 - 이것은 `datetime.isoformat()`의 역연산이고자 할 뿐입니다. 더욱 완전한 기능을 갖춘 ISO 8601 구문 분석기인 `dateutil.parser.isoparse`는 제삼자 패키지 dateutil에서 제공됩니다.

  예제:

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

  버전 3.7에 추가.

classmethod `datetime.``fromisocalendar`(year, week, day)

  년, 주 및 일로 지정된 ISO 달력 날짜에 해당하는 `datetime`을 반환합니다. datetime의 날짜가 아닌 구성 요소는 일반적인 기본값으로 채워집니다. 이것은 함수 `datetime.isocalendar()`의 역입니다.

  버전 3.8에 추가.

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)

1. datetime2는 datetime1에서 timedelta 기간만큼 이동한 시간이며, `timedelta.days` > 0이면 미래로, `timedelta.days` < 0이면 과거로 이동합니다. 결과는 입력 datetime과 같은 `tzinfo` 어트리뷰트를 가지고, 이후에 datetime2 - datetime1 == timedelta 입니다. datetime2.year가 `MINYEAR`보다 작거나 `MAXYEAR`보다 커지려고 하면 `OverflowError`가 발생합니다. 입력이 어웨어 객체일 때도 시간대 조정이 수행되지 않음에 유의하십시오.

2. datetime2 + timedelta == datetime1 을 만족하는 datetime2를 계산합니다. 덧셈과 마찬가지로, 결과는 입력 datetime과 같은 `tzinfo` 어트리뷰트를 가지며 입력이 어웨어일 때도 시간대 조정이 수행되지 않습니다.

3. `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())`입니다.

4. 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.``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` 객체는 많은 `datetime` 메서드에 의해 지역 시간으로 취급되므로, UTC로 시간을 나타내는 어웨어 datetime을 사용하는 것이 좋습니다; 결과적으로, `utcfromtimetuple`를 사용하면 잘못된 결과를 초래할 수 있습니다. UTC를 나타내는 나이브 `datetime`이 있으면, `datetime.replace(tzinfo=timezone.utc)`를 사용하여 어웨어로 만드십시오, 이제 `datetime.timetuple()`을 사용할 수 있습니다.

`datetime.``toordinal`()

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

`datetime.``timestamp`()

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

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

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

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

  버전 3.3에 추가.

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

  참고

  UTC 시간을 나타내는 나이브 `datetime` 인스턴스에서 직접 POSIX 타임스탬프를 얻는 메서드는 없습니다. 응용 프로그램에서 이 관례를 사용하고 시스템 시간대가 UTC로 설정되어 있지 않으면, `tzinfo=timezone.utc`를 제공하여 POSIX 타임스탬프를 얻을 수 있습니다:

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

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

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

`datetime.``weekday`()

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

`datetime.``isoweekday`()

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

`datetime.``isocalendar`()

  3-튜플 (ISO 연도, ISO 주 번호, ISO 요일)을 반환합니다. `self.date().isocalendar()`와 같습니다.

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

  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이면

  예제:

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

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

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

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

  - `'auto'`: `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`()

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

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

  출력 문자열은 입력이 어웨어인지 나이브인지와 관계없이 시간대 정보를 포함하지 않습니다.

  `d.ctime()`은 다음과:

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

  네이티브 C `ctime()` 함수(`time.ctime()`이 호출하지만, `datetime.ctime()`은 호출하지 않습니다)가 C 표준을 준수하는 플랫폼에서 동등합니다.

`datetime.``strftime`(format)

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

`datetime.``__format__`(format)

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

### 사용 예: `datetime`

`datetime` 객체로 작업하는 예제:

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

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

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

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

    >>> # Using datetime.timetuple() to get tuple of all attributes
    >>> tt = dt.timetuple()
    >>> for it in tt:
    ...     print(it)
    ...
    2006    # year
    11      # month
    21      # day
    16      # hour
    30      # minute
    0       # second
    1       # weekday (0 = Monday)
    325     # number of days since 1st January
    -1      # dst - method tzinfo.dst() returned None

    >>> # Date in ISO format
    >>> ic = dt.isocalendar()
    >>> for it in ic:
    ...     print(it)
    ...
    2006    # ISO year
    47      # ISO week
    2       # ISO weekday

    >>> # Formatting a datetime
    >>> dt.strftime("%A, %d. %B %Y %I:%M%p")
    'Tuesday, 21. November 2006 04:30PM'
    >>> 'The {1} is {0:%d}, the {2} is {0:%B}, the {3} is {0:%I:%M%p}.'.format(dt, "day", "month", "time")
    'The day is 21, the month is November, the time is 04:30PM.'

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

    from datetime import timedelta, datetime, tzinfo, timezone

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

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

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

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

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

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

위의 `KabulTz` 사용법:

    >>> tz1 = KabulTz()

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

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

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

## `time` 객체

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

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

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

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

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

기타 생성자:

classmethod `time.``fromisoformat`(time_string)

  `date.isoformat()`이 출력하는 형식 중 하나인 time_string에 해당하는 `time`을 반환합니다. 구체적으로, 이 함수는 다음과 같은 형식의 문자열을 지원합니다:

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

  조심

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

  예제:

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

  버전 3.7에 추가.

인스턴스 메서드:

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

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

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

  예제:

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

### 사용 예: `time`

`time` 객체로 작업하는 예제:

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

## `tzinfo` 객체

class `datetime.``tzinfo`

  이것은 추상 베이스 클래스입니다. 즉, 이 클래스를 직접 인스턴스로 만들면 안 됩니다. 특정 시간대에 대한 정보를 캡처하려면 `tzinfo`의 서브 클래스를 정의하십시오.

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

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

  피클링을 위한 특별한 요구 사항: `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.

          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

  `datetime` 모듈에는 (UTC로부터의 임의의 고정 오프셋을 처리하기 위한) 기본적인 `timezone` 클래스와 `timezone.utc` 어트리뷰트(UTC timezone 인스턴스)가 있습니다.

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

반대로, `datetime.strptime()` 클래스 메서드는 날짜와 시간을 나타내는 문자열과 해당 포맷 문자열로 `datetime` 객체를 만듭니다.

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

| `strftime` | `strptime`
--- | --- | ---
용도 | 주어진 포맷에 따라 객체를 문자열로 변환합니다 | 주어진 해당 포맷으로 문자열을 `datetime` 객체로 구문 분석합니다
메서드의 형 | 인스턴스 메서드 | 클래스 메서드
메서드가 제공되는 곳 | `date`; `datetime`; `time` | `datetime`
서명 | `strftime(format)` | `strptime(date_string, format)`

### `strftime()`과 `strptime()` 포맷 코드

다음은 1989 C 표준이 요구하는 모든 포맷 코드 목록이며, 표준 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)
`%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 날짜 값에 해당합니다.

지시자 | 의미 | 예 | 노트
--- | --- | --- | ---
`%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)

`strftime()` 메서드와 함께 사용될 때 모든 플랫폼에서 사용할 수 있는 것은 아닙니다. ISO 8601 연도와 ISO 8601 주 지시자는 위의 연도 및 주 번호 지시자와 교환할 수 없습니다. 불완전하거나 모호한 ISO 8601 지시자로 `strptime()`을 호출하면 `ValueError`가 발생합니다.

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

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

### 기술적 세부 사항

대체로 말하자면, 모든 객체가 `timetuple()` 메서드를 지원하는 것은 아니지만, `d.strftime(fmt)`는 `time` 모듈의 `time.strftime(fmt, d.timetuple())`처럼 작동합니다.

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

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

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

format에 초 미만의 성분이나 시간대 오프셋 정보가 포함된 경우는 예외입니다. 이것들은 `datetime.strptime`에서는 지원되지만 `time.strptime`에서는 버려집니다.

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

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

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

노트:

1. 포맷이 현재 로케일에 따라 다르므로, 출력값에 대해 가정을 할 때 주의해야 합니다. 필드 순서가 달라지며 (예를 들어, 《월/일/년》 과 《일/월/년》), 출력에는 로케일의 기본 인코딩을 사용하여 인코딩된 유니코드 문자가 포함될 수 있습니다 (예를 들어, 현재 로케일이 `ja_JP`이면, 기본 인코딩은 `eucJP`, `SJIS` 또는 `utf-8` 중 하나일 수 있습니다; 현재 로케일의 인코딩을 결정하려면 `locale.getlocale()`을 사용하십시오).

2. `strptime()` 메서드는 전체 [1, 9999] 범위에서 연도를 구문 분석할 수 있지만, 1000보다 작은 연도는 4자리 너비가 되도록 0으로 채워야 합니다.

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

   버전 3.3에서 변경: 버전 3.2에서, `strftime()` 메서드는 연도를 1000 이상으로 제한했습니다.

3. `strptime()` 메서드와 함께 사용할 때, `%p` 지시자는 시간을 구문 분석하는 데 `%I` 지시문을 사용할 때만 출력 시간 필드에 영향을 줍니다.

4. `time` 모듈과 달리, `datetime` 모듈은 윤초를 지원하지 않습니다.

5. `strptime()` 메서드와 함께 사용할 때, `%f` 지시자는 하나에서 여섯 자리 숫자와 오른쪽의 0-채움을 받아들입니다. `%f`는 C 표준의 포맷 문자 집합에 대한 확장입니다 (하지만 datetime 객체에서 별도로 구현되므로 항상 사용할 수 있습니다).

6. 나이브 객체의 경우, `%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` 인스턴스로 설정됩니다.

7. `strptime()` 메서드와 함께 사용될 때, `%U` 와 `%W`는 요일과 달력 연도(`%Y`)가 지정되었을 때만 계산에 사용됩니다.

8. `%U` 와 `%W`와 비슷하게, `%V`는 요일과 ISO 연도(`%G`)가 `strptime()` 포맷 문자열에 지정되었을 때만 계산에 사용됩니다. 또한 `%G`와 `%Y`를 상호 교환할 수 없음에 유의하십시오.

9. `strptime()` 메서드와 함께 사용할 때, 선행 0은 `%d`, `%m`, `%H`, `%I`, `%M`, `%S`, `%J`, `%U`, `%W` 및 `%V` 포맷에서 선택적입니다. 포맷 `%y`에는 선행 0이 필요합니다.

각주

1

  즉, 상대론적 효과를 무시한다면

2

  이것은 Dershowitz와 Reingold의 책 Calendrical Calculations에 나오는 《역산 그레고리(proleptic Gregorian)》 달력의 정의와 일치합니다. 이 달력은 모든 계산의 기본 달력입니다. 역산 그레고리력 서수(ordinal)와 다른 많은 달력 시스템 사이의 변환을 위한 알고리즘에 관해서는 이 책을 참조하십시오.

3

  R. H. van Gent의 ISO 8601 달력의 수학 지침서에 잘 설명되어 있습니다.

4

  `1900`이 윤년이 아니므로 `datetime.strptime('Feb 29', '%b %d')`를 전달하는 것은 실패합니다.