Відповіді:
>>> import datetime
>>> first_time = datetime.datetime.now()
>>> later_time = datetime.datetime.now()
>>> difference = later_time - first_time
>>> seconds_in_day = 24 * 60 * 60
datetime.timedelta(0, 8, 562000)
>>> divmod(difference.days * seconds_in_day + difference.seconds, 60)
(0, 8) # 0 minutes, 8 seconds
Віднімання пізнішого часу з першого разу difference = later_time - first_time
створює об'єкт дати, який має лише різницю. У наведеному вище прикладі це 0 хвилин, 8 секунд і 562000 мікросекунд.
delorean
неправильно представляє datetime
, pytz
підхід, наприклад, приклад коду для початку роботи може бути записаний у вигляді d = datetime.now(timezone(EST))
(один читабельний рядок замість п'яти).
Нове в Python 2.7 - це timedelta
метод екземпляра .total_seconds()
. З документів Python це еквівалентно (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6
.
Довідка: 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
Використовуючи приклад дати
>>> 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
Тривалість у роках
>>> years = divmod(duration_in_s, 31536000)[0] # Seconds in a year=365*24*60*60 = 31536000.
Тривалість у днях
>>> days = duration.days # Build-in datetime function
>>> days = divmod(duration_in_s, 86400)[0] # Seconds in a day = 86400
Тривалість годин
>>> hours = divmod(duration_in_s, 3600)[0] # Seconds in an hour = 3600
Тривалість у хвилинах
>>> minutes = divmod(duration_in_s, 60)[0] # Seconds in a minute = 60
Тривалість в секундах
>>> seconds = duration.seconds # Build-in datetime function
>>> seconds = duration_in_s
Тривалість в мікросекундах
>>> microseconds = duration.microseconds # Build-in datetime function
Загальна тривалість між двома датами
>>> 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]))
або просто:
>>> print(now - then)
Редагувати 2019 Оскільки ця відповідь набрала тяги, я додам функцію, яка може спростити використання для деяких
from datetime import datetime
def getDuration(then, now = datetime.now(), interval = "default"):
# Returns a duration as specified by variable interval
# Functions, except totalDuration, returns [quotient, remainder]
duration = now - then # For build-in functions
duration_in_s = duration.total_seconds()
def years():
return divmod(duration_in_s, 31536000) # Seconds in a year=31536000.
def days(seconds = None):
return divmod(seconds if seconds != None else duration_in_s, 86400) # Seconds in a day = 86400
def hours(seconds = None):
return divmod(seconds if seconds != None else duration_in_s, 3600) # Seconds in an hour = 3600
def minutes(seconds = None):
return divmod(seconds if seconds != None else duration_in_s, 60) # Seconds in a minute = 60
def seconds(seconds = None):
if seconds != None:
return divmod(seconds, 1)
return duration_in_s
def totalDuration():
y = years()
d = days(y[1]) # Use remainder to calculate next variable
h = hours(d[1])
m = minutes(h[1])
s = seconds(m[1])
return "Time between dates: {} years, {} days, {} hours, {} minutes and {} seconds".format(int(y[0]), int(d[0]), int(h[0]), int(m[0]), int(s[0]))
return {
'years': int(years()[0]),
'days': int(days()[0]),
'hours': int(hours()[0]),
'minutes': int(minutes()[0]),
'seconds': int(seconds()),
'default': totalDuration()
}[interval]
# Example usage
then = datetime(2012, 3, 5, 23, 8, 15)
now = datetime.now()
print(getDuration(then)) # E.g. Time between dates: 7 years, 208 days, 21 hours, 19 minutes and 15 seconds
print(getDuration(then, now, 'years')) # Prints duration in years
print(getDuration(then, now, 'days')) # days
print(getDuration(then, now, 'hours')) # hours
print(getDuration(then, now, 'minutes')) # minutes
print(getDuration(then, now, 'seconds')) # seconds
TypeError: 'float' object is not subscriptable
під час використання для:then = datetime(2017, 8, 11, 15, 58, tzinfo=pytz.UTC)
now = datetime(2018, 8, 11, 15, 58, tzinfo=pytz.UTC)
getDuration(then, now, 'years')
Просто віднімайте одне від іншого. Ви отримуєте timedelta
об’єкт з різницею.
>>> import datetime
>>> d1 = datetime.datetime.now()
>>> d2 = datetime.datetime.now() # after a 5-second or so pause
>>> d2 - d1
datetime.timedelta(0, 5, 203000)
Ви можете конвертувати dd.days
, dd.seconds
і dd.microseconds
до декількох хвилин.
Якщо a
, b
є DateTime об'єкти , то знайти різницю в часі між ними в Python 3:
from datetime import timedelta
time_difference = a - b
time_difference_in_minutes = time_difference / timedelta(minutes=1)
На попередніх версіях Python:
time_difference_in_minutes = time_difference.total_seconds() / 60
Якщо a
, b
є такі об'єкти наївним DateTime, що повертається datetime.now()
то результат може бути неправильним , якщо об'єкти представляють місцевий час з різними UTC зміщення , наприклад, навколо переходу на літній час переходів або для минулих дат / майбутніх. Більше інформації: Дізнайтеся, чи минуло 24 години між датами - Python .
Щоб отримати достовірні результати, використовуйте об'єкти дати та часові пояси, що відповідають часовому поясу.
Використовуйте 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)
Ось так я отримую кількість годин, що минули між двома об'єктами datetime.datetime:
before = datetime.datetime.now()
after = datetime.datetime.now()
hours = math.floor(((after - before).seconds) / 3600)
timedelta.seconds
надається лише кількість секунд, які явно зберігаються - гарантія документації складе менше ніж один день. Ви хочете (after - before).total_seconds()
, що дає кількість секунд, що охоплюють всю дельту.
(after - before).total_seconds() // 3600
(Python 2.7) або (after - before) // timedelta(seconds=3600)
(Python 3)
Щоб просто знайти кількість днів: timedelta має атрибут "days". Ви можете просто запитати це.
>>>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
Щойно подумав, може бути корисним згадати і про форматування, що стосується тиммедели. strptime () аналізує рядок, що представляє час відповідно до формату.
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)
Це виведе: 0: 05: 00.518000
Я використовую щось таке:
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
return t1-t2
Це мій підхід із використанням 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
mktime()
очікує, що місцевий час є вхідним фактором. Місцевий час може бути неоднозначним і mktime()
може повернути неправильну відповідь у цьому випадку. Використовуйте a - b
натомість (a, b - об'єкти datetime) . mktime()
є непотрібним, а іноді і неправильним. Не використовуйте його в цьому випадку.
Інші способи отримати різницю між датою;
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)
Тож отримайте вихід у хв.
Дякую
Я використовував різниці в часі для безперервних інтеграційних тестів для перевірки та вдосконалення своїх функцій. Ось простий код, якщо комусь це потрібно
from datetime import datetime
class TimeLogger:
time_cursor = None
def pin_time(self):
global time_cursor
time_cursor = datetime.now()
def log(self, text=None) -> float:
global time_cursor
if not time_cursor:
time_cursor = datetime.now()
now = datetime.now()
t_delta = now - time_cursor
seconds = t_delta.total_seconds()
result = str(now) + ' tl -----------> %.5f' % seconds
if text:
result += " " + text
print(result)
self.pin_time()
return seconds
time_logger = TimeLogger()
Використання:
from .tests_time_logger import time_logger
class Tests(TestCase):
def test_workflow(self):
time_logger.pin_time()
... my functions here ...
time_logger.log()
... other function(s) ...
time_logger.log(text='Tests finished')
і у мене є щось подібне у вихідному журналі
2019-12-20 17:19:23.635297 tl -----------> 0.00007
2019-12-20 17:19:28.147656 tl -----------> 4.51234 Tests finished
На основі чудової відповіді @Attaque , я пропоную більш коротку спрощену версію калькулятора різниці дат :
seconds_mapping = {
'y': 31536000,
'm': 2628002.88, # this is approximate, 365 / 12; use with caution
'w': 604800,
'd': 86400,
'h': 3600,
'min': 60,
's': 1,
'mil': 0.001,
}
def get_duration(d1, d2, interval, with_reminder=False):
if with_reminder:
return divmod((d2 - d1).total_seconds(), seconds_mapping[interval])
else:
return (d2 - d1).total_seconds() / seconds_mapping[interval]
Я змінив це, щоб уникнути декларування повторюваних функцій, видалив інтервал за замовчуванням симпатичного друку і додав підтримку на мілісекунди, тижні та місяці ISO (лише місяці на увазі є приблизними, виходячи з припущення, що кожен місяць дорівнює 365/12
).
Що виробляє:
d1 = datetime(2011, 3, 1, 1, 1, 1, 1000)
d2 = datetime(2011, 4, 1, 1, 1, 1, 2500)
print(get_duration(d1, d2, 'y', True)) # => (0.0, 2678400.0015)
print(get_duration(d1, d2, 'm', True)) # => (1.0, 50397.12149999989)
print(get_duration(d1, d2, 'w', True)) # => (4.0, 259200.00149999978)
print(get_duration(d1, d2, 'd', True)) # => (31.0, 0.0014999997802078724)
print(get_duration(d1, d2, 'h', True)) # => (744.0, 0.0014999997802078724)
print(get_duration(d1, d2, 'min', True)) # => (44640.0, 0.0014999997802078724)
print(get_duration(d1, d2, 's', True)) # => (2678400.0, 0.0014999997802078724)
print(get_duration(d1, d2, 'mil', True)) # => (2678400001.0, 0.0004999997244524721)
print(get_duration(d1, d2, 'y', False)) # => 0.08493150689687975
print(get_duration(d1, d2, 'm', False)) # => 1.019176965856293
print(get_duration(d1, d2, 'w', False)) # => 4.428571431051587
print(get_duration(d1, d2, 'd', False)) # => 31.00000001736111
print(get_duration(d1, d2, 'h', False)) # => 744.0000004166666
print(get_duration(d1, d2, 'min', False)) # => 44640.000024999994
print(get_duration(d1, d2, 's', False)) # => 2678400.0015
print(get_duration(d1, d2, 'mil', False)) # => 2678400001.4999995