time — Tidsåtkomst och konvertering

---

Denna modul tillhandahåller olika tidsrelaterade funktioner. För relaterade funktioner, se även modulerna datetime och calendar.

Även om den här modulen alltid är tillgänglig, är inte alla funktioner tillgängliga på alla plattformar. De flesta av de funktioner som definieras i den här modulen anropar funktioner i plattformens C-bibliotek med samma namn. Ibland kan det vara bra att läsa i plattformsdokumentationen, eftersom semantiken för dessa funktioner varierar mellan olika plattformar.

En förklaring av viss terminologi och vissa konventioner är på sin plats.

• epoch är den punkt där tiden startar, returvärdet för time.gmtime(0). Det är den 1 januari 1970, 00:00:00 (UTC) på alla plattformar.

• Termen sekunder sedan epoken avser det totala antalet sekunder som förflutit sedan epoken, vanligtvis exklusive skottsekunder. Skottsekunder är exkluderade från denna summa på alla POSIX-kompatibla plattformar.

• Funktionerna i denna modul kan inte hantera datum och tider före epoch eller långt in i framtiden. Brytpunkten i framtiden bestäms av C-biblioteket; för 32-bitars system är den vanligtvis år 2038.

• Funktionen strptime() kan tolka 2-siffriga årtal när den ges formatkoden %y. När 2-siffriga årtal analyseras konverteras de enligt POSIX- och ISO C-standarderna: värdena 69–99 mappas till 1969–1999 och värdena 0–68 mappas till 2000–2068.

• UTC är Coordinated Universal Time och ersatte Greenwich Mean Time eller GMT som grund för internationell tidtagning. Akronymen UTC är inte ett misstag utan en följd av ett tidigare, språkagnostiskt namngivningssystem för tidsstandarder som UT0, UT1 och UT2.

• DST är Daylight Saving Time, en justering av tidszonen med (vanligtvis) en timme under en del av året. Reglerna för sommartid är magiska (bestäms av lokala lagar) och kan ändras från år till år. C-biblioteket har en tabell som innehåller de lokala reglerna (ofta läses den från en systemfil för flexibilitetens skull) och är den enda källan till sann visdom i detta avseende.

• Precisionen i de olika realtidsfunktionerna kan vara lägre än vad som framgår av de enheter som deras värde eller argument uttrycks i. På de flesta Unix-system ”tickar” t.ex. klockan bara 50 eller 100 gånger per sekund.

• Å andra sidan är precisionen i time() och sleep() bättre än deras motsvarigheter i Unix: tider uttrycks som flyttal, time() returnerar den mest exakta tillgängliga tiden (med hjälp av Unix gettimeofday() där det är tillgängligt), och sleep() accepterar en tid med en fraktion som inte är noll (Unix select() används för att implementera detta, där det är tillgängligt).

• Tidsvärdet som returneras av gmtime(), localtime(), och strptime(), och accepteras av asctime(), mktime() och strftime(), är en sekvens av 9 heltal. Returvärdena för gmtime(), localtime() och strptime() ger också attributnamn för enskilda fält.

  Se struct_time för en beskrivning av dessa objekt.

  Ändrad i version 3.3: Typen struct_time utökades för att tillhandahålla attributen tm_gmtoff och tm_zone när plattformen stöder motsvarande struct tm-medlemmar.

  Ändrad i version 3.6: Attributen struct_time tm_gmtoff och tm_zone är nu tillgängliga på alla plattformar.

• Använd följande funktioner för att konvertera mellan olika tidsangivelser:

  Från	Till	Använd
  sekunder sedan epoken	struct_time i UTC	gmtime()
  sekunder sedan epoken	struct_time i lokal tid	lokaltid()
  struct_time i UTC	sekunder sedan epoken	kalender.timegm()
  struct_time i lokal tid	sekunder sedan epoken	mktime()

Funktioner

time.asctime([t])

Konverterar en tuple eller struct_time som representerar en tid som returneras av gmtime() eller localtime() till en sträng av följande form: 'Sun Jun 20 23:21:05 1993'. Dagfältet är två tecken långt och fylls på med mellanslag om dagen är en ensiffrig siffra, t.ex: 'Wed Jun 9 04:26:40 1993'.

