Mòdul de temps en Python 3. Mètodes principals, plantilles, exemples

Gairebé qualsevol programa utilitza el temps. A Python, s'ha desenvolupat una biblioteca separada per a això: tempss'utilitza per realitzar diverses accions amb ell. Perquè funcioni, primer s'ha de declarar al principi del codi. Aquesta línia s'utilitza per a això:

temps d'importació

Considerem diferents opcions sobre com utilitzar aquest mòdul correctament a la pràctica. 

Determinació del nombre de segons des de l'època

Per dur a terme aquesta tasca, hi ha una funció temps() que no pren paràmetres. El seu valor de retorn és quants segons han passat des de l'1 de gener de 1970. A Python, aquest temps s'anomena l'inici d'una època. Almenys en sistemes operatius de la família Unix.

Pel que fa a Windows, la data és la mateixa, però pot haver-hi problemes amb valors negatius anteriors a aquesta data. 

La zona horària utilitzada és UTC.

temps d'importació

segons = temps.temps()

print("Segons des de l'època =", segons)

La complexitat d'aquesta funció és que no mostra exactament la data, sinó només el nombre de segons. Per convertir-lo al format conegut per a tothom, cal que utilitzeu informació precisa. Per a això s'utilitza la funció temps.ctime().

Tornant la data, l'hora en el format habitual

Per tornar l'hora en el format habitual, hi ha un mètode temps.ctime(). Els claudàtors indiquen una variable o un número que indica el nombre de segons que han passat des de l'inici de l'època. Aquest mètode retorna totes les característiques de data i hora, inclosos la data, l'any, el nombre d'hores, els minuts, els segons i el dia de la setmana.

Aquesta funció també es pot utilitzar sense arguments. En aquest cas, retorna la data, l'hora, etc. actuals.

Aquí teniu un fragment de codi que ho demostra.

temps d'importació

imprimir(time.ctime())

Dimarts 23 d'octubre 10:18:23 2018

L'última línia és el que s'imprimeix a la consola on s'executa l'intèrpret de Python. El mètode formata automàticament el nombre de segons rebuts en un formulari conegut per l'usuari. És cert que tots els elements descrits anteriorment s'utilitzen poques vegades. Per regla general, heu d'obtenir només l'hora o només la data d'avui. Per a això, s'utilitza una funció independent: strftime(). Però abans de considerar-ho, hem d'analitzar la classe temps.temps_estructura.

temps de classe.temps_estructura

Aquesta és una categoria d'arguments que es poden acceptar per diversos mètodes. No té cap opció. És una tupla amb una interfície anomenada. En poques paraules, es pot accedir als elements d'aquesta classe tant pel nom com pel número d'índex.

Consta dels següents atributs.

Atenció! A diferència d'altres llenguatges de programació, aquí el mes pot anar d'1 a 12, i no de zero a 11.

Devolució d'un format específic

Utilitzant la funció strftime() podeu obtenir l'any, el mes, el dia, l'hora, els minuts i els segons individualment i tornar-los a una cadena de text. A continuació, es pot imprimir a l'usuari mitjançant la funció imprimir () o processats d'una altra manera.

