`datetime` — Grundläggande datum- och tidstyper¶

Modulen datetime innehåller klasser för manipulering av datum och tid.

Även om aritmetik för datum och tid stöds ligger fokus i implementeringen på effektiv attributextraktion för formatering och hantering av utdata.

Tips

Hoppa till formatkoderna.

Se även

Modul kalender: Allmänna kalenderrelaterade funktioner.
Modul tid: Tidstillgång och konverteringar.
Modul zoneinfo: Konkreta tidszoner som representerar IANA:s tidszonsdatabas.
Paketet dateutil: Tredjepartsbibliotek med utökat stöd för tidszoner och parsning.
Paket DateType: Tredjepartsbibliotek som introducerar distinkta statiska typer för att t.ex. tillåta static type checkers att skilja mellan naiva och medvetna datatider.

Medvetna och naiva objekt¶

Datum- och tidsobjekt kan kategoriseras som ”medvetna” eller ”naiva” beroende på om de innehåller tidszoninformation eller inte.

Med tillräcklig kunskap om tillämpliga algoritmiska och politiska tidsjusteringar, t.ex. information om tidszoner och sommartid, kan ett medvetet objekt lokalisera sig självt i förhållande till andra medvetna objekt. Ett medvetet objekt representerar ett specifikt ögonblick i tiden som inte är öppet för tolkning. [1]

Ett naivt objekt innehåller inte tillräckligt med information för att entydigt lokalisera sig själv i förhållande till andra datum-/tidsobjekt. Det är helt upp till programmet att avgöra om ett naivt objekt representerar UTC (Coordinated Universal Time), lokal tid eller tid i någon annan tidszon, precis som det är upp till programmet att avgöra om ett visst tal representerar meter, miles eller massa. Naiva objekt är lätta att förstå och arbeta med, men till priset av att de ignorerar vissa aspekter av verkligheten.

För tillämpningar som kräver medvetna objekt har objekten datetime och time ett valfritt attribut för tidszonsinformation, tzinfo, som kan sättas till en instans av en underklass av den abstrakta klassen tzinfo. Dessa tzinfo-objekt innehåller information om förskjutningen från UTC-tiden, tidszonens namn och om sommartid gäller.

Endast en konkret tzinfo-klass, timezone-klassen, tillhandahålls av datetime-modulen. Klassen timezone kan representera enkla tidszoner med fasta förskjutningar från UTC, t.ex. UTC själv eller nordamerikanska EST- och EDT-tidszoner. Stöd för tidszoner på djupare detaljnivåer är upp till applikationen. Reglerna för tidsjustering över hela världen är mer politiska än rationella, ändras ofta och det finns ingen standard som är lämplig för alla tillämpningar förutom UTC.

Konstanter¶

Modulen datetime exporterar följande konstanter:

datetime.MINYEAR¶: Det minsta tillåtna årtalet i ett date- eller datetime-objekt. MINYEAR är 1.

datetime.MAXYEAR¶: Det största tillåtna årtalet i ett date- eller datetime-objekt. MAXYEAR är 9999.

datetime.UTC¶: Alias för UTC-tidszonens singleton datetime.timezone.utc.

Tillagd i version 3.11.

Tillgängliga typer¶

class datetime.date: Ett idealiserat naivt datum som utgår från att den nuvarande gregorianska kalendern alltid har gällt och alltid kommer att gälla. Attribut: year, month, och day.

class datetime.time: En idealiserad tid, oberoende av en viss dag, under antagandet att varje dag har exakt 24*60*60 sekunder. (Det finns ingen uppfattning om ”skottsekunder” här.) Attribut: hour, minute, second, microsecond och tzinfo.

class datetime.datetime: En kombination av ett datum och en tid. Attribut: year, month, day, hour, minute, second, microsecond och tzinfo.

class datetime.timedelta: En varaktighet som uttrycker skillnaden mellan två datetime- eller date-instanser med mikrosekunders upplösning.

class datetime.tzinfo: En abstrakt basklass för objekt med information om tidszoner. Dessa används av klasserna datetime och time för att ge en anpassningsbar uppfattning om tidsjustering (t.ex. för att ta hänsyn till tidszon och/eller sommartid).

class datetime.timezone: En klass som implementerar den abstrakta basklassen tzinfo som en fast förskjutning från UTC.

Tillagd i version 3.2.

Objekt av dessa typer är oföränderliga.

Relationer mellan underklasser:

objekt
    timedelta
    tzinfo
        tidszon
    tid
    datum
        datatid

Gemensamma egenskaper¶

Typerna date, datetime, time och timezone har dessa gemensamma egenskaper:

Objekt av dessa typer är oföränderliga.
Objekt av dessa typer är hashable, vilket innebär att de kan användas som nycklar i en ordbok.
Objekt av dessa typer stöder effektiv pickling via modulen pickle.

Avgöra om ett objekt är medvetet eller naivt¶

Objekt av typen date är alltid naiva.

Ett objekt av typen time eller datetime kan vara medvetet eller naivt.

Ett datetime-objekt d är medvetet om båda följande gäller:

d.tzinfo är inte None
d.tzinfo.utcoffset(d) returnerar inte None

Annars är d naivt.

Ett time-objekt t är medvetet om båda följande villkor är uppfyllda:

t.tzinfo är inte None
t.tzinfo.utcoffset(None) returnerar inte None.

Annars är t naivt.

Skillnaden mellan medveten och naiv gäller inte för timedelta-objekt.

`timedelta` Objekt¶

Ett timedelta-objekt representerar en varaktighet, skillnaden mellan två datetime- eller date-instanser.

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

Alla argument är valfria och är som standard 0. Argumenten kan vara heltal eller flyttal och kan vara positiva eller negativa.

Endast dagar, sekunder och mikrosekunder lagras internt. Argument konverteras till dessa enheter:

En millisekund omvandlas till 1000 mikrosekunder.
En minut omvandlas till 60 sekunder.
En timme omvandlas till 3600 sekunder.
En vecka omvandlas till 7 dagar.

och dagar, sekunder och mikrosekunder normaliseras sedan så att representationen blir unik, med

0 <= microseconds < 1000000
0 <= sekunder < 3600*24 (antalet sekunder på en dag)
-999999999 <= days <= 999999999

Följande exempel illustrerar hur alla argument utöver dagar, sekunder och mikrosekunder ”slås samman” och normaliseras till dessa tre resulterande attribut:

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

Om något argument är en float och det finns bråkdelar av mikrosekunder, kombineras de bråkdelar av mikrosekunder som återstår från alla argument och summan avrundas till närmaste mikrosekund med hjälp av tiebreakermetoden ”round-half-to-even”. Om inget argument är en float är omvandlings- och normaliseringsprocesserna exakta (ingen information går förlorad).

Om det normaliserade värdet av dagar ligger utanför det angivna intervallet, OverflowError.

Observera att normalisering av negativa värden kan vara överraskande till en början. Till exempel:

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

Eftersom strängrepresentationen av timedelta-objekt kan vara förvirrande, kan du använda följande recept för att producera ett mer läsbart 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)'

Klassens attribut:

timedelta.min¶: Det mest negativa timedelta-objektet, timedelta(-999999999).

timedelta.max¶: Det mest positiva timedelta-objektet, timedelta(days=999999999, hours=23, minutes=59, seconds=59, microseconds=999999).

timedelta.resolution¶: Den minsta möjliga skillnaden mellan icke jämlika timedelta-objekt, timedelta(microseconds=1).

Observera att på grund av normaliseringen är timedelta.max större än -timedelta.min. -timedelta.max är inte representerbar som ett timedelta-objekt.

Instansattribut (skrivskyddad):

timedelta.days¶: Mellan -999,999,999 och 999,999,999 inklusive.

timedelta.seconds¶

Mellan 0 och 86.399 inklusive.

Försiktighet

Det är ett ganska vanligt fel att kod oavsiktligt använder detta attribut när det egentligen är avsett att få ett total_seconds()-värde istället:

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

timedelta.microseconds¶: Mellan 0 och 999.999 inklusive.

Operationer som stöds:

Operation	Resultat
`t1 = t2 + t3`	Summan av `t2` och `t3`. Efteråt är `t1 - t2 == t3` och `t1 - t3 == t2` sanna. (1)
`t1 = t2 - t3`	Skillnad mellan `t2` och `t3`. Efteråt är `t1 == t2 - t3` och `t2 == t1 + t3` sanna. (1)(6)
`t1 = t2 * i eller t1 = i * t2`	Delta multiplicerat med ett heltal. Efteråt är `t1 // i == t2` sant, förutsatt att `i != 0`.
	I allmänhet är `t1 * i == t1 * (i-1) + t1` sant. (1)
`t1 = t2 * f eller t1 = f * t2`	Delta multiplicerat med ett flyttal. Resultatet avrundas till närmaste multipel av timedelta.resolution med hjälp av round-half-to-even.
`f = t2 / t3`	Division (3) av total varaktighet `t2` med intervallenhet `t3`. Returnerar ett `float`-objekt.
`t1 = t2 / f eller t1 = t2 / i`	Delta dividerat med en float eller en int. Resultatet avrundas till närmaste multipel av timedelta.resolution med hjälp av round-half-to-even.
`t1 = t2 // i` eller `t1 = t2 // t3`	Golvet beräknas och återstoden (om någon) kastas bort. I det andra fallet returneras ett heltal. (3)
`t1 = t2 % t3`	Återstoden beräknas som ett `timedelta`-objekt. (3)
`q, r = divmod(t1, t2)`	Beräknar kvoten och resten: `q = t1 // t2` (3) och `r = t1 % t2`. `q` är ett heltal och `r` är ett `timedelta`-objekt.
`+t1`	Returnerar ett `timedelta`-objekt med samma värde. (2)
`-t1`	Motsvarar `timedelta(-t1.days, -t1.seconds, -t1.microseconds)`, och `t1 * -1`. (1)(4)
`abs(t)`	Motsvarar `+t` när `t.days >= 0`, och `-t` när `t.days < 0`. (2)
`str(t)`	Returnerar en sträng i formen `[D dag[ar], ][H]H:MM:SS[.UUUUUU]`, där D är negativ för negativ `t`. (5)
`repr(t)`	Returnerar en strängrepresentation av `timedelta`-objektet som ett anrop från konstruktören med kanoniska attributvärden.

Anteckningar:

Detta är exakt men kan överfyllas.
Detta är exakt och kan inte rinna över.
Division med noll ger upphov till ZeroDivisionError.
-timedelta.max kan inte representeras som ett timedelta-objekt.
Strängrepresentationer av timedelta-objekt normaliseras på samma sätt som deras interna representation. Detta leder till något ovanliga resultat för negativa timedelta. Till exempel:
```
>>> timedelta(hours=-5)
datetime.timedelta(days=-1, seconds=68400)
>>> print(_)
-1 day, 19:00:00
```
Uttrycket t2 - t3 kommer alltid att vara lika med uttrycket t2 + (-t3) utom när t3 är lika med timedelta.max; i så fall kommer det förra att ge ett resultat medan det senare kommer att överskridas.

Förutom de operationer som anges ovan stöder timedelta-objekt vissa additioner och subtraktioner med date- och datetime-objekt (se nedan).

Ändrad i version 3.2: Floor division och true division av ett timedelta-objekt med ett annat timedelta-objekt stöds nu, liksom restoperationer och funktionen divmod(). Sann division och multiplikation av ett timedelta-objekt med ett float-objekt stöds nu.

timedelta-objekt stöder jämlikhets- och ordningsjämförelser.

I booleska sammanhang anses ett timedelta-objekt vara sant om och endast om det inte är lika med timedelta(0).

Instansmetoder:

timedelta.total_seconds()¶

Returnerar det totala antalet sekunder som ingår i varaktigheten. Motsvarar td / timedelta(sekunder=1). För andra intervallenheter än sekunder, använd divisionsformen direkt (t.ex. td / timedelta(microseconds=1)).

Observera att för mycket stora tidsintervall (större än 270 år på de flesta plattformar) kommer denna metod att förlora mikrosekundsnoggrannhet.

Tillagd i version 3.2.

Exempel på användning: `timedelta`¶

Ytterligare ett exempel på normalisering:

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

Exempel på aritmetik för 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)

`datum` Objekt¶

Ett date-objekt representerar ett datum (år, månad och dag) i en idealiserad kalender, den nuvarande gregorianska kalendern som är obegränsat förlängd i båda riktningarna.

Den 1 januari år 1 kallas dag nummer 1, den 2 januari år 1 kallas dag nummer 2, och så vidare. [2]

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

Alla argument är obligatoriska. Argumenten måste vara heltal inom följande intervall:

MINYEAR <= år <= MAXYEAR
1 <= month <= 12
1 <= dag <= antal dagar i den angivna månaden och året

Om ett argument utanför dessa intervall anges, kommer ValueError att tas upp.

Övriga konstruktörer, alla klassmetoder:

classmethod date.today()¶

Returnera aktuellt lokalt datum.

Detta är likvärdigt med date.fromtimestamp(time.time()).

classmethod date.fromtimestamp(timestamp)¶

Returnerar det lokala datumet som motsvarar POSIX-tidstämpeln, såsom det returneras av time.time().

Detta kan ge upphov till OverflowError, om tidsstämpeln ligger utanför det värdeintervall som stöds av plattform C localtime()-funktionen, och OSError om localtime() misslyckas. Det är vanligt att detta begränsas till år från 1970 till 2038. Observera att på icke-POSIX-system som inkluderar skottsekunder i sin uppfattning om en tidsstämpel, ignoreras skottsekunder av fromtimestamp().

Ändrad i version 3.3: Utlös OverflowError istället för ValueError om tidsstämpeln ligger utanför det värdeintervall som stöds av plattform C localtime()-funktionen. Skapa OSError istället för ValueError om localtime() misslyckas.

classmethod date.fromordinal(ordinal)¶

Returnera datumet som motsvarar den proleptiska gregorianska ordinalen, där 1 januari år 1 har ordinal 1.

ValueError uppstår om inte 1 <= ordinal <= date.max.toordinal(). För varje datum d, date.fromordinal(d.toordinal()) == d.

classmethod date.fromisoformat(date_string)¶

Returnerar ett date som motsvarar en date_string som anges i valfritt giltigt ISO 8601-format, med följande undantag:

Datum med reducerad precision stöds inte för närvarande (YYYY-MM, YYYY).
Utökade datumrepresentationer stöds inte för närvarande (±YYYYYY-MM-DD).
Ordinarie datum stöds inte för närvarande (YYYY-OOO).

Exempel:

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

Tillagd i version 3.7.

Ändrad i version 3.11: Tidigare stödde denna metod endast formatet ”YYYYY-MM-DD”.

classmethod date.fromisocalendar(year, week, day)¶: Returnerar ett date som motsvarar det ISO-kalenderdatum som anges med år, vecka och dag. Detta är inversen av funktionen date.isocalendar().

Tillagd i version 3.8.

classmethod date.strptime(date_string, format)¶

Returnerar en date som motsvarar date_string, tolkad enligt format. Detta är likvärdigt med:

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

ValueError uppstår om datumsträngen och formatet inte kan tolkas av time.strptime() eller om det returnerar ett värde som inte är en tidstupel. Se även strftime() och strptime() Behavior och date.fromisoformat().

Anteckning

Om format anger en dag eller månad utan årtal kommer en DeprecationWarning att skickas ut. Detta för att undvika en bugg för skottår i kod som försöker tolka endast en månad och dag eftersom standardåret som används om det inte finns något i formatet inte är ett skottår. Sådana format-värden kan ge upphov till ett fel från och med Python 3.15. Lösningen är att alltid inkludera ett år i ditt format. Om du analyserar date_string-värden som inte har ett år, lägg uttryckligen till ett år som är ett skottår innan du analyserar:

>>> from datetime import date
>>> date_string = "02/29"
>>> when = date.strptime(f"{date_string};1984", "%m/%d;%Y")  # Avoids leap year bug.
>>> when.strftime("%B %d")
'February 29'

Tillagd i version 3.14.

Klassens attribut:

date.min¶: Det tidigaste representerbara datumet, date(MINYEAR, 1, 1).

date.max¶: Det senaste representerbara datumet, date(MAXYEAR, 12, 31).

date.resolution¶: Den minsta möjliga skillnaden mellan datumobjekt som inte är lika, timedelta(days=1).

Instansattribut (skrivskyddad):

date.year¶: Mellan MINYEAR och MAXYEAR inklusive.

date.month¶: Mellan 1 och 12 inklusive.

date.day¶: Mellan 1 och antalet dagar i den givna månaden i det givna året.

Operationer som stöds:

Operation	Resultat
`datum2 = datum1 + timedelta`	`date2` kommer att vara `timedelta.days` dagar efter `date1`. (1)
`date2 = date1 - timedelta`	Beräknar `date2` så att `date2 + timedelta == date1`. (2)
`timedelta = date1 - date2`	(3)
`datum1 == datum2` `datum1 != datum2`	Jämförelse av jämlikhet. (4)
`datum1 < datum2` `datum1 > datum2` `datum1 <= datum2` `datum1 >= datum2`	Jämförelse av order. (5)

Anteckningar:

date2 flyttas framåt i tiden om timedelta.days > 0, eller bakåt om timedelta.days < 0. Därefter date2 - date1 == timedelta.days. timedelta.seconds och timedelta.microseconds ignoreras. OverflowError` uppstår om date2.year skulle vara mindre än MINYEAR` eller större än MAXYEAR.
timedelta.seconds och timedelta.microseconds ignoreras.
Detta är exakt och kan inte överskridas. timedelta.seconds och timedelta.microseconds är 0, och date2 + timedelta == date1 efter.
date-objekt är lika om de representerar samma datum.

date-objekt som inte också är datetime-instanser är aldrig lika med datetime-objekt, även om de representerar samma datum.
date1 anses vara mindre än date2 när date1 föregår date2 i tid. Med andra ord, datum1 < datum2 om och endast om datum1.toordinal() < datum2.toordinal().

Orderjämförelse mellan ett date-objekt som inte också är en datetime-instans och ett datetime-objekt ger upphov till TypeError.

Ändrad i version 3.13: Jämförelse mellan datetime-objekt och en instans av underklassen date som inte är en underklass till datetime konverterar inte längre den senare till date, utan att ta hänsyn till tidsdelen och tidszonen. Standardbeteendet kan ändras genom att åsidosätta de speciella jämförelsemetoderna i underklasser.

I booleska kontexter anses alla date-objekt vara sanna.

Instansmetoder:

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

Returnerar ett nytt date-objekt med samma värden, men med angivna parametrar uppdaterade.

Exempel:

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

Den generiska funktionen copy.replace() stöder även date-objekt.

date.timetuple()¶

Returnerar en time.struct_time såsom den som returneras av time.localtime().

Timmar, minuter och sekunder är 0 och DST-flaggan är -1.

d.timetuple() är likvärdigt med:

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

där yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 är dagsnumret inom det aktuella året med början med 1 för 1 januari.

date.toordinal()¶: Returnerar den proleptiska gregorianska ordinalen för datumet, där 1 januari år 1 har ordinal 1. För varje date-objekt d, date.fromordinal(d.toordinal()) == d.

date.weekday()¶: Returnerar veckodagen som ett heltal, där måndag är 0 och söndag är 6. Till exempel, date(2002, 12, 4).weekday() == 2, en onsdag. Se även isoweekday().

date.isoweekday()¶: Returnerar veckodagen som ett heltal, där måndag är 1 och söndag är 7. Till exempel, date(2002, 12, 4).isoweekday() == 3, en onsdag. Se även weekday(), isocalendar().

date.isocalendar()¶

Returnerar ett named tuple-objekt med tre komponenter: year, week och weekday.

ISO-kalendern är en allmänt använd variant av den gregorianska kalendern. [3]

ISO-året består av 52 eller 53 hela veckor, och där en vecka börjar på en måndag och slutar på en söndag. Den första veckan i ett ISO-år är den första (gregorianska) kalenderveckan i ett år som innehåller en torsdag. Detta kallas vecka nummer 1, och ISO-året för den torsdagen är detsamma som dess gregorianska år.

Till exempel börjar 2004 på en torsdag, så den första veckan i ISO-året 2004 börjar måndagen den 29 december 2003 och slutar söndagen den 4 januari 2004:

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

Ändrad i version 3.9: Resultatet ändrades från en tuple till en named tuple.

date.isoformat()¶

Returnerar en sträng som representerar datumet i ISO 8601-format, YYYY-MM-DD:

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