Om t inte anges används den aktuella tiden som returneras av localtime(). Information om lokal tid används inte av asctime().

Anteckning

Till skillnad från C-funktionen med samma namn lägger asctime() inte till någon efterföljande ny rad.

time.pthread_getcpuclockid(thread_id)

Returnerar clk_id för den trådspecifika CPU-tidsklockan för den angivna thread_id.

Använd threading.get_ident() eller attributet ident i threading.Thread-objekt för att få ett lämpligt värde för thread_id.

Varning

Om du skickar ett ogiltigt eller föråldrat thread_id kan det leda till odefinierat beteende, t.ex. segmenteringsfel.

Tillgänglighet: Unix

Se man-sidan för pthread_getcpuclockid(3) för ytterligare information.

Tillagd i version 3.7.

time.clock_getres(clk_id)

Returnerar upplösningen (precisionen) för den angivna klockan clk_id. Se Klock-ID-konstanter för en lista över accepterade värden för clk_id.

Tillgänglighet: Unix.

Tillagd i version 3.3.

time.clock_gettime(clk_id) → float

Returnerar tiden för den angivna klockan clk_id. Se Klock-ID-konstanter för en lista över accepterade värden för clk_id.

Använd clock_gettime_ns() för att undvika den precisionsförlust som orsakas av typen float.

Tillgänglighet: Unix.

Tillagd i version 3.3.

time.clock_gettime_ns(clk_id) → int

Liknar clock_gettime() men returnerar tid som nanosekunder.

Tillgänglighet: Unix.

Tillagd i version 3.7.

time.clock_settime(clk_id, time: float)

Ställer in tiden för den angivna klockan clk_id. För närvarande är CLOCK_REALTIME det enda accepterade värdet för clk_id.

Använd clock_settime_ns() för att undvika den precisionsförlust som orsakas av typen float.

Tillgänglighet: Unix, not Android, not iOS.

Tillagd i version 3.3.

time.clock_settime_ns(clk_id, time: int)

Liknar clock_settime() men ställer in tiden med nanosekunder.

Tillgänglighet: Unix, not Android, not iOS.

Tillagd i version 3.7.

time.ctime([secs])

Konverterar en tid uttryckt i sekunder sedan epoch till en sträng av formen: 'Sun Jun 20 23:21:05 1993' som representerar lokal tid. Dagfältet är två tecken långt och fylls på med mellanslag om dagen är en siffra, t.ex: 'Wed Jun 9 04:26:40 1993'.

Om secs inte anges eller om None, används den aktuella tid som returneras av time(). ctime(secs) är ekvivalent med asctime(localtime(secs)). Information om lokal tid används inte av ctime().

time.get_clock_info(name)

Hämta information om den angivna klockan som ett namnrymdsobjekt. Klocknamn som stöds och motsvarande funktioner för att läsa deras värde är:

• 'monotonic': time.monotonic()

• 'perf_counter': time.perf_counter()

• 'process_time': time.process_time()

• 'thread_time': time.thread_time()

• 'tid': tid.tid()

Resultatet har följande egenskaper:

• justerbar: True om klockan kan ändras automatiskt (t.ex. av en NTP-daemon) eller manuellt av systemadministratören, False annars

• implementation: Namnet på den underliggande C-funktion som används för att hämta klockvärdet. Se Klock-ID-konstanter för möjliga värden.

• monotonisk: True om klockan inte kan gå baklänges, False annars

• upplösning: Klockans upplösning i sekunder (float)

Tillagd i version 3.3.

time.gmtime([secs])

Konverterar en tid uttryckt i sekunder sedan epoch till en struct_time i UTC där dst-flaggan alltid är noll. Om secs inte anges eller None, används den aktuella tiden som returneras av time(). Bråkdelar av en sekund ignoreras. Se ovan för en beskrivning av struct_time-objektet. Se calendar.timegm() för inversen av denna funktion.

time.localtime([secs])

