datetime --- Basic date and time types — Dokumentasi Python 3.15.2
Navigasi index modul | berikut | sebelum | Python » 3.15.2 documentation » The Python standard library » Tipe Data » datetime --- Basic date and time types | Tema | 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 Skip to the format codes . Lihat juga Modul calendar General calendar related functions. Modul time Time access and conversions. Module zoneinfo Concrete time zones representing the IANA time zone database. Package dateutil Third-party library with expanded time zone and parsing support. Package DateType Third-party library that introduces distinct static types to for example, allow static type checkers to differentiate between naive and aware datetimes.
Aware and naive objects ¶ Date and time objects may be categorized as "aware" or "naive" depending on whether or not they include time zone 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 time zone 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 time zones with fixed offsets from UTC, such as UTC itself or North American EST and EDT time zones. Supporting time zones 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. Konstanta ¶ The datetime module exports the following constants: datetime. MINYEAR ¶ The smallest year number allowed in a date or datetime object. MINYEAR is 1. datetime. MAXYEAR ¶ The largest year number allowed in a date or datetime object. MAXYEAR is 9999. datetime.
UTC ¶ Alias for the UTC time zone singleton datetime.timezone.utc . Added in version 3.11. Available types ¶ class datetime. date An idealized naive date, assuming the current Gregorian calendar always was, and always will be, in effect. Attributes: year , month , and day . class 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 . class datetime. datetime A combination of a date and a time.
Attributes: year , month , day , hour , minute , second , microsecond , and tzinfo . class datetime. timedelta A duration expressing the difference between two datetime or date instances to microsecond resolution. class 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). class datetime. timezone A class that implements the tzinfo abstract base class as a fixed offset from the UTC.
Added in version 3.2. Objects of these types are immutable. Subclass relationships: 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 d.utcoffset() does not return None . Otherwise, d is naive. A time object t is aware if t.utcoffset() does not return None . 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 datetime or date instances. class 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: >>> import datetime as dt >>> delta = dt . timedelta ( ... days = 50 , ... seconds = 27 , ... microseconds = 10 , ... milliseconds = 29000 , ... minutes = 5 , ... hours = 8 , ... weeks = 2 ... ) >>> # Only days, seconds, and microseconds remain >>> delta datetime.timedelta(days=64, seconds=29156, microseconds=10) Tip import datetime as dt instead of import datetime or from datetime import datetime to avoid confusion between the module and the class.
See How I Import Python’s datetime Module . 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 round-half-to-even 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: >>> import datetime as dt >>> d = dt . timedelta ( microseconds =- 1 ) >>> ( d . days , d . seconds , d . microseconds ) (-1, 86399, 999999) Since the string representation of timedelta objects can be confusing, use the following recipe to produce a more readable format: >>> def pretty_timedelta ( td ): ... if td . days >= 0 : ... return str ( td ) ... return f '-( { - td !s} )' ... >>> d = timedelta ( hours =- 1 ) >>> str ( d ) # not human-friendly '-1 day, 23:00:00' >>> pretty_timedelta ( d ) '-(1:00:00)' Class attributes: timedelta. min ¶ The most negative timedelta object, timedelta(-999999999) . timedelta. max ¶ The most positive timedelta object, timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999) . timedelta. resolution ¶ The smallest possible difference between non-equal timedelta objects, timedelta(microseconds=1) .
Note that, because of normalization, timedelta.max is greater than -timedelta.min . -timedelta.max is not representable as a timedelta object. Instance attributes (read-only): timedelta. days ¶ Between -999,999,999 and 999,999,999 inclusive. timedelta. sec
The rest of this page is on the live site.