datetime
— Basic date and time types
Source code: Lib/datetime.py
The datetime
module supplies classes for manipulating dates and times.
While date and time arithmetic is supported, the focus of the implementation is on efficient attribute extraction for output formatting and manipulation.
{tip}Module calendar
General calendar related functions.
Module time
Time access and conversions.
Package dateutil Thirdparty library with expanded time zone and parsing support.
Aware and Naive Objects
Date and time objects may be categorized as “aware” or “naive” depending on whether or not they include timezone information.
With sufficient knowledge of applicable algorithmic and political time adjustments, such as time zone and daylight saving time information, an aware object can locate itself relative to other aware objects. An aware object represents a specific moment in time that is not open to interpretation. 1
A naive object does not contain enough information to unambiguously locate itself relative to other date/time objects. Whether a naive object represents Coordinated Universal Time (UTC), local time, or time in some other timezone is purely up to the program, just like it is up to the program whether a particular number represents metres, miles, or mass. Naive objects are easy to understand and to work with, at the cost of ignoring some aspects of reality.
For applications requiring aware objects, datetime
and time
objects have an optional time zone information attribute, tzinfo
, that can be set to an instance of a subclass of the abstract tzinfo
class. These tzinfo
objects capture information about the offset from UTC time, the time zone name, and whether daylight saving time is in effect.
Only one concrete tzinfo
class, the timezone
class, is supplied by the datetime
module. The timezone
class can represent simple timezones with fixed offsets from UTC, such as UTC itself or North American EST and EDT timezones. Supporting timezones at deeper levels of detail is up to the application. The rules for time adjustment across the world are more political than rational, change frequently, and there is no standard suitable for every application aside from UTC.
Constants
The datetime
module exports the following constants:
datetime.
MINYEAR
datetime.
MINYEAR
The smallest year number allowed in a date
or datetime
object. MINYEAR
is 1
.
datetime.
MAXYEAR
datetime.
MAXYEAR
The largest year number allowed in a date
or datetime
object. MAXYEAR
is 9999
.
Available Types
datetime.
date
An idealized naive date, assuming the current Gregorian calendar always was, and always will be, in effect. Attributes: year
, month
, and day
.
datetime.
time
An idealized time, independent of any particular day, assuming that every day has exactly 24*60*60 seconds. (There is no notion of “leap seconds” here.) Attributes: hour
, minute
, second
, microsecond
, and tzinfo
.
datetime.
datetime
A combination of a date and a time. Attributes: year
, month
, day
, hour
, minute
, second
, microsecond
, and tzinfo
.
datetime.
timedelta
A duration expressing the difference between two date
, time
, or datetime
instances to microsecond resolution.
datetime.
tzinfo
An abstract base class for time zone information objects. These are used by the datetime
and time
classes to provide a customizable notion of time adjustment (for example, to account for time zone and/or daylight saving time).
datetime.
timezone
A class that implements the tzinfo
abstract base class as a fixed offset from the UTC.
New in version 3.2.
Objects of these types are immutable.
Subclass relationships:
object
timedelta
tzinfo
timezone
time
date
datetime
Common Properties
The date
, datetime
, time
, and timezone
types share these common features:

Objects of these types are immutable.

Objects of these types are hashable, meaning that they can be used as dictionary keys.

Objects of these types support efficient pickling via the
pickle
module.
Determining if an Object is Aware or Naive
Objects of the date
type are always naive.
An object of type time
or datetime
may be aware or naive.
A datetime
object d is aware if both of the following hold:

d.tzinfo
is notNone

d.tzinfo.utcoffset(d)
does not returnNone
Otherwise, d is naive.
A time
object t is aware if both of the following hold:

t.tzinfo
is notNone

t.tzinfo.utcoffset(None)
does not returnNone
.
Otherwise, t is naive.
The distinction between aware and naive doesn’t apply to timedelta
objects.
timedelta
Objects
A timedelta
object represents a duration, the difference between two dates or times.
class datetime.
timedelta
(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)
datetime.
timedelta
(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)All arguments are optional and default to 0
. Arguments may be integers or floats, and may be positive or negative.
Only days, seconds and microseconds are stored internally. Arguments are converted to those units:

A millisecond is converted to 1000 microseconds.

A minute is converted to 60 seconds.

An hour is converted to 3600 seconds.

A week is converted to 7 days.
and days, seconds and microseconds are then normalized so that the representation is unique, with

0 <= microseconds < 1000000