Som gmtime() men konverterar till lokal tid. Om secs inte anges eller None, används den aktuella tiden som returneras av time(). Flaggan dst sätts till 1 när sommartid gäller för den angivna tiden.

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

time.mktime(t)

Detta är den omvända funktionen av localtime(). Dess argument är struct_time eller en fullständig 9-tupel (eftersom dst-flaggan behövs; använd -1 som dst-flagga om den är okänd) som uttrycker tiden i lokal tid, inte UTC. Den returnerar ett flyttal, för kompatibilitet med time(). Om inmatningsvärdet inte kan representeras som en giltig tid, kommer antingen OverflowError eller ValueError att tas upp (vilket beror på om det ogiltiga värdet fångas upp av Python eller de underliggande C-biblioteken). Det tidigaste datumet för vilket den kan generera en tid är plattformsberoende.

time.monotonic() → float

Returnerar värdet (i bråkdelar av sekunder) för en monoton klocka, dvs. en klocka som inte kan gå baklänges. Klockan påverkas inte av uppdateringar av systemklockan. Referenspunkten för det returnerade värdet är odefinierad, så att endast skillnaden mellan resultaten av två anrop är giltig.

Klockan:

• I Windows anropar du QueryPerformanceCounter() och QueryPerformanceFrequency().

• På macOS, anropa mach_absolute_time() och mach_timebase_info().

• På HP-UX anropar du gethrtime().

• Anropa clock_gettime(CLOCK_HIGHRES) om tillgängligt.

• I annat fall anropa clock_gettime(CLOCK_MONOTONIC).

Använd monotonic_ns() för att undvika den precisionsförlust som orsakas av typen float.

Tillagd i version 3.3.

Ändrad i version 3.5: Funktionen är nu alltid tillgänglig och klockan är nu densamma för alla processer.

Ändrad i version 3.10: På macOS är klockan nu densamma för alla processer.

time.monotonic_ns() → int

Liknar monotonic(), men returnerar tid som nanosekunder.

Tillagd i version 3.7.

time.perf_counter() → float

Returnerar värdet (i bråkdelar av sekunder) för en prestandaräknare, dvs. en klocka med högsta möjliga upplösning för att mäta en kort tid. Det inkluderar tid som förflutit under sömn. Klockan är densamma för alla processer. Referenspunkten för det returnerade värdet är odefinierad, vilket innebär att endast skillnaden mellan resultaten av två anrop är giltig.

I CPython används samma klocka som time.monotonic() och är en monoton klocka, dvs. en klocka som inte kan gå baklänges.

Använd perf_counter_ns() för att undvika den precisionsförlust som orsakas av typen float.

Tillagd i version 3.3.

Ändrad i version 3.10: I Windows är klockan nu densamma för alla processer.

Ändrad i version 3.13: Använd samma klocka som time.monotonic().

time.perf_counter_ns() → int

Liknar perf_counter(), men returnerar tid som nanosekunder.

Tillagd i version 3.7.

time.process_time() → float

Returnerar värdet (i bråkdelar av sekunder) av summan av systemets och användarens CPU-tid för den aktuella processen. Den inkluderar inte tid som förflutit under vila. Den är processomfattande per definition. Referenspunkten för det returnerade värdet är odefinierad, vilket innebär att endast skillnaden mellan resultaten av två anrop är giltig.

Använd process_time_ns() för att undvika den precisionsförlust som orsakas av typen float.

Tillagd i version 3.3.

time.process_time_ns() → int

Liknar process_time() men returnerar tid som nanosekunder.

Tillagd i version 3.7.

time.sleep(secs)

Avbryter exekveringen av den anropande tråden under det angivna antalet sekunder. Argumentet kan vara ett flyttal för att ange en mer exakt sömntid.

Om viloläget avbryts av en signal och inget undantag utlöses av signalhanteraren, startas viloläget om med en nyberäknad timeout.

Avstängningstiden kan vara längre än vad som begärts med ett godtyckligt belopp, på grund av schemaläggningen av annan aktivitet i systemet.

Implementering i Windows