Com a argument, una funció pot prendre qualsevol variable que prengui un valor retornat per altres funcions d'aquest mòdul. Per exemple, podeu transferir-hi l'hora local (se'n parlarà més endavant), de la qual traurà les dades necessàries.

Aquí teniu el fragment de codi on ho fem.

temps d'importació

named_tuple = time.localtime() # obtenir struct_time

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

imprimir(cadena_hora)

Si executeu aquest codi, es mostraran la data i l'hora actuals. El format i la seqüència dels elements es poden canviar. Són els següents:

1. %Y és l'any.
2. %m és el mes.
3. %d - dia.
4. %H - temps.
5. %M – minuts.
6. %S – segon.

En conseqüència, podeu fer que la sortida sigui exclusivament del mes i del dia. Per fer-ho, simplement no cal que doneu una ordre per mostrar l'any. És a dir, escriviu a la fórmula anterior com a argument %m/%d, i ja està. O viceversa, %d/%m. 

De fet, el nombre de literals de cadena és molt més gran. Aquí teniu una taula on es descriuen amb detall.

Posposa un fil durant un nombre determinat de segons

Per a això s'utilitza la funció dormir (). Un bloc bastant gran de tasques de programació està associat amb el pas del temps. De vegades has de posposar el següent pas per un temps determinat. Per exemple, si necessiteu interactuar amb una base de dades que triga un cert temps a processar-se.

Com a argument, el mètode utilitza un valor que expressa el nombre de segons per retardar el pas següent de l'algorisme.

Per exemple, en aquest fragment, el retard és de 10 segons.

temps d'importació

pausa = 10

print(«Programa iniciat...»)

temps.dormir (pausa)

print(str(pausa) + » segons han passat.»)

Com a resultat, obtindrem això:

Programa començat...

Han passat 10 segons.

Com podem veure a la sortida, el programa primer informa que s'ha iniciat. I després de deu segons, va escriure que aquest temps havia passat.

La funció us permet especificar la durada de la pausa en mil·lisegons. Per fer-ho, utilitzem valors fraccionaris de l'argument de la funció dormir. Per exemple, 0,1. Això vol dir que el retard serà de 100 mil·lisegons.

Obteniu hora local

Utilitzant la funció localtime(), el programa obté el nombre de segons des de l'inici de l'època en una zona horària específica. 

Donem un exemple de codi per a més claredat.

temps d'importació

resultat = time.localtime(1575721830)

print("resultat:", resultat)

print(«nгод:», resultat.tm_any)

print(«tm_hour:», resultat.tm_hour)

Retorna struct_time en UTC en funció del nombre de segons des de l'època

Aquesta tasca s'aconsegueix utilitzant time.gmtime(). mètode. Ens quedarà més clar si posem un exemple.

temps d'importació

resultat = temps.gmtime(1575721830)

print("resultat:", resultat)

print(«nгод:», resultat.tm_any)

print(«tm_hour:», resultat.tm_hour)

Si activeu aquesta seqüència d'accions, es mostrarà un conjunt d'elements relacionats amb l'hora, l'any i la zona horària.

Retorna el nombre de segons des de l'inici de l'època amb la conversió automàtica a l'hora local

Si us trobeu davant d'aquesta tasca, s'implementa mitjançant el mètode mktime(), que pren struct_time. Després d'això, realitza l'acció inversa de la funció hora local(). És a dir, converteix l'hora segons la zona horària local en el nombre de segons que han passat des de l'inici de l'època, ajustat per a la zona horària.

Les funcions mktime() i localtime() estan estretament entrellaçades. Aquest fragment de codi ho demostra clarament. Fem-hi una ullada per entendre més profundament com funciona. 

temps d'importació

segons = 1575721830

# retorna struct_time

t = hora.hora local (segons)

imprimir(«t1: «, t)

# retorna segons des de struct_time

s = temps.mktime(t)

imprimir(«ns:», segons)

Veiem que la variable 2 s'ha assignat 1575721830 segons des de l'època. En primer lloc, el programa obté la data exacta, l'hora i altres paràmetres, basant-se en aquest valor, el posen en una variable t, i després converteix el seu contingut en una variable s.

Després d'això, supera una nova línia i mostra el nombre de segons a la consola. Podeu comprovar que serà el mateix número que s'ha assignat a la variable segons.

Data de sortida de 9 números que fan referència a struct_time

Suposem que tenim 9 números que representen l'any, el mes, la data, el dia de la setmana i una sèrie d'altres valors, i hem de combinar-los en una cadena. Per a això s'utilitza la funció asctime(). Ella accepta o està preparada struct_time, o qualsevol altra tupla de 9 valors que signifiqui el mateix. Després d'això, es retorna una cadena, que és una data, hora i una sèrie d'altres paràmetres. 

És molt convenient utilitzar aquest mètode per incorporar dades diferents especificades per l'usuari en una sola variable..

Per exemple, pot ser un programa on l'usuari especifiqui per separat el dia, el mes, l'any, el dia de la setmana i altres dades relacionades amb la inscripció a un esdeveniment. Després d'això, la informació rebuda s'introdueix a la base de dades i després s'envia a una altra persona que la sol·liciti.

Obtenció de l'hora i la data en funció de la cadena de Python

Suposem que l'usuari ha especificat dades diferents i hem de combinar-les en una línia en el format que la persona ha introduït, i després fer una còpia a una altra variable i reconstruir-la en un format estàndard allà. Per a això s'utilitza la funció temps.strptime().

Pren una variable en la qual s'especifica aquest valor i ens retorna el que ja és familiar struct_time.

Per a més claredat, escriurem aquest programa.

temps d'importació

time_string = «15 de juny de 2019»

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

imprimir (resultat)

Endevineu quina serà la sortida? Intenta endevinar sense mirar la línia de fons. I després comproveu la resposta.

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)

En una paraula, treballar amb dates i hores a Python no és gens difícil. N'hi ha prou amb seguir aquestes instruccions i tot funcionarà. Ús de la Biblioteca temps l'usuari té un gran nombre d'oportunitats per treballar amb el temps, com ara:

1. Suspensió de l'execució del programa durant un període de temps especificat.
2. Mostra el temps que ha passat des de l'època, en segons. Aquesta informació es pot utilitzar per sumar el temps o realitzar altres operacions matemàtiques sobre ell.
3. Converteix a un format convenient. A més, el mateix programador pot establir quins elements es mostraran i en quina seqüència. 

També hi ha moltes altres possibilitats, però avui n'hem analitzat les més bàsiques. Seran útils en gairebé qualsevol programa que d'alguna manera funcioni amb el temps. Bona sort.