Tidsmodul i Python 3. Huvudmetoder, mallar, exempel

Nästan alla program använder tid. I Python har ett separat bibliotek utvecklats för detta – tidanvänds för att utföra en mängd olika åtgärder med den. För att få det att fungera måste det först deklareras i början av koden. Den här raden används för detta:

importtid

Låt oss överväga olika alternativ för hur man använder den här modulen korrekt i praktiken. 

Bestämma antalet sekunder sedan epoken

För att utföra denna uppgift finns det en funktion tid() som inte tar några parametrar. Dess returvärde är hur många sekunder som har gått sedan 1 januari 1970. I Python kallas denna tid för början på en epok. Åtminstone i operativsystem i Unix-familjen.

När det gäller Windows är datumet detsamma, men det kan finnas problem med negativa värden som var före detta datum. 

Tidszonen som används är UTC.

importtid

sekunder = tid.tid()

print(“Sekunder sedan epok =”, sekunder)

Komplexiteten med denna funktion är att den inte visar exakt datum, utan bara antalet sekunder. För att konvertera till det format som alla känner till måste du använda korrekt information. För detta används funktionen time.ctime().

Returnerar datum och tid i vanligt format

För att returnera tiden i det vanliga formatet finns det en metod time.ctime(). Hakparenteserna indikerar en variabel eller ett tal som anger antalet sekunder som har gått sedan epokens början. Denna metod returnerar alla datum- och tidsegenskaper, inklusive datum, år, antal timmar, minuter, sekunder och veckodag.

Denna funktion kan även användas utan argument. I det här fallet returnerar den aktuellt datum, tid och så vidare.

Här är ett kodavsnitt som visar detta.

importtid

print(time.ctime())

Tis 23 okt 10:18:23 2018

Den sista raden är vad som skrivs ut till konsolen där Python-tolken körs. Metoden formaterar automatiskt det mottagna antalet sekunder till en användarbekant form. Det är sant att alla element som beskrivs ovan används sällan. Som regel behöver du antingen bara få tiden, eller bara dagens datum. För detta används en separat funktion – strftime(). Men innan vi överväger det måste vi analysera klassen time.struct_time.

klasstid.struct_time

Detta är en kategori av argument som kan accepteras med en rad olika metoder. Den har inga alternativ. Det är en tuppel med ett namngivet gränssnitt. Enkelt uttryckt kan elementen i denna klass nås både med namn och indexnummer.

Den består av följande attribut.

Uppmärksamhet! Till skillnad från ett antal andra programmeringsspråk kan månaden här variera från 1 till 12, och inte från noll till 11.

Returnera ett specifikt format

Använda funktionen strftime () du kan få år, månad, dag, timme, minuter, sekunder individuellt och returnera dem till en textsträng. Sedan kan den skrivas ut till användaren med hjälp av funktionen skriv ut () eller på annat sätt bearbetas.

Som ett argument kan en funktion ta vilken variabel som helst som tar ett värde som returneras av andra funktioner i denna modul. Till exempel kan du överföra den lokala tiden till den (det kommer att diskuteras senare), från vilken den kommer att dra ut nödvändiga data.

Här är kodavsnittet där vi gör det.

importtid

named_tuple = time.localtime() # get struct_time

time_string = time.strftime(«%m/%d/%Y, %H:%M:%S», named_tuple)

print(time_string)

Om du kör den här koden kommer aktuellt datum och tid att visas. Formatet och sekvensen av element kan ändras. De är följande:

1. %Y är året.
2. %m är månaden.
3. %D-dagen.
4. %H – tid.
5. %M – minuter.
6. %S – sekund.

Följaktligen kan du göra det så att utgången uteslutande är för månaden och dagen. För att göra detta behöver du helt enkelt inte ge ett kommando för att visa årtalet. Det vill säga, skriv i formeln ovan som ett argument %m/%d, och det är allt. Eller vice versa, %d/%m. 

Faktum är att antalet strängliteraler är mycket större. Här är en tabell där de beskrivs i detalj.

Skjut upp en tråd ett visst antal sekunder

För detta används funktionen sova (). Ett ganska stort block av programmeringsuppgifter är förknippat med tidens gång. Ibland måste man skjuta upp nästa steg en viss tid. Till exempel om du behöver interagera med en databas som tar en viss tid att bearbeta.

Som argument använder metoden ett värde som uttrycker antalet sekunder för att fördröja nästa steg från algoritmen.

Till exempel, i det här utdraget är fördröjningen 10 sekunder.

importtid

paus = 10

print(«Program startat...»)

time.sleep(paus)

print(str(paus) + » sekunder passerade.»)

Som ett resultat kommer vi att få detta:

Programmet startat...

10 sekunder gick.