Om secs är noll i Windows överlåter tråden återstoden av sin tidsandel till någon annan tråd som är redo att köra. Om det inte finns några andra trådar som är redo att köras returneras funktionen omedelbart och tråden fortsätter att köras. På Windows 8.1 och senare använder implementeringen en högupplöst timer som ger en upplösning på 100 nanosekunder. Om secs är noll används Sleep(0).

Unix-implementering

• Använd clock_nanosleep() om det finns tillgängligt (upplösning: 1 nanosekund);

• Eller använd nanosleep() om det finns tillgängligt (upplösning: 1 nanosekund);

• Eller använd select() (upplösning: 1 mikrosekund).

Anteckning

För att efterlikna en ”no-op”, använd pass istället för time.sleep(0).

För att frivilligt överlåta processorn, ange en realtids- scheduling policy och använd os.sched_yield() istället.

Utlöser en auditing event time.sleep med argumentet secs.

Ändrad i version 3.5: Funktionen sover nu minst sekunder även om sömnen avbryts av en signal, förutom om signalhanteraren utlöser ett undantag (se PEP 475 för motivering).

Ändrad i version 3.11: På Unix används nu funktionerna clock_nanosleep() och nanosleep() om de är tillgängliga. På Windows används nu en väntande timer.

Ändrad i version 3.13: Utlöser en granskningshändelse.

time.strftime(format[, t])

Konverterar en tupel eller struct_time som representerar en tid som returneras av gmtime() eller localtime() till en sträng som anges av argumentet format. Om t inte anges används den aktuella tiden som returneras av localtime(). format måste vara en sträng. ValueError utlöses om något fält i t ligger utanför det tillåtna intervallet.

0 är ett lagligt argument för vilken position som helst i tidstupeln; om det normalt är olagligt tvingas värdet till ett korrekt värde.

Följande direktiv kan bäddas in i format-strängen. De visas utan den valfria fältbredd- och precisionsspecifikationen, och ersätts av de angivna tecknen i strftime()-resultatet:

Direktiv	Betydelse	Anteckningar
%a	Locale’s förkortade veckodagsnamn.
%A	Lokalens fullständiga veckodagsnamn.
%b	Lokalens förkortade månadsnamn.
%B	Lokalens fullständiga månadsnamn.
%c	Locales lämpliga datum- och tidsrepresentation.
%d	Månadens dag som ett decimaltal [01,31].
%f	Mikrosekunder som ett decimaltal [000000,999999].	(1)
%H	Timme (24-timmarsklocka) som decimaltal [00,23].
%I	Timme (12-timmars klocka) som decimaltal [01,12].
%j	Årets dag som ett decimaltal [001,366].
%m	Månad som ett decimaltal [01,12].
%M	Minut som ett decimaltal [00,59].
%p	Lokalens motsvarighet till antingen AM eller PM.	(2)
%S	Sekunder som decimaltal [00,61].	(3)
%U	Årets veckonummer (söndag som första veckodag) som ett decimaltal [00,53]. Alla dagar i ett nytt år som föregår den första söndagen anses vara i vecka 0.	(4)
%u	Veckodag (måndag är 1; söndag är 7) som ett decimaltal [1, 7].
%w	Veckodag som ett decimaltal [0(söndag),6].
%W	Årets veckonummer (måndag som första dag i veckan) som decimaltal [00,53]. Alla dagar i ett nytt år som föregår den första måndagen anses vara i vecka 0.	(4)
%x	Locales lämpliga datumrepresentation.
%X	Locales lämpliga tidsrepresentation.
%y	Årtal utan århundrade som decimaltal [00,99].
%Y	År med sekel som decimaltal.
%z	Tidszonsförskjutning som anger en positiv eller negativ tidsskillnad från UTC/GMT av formen +HHMM eller -HHMM, där H representerar decimala timsiffror och M representerar decimala minutsiffror [-23:59, +23:59]. [1]
%Z	Namn på tidszon (inga tecken om det inte finns någon tidszon). Föråldrad. [1]
%G	ISO 8601-år (liknar %Y men följer reglerna för ISO 8601-kalenderåret). Året börjar med den vecka som innehåller den första torsdagen i kalenderåret.
%V	ISO 8601 veckonummer (som ett decimaltal [01,53]). Årets första vecka är den vecka som innehåller årets första torsdag. Veckorna börjar på måndagen.
%%	Ett bokstavligt '%'-tecken.