0 <= seconds < 3600*24
(the number of seconds in one day) 
999999999 <= days <= 999999999
The following example illustrates how any arguments besides days, seconds and microseconds are “merged” and normalized into those three resulting attributes:
>>> 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)
If any argument is a float and there are fractional microseconds, the fractional microseconds left over from all arguments are combined and their sum is rounded to the nearest microsecond using roundhalftoeven tiebreaker. If no argument is a float, the conversion and normalization processes are exact (no information is lost).
If the normalized value of days lies outside the indicated range, OverflowError
is raised.
Note that normalization of negative values may be surprising at first. For example:
>>> from datetime import timedelta
>>> d = timedelta(microseconds=1)
>>> (d.days, d.seconds, d.microseconds)
(1, 86399, 999999)
Class attributes:
timedelta.
min
timedelta.
min
The most negative timedelta
object, timedelta(999999999)
.
timedelta.
max
timedelta.
max
The most positive timedelta
object, timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999)
.
timedelta.
resolution
timedelta.
resolution
The smallest possible difference between nonequal timedelta
objects, timedelta(microseconds=1)
.
Note that, because of normalization, timedelta.max
> timedelta.min
. timedelta.max
is not representable as a timedelta
object.
Instance attributes (readonly):
Attribute 
Value 


Between 999999999 and 999999999 inclusive 

Between 0 and 86399 inclusive 

Between 0 and 999999 inclusive 
Supported operations:
Operation 
Result 


Sum of t2 and t3. Afterwards t1t2 == t3 and t1t3 == t2 are true. (1) 

Difference of t2 and t3. Afterwards t1 == t2  t3 and t2 == t1 + t3 are true. (1)(6) 

Delta multiplied by an integer. Afterwards t1 // i == t2 is true, provided 
In general, t1 * i == t1 * (i1) + t1 is true. (1) 


Delta multiplied by a float. The result is rounded to the nearest multiple of timedelta.resolution using roundhalftoeven. 

Division (3) of overall duration t2 by interval unit t3. Returns a 

Delta divided by a float or an int. The result is rounded to the nearest multiple of timedelta.resolution using roundhalftoeven. 

The floor is computed and the remainder (if any) is thrown away. In the second case, an integer is returned. (3) 

The remainder is computed as a 

Computes the quotient and the remainder: 

Returns a 

equivalent to 

equivalent to +t when 

Returns a string in the form 

Returns a string representation of the 
Notes:

This is exact but may overflow.

This is exact and cannot overflow.

Division by 0 raises
ZeroDivisionError
. 
timedelta.max is not representable as a
timedelta
object. 
String representations of
timedelta
objects are normalized similarly to their internal representation. This leads to somewhat unusual results for negative timedeltas. For example:>>> timedelta(hours=5) datetime.timedelta(days=1, seconds=68400) >>> print(_) 1 day, 19:00:00

