python에서 두 datetime 객체의 시간 차이를 찾으려면 어떻게 해야 합니까?

python에서 두 datetime 객체의 시간 차이를 찾으려면 어떻게 해야 합니까?

개의 를 분 해야 하나요?datetime 오브젝트?

>>> import datetime
>>> first_time = datetime.datetime.now()
>>> later_time = datetime.datetime.now()
>>> difference = later_time - first_time
datetime.timedelta(0, 8, 562000)
>>> seconds_in_day = 24 * 60 * 60
>>> divmod(difference.days * seconds_in_day + difference.seconds, 60)
(0, 8)      # 0 minutes, 8 seconds

시간에서 difference = later_time - first_time날짜/시간/시간/날짜/시간 지정.위의 예에서는 0분, 8초 및 562000 마이크로초입니다.

날짜/시간 예제 사용

>>> 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

및 에 관한 : ".seconds" ".seconds" 입니다.
datetime.seconds ★★★★★★★★★★★★★★★★★」datetime.microseconds[0,86400)] [0,10^6)]을 클릭합니다.

timedelta가 반환된 최대값보다 클 경우 주의하여 사용해야 합니다.

예:

end 200 200μs 후 200μs 이 200 is is 이다.start:

>>> start = datetime(2020,12,31,22,0,0,500)
>>> end = datetime(2020,12,31,23,0,0,700)
>>> delta = end - start
>>> delta.microseconds
RESULT: 200
EXPECTED: 3600000200

end 뒤의 1h입니다.start:

>>> start = datetime(2020,12,30,22,0,0)
>>> end = datetime(2020,12,31,23,0,0)
>>> delta = end - start
>>> delta.seconds
RESULT: 3600
EXPECTED: 90000

2.은 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

이치노그 결과,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 = d2 - d1
>>> print (dd.days) # get days
>>> print (dd.seconds) # get seconds
>>> print (dd.microseconds) # get microseconds
>>> print (int(round(dd.total_seconds()/60, 0))) # get minutes

ifa,b 3 python 3의 datetime에서 입니다.

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

ifa,b는 순진한 입니다.를 들어 반환되는 객체입니다.datetime.now()DST 전환 전후 또는 과거/미래 날짜 등 UTC 오프셋이 다른 현지 시간을 객체가 나타내는 경우 결과가 잘못될 수 있습니다.상세:데이터 시간 사이에 24시간이 경과했는지 확인합니다(Python).

신뢰할 수 있는 결과를 얻으려면 UTC 시간 또는 시간대 인식 datetime 개체를 사용합니다.

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에는 '일수' 속성이 있습니다.당신은 그것을 간단히 문의할 수 있습니다.

>>>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

timedelta에 대해서도 포맷을 언급하는 것이 도움이 될 것 같습니다.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

입수 방법hour,minute그리고.second,당신은 이걸 할 수 있다.

>>> import datetime
>>> first_time = datetime.datetime.now()
>>> later_time = datetime.datetime.now()
>>> difference = later_time - first_time
>>> m, s = divmod(difference.total_seconds(), 60)
>>> print("H:M:S is {}:{}:{}".format(m//60, m%60, s))

그러면 초단위의 차이가 나타납니다(분수를 얻으려면 60으로 나누기만 하면 됩니다).

import time
import datetime

t_start = datetime.datetime.now()

time.sleep(10)

t_end = datetime.datetime.now()
elapsedTime = (t_end - t_start )

print(elapsedTime.total_seconds())

출력:

10.009222

이것이 가장 간단한 방법이며, 정밀도나 오버플로를 걱정할 필요는 없습니다.

예를 들어,elapsedTime.seconds정확도가 많이 떨어집니다(정수를 반환합니다).또한.elapsedTime.microseconds이 답변이 지적한 바와 같이 10^6의 상한선입니다.예를 들어 10초 동안sleep(),elapsedTime.microseconds주다8325(잘못된 것은 이 근처에 있어야 한다.)10,000,000).

이것은 현재 시간과 오전 9시 30분 사이의 차이를 찾기 위해서이다.

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

@Attaque great answer를 바탕으로 날짜/시간 차이 계산기의 간략화된 버전을 제안합니다.

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

이것이 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

날짜 간의 차이를 얻는 기타 방법

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)

Min으로 출력해 주세요.

감사합니다.

저는 제 기능을 점검하고 개선하기 위해 연속 통합 테스트에 시차를 활용했습니다.여기 간단한 코드가 있습니다.

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

이 빠른 스니펫은 긴 시간 간격으로 도움이 될 수 있습니다.

    from datetime import datetime as dttm
    time_ago = dttm(2017, 3, 1, 1, 1, 1, 1348)
    delta = dttm.now() - time_ago
    days = delta.days # can be converted into years which complicates a bit…
    hours, minutes, seconds = map(int, delta.__format__('').split('.')[0].split(' ')[-1].split(':'))

Python v.3.8.6에서 테스트 완료

다음은 일반화하거나 함수로 전환하기 쉽고 합리적이고 간결하고 따르기 쉬운 답변입니다.

ts_start=datetime(2020, 12, 1, 3, 9, 45)
ts_end=datetime.now()
ts_diff=ts_end-ts_start
secs=ts_diff.total_seconds()
days,secs=divmod(secs,secs_per_day:=60*60*24)
hrs,secs=divmod(secs,secs_per_hr:=60*60)
mins,secs=divmod(secs,secs_per_min:=60)
secs=round(secs, 2)
answer='Duration={} days, {} hrs, {} mins and {} secs'.format(int(days),int(hrs),int(mins),secs)
print(answer)

그것은 형태로 답을 준다.Duration=270 days, 10 hrs, 32 mins and 42.13 secs

import datetime
date = datetime.date(1, 1, 1)
#combine a dummy date to the time
datetime1 = datetime.datetime.combine(date, start_time)
datetime2 = datetime.datetime.combine(date, stop_time)  
#compute the difference
time_elapsed = datetime1 - datetime2

start_time --> datetime 객체의 시작 시각
end_time--> datetime 객체의 종료 시간

날짜/시간을 직접 뺄 수는 없습니다.시간 객체
따라서 랜덤 날짜를 추가해야 합니다(콤바인을 사용합니다).
또는 (1,1,1) 대신 "오늘"을 사용할 수 있습니다.

이것이 도움이 되기를 바란다

언급URL : https://stackoverflow.com/questions/1345827/how-do-i-find-the-time-difference-between-two-datetime-objects-in-python