Anteckningar:

1. Formatdirektivet %f gäller bara för strptime(), inte för strftime(). Se dock även datetime.datetime.strptime() och datetime.datetime.strftime() där formatdirektivet %f gäller för mikrosekunder.

2. När det används med funktionen strptime() påverkar direktivet %p endast fältet för utmatad timme om direktivet %I används för att tolka timmen.

3. Intervallet är egentligen 0 till 61; värdet 60 är giltigt i tidsstämplar som representerar leap seconds och värdet 61 stöds av historiska skäl.

4. När de används med funktionen strptime() används %U och %W endast i beräkningar när veckodag och år anges.

Här är ett exempel, ett format för datum som är kompatibelt med det som anges i RFC 2822 Internet email standard. [1]

>>> from time import gmtime, strftime
>>> strftime("%a, %d %b %Y %H:%M:%S +0000", gmtime())
'Thu, 28 Jun 2001 14:17:15 +0000'

Ytterligare direktiv kan stödjas på vissa plattformar, men endast de som listas här har en betydelse som standardiserats av ANSI C. För att se den fullständiga uppsättningen formatkoder som stöds på din plattform, se strftime(3)-dokumentationen.

På vissa plattformar kan en valfri specifikation av fältbredd och precision följa direkt efter den inledande '%' i ett direktiv i följande ordning; detta är inte heller portabelt. Fältbredden är normalt 2 utom för %j där den är 3.

time.strptime(string[, format])

Analyserar en sträng som representerar en tid enligt ett format. Returvärdet är en struct_time som returneras av gmtime() eller localtime().

Parametern format använder samma direktiv som används av strftime(); standardvärdet är "%a %b %d %H:%M:%S %Y" vilket matchar formateringen som returneras av ctime(). Om sträng inte kan analyseras enligt format, eller om den har överflödig data efter analyseringen, kommer ValueError att visas. De standardvärden som används för att fylla i saknade data när mer exakta värden inte kan härledas är (1900, 1, 1, 0, 0, 0, 0, 0, 1, -1). Både string och format måste vara strängar.

Till exempel:

>>> import time
>>> time.strptime("30 Nov 00", "%d %b %y")
time.struct_time(tm_year=2000, tm_mon=11, tm_mday=30, tm_hour=0, tm_min=0,
                 tm_sec=0, tm_wday=3, tm_yday=335, tm_isdst=-1)

Stöd för direktivet %Z baseras på värdena i tzname och om daylight är sant. På grund av detta är det plattformsspecifikt med undantag för att känna igen UTC och GMT som alltid är kända (och anses vara tidszoner utan sommartid).

Endast de direktiv som anges i dokumentationen stöds. Eftersom strftime() implementeras per plattform kan den ibland erbjuda fler direktiv än de som listas. Men strptime() är oberoende av plattform och stöder därför inte nödvändigtvis alla tillgängliga direktiv som inte är dokumenterade som stödda.

class time.struct_time

Typen av tidsvärdessekvens som returneras av gmtime(), localtime() och strptime(). Det är ett objekt med ett named tuple-gränssnitt: värden kan nås via index och via attributnamn. Följande värden är närvarande:

Index	Attribut	Värden
0	tm_year	(t.ex. 1993)
1	tm_mon	intervall [1, 12]
2	tm_mday	intervall [1, 31]
3	tm_hour	intervall [0, 23]
4	tm_min	intervall [0, 59]
5	tm_sec	intervall [0, 61]; se Anmärkning (2) i strftime()
6	tm_wday	intervall [0, 6]; Måndag är 0
7	tm_yday	range [1, 366]
8	tm_isdst	0, 1 eller -1; se nedan
N/A	tm_zone	förkortning av tidszonens namn
N/A	tm_gmtoff	offset öster om UTC i sekunder

Observera att till skillnad från C-strukturen är månadsvärdet ett intervall på [1, 12], inte [0, 11].