The expression
t2  t3
will always be equal to the expressiont2 + (t3)
except when t3 is equal totimedelta.max
; in that case the former will produce a result while the latter will overflow.
In addition to the operations listed above, timedelta
objects support certain additions and subtractions with date
and datetime
objects (see below).
Changed in version 3.2: Floor division and true division of a timedelta
object by another timedelta
object are now supported, as are remainder operations and the divmod()
function. True division and multiplication of a timedelta
object by a float
object are now supported.
Comparisons of timedelta
objects are supported, with some caveats.
The comparisons ==
or !=
always return a bool
, no matter the type of the compared object:
>>> from datetime import timedelta
>>> delta1 = timedelta(seconds=57)
>>> delta2 = timedelta(hours=25, seconds=2)
>>> delta2 != delta1
True
>>> delta2 == 5
False
For all other comparisons (such as <
and >
), when a timedelta
object is compared to an object of a different type, TypeError
is raised:
>>> 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'
In Boolean contexts, a timedelta
object is considered to be true if and only if it isn’t equal to timedelta(0)
.
Instance methods:
timedelta.
total_seconds
()
timedelta.
total_seconds
()Return the total number of seconds contained in the duration. Equivalent to td / timedelta(seconds=1)
. For interval units other than seconds, use the division form directly (e.g. td / timedelta(microseconds=1)
).
Note that for very large time intervals (greater than 270 years on most platforms) this method will lose microsecond accuracy.
New in version 3.2.
Examples of usage: timedelta
An additional example of normalization:
>>> # 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
Examples of timedelta
arithmetic:
>>> 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
Objects
A date
object represents a date (year, month and day) in an idealized calendar, the current Gregorian calendar indefinitely extended in both directions.
January 1 of year 1 is called day number 1, January 2 of year 1 is called day number 2, and so on. 2
class datetime.
date
(year, month, day)
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 <= number of days in the given month and year
If an argument outside those ranges is given, ValueError
is raised.
Other constructors, all class methods:
classmethod date.
today
()
date.
today
()Return the current local date.
This is equivalent to date.fromtimestamp(time.time())
.
classmethod date.
fromtimestamp
(timestamp)
date.
fromtimestamp
(timestamp)Return the local date corresponding to the POSIX timestamp, such as is returned by time.time()
.
This may raise OverflowError
, if the timestamp is out of the range of values supported by the platform C localtime()
function, and OSError
on localtime()
failure. It’s common for this to be restricted to years from 1970 through 2038. Note that on nonPOSIX systems that include leap seconds in their notion of a timestamp, leap seconds are ignored by fromtimestamp()
.
Changed in version 3.3: Raise OverflowError
instead of ValueError
if the timestamp is out of the range of values supported by the platform C localtime()
function. Raise OSError
instead of ValueError
on localtime()
failure.
classmethod date.
fromordinal
(ordinal)
date.
fromordinal
(ordinal)Return the date corresponding to the proleptic Gregorian ordinal, where January 1 of year 1 has ordinal 1.
ValueError
is raised unless 1 <= ordinal <= date.max.toordinal()
. For any date d, date.fromordinal(d.toordinal()) == d
.
classmethod date.
fromisoformat
(date_string)
date.
fromisoformat
(date_string)Return a date
corresponding to a date_string given in the format YYYYMMDD
:
>>> from datetime import date
>>> date.fromisoformat('20191204')
datetime.date(2019, 12, 4)
This is the inverse of date.isoformat()
. It only supports the format YYYYMMDD
.
New in version 3.7.
classmethod date.
fromisocalendar
(year, week, day)
date.
fromisocalendar
(year, week, day)Return a date
corresponding to the ISO calendar date specified by year, week and day. This is the inverse of the function date.isocalendar()
.
New in version 3.8.
Class attributes:
date.
min
date.
min
The earliest representable date, date(MINYEAR, 1, 1)
.
date.
max
date.
max
The latest representable date, date(MAXYEAR, 12, 31)
.
Aware and Naive ObjectsDate and time objects may be categorized as “aware” or “naive” ...
1520 0 1 years ago
ConstantsThe datetime module exports the following constants:
1538 0 1 years ago
datetime.MINYEARThe smallest year number allowed in a date or datetime object. MINYEAR is...
1181 0 1 years ago
datetime.MAXYEARThe largest year number allowed in a date or datetime object. MAXYEAR is ...
1577 0 1 years ago
Available Typesclass datetime.dateAn idealized naive date, assuming the current Gregorian ...
960 0 1 years ago
timedelta ObjectsA timedelta object represents a duration, the difference between two date...
904 0 1 years ago
class datetime.timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, ho...
1734 0 1 years ago
timedelta.minThe most negative timedelta object, timedelta(999999999).
1276 0 1 years ago
timedelta.maxThe most positive timedelta object, timedelta(days=999999999, hours=23, minu...
1025 0 1 years ago
timedelta.resolutionThe smallest possible difference between nonequal timedelta objects,...
1368 0 1 years ago
timedelta.total_seconds()Return the total number of seconds contained in the duration. Eq...
1358 0 1 years ago
date ObjectsA date object represents a date (year, month and day) in an idealized calendar...
1153 0 1 years ago
class datetime.date(year, month, day)All arguments are required. Arguments must be intege...
1155 0 1 years ago
classmethod date.today()Return the current local date.This is equivalent to date.fromtime...
1040 0 1 years ago
classmethod date.fromtimestamp(timestamp)Return the local date corresponding to the POSIX...
1657 0 1 years ago
classmethod date.fromordinal(ordinal)Return the date corresponding to the proleptic Grego...
1443 0 1 years ago
classmethod date.fromisoformat(date_string)Return a date corresponding to a date_string g...
1054 0 1 years ago
classmethod date.fromisocalendar(year, week, day)Return a date corresponding to the ISO c...
1513 0 1 years ago
date.minThe earliest representable date, date(MINYEAR, 1, 1).
1671 0 1 years ago
date.maxThe latest representable date, date(MAXYEAR, 12, 31).
1308 0 1 years ago