Come faccio a trovare la differenza di tempo tra due oggetti datetime in Python?

StackOverflow https://stackoverflow.com/questions/1345827

Domanda

Come faccio a dire la differenza di tempo in minuti tra due oggetti datetime?

È stato utile?

Soluzione 

>>> import datetime
>>> a = datetime.datetime.now()
>>> b = datetime.datetime.now()
>>> c = b - a
datetime.timedelta(0, 8, 562000)
>>> divmod(c.days * 86400 + c.seconds, 60)
(0, 8)      # 0 minutes, 8 seconds

Altri suggerimenti

Nuovo su Python 2.7 è il metodo di istanza timedelta .total_seconds(). Dalla documentazione Python, questo è equivalente a (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6.

Riferimento: http://docs.python.org/2/library/datetime .html # datetime.timedelta.total_seconds 

>>> import datetime
>>> time1 = datetime.datetime.now()
>>> time2 = datetime.datetime.now() # waited a few minutes before pressing enter
>>> elapsedTime = time2 - time1
>>> elapsedTime
datetime.timedelta(0, 125, 749430)
>>> divmod(elapsedTime.total_seconds(), 60)
(2.0, 5.749430000000004) # divmod returns quotient and remainder
# 2 minutes, 5.74943 seconds

Utilizzo di esempio datetime 

>>> from datetime import datetime
>>> then = datetime(2012, 3, 5, 23, 8, 15)        # Random date in the past
>>> now  = datetime.now()                         # Now
>>> duration = now - then                         # For build-in functions
>>> duration_in_s = duration.total_seconds()      # Total number of seconds between dates

Durata in anni 

>>> years = divmod(duration_in_s, 31556926)[0]    # Seconds in a year=31556926.

Periodo in giorni 

>>> days  = duration.days                         # Build-in datetime function
>>> days  = divmod(duration_in_s, 86400)[0]       # Seconds in a day = 86400

Durata ore 

>>> hours = divmod(duration_in_s, 3600)[0]        # Seconds in an hour = 3600

Durata film in minuti 

>>> minutes = divmod(duration_in_s, 60)[0]        # Seconds in a minute = 60

durata in secondi 

>>> seconds = duration.seconds                    # Build-in datetime function
>>> seconds = duration_in_s

Periodo in microsecondi 

>>> microseconds = duration.microseconds          # Build-in datetime function

Durata totale tra le due date 

>>> days    = divmod(duration_in_s, 86400)        # Get days (without [0]!)
>>> hours   = divmod(days[1], 3600)               # Use remainder of days to calc hours
>>> minutes = divmod(hours[1], 60)                # Use remainder of hours to calc minutes
>>> seconds = divmod(minutes[1], 1)               # Use remainder of minutes to calc seconds
>>> print("Time between dates: %d days, %d hours, %d minutes and %d seconds" % (days[0], hours[0], minutes[0], seconds[0]))

o più semplicemente: 

>>> print(now - then)

Just sottrarre l'uno dall'altro. Si ottiene un oggetto timedelta con la differenza. 

>>> import datetime
>>> d1 = datetime.datetime.now()
>>> d2 = datetime.datetime.now() # after a 5-second or so pause
>>> d2 - d1
datetime.timedelta(0, 5, 203000)

È possibile convertire dd.days, dd.seconds e dd.microseconds di minuti.

Se a, b sono oggetti datetime poi per trovare la differenza di tempo tra di loro in Python 3: 

from datetime import timedelta

time_difference = a - b
time_difference_in_minutes = time_difference / timedelta(minutes=1)

Nelle versioni precedenti di Python: 

time_difference_in_minutes = time_difference.total_seconds() / 60

Se a, b sono oggetti datetime naive come quella restituita dalla datetime.now() allora il risultato può essere sbagliato se gli oggetti rappresentano ora locale con diversi UTC compensa per esempio, intorno transizioni DST o per passate / date future. Maggiori dettagli:. trovare se 24 ore sono passati tra datetimes - Python

Per ottenere risultati affidabili, usare il tempo UTC o oggetti datetime timezone-aware.

Usa divmod: 

now = int(time.time()) # epoch seconds
then = now - 90000 # some time in the past

d = divmod(now-then,86400)  # days
h = divmod(d[1],3600)  # hours
m = divmod(h[1],60)  # minutes
s = m[1]  # seconds

print '%d days, %d hours, %d minutes, %d seconds' % (d[0],h[0],m[0],s)

Questo è come ottenere il numero di ore che trascorsero fra due oggetti datetime.datetime: 

before = datetime.datetime.now()
after  = datetime.datetime.now()
hours  = math.floor(((after - before).seconds) / 3600)

Per trovare solo il numero di giorni: timedelta ha un attributo 'giorni. Si può semplicemente query. 

>>>from datetime import datetime, timedelta
>>>d1 = datetime(2015, 9, 12, 13, 9, 45)
>>>d2 = datetime(2015, 8, 29, 21, 10, 12)
>>>d3 = d1- d2
>>>print d3
13 days, 15:59:33
>>>print d3.days
13

Proprio pensato che potrebbe essere utile citare la formattazione, nonché per quanto riguarda timedelta. strptime () analizza una stringa rappresentante un tempo secondo un formato. 

from datetime import datetime

datetimeFormat = '%Y/%m/%d %H:%M:%S.%f'    
time1 = '2016/03/16 10:01:28.585'
time2 = '2016/03/16 09:56:28.067'  
time_dif = datetime.strptime(time1, datetimeFormat) - datetime.strptime(time2,datetimeFormat)
print(time_dif)

Questa uscita volontà:     0: 05: 00,518000

Io uso qualcosa di simile: 

from datetime import datetime

def check_time_difference(t1: datetime, t2: datetime):
    t1_date = datetime(
        t1.year,
        t1.month,
        t1.day,
        t1.hour,
        t1.minute,
        t1.second)

    t2_date = datetime(
        t2.year,
        t2.month,
        t2.day,
        t2.hour,
        t2.minute,
        t2.second)

    t_elapsed = t1_date - t2_date

    return t_elapsed

# usage 
f = "%Y-%m-%d %H:%M:%S+01:00"
t1 = datetime.strptime("2018-03-07 22:56:57+01:00", f)
t2 = datetime.strptime("2018-03-07 22:48:05+01:00", f)
elapsed_time = check_time_difference(t1, t2)

print(elapsed_time)
#return : 0:08:52

questo è quello di calcolare la differenza tra ora e 09:30 

t=datetime.now()-datetime.now().replace(hour=9,minute=30)

Questo è il mio approccio con mktime . 

from datetime import datetime, timedelta
from time import mktime

yesterday = datetime.now() - timedelta(days=1)
today = datetime.now()

difference_in_seconds = abs(mktime(yesterday.timetuple()) - mktime(today.timetuple()))
difference_in_minutes = difference_in_seconds / 60

Altri modi per ottenere differenza fra la data; 

import dateutil.parser
import datetime
last_sent_date = "" # date string
timeDifference = current_date - dateutil.parser.parse(last_sent_date)
time_difference_in_minutes = (int(timeDifference.days) * 24 * 60) + int((timeDifference.seconds) / 60)

Quindi, ottenere output in Min.

Grazie

Autorizzato sotto: CC-BY-SA insieme a attribuzione
Non affiliato a StackOverflow
scroll top