I anrop till mktime() kan tm_isdst sättas till 1 när sommartid gäller och till 0 när den inte gäller. Ett värde på -1 indikerar att detta inte är känt, och kommer vanligtvis att resultera i att rätt tillstånd fylls i.

När en tupel med fel längd skickas till en funktion som förväntar sig en struct_time, eller som har element av fel typ, uppstår ett TypeError.

time.time() → float

Returnerar tiden i sekunder sedan epoch som ett flyttal. Hanteringen av leap seconds är plattformsberoende. På Windows och de flesta Unix-system räknas inte skottsekunderna in i tiden i sekunder sedan epoch. Detta kallas vanligen för Unix-tid.

Observera att även om tiden alltid returneras som ett flyttal, är det inte alla system som ger tid med bättre precision än 1 sekund. Även om denna funktion normalt returnerar icke-dekalerande värden, kan den returnera ett lägre värde än ett tidigare anrop om systemklockan har ställts tillbaka mellan de två anropen.

Det tal som returneras av time() kan konverteras till ett vanligare tidsformat (dvs. år, månad, dag, timme, etc…) i UTC genom att skicka det till funktionen gmtime() eller i lokal tid genom att skicka det till funktionen localtime(). I båda fallen returneras ett struct_time-objekt, från vilket komponenterna i kalenderdatumet kan nås som attribut.

Klockan:

• I Windows anropar du GetSystemTimePreciseAsFileTime().

• Anropa clock_gettime(CLOCK_REALTIME) om tillgängligt.

• Annars anropar du gettimeofday().

Använd time_ns() för att undvika den precisionsförlust som orsakas av typen float.

Ändrad i version 3.13: I Windows anropas GetSystemTimePreciseAsFileTime() istället för GetSystemTimeAsFileTime().

time.time_ns() → int

Liknar time() men returnerar tiden som ett heltal av nanosekunder sedan epoch.

Tillagd i version 3.7.

time.thread_time() → float

Returnerar värdet (i bråkdelar av sekunder) av summan av systemets och användarens CPU-tid för den aktuella tråden. Den inkluderar inte tid som förflutit under sömn. Det är trådspecifikt per definition. Referenspunkten för det returnerade värdet är odefinierad, vilket innebär att endast skillnaden mellan resultaten av två anrop i samma tråd är giltig.

Använd thread_time_ns() för att undvika den precisionsförlust som orsakas av typen float.

Tillgänglighet: Linux, Unix, Windows.

Unix-system som stöder CLOCK_THREAD_CPUTIME_ID.

Tillagd i version 3.7.

time.thread_time_ns() → int

Liknar thread_time() men returnerar tid som nanosekunder.

Tillagd i version 3.7.

time.tzset()

Återställer tidsomvandlingsreglerna som används av biblioteksrutinerna. Miljövariabeln TZ anger hur detta ska göras. Den kommer också att ställa in variablerna tzname (från miljövariabeln TZ), timezone (icke-DST sekunder väster om UTC), altzone (DST sekunder väster om UTC) och daylight (till 0 om denna tidszon inte har några regler för sommartid, eller till icke-noll om det finns en tid, dåtid, nutid eller framtid då sommartid gäller).

Tillgänglighet: Unix.

Anteckning

Även om ändring av miljövariabeln TZ i många fall kan påverka utdata från funktioner som localtime() utan att anropa tzset(), bör man inte förlita sig på detta beteende.

Miljövariabeln TZ får inte innehålla några blanksteg.

Standardformatet för miljövariabeln TZ är (blanksteg har lagts till för tydlighetens skull):

std offset [dst [offset [,start[/tid], slut[/tid]]]]

Var komponenterna finns:

std och dst

Tre eller fler alfanumeriska tecken som anger tidszonens förkortningar. Dessa kommer att överföras till time.tzname

offset

Offset har följande form: ± hh[:mm[:ss]]. Detta anger värdet som läggs till den lokala tiden för att komma fram till UTC. Om det föregås av ett ’-’ är tidszonen öster om nollmeridianen, annars är den väster. Om ingen offset följer efter dst antas sommartiden vara en timme före standardtiden.