date.__str__()¶: För ett datum d är str(d) likvärdigt med d.isoformat().

date.ctime()¶

Returnerar en sträng som representerar datumet:

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

d.ctime() är likvärdigt med:

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

på plattformar där den inbyggda C-funktionen ctime() (som time.ctime() åberopar, men som date.ctime() inte åberopar) överensstämmer med C-standarden.

date.strftime(format)¶: Returnerar en sträng som representerar datumet, styrd av en explicit formatsträng. Formatkoder som hänvisar till timmar, minuter eller sekunder får 0 värden. Se även strftime() och strptime() Behavior och date.isoformat().

date.__format__(format)¶: Samma som date.strftime(). Detta gör det möjligt att ange en formatsträng för ett date-objekt i formatted string literals och när man använder str.format(). Se även strftime() och strptime() Behavior och date.isoformat().

Exempel på användning: `date`¶

Exempel på att räkna dagar till en händelse:

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

Fler exempel på att arbeta med 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` Objekt¶

Ett datetime-objekt är ett enda objekt som innehåller all information från ett date-objekt och ett time-objekt.

Liksom ett date-objekt förutsätter datetime att den aktuella gregorianska kalendern är förlängd i båda riktningarna; liksom ett time-objekt förutsätter datetime att det finns exakt 3600*24 sekunder varje dag.

Konstruktör:

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

Argumenten year, month och day är obligatoriska. tzinfo kan vara None, eller en instans av en tzinfo-underklass. De återstående argumenten måste vara heltal inom följande intervall:

MINYEAR <= år <= MAXYEAR,
1 <= månad <= 12,
1 <= dag <= antal dagar i den angivna månaden och året,
0 <= timme < 24,
0 <= minut < 60,
0 <= sekund < 60,
0 <= mikrosekund < 1000000,
veck i [0, 1].

Om ett argument utanför dessa intervall anges, kommer ValueError att tas upp.

Ändrad i version 3.6: Lagt till parametern fold.

Övriga konstruktörer, alla klassmetoder:

classmethod datetime.today()¶

Returnerar aktuellt lokalt datum och tid, med tzinfo None.

Motsvarar:

datetime.fromtimestamp(time.time())

Se även now(), fromtimestamp().

Denna metod är funktionellt likvärdig med now(), men utan parametern tz.

classmethod datetime.now(tz=None)¶

Återge aktuellt lokalt datum och lokal tid.

Om det valfria argumentet tz är None eller inte anges, är detta som today(), men ger om möjligt mer precision än vad som kan erhållas genom att gå igenom en time.time()-tidsstämpel (detta kan till exempel vara möjligt på plattformar som tillhandahåller C gettimeofday()-funktionen).

Om tz inte är None måste det vara en instans av en tzinfo-underklass, och aktuellt datum och aktuell tid konverteras till tz:s tidszon.

Denna funktion är att föredra framför today() och utcnow().

Anteckning

Efterföljande anrop till datetime.now() kan returnera samma ögonblick beroende på precisionen i den underliggande klockan.

classmethod datetime.utcnow()¶

Returnerar aktuellt UTC-datum och UTC-tid, med tzinfo None.

Detta är som now(), men returnerar aktuellt UTC-datum och tid, som ett naivt datetime-objekt. En medveten aktuell UTC-datatid kan erhållas genom att anropa datetime.now(timezone.utc). Se även now().

Varning

Eftersom naiva datetime-objekt behandlas av många datetime-metoder som lokal tid, är det att föredra att använda medvetna datetimes för att representera tider i UTC. Det rekommenderade sättet att skapa ett objekt som representerar aktuell tid i UTC är därför att anropa datetime.now(timezone.utc).

Föråldrad sedan version 3.12: Använd datetime.now() med UTC istället.

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

Returnerar det lokala datumet och tiden som motsvarar POSIX-tidstämpeln, såsom den returneras av time.time(). Om det valfria argumentet tz är None eller inte anges, konverteras tidsmarkören till plattformens lokala datum och tid och det returnerade datetime-objektet är naivt.

Om tz inte är None måste det vara en instans av en tzinfo-underklass, och tidsstämpeln konverteras till tz:s tidszon.

fromtimestamp() kan ge upphov till OverflowError, om tidsstämpeln är utanför det värdeintervall som stöds av plattformens C-funktioner localtime() eller gmtime(), och OSError om localtime() eller gmtime() misslyckas. Det är vanligt att detta begränsas till år 1970 till och med 2038. Observera att på icke-POSIX-system som inkluderar skottsekunder i sin uppfattning av en tidsstämpel, ignoreras skottsekunder av fromtimestamp(), och då är det möjligt att ha två tidsstämplar som skiljer sig med en sekund som ger identiska datetime-objekt. Denna metod är att föredra framför utcfromtimestamp().

Ändrad i version 3.3: Skapa OverflowError istället för ValueError om tidsstämpeln ligger utanför det värdeintervall som stöds av plattform C-funktionerna localtime() eller gmtime(). Skapa OSError istället för ValueError om localtime() eller gmtime() misslyckas.

Ändrad i version 3.6: fromtimestamp() kan returnera instanser med fold satt till 1.

classmethod datetime.utcfromtimestamp(timestamp)¶

Returnerar UTC datetime motsvarande POSIX-tidsstämpeln, med tzinfo None. (Det resulterande objektet är naivt.)

Detta kan ge upphov till OverflowError, om tidsstämpeln ligger utanför det värdeintervall som stöds av plattform C gmtime()-funktionen, och OSError om gmtime() misslyckas. Det är vanligt att detta är begränsat till år 1970 till 2038.

För att få ett medvetet datetime-objekt, anropa fromtimestamp():

datetime.fromtimestamp(timestamp, tidszon.utc)

På POSIX-kompatibla plattformar är det likvärdigt med följande uttryck:

datetime(1970, 1, 1, tzinfo=tidszon.utc) + timedelta(sekunder=tidstämpel)

förutom att den senare formeln alltid stöder hela årsintervallet: mellan MINYEAR och MAXYEAR inklusive.

Varning

Eftersom naiva datetime-objekt behandlas av många datetime-metoder som lokal tid, är det att föredra att använda medvetna datetimes för att representera tider i UTC. Det rekommenderade sättet att skapa ett objekt som representerar en specifik tidsstämpel i UTC är därför att anropa datetime.fromtimestamp(timestamp, tz=timezone.utc).

Ändrad i version 3.3: Utlös OverflowError istället för ValueError om tidsstämpeln ligger utanför det värdeintervall som stöds av plattform C gmtime()-funktionen. Skapa OSError istället för ValueError om gmtime() misslyckas.

Föråldrad sedan version 3.12: Använd datetime.fromtimestamp() med UTC istället.

classmethod datetime.fromordinal(ordinal)¶: Returnerar datetime motsvarande den proleptiska gregorianska ordinalen, där 1 januari år 1 har ordinal 1. ValueError uppstår om inte 1 <= ordinal <= datetime.max.toordinal(). Timmen, minuten, sekunden och mikrosekunden i resultatet är alla 0, och tzinfo är None.

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

Returnerar ett nytt datetime-objekt vars datumkomponenter är lika med det givna date-objektets och vars tidskomponenter är lika med det givna time-objektets. Om argumentet tzinfo anges används dess värde för att ange attributet tzinfo för resultatet, annars används attributet tzinfo för argumentet time. Om date-argumentet är ett datetime-objekt ignoreras dess tidskomponenter och tzinfo-attribut.

För varje datetime-objekt d, d == datetime.combine(d.date(), d.time(), d.tzinfo).

Ändrad i version 3.6: Lagt till argumentet tzinfo.

classmethod datetime.fromisoformat(date_string)¶

Returnera en datetime som motsvarar en date_string i valfritt giltigt ISO 8601-format, med följande undantag:

Tidszonsförskjutningar kan ha bråkdelar av sekunder.
Avgränsaren T kan ersättas med valfritt unicode-tecken.
Bråkdelar av timmar och minuter stöds inte.
Datum med reducerad precision stöds inte för närvarande (YYYY-MM, YYYY).
Utökade datumrepresentationer stöds inte för närvarande (±YYYYYY-MM-DD).
Ordinarie datum stöds inte för närvarande (YYYY-OOO).

Exempel:

>>> from datetime import datetime
>>> datetime.fromisoformat('2011-11-04')
datetime.datetime(2011, 11, 4, 0, 0)
>>> datetime.fromisoformat('20111104')
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-04T00:05:23Z')
datetime.datetime(2011, 11, 4, 0, 5, 23, tzinfo=datetime.timezone.utc)
>>> datetime.fromisoformat('20111104T000523')
datetime.datetime(2011, 11, 4, 0, 5, 23)
>>> datetime.fromisoformat('2011-W01-2T00:05:23.283')
datetime.datetime(2011, 1, 4, 0, 5, 23, 283000)
>>> 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)))

Tillagd i version 3.7.

Ändrad i version 3.11: Tidigare stödde den här metoden endast format som kunde anges av date.isoformat() eller datetime.isoformat().

classmethod datetime.fromisocalendar(year, week, day)¶: Returnerar en datetime som motsvarar ISO-kalenderdatumet specificerat med år, vecka och dag. De komponenter i datetime som inte är datum fylls i med sina normala standardvärden. Detta är inversen av funktionen datetime.isocalendar().

Tillagd i version 3.8.

classmethod datetime.strptime(date_string, format)¶

Returnerar en datetime som motsvarar date_string, tolkad enligt format.

Om format inte innehåller mikrosekunder eller information om tidszon motsvarar detta:

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

ValueError uppstår om datumsträngen och formatet inte kan tolkas av time.strptime() eller om det returnerar ett värde som inte är en tidstupel. Se även strftime() och strptime() Behavior och datetime.fromisoformat().

Ändrad i version 3.13: Om format anger en dag eller månad utan årtal skickas nu en DeprecationWarning ut. Detta för att undvika en bugg för skottår i kod som försöker tolka endast en månad och dag eftersom standardåret som används om det inte finns något i formatet inte är ett skottår. Sådana format-värden kan ge upphov till ett fel från och med Python 3.15. Lösningen är att alltid inkludera ett år i ditt format. Om du analyserar date_string-värden som inte har ett år, lägg uttryckligen till ett år som är ett skottår innan du analyserar:

>>> from datetime import datetime
>>> date_string = "02/29"
>>> when = datetime.strptime(f"{date_string};1984", "%m/%d;%Y")  # Avoids leap year bug.
>>> when.strftime("%B %d")
'February 29'

Klassens attribut:

datetime.min¶: Den tidigaste representerbara datetime, datetime(MINYEAR, 1, 1, tzinfo=None).

datetime.max¶: Den senaste representerbara datetime, datetime(MAXYEAR, 12, 31, 23, 59, 59, 999999, tzinfo=None).

datetime.resolution¶: Den minsta möjliga skillnaden mellan icke lika datetime-objekt, timedelta(microseconds=1).

Instansattribut (skrivskyddad):

datetime.year¶: Mellan MINYEAR och MAXYEAR inklusive.

datetime.month¶: Mellan 1 och 12 inklusive.

datetime.day¶: Mellan 1 och antalet dagar i den givna månaden i det givna året.

datetime.hour¶: I range(24).

datetime.minute¶: I range(60).

datetime.second¶: I range(60).

datetime.microsecond¶: I intervall(1000000).

datetime.tzinfo¶: Det objekt som skickades som tzinfo-argument till datetime-konstruktören, eller None om inget skickades.

datetime.fold¶: I [0, 1]. Används för att särskilja väggtider under ett upprepat intervall. (Ett upprepat intervall inträffar när klockorna ställs tillbaka i slutet av sommartiden eller när UTC-offset för den aktuella zonen minskas av politiska skäl) Värdena 0 och 1 representerar den tidigare respektive den senare av de två tidpunkterna med samma väggtidsrepresentation.

Tillagd i version 3.6.

Operationer som stöds:

Operation	Resultat
`datetime2 = datetime1 + timedelta`	(1)
`datetime2 = datetime1 - timedelta`	(2)
`timedelta = datetime1 - datetime2`	(3)
`datetime1 == datetime2` `datetime1 != datetime2`	Jämförelse av jämlikhet. (4)
`datetime1 < datetime2` `datetime1 > datetime2` `datetime1 <= datetime2` `datetime1 >= datetime2`	Jämförelse av order. (5)

datetime2 är en varaktighet av timedelta borttagen från datetime1, som rör sig framåt i tiden om timedelta.days > 0, eller bakåt om timedelta.days < 0. Resultatet har samma tzinfo-attribut som den ingående datatiden, och datetime2 - datetime1 == timedelta efter. OverflowError uppstår om datetime2.year skulle vara mindre än MINYEAR` eller större än MAXYEAR`. Observera att inga tidszonsjusteringar görs även om indata är ett aware-objekt.
Beräknar datetime2 så att datetime2 + timedelta == datetime1. När det gäller tillägg har resultatet samma tzinfo-attribut som den ingående datatiden, och inga tidszonjusteringar görs även om den ingående datatiden är medveten.
Subtraktion av en datetime från en datetime definieras endast om båda operanderna är naiva, eller om båda är medvetna. Om en är medveten och den andra är naiv, uppstår TypeError.

Om båda är naiva, eller båda är medvetna och har samma tzinfo-attribut, ignoreras tzinfo-attributen och resultatet är ett timedelta-objekt t så att datetime2 + t == datetime1. Inga tidszonjusteringar görs i det här fallet.

Om båda är medvetna och har olika tzinfo-attribut, fungerar a-b som om a och b först konverterades till naiva UTC-datatider. Resultatet är (a.replace(tzinfo=None) - a.utcoffset()) - (b.replace(tzinfo=None) - b.utcoffset()) förutom att implementationen aldrig överflödar.
datetime-objekt är lika om de representerar samma datum och tid, med hänsyn tagen till tidszonen.

Naivt och medvetet datetime-objekt är aldrig lika.

Om båda jämförelseobjekten är medvetna och har samma attribut tzinfo, ignoreras attributen tzinfo och fold och basdatumen jämförs. Om båda jämförelseobjekten är medvetna och har olika tzinfo-attribut, fungerar jämförelsen som om jämförelseobjekten först konverterades till UTC-datatider, förutom att implementationen aldrig överflödar. datetime-instanser i ett upprepat intervall är aldrig lika med datetime-instanser i en annan tidszon.
datetime1 anses vara kortare än datetime2 när datetime1 föregår datetime2 i tid, med hänsyn tagen till tidszonen.

Orderjämförelse mellan naiva och medvetna datetime-objekt ger upphov till TypeError.

Om båda jämförelseobjekten är medvetna och har samma attribut tzinfo, ignoreras attributen tzinfo och fold och basdatumen jämförs. Om båda jämförelseobjekten är medvetna och har olika tzinfo-attribut, fungerar jämförelsen som om jämförelseobjekten först konverterades till UTC-datatider, förutom att implementationen aldrig överflödar.

Ändrad i version 3.3: Jämlikhetsjämförelser mellan medvetna och naiva datetime-instanser ger inte upphov till TypeError.

Ändrad i version 3.13: Jämförelse mellan datetime-objekt och en instans av underklassen date som inte är en underklass till datetime konverterar inte längre den senare till date, utan att ta hänsyn till tidsdelen och tidszonen. Standardbeteendet kan ändras genom att åsidosätta de speciella jämförelsemetoderna i underklasser.

Instansmetoder:

datetime.date()¶: Returnerar date-objekt med samma år, månad och dag.

datetime.time()¶: Returnerar time-objekt med samma timme, minut, sekund, mikrosekund och vikning. tzinfo är None. Se även metod timetz().

Ändrad i version 3.6: Fold-värdet kopieras till det returnerade time-objektet.

datetime.timetz()¶: Returnerar time-objekt med samma tim-, minut-, sekund-, mikrosekund-, fold- och tzinfo-attribut. Se även metoden time().

Ändrad i version 3.6: Fold-värdet kopieras till det returnerade time-objektet.

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

Returnerar ett nytt datetime-objekt med samma attribut, men med angivna parametrar uppdaterade. Observera att tzinfo=None kan anges för att skapa en naiv datatid från en medveten datatid utan konvertering av datum- och tidsdata.

datetime-objekt stöds också av den generiska funktionen copy.replace().

Ändrad i version 3.6: Lagt till parametern fold.

datetime.astimezone(tz=None)¶

Returnerar ett datetime-objekt med det nya tzinfo-attributet tz, som justerar datum- och tidsdata så att resultatet är samma UTC-tid som self, men i tz:s lokala tid.

Om tz anges måste den vara en instans av en underklass till tzinfo, och dess metoder utcoffset() och dst() får inte returnera None. Om self är naiv, antas den representera tiden i systemets tidszon.

Om den anropas utan argument (eller med tz=None) antas systemets lokala tidszon för måltidszonen. Attributet .tzinfo för den konverterade datetime-instansen kommer att sättas till en instans av timezone med zonnamnet och offset som erhållits från operativsystemet.

Om self.tzinfo är tz, är self.astimezone(tz) lika med self: ingen justering av datum- eller tidsdata utförs. Annars är resultatet lokal tid i tidszonen tz, som representerar samma UTC-tid som self: efter astz = dt.astimezone(tz) kommer astz - astz.utcoffset() att ha samma datum- och tidsdata som dt - dt.utcoffset().

Om du bara vill bifoga ett timezone-objekt tz till en datetime dt utan att justera datum- och tidsdata, använd dt.replace(tzinfo=tz). Om du bara vill ta bort timezone-objektet från en medveten datetime dt utan konvertering av datum- och tidsdata, använd dt.replace(tzinfo=None).

Observera att standardmetoden tzinfo.fromutc() kan åsidosättas i en tzinfo-underklass för att påverka det resultat som returneras av astimezone(). Om man bortser från felfall fungerar astimezone() på följande sätt:

def astimezone(self, tz):
    om self.tzinfo är tz:
        returnera själv
    # Konvertera self till UTC och bifoga det nya tidszonobjektet.
    utc = (self - self.utcoffset()).replace(tzinfo=tz)
    # Konvertera från UTC till tz:s lokala tid.
    return tz.fromutc(utc)

Ändrad i version 3.3: tz kan nu utelämnas.

Ändrad i version 3.6: Metoden astimezone() kan nu anropas på naiva instanser som antas representera systemets lokala tid.

datetime.utcoffset()¶: Om tzinfo är None, returneras None, annars returneras self.tzinfo.utcoffset(self), och ett undantag uppstår om det senare inte returnerar None eller ett timedelta-objekt med magnitud mindre än en dag.

Ändrad i version 3.7: UTC-förskjutningen är inte begränsad till ett helt antal minuter.

datetime.dst()¶: Om tzinfo är None, returneras None, annars returneras self.tzinfo.dst(self), och ett undantag uppstår om det senare inte returnerar None eller ett timedelta-objekt med magnitud mindre än en dag.

Ändrad i version 3.7: DST-förskjutningen är inte begränsad till ett helt antal minuter.

datetime.tzname()¶: Om tzinfo är None, returnerar None, annars returnerar self.tzinfo.tzname(self), utlöser ett undantag om det senare inte returnerar None eller ett strängobjekt,

datetime.timetuple()¶

Returnerar en time.struct_time såsom den som returneras av time.localtime().

d.timetuple() är likvärdigt med:

time.struct_time((d.år, d.månad, d.dag,
                  d.timme, d.minut, d.sekund,
                  d.veckodag(), yday, dst))

där yday = d.toordinal() - date(d.year, 1, 1).toordinal() + 1 är dagsnumret inom det aktuella året med början med 1 för den 1 januari. Flaggan tm_isdst för resultatet sätts i enlighet med metoden dst(): tzinfo är None eller dst() returnerar None, tm_isdst sätts till -1; annars om dst() returnerar ett värde som inte är noll, sätts tm_isdst till 1; annars sätts tm_isdst till 0.

datetime.utctimetuple()¶

Om datetime-instansen d är naiv, är detta samma sak som d.timetuple() förutom att tm_isdst tvingas till 0 oavsett vad d.dst() returnerar. DST är aldrig i kraft för en UTC-tid.

Om d är medveten, normaliseras d till UTC-tid, genom att subtrahera d.utcoffset(), och en time.struct_time för den normaliserade tiden returneras. tm_isdst tvingas till 0. Observera att ett OverflowError kan uppstå om d.year var MINYEAR eller MAXYEAR och UTC-justering spiller över en årsgräns.

Varning

Eftersom naiva datetime-objekt behandlas av många datetime-metoder som lokal tid, är det att föredra att använda medvetna datetimes för att representera tider i UTC; som ett resultat kan användning av datetime.utctimetuple() ge missvisande resultat. Om du har en naiv datetime som representerar UTC, använd datetime.replace(tzinfo=timezone.utc) för att göra den medveten, varpå du kan använda datetime.timetuple().

datetime.toordinal()¶: Returnerar den proleptiska gregorianska ordinalen för datumet. Samma som self.date().toordinal().

datetime.timestamp()¶

Returnerar POSIX-tidsstämpel motsvarande datetime-instansen. Returvärdet är en float liknande den som returneras av time.time().

Naiva datetime-instanser antas representera lokal tid och den här metoden förlitar sig på plattform C mktime()-funktionen för att utföra konverteringen. Eftersom datetime har stöd för ett större antal värden än mktime() på många plattformar, kan denna metod ge upphov till OverflowError eller OSError för tider långt tillbaka i tiden eller långt in i framtiden.

För medvetna datetime-instanser beräknas returvärdet som:

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

Tillagd i version 3.3.

Ändrad i version 3.6: Metoden timestamp() använder attributet fold för att särskilja tiderna under ett upprepat intervall.

Anteckning

Det finns ingen metod för att erhålla POSIX-tidsstämpeln direkt från en naiv datetime-instans som representerar UTC-tid. Om ditt program använder den här konventionen och systemets tidszon inte är inställd på UTC, kan du få POSIX-tidsstämpeln genom att ange tzinfo=timezone.utc:

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

eller genom att beräkna tidsstämpeln direkt:

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

datetime.weekday()¶: Returnerar veckodagen som ett heltal, där måndag är 0 och söndag är 6. Samma som self.date().weekday(). Se även isoweekday().

datetime.isoweekday()¶: Returnerar veckodagen som ett heltal, där måndag är 1 och söndag är 7. Samma som self.date().isoweekday(). Se även weekday(), isocalendar().

datetime.isocalendar()¶: Returnerar en named tuple med tre komponenter: år, vecka och veckodag. Samma som self.date().isocalendar().

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

Returnerar en sträng som representerar datum och tid i ISO 8601-format:

YYYY-MM-DDTHH:MM:SS.ffffff, om microsecond inte är 0
YYYY-MM-DDTHH:MM:SS, om microsecond är 0

Om utcoffset() inte returnerar None, läggs en sträng till som anger UTC-offset:

YYYY-MM-DDTHH:MM:SS.ffffff+HH:MM[:SS[.ffffff]], om microsecond inte är 0
YYYY-MM-DDTHH:MM:SS+HH:MM[:SS[.ffffff]], om microsecond är 0

Exempel:

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

Det valfria argumentet sep (standard 'T') är en enteckensseparator som placeras mellan datum- och tidsdelarna i resultatet. Till exempel:

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

Det valfria argumentet timespec anger antalet ytterligare komponenter i tiden som ska inkluderas (standardvärdet är 'auto'). Det kan vara något av följande:

'auto': Samma som 'seconds' om microsecond är 0, samma som 'microseconds' annars.
'timmar': Inkluderar hour i det tvåsiffriga formatet HH.
'minuter: Inkludera hour och minute i formatet HH:MM.
'seconds': Inkludera hour, minute och second i formatet HH:MM:SS.
'millisekunder': Inkludera hela tiden, men trunkera bråkdelen av sekunddelen till millisekunder. format HH:MM:SS.sss.
'mikrosekunder': Inkludera full tid i formatet HH:MM:SS.ffffff.

Anteckning

Exkluderade tidskomponenter är trunkerade, inte avrundade.

ValueError kommer att uppstå på ett ogiltigt timespec argument:

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

Ändrad i version 3.6: Parametern timespec har lagts till.

datetime.__str__()¶: För en datetime-instans d är str(d) ekvivalent med d.isoformat(' ').

datetime.ctime()¶

Returnerar en sträng som representerar datum och tid:

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

Utdatasträngen kommer inte att innehålla tidszoninformation, oavsett om indata är medveten eller naiv.

d.ctime() är likvärdigt med:

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

på plattformar där den inbyggda C-funktionen ctime() (som time.ctime() anropar, men som datetime.ctime() inte anropar) överensstämmer med C-standarden.

datetime.strftime(format)¶: Returnerar en sträng som representerar datum och tid, styrd av en explicit formatsträng. Se även strftime() och strptime() Behavior och datetime.isoformat().

datetime.__format__(format)¶: Samma som datetime.strftime(). Detta gör det möjligt att ange en formatsträng för ett datetime-objekt i formatted string literals och när man använder str.format(). Se även strftime() och strptime() Behavior och datetime.isoformat().

Exempel på användning: `datetime`¶

Exempel på hur man arbetar med datetime-objekt:

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

I exemplet nedan definieras en tzinfo-underklass som samlar in tidszoninformation för Kabul, Afghanistan, som använde +4 UTC fram till 1945 och därefter +4:30 UTC:

from datetime import timedelta, datetime, tzinfo, tidszon

klass KabulTz(tzinfo):
    # Kabul använde +4 fram till 1945, då de gick över till +4:30
    UTC_MOVE_DATE = datetime(1944, 12, 31, 20, tzinfo=timezone.utc)

    def utcoffset(self, dt):
        om dt.år < 1945:
            return timedelta(timmar=4)
        elif (1945, 1, 1, 0, 0) <= dt.timetuple()[:5] < (1945, 1, 1, 0, 30):
            # Ett tvetydigt ("imaginärt") halvtimmesintervall som representerar
            # ett "veck" i tiden på grund av skiftet från +4 till +4:30.
            # Om dt faller inom det imaginära intervallet, använd fold för att bestämma hur
            # hur det ska lösas. Se PEP495.
            return timedelta(timmar=4, minuter=(30 if dt.fold else 0))
        else:
            return timedelta(timmar=4, minuter=30)

    def fromutc(self, dt):
        # Följ samma valideringar som i datetime.tzinfo
        if not isinstance(dt, datetime):
            raise TypeError("fromutc() kräver ett datetime-argument")
        om dt.tzinfo inte är self:
            raise ValueError("dt.tzinfo är inte self")

        # En anpassad implementering krävs för fromutc eftersom
        # indata till denna funktion är en datatid med utc-värden
        # men med en tzinfo inställd på self.
        # Se datetime.astimezone eller fromtimestamp.
        if dt.replace(tzinfo=timezone.utc) >= self.UTC_MOVE_DATE:
            return dt + timedelta(timmar=4, minuter=30)
        i annat fall
            return dt + timedelta(timmar=4)

    def dst(self, dt):
        # Kabul följer inte sommartid.
        returnera timedelta(0)

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

Användning av KabulTz från ovan:

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

Ett time-objekt representerar en (lokal) tid på dygnet, oberoende av en viss dag, och kan justeras via ett tzinfo-objekt.

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

Alla argument är valfria. tzinfo kan vara None, eller en instans av en tzinfo-underklass. De återstående argumenten måste vara heltal inom följande intervall:

0 <= timme < 24,
0 <= minut < 60,
0 <= sekund < 60,
0 <= mikrosekund < 1000000,
veck i [0, 1].

Om ett argument utanför dessa intervall anges, kommer ValueError att uppstå. Alla har standardvärdet 0 utom tzinfo, som har standardvärdet None.

Klassens attribut:

time.min¶: Den tidigaste representerbara time, time(0, 0, 0, 0).

time.max¶: Den senaste representerbara time, time(23, 59, 59, 999999).

time.resolution¶: Den minsta möjliga skillnaden mellan icke lika time-objekt, timedelta(microseconds=1), men observera att aritmetik på time-objekt inte stöds.

Instansattribut (skrivskyddad):

time.hour¶: I range(24).

time.minute¶: I range(60).

time.second¶: I range(60).

time.microsecond¶: I intervall(1000000).

time.tzinfo¶: Det objekt som skickades som tzinfo-argument till time-konstruktören, eller None om inget skickades.

time.fold¶: I [0, 1]. Används för att särskilja väggtider under ett upprepat intervall. (Ett upprepat intervall inträffar när klockorna ställs tillbaka i slutet av sommartiden eller när UTC-offset för den aktuella zonen minskas av politiska skäl) Värdena 0 och 1 representerar den tidigare respektive den senare av de två tidpunkterna med samma väggtidsrepresentation.

Tillagd i version 3.6.

time-objekt stöder jämlikhets- och ordningsjämförelser, där a anses vara mindre än b när a föregår b i tid.

Naiva och medvetna time-objekt är aldrig lika. Orderjämförelse mellan naiva och medvetna time-objekt ger upphov till TypeError.

Om båda jämförelseobjekten är medvetna och har samma attribut tzinfo, ignoreras attributen tzinfo och fold och bastiderna jämförs. Om båda jämförelsetiderna är medvetna och har olika tzinfo-attribut, justeras jämförelsetiderna först genom att subtrahera deras UTC-offset (erhållen från self.utcoffset()).

Ändrad i version 3.3: Jämlikhetsjämförelser mellan medvetna och naiva time-instanser ger inte upphov till TypeError.

I booleska sammanhang anses ett time-objekt alltid vara sant.

Ändrad i version 3.5: Före Python 3.5 ansågs ett time-objekt vara falskt om det representerade midnatt i UTC. Detta beteende ansågs obskyrt och felbenäget och har tagits bort i Python 3.5. Se bpo-13936 för fullständiga detaljer.

Andra konstruktörer:

classmethod time.fromisoformat(time_string)¶

Returnera en time som motsvarar en time_string i valfritt giltigt ISO 8601-format, med följande undantag:

Tidszonsförskjutningar kan ha bråkdelar av sekunder.
Det inledande T, som normalt krävs i fall där det kan råda oklarhet mellan ett datum och en tid, krävs inte.
Bråksekunder kan ha valfritt antal siffror (allt över 6 trunkeras).
Bråkdelar av timmar och minuter stöds inte.

Exempel:

>>> from datetime import time
>>> time.fromisoformat('04:23:01')
datetime.time(4, 23, 1)
>>> time.fromisoformat('T04:23:01')
datetime.time(4, 23, 1)
>>> time.fromisoformat('T042301')
datetime.time(4, 23, 1)
>>> time.fromisoformat('04:23:01.000384')
datetime.time(4, 23, 1, 384)
>>> 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)))
>>> time.fromisoformat('04:23:01Z')
datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)
>>> time.fromisoformat('04:23:01+00:00')
datetime.time(4, 23, 1, tzinfo=datetime.timezone.utc)

Tillagd i version 3.7.

Ändrad i version 3.11: Tidigare stödde den här metoden endast format som kunde utfärdas av time.isoformat().

classmethod time.strptime(date_string, format)¶

Returnerar en time som motsvarar date_string, tolkad enligt format.

Om format inte innehåller mikrosekunder eller tidszonsinformation motsvarar detta:

tid(*(tid.strptime(datum_sträng, format)[3:6]))

ValueError uppstår om date_string och format inte kan tolkas av time.strptime() eller om den returnerar ett värde som inte är en tidstupel. Se även strftime() och strptime() Behavior och time.fromisoformat().

Tillagd i version 3.14.

Instansmetoder:

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

Returnerar en ny time med samma värden, men med angivna parametrar uppdaterade. Observera att tzinfo=None kan anges för att skapa en naiv time från en aware time, utan konvertering av tidsdata.

time-objekt stöds också av den generiska funktionen copy.replace().

Ändrad i version 3.6: Lagt till parametern fold.

time.isoformat(timespec='auto')¶

Returnerar en sträng som representerar tiden i ISO 8601-format, en av:

HH:MM:SS.ffffff, om microsecond inte är 0
HH:MM:SS, om microsekund är 0
HH:MM:SS.ffffff+HH:MM[:SS[.ffffff]], om utcoffset() inte returnerar None
HH:MM:SS+HH:MM[:SS[.ffffff]], om microsecond är 0 och utcoffset() inte returnerar None

Det valfria argumentet timespec anger antalet ytterligare komponenter i tiden som ska inkluderas (standardvärdet är 'auto'). Det kan vara något av följande:

'auto': Samma som 'seconds' om microsecond är 0, samma som 'microseconds' annars.
'timmar': Inkluderar hour i det tvåsiffriga formatet HH.
'minuter: Inkludera hour och minute i formatet HH:MM.
'seconds': Inkludera hour, minute och second i formatet HH:MM:SS.
'millisekunder': Inkludera hela tiden, men trunkera bråkdelen av sekunddelen till millisekunder. format HH:MM:SS.sss.
'mikrosekunder': Inkludera full tid i formatet HH:MM:SS.ffffff.

Anteckning

Exkluderade tidskomponenter är trunkerade, inte avrundade.

ValueError kommer att uppstå vid ett ogiltigt timespec-argument.

Exempel:

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

Ändrad i version 3.6: Parametern timespec har lagts till.

time.__str__()¶: För en tid t är str(t) ekvivalent med t.isoformat().

time.strftime(format)¶: Returnerar en sträng som representerar tiden, styrd av en explicit formatsträng. Se även strftime() och strptime() Behavior och time.isoformat().

time.__format__(format)¶: Samma som time.strftime(). Detta gör det möjligt att ange en formatsträng för ett time-objekt i :formatted string literals och när man använder str.format(). Se även strftime() och strptime() Behavior och time.isoformat().

time.utcoffset()¶: Om tzinfo är None, returneras None, annars returneras self.tzinfo.utcoffset(None), och ett undantag uppstår om det senare inte returnerar None eller ett timedelta-objekt med magnitud mindre än en dag.

Ändrad i version 3.7: UTC-förskjutningen är inte begränsad till ett helt antal minuter.

time.dst()¶: Om tzinfo är None, returneras None, annars returneras self.tzinfo.dst(None), och ett undantag uppstår om det senare inte returnerar None, eller ett timedelta objekt med magnitud mindre än en dag.

Ändrad i version 3.7: DST-förskjutningen är inte begränsad till ett helt antal minuter.

time.tzname()¶: Om tzinfo är None, returneras None, annars returneras self.tzinfo.tzname(None), eller så uppstår ett undantag om det senare inte returnerar None eller ett strängobjekt.

Exempel på användning: `time`¶

Exempel på att arbeta med ett time-objekt:

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

class datetime.tzinfo¶

Detta är en abstrakt basklass, vilket innebär att denna klass inte bör instansieras direkt. Definiera en subklass av tzinfo för att fånga information om en viss tidszon.

En instans av (en konkret underklass av) tzinfo kan skickas till konstruktörerna för objekten datetime och time. De senare objekten ser sina attribut som i lokal tid, och objektet tzinfo stöder metoder som avslöjar förskjutning av lokal tid från UTC, namnet på tidszonen och DST-förskjutning, allt i förhållande till ett datum- eller tidsobjekt som skickas till dem.

Du måste härleda en konkret underklass och (åtminstone) tillhandahålla implementeringar av standardmetoderna tzinfo som behövs av de datetime-metoder du använder. Modulen datetime tillhandahåller timezone, en enkel konkret underklass till tzinfo som kan representera tidszoner med fast förskjutning från UTC, t.ex. UTC själv eller nordamerikanska EST och EDT.

Särskilt krav för betning: En tzinfo subklass måste ha en __init__() metod som kan anropas utan argument, annars kan den picklas men eventuellt inte unpicklas igen. Detta är ett tekniskt krav som kan komma att lättas på i framtiden.

En konkret subklass av tzinfo kan behöva implementera följande metoder. Exakt vilka metoder som behövs beror på hur medvetna datetime-objekt används. Om du är osäker, implementera helt enkelt alla.

tzinfo.utcoffset(dt)¶

Returnerar förskjutning av lokal tid från UTC, som ett timedelta-objekt som är positivt öster om UTC. Om lokal tid är väster om UTC bör detta vara negativt.

Detta representerar den totala förskjutningen från UTC; till exempel, om ett tzinfo-objekt representerar både tidszon- och DST-justeringar, bör utcoffset() returnera summan av dessa. Om UTC-förskjutningen inte är känd, returneras None. Annars måste värdet som returneras vara ett timedelta-objekt strikt mellan -timedelta(hours=24) och timedelta(hours=24) (storleken på förskjutningen måste vara mindre än en dag). De flesta implementationer av utcoffset() kommer förmodligen att se ut som en av dessa två:

return CONSTANT # klass för fast offset
return CONSTANT + self.dst(dt) # dagsljusmedveten klass

Om utcoffset() inte returnerar None, bör inte heller dst() returnera None.

Standardimplementeringen av utcoffset() ger upphov till NotImplementedError.

Ändrad i version 3.7: UTC-förskjutningen är inte begränsad till ett helt antal minuter.

tzinfo.dst(dt)¶

Returnerar justeringen av sommartid (DST) som ett timedelta-objekt eller None om DST-information inte är känd.

Returnerar timedelta(0) om DST inte är i kraft. Om DST gäller, returneras förskjutningen som ett timedelta-objekt (se utcoffset() för detaljer). Observera att DST-offset, om tillämpligt, redan har lagts till UTC-offset som returneras av utcoffset(), så det finns inget behov av att konsultera dst() om du inte är intresserad av att få DST-information separat. Till exempel anropar datetime.timetuple() sitt tzinfo-attributs dst()-metod för att avgöra hur flaggan tm_isdst ska sättas, och tzinfo.fromutc() anropar dst() för att ta hänsyn till DST-ändringar när man korsar tidszoner.

En instans tz av en tzinfo-underklass som modellerar både standardtid och dagtid måste vara konsekvent i denna mening:

tz.utcoffset(dt) - tz.dst(dt)

måste returnera samma resultat för varje datetime dt med dt.tzinfo == tz. För sunda tzinfo-underklasser ger detta uttryck tidszonens ”standardförskjutning”, som inte bör bero på datum eller tid, utan endast på geografisk plats. Implementationen av datetime.astimezone() förlitar sig på detta, men kan inte upptäcka överträdelser; det är programmerarens ansvar att säkerställa det. Om en tzinfo-underklass inte kan garantera detta, kan den kanske åsidosätta standardimplementeringen av tzinfo.fromutc() för att fungera korrekt med astimezone() oavsett.

De flesta implementationer av dst() kommer förmodligen att se ut som en av dessa två:

def dst(self, dt):
    # en klass med fast offset: tar inte hänsyn till DST
    returnera timedelta(0)

eller:

def dst(själv, dt):
    # Kod för att ställa in dston och dstoff till tidszonens DST
    # övergångstider baserat på inmatningen dt.year, och uttryckt
    # i lokal standardtid.

    if dston <= dt.replace(tzinfo=None) < dstoff:
        returnera timedelta(timmar=1)
    i annat fall
        returnera timedelta(0)

Standardimplementeringen av dst() ger upphov till NotImplementedError.

Ändrad i version 3.7: DST-förskjutningen är inte begränsad till ett helt antal minuter.

tzinfo.tzname(dt)¶

Returnerar tidszonens namn som motsvarar datetime-objektet dt, som en sträng. Ingenting om strängnamn definieras av datetime-modulen, och det finns inget krav på att det ska betyda något särskilt. Till exempel, "GMT", "UTC", "-500", "-5:00", "EDT", "US/Eastern", "America/New York" är alla giltiga svar. Returnerar None om ett strängnamn inte är känt. Observera att detta är en metod snarare än en fast sträng, främst eftersom vissa tzinfo-underklasser kommer att vilja returnera olika namn beroende på det specifika värdet för dt som skickas, särskilt om tzinfo-klassen tar hänsyn till sommartid.

Standardimplementeringen av tzname() ger upphov till NotImplementedError.

Dessa metoder anropas av ett datetime- eller time-objekt som svar på deras metoder med samma namn. Ett datetime-objekt skickar sig själv som argument, och ett time-objekt skickar None som argument. En tzinfo-underklass metoder bör därför vara förberedda på att acceptera ett dt-argument av None, eller av klassen datetime.

När None skickas, är det upp till klassens designer att bestämma det bästa svaret. Att returnera None är till exempel lämpligt om klassen vill säga att tidsobjekt inte deltar i tzinfo-protokollen. Det kan vara mer användbart för utcoffset(None) att returnera standard UTC-offset, eftersom det inte finns någon annan konvention för att upptäcka standardoffset.

När ett datetime-objekt skickas som svar till en datetime-metod är dt.tzinfo samma objekt som self. tzinfo-metoder kan förlita sig på detta, såvida inte användarkoden anropar tzinfo-metoder direkt. Avsikten är att tzinfo-metoderna ska tolka dt som lokal tid och inte behöva bekymra sig om objekt i andra tidszoner.

Det finns ytterligare en tzinfo-metod som en subklass kan vilja åsidosätta:

tzinfo.fromutc(dt)¶

Detta anropas från standardimplementeringen datetime.astimezone(). När det anropas därifrån är dt.tzinfo self, och dt:s datum- och tidsdata ska ses som uttryck för en UTC-tid. Syftet med fromutc() är att justera datum- och tidsdata och returnera en motsvarande datatid i self:s lokala tid.

De flesta tzinfo-underklasser bör kunna ärva standardimplementeringen av fromutc() utan problem. Den är tillräckligt stark för att hantera tidszoner med fast offset och tidszoner som redovisar både standardtid och sommartid, och det senare även om övergångstiderna till sommartid skiljer sig åt mellan olika år. Ett exempel på en tidszon som standardimplementeringen av fromutc() kanske inte hanterar korrekt i alla fall är en tidszon där standardförskjutningen (från UTC) beror på det specifika datumet och tiden som passerat, vilket kan hända av politiska skäl. Standardimplementeringarna av astimezone() och fromutc() kanske inte ger det resultat du vill ha om resultatet är en av de timmar som sträcker sig över det ögonblick då standardförskjutningen ändras.

Standardimplementeringen av fromutc(), som hoppar över kod för felfall, fungerar på följande sätt:

def fromutc(self, dt):
    # raise ValueError fel om dt.tzinfo inte är self
    dtoff = dt.utcoffset()
    dtdst = dt.dst()
    # ger upphov till ValueError om dtoff är None eller dtdst är None
    delta = dtoff - dtdst # detta är self:s standardförskjutning
    if delta:
        dt += delta # konvertera till lokal standardtid
        dtdst = dt.dst()
        # raise ValueError om dtdst är None
    if dtdst:
        returnera dt + dtdst
    else:
        returnera dt

I följande tzinfo_examples.py-fil finns några exempel på tzinfo-klasser:

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
# https://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")

Observera att det finns oundvikliga subtiliteter två gånger per år i en tzinfo-underklass som tar hänsyn till både standardtid och sommartid, vid övergångspunkterna för sommartid. För att vara konkret, tänk på US Eastern (UTC -0500), där EDT börjar minuten efter 1:59 (EST) den andra söndagen i mars och slutar minuten efter 1:59 (EDT) den första söndagen i november:

  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

  slut 23:MM 0:MM 1:MM 1:MM 2:MM 3:MM

När DST startar (startlinjen) hoppar den lokala väggklockan från 1:59 till 3:00. En väggtid av formen 2:MM är inte riktigt meningsfull den dagen, så astimezone(Eastern) kommer inte att leverera ett resultat med hour == 2 den dagen DST börjar. Till exempel, vid vårens framåtriktade övergång 2016 får vi:

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

När sommartiden upphör (raden ”end”) uppstår ett potentiellt värre problem: det finns en timme som inte kan stavas entydigt i lokal väggtid: den sista timmen med sommartid. I Eastern är det tider av formen 5:MM UTC på den dag då sommartiden slutar. Den lokala väggklockan hoppar från 1:59 (sommartid) tillbaka till 1:00 (normaltid) igen. Lokala tider av formen 1:MM är tvetydiga. astimezone() efterliknar den lokala klockans beteende genom att mappa två intilliggande UTC-timmar till samma lokala timme. I exemplet Eastern mappar UTC-tider av formen 5:MM och 6:MM båda till 1:MM när de konverteras till Eastern, men de tidigare tiderna har attributet fold satt till 0 och de senare tiderna har det satt till 1. Till exempel, vid övergången Fall back 2016, får vi:

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

Observera att datetime-instanser som skiljer sig åt endast genom värdet på attributet fold betraktas som likvärdiga i jämförelser.

Program som inte tål tvetydigheter i väggtid bör uttryckligen kontrollera värdet på attributet fold eller undvika att använda hybrid-underklasser av tzinfo; det finns inga tvetydigheter när man använder timezone eller någon annan underklass av tzinfo med fast offset (t.ex. en klass som endast representerar EST (fast offset -5 timmar) eller endast EDT (fast offset -4 timmar)).

Se även

zoneinfo
Modulen datetime har en grundläggande timezone-klass (för hantering av godtyckliga fasta förskjutningar från UTC) och dess timezone.utc-attribut (en UTC timezone-instans).

zoneinfo ger IANA-tidszonsdatabasen (även känd som Olson-databasen) till Python, och dess användning rekommenderas.

IANA tidszon databas: Time Zone Database (ofta kallad tz, tzdata eller zoneinfo) innehåller kod och data som representerar den lokala tidens historia för många representativa platser runt om i världen. Den uppdateras regelbundet för att återspegla ändringar som gjorts av politiska organ i tidszonsgränser, UTC-förskjutningar och regler för sommartid.

`tidszon` Objekt¶

Klassen timezone är en underklass till tzinfo, där varje instans representerar en tidszon som definieras av en fast förskjutning från UTC.

Objekt av denna klass kan inte användas för att representera tidszonsinformation på platser där olika förskjutningar används under olika dagar på året eller där historiska förändringar har gjorts av civiltiden.

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

Argumentet offset måste anges som ett timedelta-objekt som representerar skillnaden mellan den lokala tiden och UTC. Det måste vara strikt mellan -timedelta(hours=24) och timedelta(hours=24), annars uppstår ValueError.

Argumentet name är valfritt. Om det anges måste det vara en sträng som kommer att användas som det värde som returneras av datetime.tzname()-metoden.

Tillagd i version 3.2.

Ändrad i version 3.7: UTC-förskjutningen är inte begränsad till ett helt antal minuter.

timezone.utcoffset(dt)¶

Returnerar det fasta värde som anges när timezone-instansen konstrueras.

Argumentet dt ignoreras. Returvärdet är en timedelta-instans som är lika med skillnaden mellan den lokala tiden och UTC.

Ändrad i version 3.7: UTC-förskjutningen är inte begränsad till ett helt antal minuter.

timezone.tzname(dt)¶

Returnerar det fasta värde som anges när timezone-instansen konstrueras.

Om name inte anges i konstruktorn, genereras det namn som returneras av tzname(dt) från värdet på offset enligt följande. Om offset är timedelta(0) är namnet ”UTC”, annars är det en sträng i formatet UTC±HH:MM, där ± är tecknet för offset, HH och MM är två siffror i offset.hours respektive offset.minutes.

Ändrad i version 3.6: Namn som genereras från offset=timedelta(0) är nu vanligt 'UTC', inte 'UTC+00:00'.

timezone.dst(dt)¶: Returnerar alltid None.

timezone.fromutc(dt)¶: Returnerar dt + offset. Argumentet dt måste vara en medveten datetime-instans, med tzinfo satt till self.

Klassens attribut:

timezone.utc¶: UTC-tidszonen, timezone(timedelta(0)).

`strftime()` och `strptime()` Behavior¶

objekten date, datetime och time har alla stöd för metoden strftime(format), som skapar en sträng som representerar tiden under kontroll av en explicit formatsträng.

Omvänt skapar klassmetoderna date.strptime(), datetime.strptime() och time.strptime() ett objekt från en sträng som representerar tiden och en motsvarande formatsträng.

Tabellen nedan ger en jämförelse på hög nivå mellan strftime() och strptime():

	`strftime`	`strptime`
Användning	Konverterar objekt till en sträng enligt ett givet format	Parsa en sträng till ett objekt med ett motsvarande format
Typ av metod	Instansmetod	Klassmetod
Underskrift	`strftime(format)`	`strptime(datum_sträng, format)`

`strftime()` och `strptime()` Formatkoder¶

Dessa metoder accepterar formatkoder som kan användas för att analysera och formatera datum:

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

Nedan följer en lista över alla formatkoder som krävs enligt 1989 års C-standard, och dessa fungerar på alla plattformar med en standard C-implementering.

Direktiv	Betydelse	Exempel	Anteckningar
`%a`	Veckodag som lokalens förkortade namn.	Sön, mån, …, lör (en_US); Så, Mo, …, Sa (de_DE)	(1)
`%A`	Veckodag som lokalens fullständiga namn.	Söndag, måndag, …, lördag (en_US); Sonntag, Montag, …, Samstag (de_DE)	(1)
`%w`	Veckodag som ett decimaltal, där 0 är söndag och 6 är lördag.	0, 1, …, 6
`%d`	Månadens dag som ett nollställt decimaltal.	01, 02, …, 31	(9)
`%b`	Månad som lokalens förkortade namn.	Jan, feb, …, dec (en_US); Jan, Feb, …, Dez (de_DE)	(1)
`%B`	Månad som lokalens fullständiga namn.	Januari, februari, …, december (en_US); Januari, februari, …, december (de_DE)	(1)
`%m`	Månad som ett nollfyllt decimaltal.	01, 02, …, 12	(9)
`%y`	Årtal utan sekel som nollställt decimaltal.	00, 01, …, 99	(9)
`%Y`	År med sekel som decimaltal.	0001, 0002, …, 2013, 2014, …, 9998, 9999	(2)
`%H`	Timme (24-timmarsklocka) som ett decimaltal med nolltillägg.	00, 01, …, 23	(9)
`%I`	Timme (12-timmars klocka) som ett decimaltal med nolltillägg.	01, 02, …, 12	(9)
`%p`	Lokalens motsvarighet till antingen AM eller PM.	AM, PM (en_US); am, pm (de_DE)	(1), (3)
`%M`	Minut som ett nollfyllt decimaltal.	00, 01, …, 59	(9)
`%S`	Andra som ett nollfyllt decimaltal.	00, 01, …, 59	(4), (9)
`%f`	Mikrosekund som ett decimaltal, nollställt till 6 siffror.	000000, 000001, …, 999999	(5)
`%z`	UTC-offset i formen `±HHMM[SS[.ffffff]]` (tom sträng om objektet är naivt).	(tom), +0000, -0400, +1030, +063415, -030712.345216	(6)
`%Z`	Tidszonens namn (tom sträng om objektet är naivt).	(tom), UTC, GMT	(6)
`%j`	Årets dag som ett nollställt decimaltal.	001, 002, …, 366	(9)
`%U`	Veckonummer för året (söndag som första dag i veckan) som ett nollställt decimaltal. Alla dagar i ett nytt år som föregår den första söndagen anses vara i vecka 0.	00, 01, …, 53	(7), (9)
`%W`	Veckonummer för året (måndag som första dag i veckan) som ett nollställt decimaltal. Alla dagar i ett nytt år som föregår den första måndagen anses vara i vecka 0.	00, 01, …, 53	(7), (9)
`%c`	Locales lämpliga datum- och tidsrepresentation.	Tue Aug 16 21:30:00 1988 (en_US); Di 16 Aug 21:30:00 1988 (de_DE)	(1)
`%x`	Locales lämpliga datumrepresentation.	08/16/88 (Ingen); 08/16/1988 (en_US); 16.08.1988 (de_DE)	(1)
`%X`	Locales lämpliga tidsrepresentation.	21:30:00 (en_US); 21:30:00 (de_DE)	(1)
`%%`	Ett bokstavligt `'%'`-tecken.	%

Flera ytterligare direktiv som inte krävs enligt C89-standarden ingår för enkelhetens skull. Alla dessa parametrar motsvarar ISO 8601 datumvärden.

Direktiv	Betydelse	Exempel	Anteckningar
`%G`	ISO 8601 år med århundrade som representerar det år som innehåller större delen av ISO-veckan (`%V`).	0001, 0002, …, 2013, 2014, …, 9998, 9999	(8)
`%u`	ISO 8601 veckodag som ett decimaltal där 1 är måndag.	1, 2, …, 7
`%V`	ISO 8601-vecka som ett decimaltal med måndag som första dag i veckan. Vecka 01 är den vecka som innehåller den 4 januari.	01, 02, …, 53	(8), (9)
`%:z`	UTC-offset i formen `±HH:MM[:SS[.ffffff]]` (tom sträng om objektet är naivt).	(tom), +00:00, -04:00, +10:30, +06:34:15, -03:07:12.345216	(6)

Dessa kanske inte är tillgängliga på alla plattformar när de används med metoden strftime(). Direktiven ISO 8601 år och ISO 8601 vecka är inte utbytbara med direktiven för år och veckonummer ovan. Anrop av strptime() med ofullständiga eller tvetydiga ISO 8601-direktiv kommer att ge upphov till ett ValueError.

Den fullständiga uppsättningen formatkoder som stöds varierar mellan olika plattformar, eftersom Python anropar plattform C-bibliotekets strftime()-funktion, och plattformsvariationer är vanliga. För att se den fullständiga uppsättningen formatkoder som stöds på din plattform, se strftime(3)-dokumentationen. Det finns också skillnader mellan plattformar i hanteringen av formatspecifikatorer som inte stöds.

Tillagd i version 3.6: %G, %u och %V lades till.

Tillagd i version 3.12: %:z lades till.

Tekniska detaljer¶

I stort sett fungerar d.strftime(fmt) som time-modulens time.strftime(fmt, d.timetuple()) även om inte alla objekt stöder en timetuple()-metod.

För klassmetoden datetime.strptime() är standardvärdet 1900-01-01T00:00:00.000: alla komponenter som inte anges i formatsträngen hämtas från standardvärdet. [4]

Att använda datetime.strptime(date_string, format) är likvärdigt med:

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

utom när formatet innehåller subsekundkomponenter eller information om tidszonsförskjutning, som stöds i datetime.strptime men kasseras av time.strptime.

För time-objekt bör formatkoderna för år, månad och dag inte användas, eftersom time-objekt inte har några sådana värden. Om de ändå används, ersätts år med 1900 och månad och dag med 1.

För date-objekt ska formatkoderna för timmar, minuter, sekunder och mikrosekunder inte användas, eftersom date-objekt inte har några sådana värden. Om de ändå används, ersätts de med 0.

Av samma anledning är hanteringen av formatsträngar som innehåller Unicode-kodpunkter som inte kan representeras i den aktuella lokalens teckenuppsättning också plattformsberoende. På vissa plattformar bevaras sådana kodpunkter intakta i utdata, medan på andra kan strftime ge upphov till UnicodeError eller returnera en tom sträng istället.

Anteckningar:

Eftersom formatet beror på den aktuella språkdräkten bör man vara försiktig när man gör antaganden om utdatavärdet. Fältordningen kan variera (t.ex. ”månad/dag/år” jämfört med ”dag/månad/år”) och utdata kan innehålla icke-ASCII-tecken.
Metoden strptime() kan tolka årtal i hela intervallet [1, 9999], men år < 1000 måste nollställas till 4-siffrig bredd.

Ändrad i version 3.2: I tidigare versioner var metoden strftime() begränsad till år >= 1900.

Ändrad i version 3.3: I version 3.2 var metoden strftime() begränsad till år >= 1000.
När det används med metoden strptime() påverkar direktivet %p endast fältet för utmatad timme om direktivet %I används för att analysera timmen.
Till skillnad från modulen time har modulen datetime inte stöd för skottsekunder.
När det används med metoden strptime() accepterar direktivet %f en till sex siffror och nollställen till höger. %f är en utökning av uppsättningen formattecken i C-standarden (men implementeras separat i datetime-objekt och är därför alltid tillgängliga).
För ett naivt objekt ersätts formatkoderna %z, %:z och %Z med tomma strängar.

För ett medvetet objekt:

%z
utcoffset() omvandlas till en sträng av formen ±HHMM[SS[.ffffff]], där HH är en tvåsiffrig sträng som anger antalet UTC-förskjutna timmar, MM är en tvåsiffrig sträng som anger antalet UTC-förskjutna minuter, SS är en tvåsiffrig sträng som anger antalet UTC-förskjutna sekunder och ffffffff är en sexsiffrig sträng som anger antalet UTC-förskjutna mikrosekunder. Delen ffffffff utelämnas när förskjutningen är ett helt antal sekunder och både delen ffffffff och SS utelämnas när förskjutningen är ett helt antal minuter. Om utcoffset() till exempel returnerar timedelta(hours=-3, minutes=-30), ersätts %z med strängen '-0330'.

Ändrad i version 3.7: UTC-förskjutningen är inte begränsad till ett helt antal minuter.

Ändrad i version 3.7: När direktivet %z ges till metoden strptime() kan UTC-offseten ha ett kolon som separator mellan timmar, minuter och sekunder. Till exempel kommer '+01:00:00' att tolkas som en förskjutning på en timme. Att ange 'Z' är dessutom identiskt med '+00:00'.
%:z
Uppför sig exakt som %z, men har en kolonavgränsare mellan timmar, minuter och sekunder.

%Z
I strftime() ersätts %Z med en tom sträng om tzname() returnerar None; annars ersätts %Z med det returnerade värdet, som måste vara en sträng.

strptime() accepterar bara vissa värden för %Z:
1. valfritt värde i time.tzname för din maskins locale
2. de hårdkodade värdena UTC och GMT
Så någon som bor i Japan kan ha JST, UTC och GMT som giltiga värden, men förmodligen inte EST. Det kommer att ge upphov till ValueError för ogiltiga värden.
Ändrad i version 3.2: När direktivet %z ges till metoden strptime(), kommer ett medvetet datetime-objekt att produceras. Resultatets tzinfo kommer att sättas till en timezone-instans.
När de används med metoden strptime() används %U och %W endast i beräkningar när veckodagen och kalenderåret (%Y) anges.
I likhet med %U och %W används %V endast i beräkningar när veckodagen och ISO-året (%G) anges i en strptime()-formatsträng. Observera också att %G och %Y inte är utbytbara.
När den används med metoden strptime() är den inledande nollan valfri för formaten %d, %m, %H, %I, %M, %S, %j, %U, %W och %V. Formatet %y kräver en inledande nolla.
När du analyserar en månad och dag med strptime() ska du alltid inkludera ett år i formatet. Om det värde du behöver analysera saknar ett år, lägg till ett explicit dummy skottår. Annars kommer din kod att ge upphov till ett undantag när den stöter på skottdagen eftersom det standardår som används av parsern inte är ett skottår. Användare stöter på den här buggen vart fjärde år…
```
>>> month_day = "02/29"
>>> datetime.strptime(f"{month_day};1984", "%m/%d;%Y")  # No leap year bug.
datetime.datetime(1984, 2, 29, 0, 0)
```
Deprecated since version 3.13, will be removed in version 3.15: strptime() anrop som använder en formatsträng som innehåller en dag i månaden utan årtal ger nu en DeprecationWarning. I 3.15 eller senare kan vi ändra detta till ett fel eller ändra standardåret till ett skottår. Se gh-70647.

Fotnoter

`datetime` — Grundläggande datum- och tidstyper¶

Medvetna och naiva objekt¶

Konstanter¶

Tillgängliga typer¶

Gemensamma egenskaper¶

Avgöra om ett objekt är medvetet eller naivt¶

`timedelta` Objekt¶

Exempel på användning: `timedelta`¶

`datum` Objekt¶

Exempel på användning: `date`¶

`datetime` Objekt¶

Exempel på användning: `datetime`¶

`time` Objekt¶

Exempel på användning: `time`¶

`tzinfo` Objekt¶

`tidszon` Objekt¶

`strftime()` och `strptime()` Behavior¶

`strftime()` och `strptime()` Formatkoder¶

Tekniska detaljer¶

Innehåll

Föregående ämne

Nästa ämne

Denna sidan

datetime — Grundläggande datum- och tidstyper¶

Medvetna och naiva objekt¶

Konstanter¶

Tillgängliga typer¶

Gemensamma egenskaper¶

Avgöra om ett objekt är medvetet eller naivt¶

timedelta Objekt¶

Exempel på användning: timedelta¶

datum Objekt¶

Exempel på användning: date¶

datetime Objekt¶

Exempel på användning: datetime¶

time Objekt¶

Exempel på användning: time¶

tzinfo Objekt¶

tidszon Objekt¶

strftime() och strptime() Behavior¶

strftime() och strptime() Formatkoder¶

Tekniska detaljer¶

`datetime` — Grundläggande datum- och tidstyper¶

`timedelta` Objekt¶

Exempel på användning: `timedelta`¶

`datum` Objekt¶

Exempel på användning: `date`¶

`datetime` Objekt¶

Exempel på användning: `datetime`¶

`time` Objekt¶

Exempel på användning: `time`¶

`tzinfo` Objekt¶

`tidszon` Objekt¶

`strftime()` och `strptime()` Behavior¶

`strftime()` och `strptime()` Formatkoder¶