Python DateTime.Timedelta

Python inneholder forskjellige pakker som har moduler for å utføre enhver oppgave som vi kan forstå. Python har en pakke som heter Timedelta som illustrerer tid. Det er mest ansatt for å bestemme tidsvariasjonen mellom tider og datoer. Det blir ofte brukt for å få gjenstandene med litt modifiserte tider og datoer. Noen matematiske operasjoner utføres også av Timedelta () -funksjonen. Datetime -klassen i Python tilbyr en rekke prosesser for å jobbe med dager, varigheter og perioder. Datoen og datetiden er komponenter, så når vi samhandler med disse, må vi jobbe med objektklassene i stedet for byte eller tider og datoer. Vi må importere datetime -modulen før vi håndterer datoene eller tidene.

Syntaks av Timedelta () -funksjon

I Timedelta () -funksjonen er parametrene som er gitt valgfrie. De inneholder standardverdiene på null. Heltallene og flottørene er typer data som brukes i alle disse parametrene. Timedelta () -metoden returnerer en dato. Den formaterte () -funksjonen til “Timedelta” kan gi en svært lesbar strengillustrasjon når varigheten er spesifisert som en streng.

Mens de evaluerer tidsrammer i et sekund, min, HRS, dager eller år, blir Timedelta -klassene ofte brukt til å holde skillet mellom de forskjellige dato- og tidsforekomstene. Konstruktøren til denne funksjonen krever to parametere for opprinnelses- og termineringstimingene, samt parameteren "Precision" som kan brukes til å spesifisere antall ganger desimalstedene er inkludert i utfallet.

Vi vil undersøke mange tilnærminger i denne artikkelen for å observere hvordan Timedelta () -funksjonen til Python opererer.

Eksempel 1:

I denne illustrasjonen vil vi se hvordan Timedelta () -funksjonen fungerer for å bestemme en fremtidig dato.

Fra DateTime Import DateTime, Timedelta
ini_time_for_now = DateTime.nå()
print ("Gjeldende dato:", str (ini_time_for_now))
Future_date_after_4yrs = ini_time_for_now + \
Timedelta (dager = 1460)
Future_date_after_4days = ini_time_for_now + \
Timedelta (dager = 4)
Print ('Future Date etter 4 år:', STR (Future_date_after_4yrs)))
Print ('Future Date After 4 Days:', Str (Future_date_after_4days)))

Først importerer vi de to klassene - DateTime og Timedelta - fra DateTime -pakken. Deretter erklærer vi en variabel. Sammen med dette bruker vi datetiden.nå () funksjon for å få eksisterende dato og tid for systemet. For å skrive ut denne eksisterende datoen, bruker vi PRINT () -funksjonen. Innenfor denne funksjonen kaller vi Str () -metoden. Denne metoden inneholder eksisterende tid og dato. Så vi spesifiserer henholdsvis antall år og antall dager.

For å finne fremtidig dato etter 4 år, kaller vi Timedelta () -metoden. Denne metoden har dagens parameter, og verdien er 1460. Deretter, for å finne fremtidig dato etter 4 dager, bruker vi Timedelta () -funksjonen igjen. Nå passerer vi dag 4 som attributtet til funksjonen. Vi påkaller trykket () -funksjonen for å vise begge fremtidige datoer etter 4 år og etter 4 dager.

Eksempel 2:

I dette tilfellet lærer vi hvordan Timedelta () -funksjonen fungerer for å få den siste datoen som var et visst antall timer eller år siden.

Fra DateTime Import DateTime, Timedelta
ini_time_for_now = DateTime.nå()
Print ('Gjeldende dato:', STR (ini_time_for_now))
past_date_before_4yrs = ini_time_for_now - \
Timedelta (dager = 1460)
past_date_before_4hours = ini_time_for_now - \
Timedelta (timer = 4)
Skriv ut ('Past Date før 4 år:', STR (Past_date_before_4yrs))
skriv ut ('Past Date før 4 timer:', str (past_date_before_4hours))

Først er to klasser fra DateTime -biblioteket, DateTime og Timedelta, integrert. En pakke som viser tidsvarigheten mellom de gitte intervallene kalles Timedelta. Pakken gir funksjonalitet som lar brukerne finne ut hvor mye tid som har gått mellom flere tidspunkter når det gjelder sek. Datetime -rammeverket er også tilgjengelig i Python og kan brukes til å håndtere datoer. Timedelta -modulen til DateTime -pakken gjør det enkelt å beregne tidsrammer.

Vi kan utføre den matematiske operasjonen (tillegg eller subtraksjon) fra dataklassen ved hjelp av Timedelta () -funksjonen. Deretter er en variabel definert. I tillegg bruker vi datetiden.nå () metode for å hente systemets nåværende dato og tid. Deretter kaller vi metoden Print () for å sende ut denne gjeldende datoen. Vi bruker STR () -teknikken i denne funksjonen. Denne prosedyren inneholder gjeldende tid og dato.

Vi ønsker å beregne de foregående datoene. Derfor gir vi årene og dagene, tilsvarende. Vi bruker Timedelta () -funksjonen for å lokalisere datoene i det siste som er mindre enn 4 år før. Dagsargumentet for denne metoden har en verdi på 1460. Deretter kaller vi Timedelta () -funksjonen igjen for å bestemme den forrige datoen som var før 4 timer. Nå gir vi funksjonen verdien av timen 4 som en parameter. For å vise datoene som er tidligere enn 4 år og 4 timer, kan vi bruke PRINT () -funksjonen.

Eksempel 3:

Timedelta () -funksjonen kan brukes til å finne tidsforskjellen mellom to spesifiserte datoer. La oss se hvordan det fungerer.

Fra DateTime Import DateTime, Timedelta
Eksisterende_date = DateTime.nå()
trykk ('Den eksisterende datoen er:', eksisterende_date)
kommende_date = eksisterende_date + \
Timedelta (dager = 5)
Print ("The Commoming Day:", kommende_date)
trykk ('Tidsvariasjonen i gitte dager:', kommende_date - eksisterende_date)

Ved starten av programmet er to klasser, DateTime og Timedelta, inkludert fra topptekstfilen DateTime. I neste linje får vi den eksisterende datoen ved å bruke datetiden.nå () Metode. Vi har en "eksisterende_date" -variabel som brukes til å lagre datamaskinens eksisterende dato. Print () -metoden kalles for å skrive ut denne datoen. Vi ønsker å bestemme fremtidig dato, så Timedelta () -funksjonen kalles.

Her definerer vi verdien av "dagene" -parameteren til 5 fordi vi ønsker å få datoen etter 5 dager. Print () -metoden skriver ut den nye fremtidige datoen på skjermen. I den siste linjen bruker vi setningen () igjen for å vise tidsvariasjonen mellom eksisterende dato og fremtidig dato.

Konklusjon

I denne artikkelen diskuterte vi Timedelta () -metoden som er en del av datetime -modulen og kan brukes til å justere datoene, identifisere datoene gjennom fortiden og fremtiden og evaluere datoens variasjoner. Det gir en av de mest grunnleggende teknikkene for å håndtere datoene. Timedelta () -metoden ble brukt i en illustrasjon for å forutsi datoene i fortiden og fremtiden. Ved bruk av Timedelta () -metoden bestemte vi tidligere skillet mellom de forskjellige datoene.