start[/tid], slut[/tid]

Anger när man ska byta till och från sommartid. Formatet för start- och slutdatumen är något av följande:

Jn

Den julianska dagen n (1 <= n <= 365). Skottdagar räknas inte, så under alla år är den 28 februari dag 59 och den 1 mars dag 60.

n

Den nollbaserade julianska dagen (0 <= n <= 365). Skottdagar räknas och det är möjligt att hänvisa till den 29 februari.

Mm.n.d

Den d:e dagen (0 <= d <= 6) i vecka n i månad m under året (1 <= n <= 5, 1 <= m <= 12, där vecka 5 betyder ”den sista d-dagen i månad m” som kan inträffa antingen under den fjärde eller den femte veckan). Vecka 1 är den första vecka under vilken den d:e dagen inträffar. Dag noll är en söndag.

time har samma format som offset förutom att inget inledande tecken (’-’ eller ’+’) tillåts. Standardvärdet, om tid inte anges, är 02:00:00.

>>> os.environ['TZ'] = 'EST+05EDT,M4.1.0,M10.5.0'
>>> time.tzset()
>>> time.strftime('%X %x %Z')
'02:07:36 05/08/03 EDT'
>>> os.environ['TZ'] = 'AEST-10AEDT-11,M10.5.0,M3.5.0'
>>> time.tzset()
>>> time.strftime('%X %x %Z')
'16:08:12 05/08/03 AEST'

På många Unix-system (inklusive *BSD, Linux, Solaris och Darwin) är det mer praktiskt att använda systemets zoninfo-databas (tzfile(5)) för att ange tidszonsreglerna. Detta gör du genom att ställa in miljövariabeln TZ till sökvägen för den önskade tidszonsdatafilen, i förhållande till roten för systemets tidszonsdatabas ’zoneinfo’, som vanligtvis finns i /usr/share/zoneinfo. Till exempel 'US/Eastern', 'Australia/Melbourne', 'Egypt' eller 'Europe/Amsterdam'.

>>> os.environ['TZ'] = 'US/Eastern'
>>> time.tzset()
>>> time.tzname
('EST', 'EDT')
>>> os.environ['TZ'] = 'Egypt'
>>> time.tzset()
>>> time.tzname
('EET', 'EEST')

Klock-ID-konstanter

Dessa konstanter används som parametrar för clock_getres() och clock_gettime().

time.CLOCK_BOOTTIME

Identisk med CLOCK_MONOTONIC, förutom att den även inkluderar all tid då systemet är avstängt.

Detta gör det möjligt för program att få en monoton klocka med suspensionsmedvetenhet utan att behöva hantera komplikationerna med CLOCK_REALTIME, som kan ha diskontinuiteter om tiden ändras med settimeofday() eller liknande.

Tillgänglighet: Linux >= 2.6.39.

Tillagd i version 3.7.

time.CLOCK_HIGHRES

Solaris OS har en CLOCK_HIGHRES-timer som försöker använda en optimal maskinvarukälla och kan ge en upplösning som ligger nära nanosekunder. CLOCK_HIGHRES är den icke justerbara, högupplösta klockan.

Tillgänglighet: Solaris.

Tillagd i version 3.3.

time.CLOCK_MONOTONIC

Klocka som inte kan ställas in och som representerar monoton tid sedan någon ospecificerad startpunkt.

Tillgänglighet: Unix.

Tillagd i version 3.3.

time.CLOCK_MONOTONIC_RAW

Liknar CLOCK_MONOTONIC, men ger tillgång till en rå hårdvarubaserad tid som inte är föremål för NTP-justeringar.

Tillgänglighet: Linux >= 2.6.28, macOS >= 10.12.

Tillagd i version 3.3.

time.CLOCK_MONOTONIC_RAW_APPROX

Liknar CLOCK_MONOTONIC_RAW, men läser ett värde som cachas av systemet vid kontextbyte och har därför mindre noggrannhet.

Tillgänglighet: macOS >= 10.12.

Tillagd i version 3.13.

time.CLOCK_PROCESS_CPUTIME_ID

Högupplösta timer per process från CPU.