Som vi kan se av resultatet rapporterar programmet först att det har startat. Och efter tio sekunder skrev hon att den här tiden hade gått.

Funktionen låter dig ange pausens varaktighet i millisekunder. För att göra detta använder vi bråkvärden av funktionsargumentet sömn. Till exempel, 0,1. Det betyder att fördröjningen blir 100 millisekunder.

Få lokal tid

Med hjälp av funktionen localtime() får programmet antalet sekunder sedan epokens början i en specifik tidszon. 

Låt oss ge en exempelkod för tydlighetens skull.

importtid

resultat = time.localtime(1575721830)

print(“resultat:”, resultat)

print(«nгод:», result.tm_year)

print(«tm_hour:», result.tm_hour)

Returnera struct_time i UTC baserat på antalet sekunder sedan epok

Denna uppgift uppnås med hjälp av time.gmtime(). metod. Det blir tydligare om vi ger ett exempel.

importtid

resultat = time.gmtime(1575721830)

print(“resultat:”, resultat)

print(«nгод:», result.tm_year)

print(«tm_hour:», result.tm_hour)

Om du aktiverar denna sekvens av åtgärder, kommer en uppsättning element relaterade till tid, år och tidszon att visas.

Returnera antalet sekunder sedan epokens början med automatisk konvertering till lokal tid

Ställs du inför en sådan uppgift genomförs den med metoden mktime (), som tar struct_time. Efter det utför den den omvända åtgärden av funktionen lokal tid(). Det vill säga, den omvandlar tiden enligt den lokala tidszonen till antalet sekunder som har gått sedan epokens början, justerat för tidszonen.

Funktionerna mktime() och localtime() är tätt sammanflätade. Detta kodavsnitt visar tydligt detta. Låt oss ta en titt på det för att förstå djupare hur det fungerar. 

importtid

sekunder = 1575721830

# returnerar struct_time

t = tid.lokaltid(sekunder)

print(«t1: «, t)

# returnerar sekunder från struct_time

s = tid.mktid(t)

print(«ns:», sekunder)

Vi ser att variabeln sekunder har tilldelats 1575721830 sekunder sedan epoken. Först får programmet exakt datum, tid och andra parametrar, baserat på detta värde, lägg det i en variabel t, och konverterar sedan dess innehåll till en variabel s.

Därefter slår en ny rad av och visar antalet sekunder i konsolen. Du kan kontrollera att det kommer att vara samma nummer som tilldelades sekundvariabeln.

Utdata från 9 siffror som refererar till struct_time

Anta att vi har 9 tal som representerar år, månad, datum, veckodag och ett antal andra värden, och vi måste kombinera dem till en sträng. För detta används funktionen asctime(). Hon accepterar eller är redo struct_time, eller någon annan tupel med 9 värden som står för detsamma. Därefter returneras en sträng som är ett datum, tid och ett antal andra parametrar. 

Det är mycket bekvämt att använda den här metoden för att föra olika användarspecificerade data till en enda variabel..

Det kan till exempel vara ett program där användaren separat anger dag, månad, år, veckodag och annan information om registrering till ett evenemang. Därefter läggs den mottagna informationen in i databasen och skickas sedan till en annan person som begär det.

Hämta tid och datum baserat på Python-sträng

Anta att användaren har specificerat olika data, och vi måste kombinera dem till en rad i det format som personen angav, och sedan göra en kopia till en annan variabel och bygga om den till ett standardformat där. För detta används funktionen time.strptime().

Den tar en variabel där detta värde är specificerat och returnerar det som redan är bekant för oss struct_time.

För tydlighetens skull kommer vi att skriva ett sådant program.

importtid

time_string = «15 juni 2019»

resultat = time.strptime(time_string, «%d %B, %Y»)

skriva ut (resultat)

Gissa vad resultatet blir? Försök att gissa utan att titta på den nedersta raden. Och kolla sedan svaret.

time.struct_time(tm_year=2019, tm_mon=6, tm_mday=15, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=5, tm_yday=166, tm_isdst=-1)

Med ett ord, att arbeta med datum och tider i Python är inte alls svårt. Det räcker att följa dessa instruktioner, och allt kommer att fungera. Använda biblioteket tid användaren får ett stort antal möjligheter att arbeta med tid, såsom:

1. Stäng av programkörningen under en viss tid.
2. Visa tiden som har gått sedan epoken, i sekunder. Denna information kan användas för att summera tid eller utföra andra matematiska operationer på den.
3. Konvertera till ett bekvämt format. Dessutom kan programmeraren själv ställa in vilka element som ska visas och i vilken ordningsföljd. 

Det finns också en rad andra möjligheter, men idag har vi analyserat de mest grundläggande. De kommer väl till pass i nästan alla program som på något sätt fungerar med tiden. Lycka till.