Tillgänglighet: Unix.

Tillagd i version 3.3.

time.CLOCK_PROF

Högupplösta timer per process från CPU.

Tillgänglighet: FreeBSD, NetBSD >= 7, OpenBSD.

Tillagd i version 3.7.

time.CLOCK_TAI

Internationell atomtid

Systemet måste ha en aktuell skottsekundstabell för att detta ska ge rätt svar. PTP- eller NTP-programvara kan upprätthålla en skottsekundstabell.

Tillgänglighet: Linux.

Tillagd i version 3.9.

time.CLOCK_THREAD_CPUTIME_ID

Trådspecifik CPU-tidsklocka.

Tillgänglighet: Unix.

Tillagd i version 3.3.

time.CLOCK_UPTIME

Tid vars absoluta värde är den tid som systemet har varit igång och inte avbrutits, vilket ger en exakt mätning av drifttiden, både absolut och i intervall.

Tillgänglighet: FreeBSD, OpenBSD >= 5.5.

Tillagd i version 3.7.

time.CLOCK_UPTIME_RAW

Klocka som ökar monotont och registrerar tiden sedan en godtycklig punkt, som inte påverkas av frekvens- eller tidsjusteringar och som inte ökar när systemet är i viloläge.

Tillgänglighet: macOS >= 10.12.

Tillagd i version 3.8.

time.CLOCK_UPTIME_RAW_APPROX

Som CLOCK_UPTIME_RAW, men värdet cachas av systemet vid kontextbyten och är därför mindre exakt.

Tillgänglighet: macOS >= 10.12.

Tillagd i version 3.13.

Följande konstant är den enda parameter som kan skickas till clock_settime().

time.CLOCK_REALTIME

Klocka i realtid. För att ställa in denna klocka krävs lämpliga behörigheter. Klockan är densamma för alla processer.

Tillgänglighet: Unix.

Tillagd i version 3.3.

Konstanter för tidszon

time.altzone

Förskjutningen av den lokala DST-tidszonen, i sekunder väster om UTC, om en sådan har definierats. Detta är negativt om den lokala tidszonen för sommartid är öster om UTC (som i Västeuropa, inklusive Storbritannien). Använd endast detta om daylight är icke-noll. Se anmärkning nedan.

time.daylight

Nonzero om en DST-tidszon har definierats. Se anmärkning nedan.

time.timezone

Förskjutningen av den lokala (icke-DST) tidszonen, i sekunder väster om UTC (negativ i större delen av Västeuropa, positiv i USA, noll i Storbritannien). Se anmärkning nedan.

time.tzname

En tupel av två strängar: den första är namnet på den lokala tidszonen som inte är DST, den andra är namnet på den lokala tidszonen som är DST. Om ingen DST-tidszon är definierad ska den andra strängen inte användas. Se anmärkning nedan.

Anteckning

För ovanstående tidszonskonstanter (altzone, daylight, timezone och tzname) bestäms värdet av de tidszonsregler som gäller när modulen laddas eller när tzset() senast anropas och kan vara felaktiga för tidigare tidpunkter. Det rekommenderas att använda resultaten tm_gmtoff och tm_zone från localtime() för att få information om tidszon.

Se även

Modul datetime

Mer objektorienterat gränssnitt för datum och klockslag.

Modul locale

Tjänster för internationalisering. Lokalinställningen påverkar tolkningen av många formatspecifikatorer i strftime() och strptime().

Modul kalender

Allmänna kalenderrelaterade funktioner. timegm() är inversen av gmtime() från denna modul.

Fotnoter

[1] (1,2,3)

Användningen av %Z är nu föråldrad, men %z escapen som expanderar till den önskade tim/minutförskjutningen stöds inte av alla ANSI C-bibliotek. En strikt läsning av den ursprungliga standarden RFC 822 från 1982 kräver också ett tvåsiffrigt år (%y i stället för %Y), men praxis övergick till fyrsiffriga år långt före år 2000. Efter det blev RFC 822 föråldrad och det fyrsiffriga året har först rekommenderats av RFC 1123 och sedan påbjudits av RFC 2822.