반응형
<질문>
두 사람 사이의 시차를 분 단위로 어떻게 알 수 있습니까?datetime사물?
<답변1>
>>> 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차이 만 보유하는 datetime 객체를 생성합니다. 위의 예에서는 0분, 8초 및 562000마이크로초입니다.
<답변2>
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
기간(년)
>>> 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 및 .microseconds에 대한 주의 사항datetime.seconds그리고datetime.microseconds각각 [0,86400) 및 [0,10^6)으로 제한됩니다.
timedelta가 최대 반환 값보다 큰 경우 주의해서 사용해야 합니다.
예:
end1시간 200μs 후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
end1d 및 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
<답변3>
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
<답변4>
다른 것에서 하나를 빼십시오. 당신은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
<답변5>
만약에a,bPython 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
만약에a,b다음과 같은 순진한 datetime 객체입니다.datetime.now()개체가 다른 UTC 오프셋(예: DST 전환 전후 또는 과거/미래 날짜)을 사용하여 현지 시간을 나타내는 경우 결과가 잘못될 수 있습니다. 자세한 내용은:Find if 24 hrs have passed between datetimes - Python.
신뢰할 수 있는 결과를 얻으려면 UTC 시간 또는 시간대 인식 datetime 객체를 사용하십시오.
<답변6>
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)
<답변7>
일 수를 찾으려면 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
<답변8>
다음은 두 개의 datetime.datetime 객체 사이에 경과된 시간을 얻는 방법입니다.
before = datetime.datetime.now()
after = datetime.datetime.now()
hours = math.floor(((after - before).seconds) / 3600)
<답변9>
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이 출력됩니다.
<답변10>
를 얻으려면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))
<답변11>
나는 다음과 같이 사용합니다.
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
<답변12>
이렇게 하면 차이가 초 단위로 표시됩니다(그런 다음 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으로 제한됩니다.this answer지적했다. 예를 들어 10초 동안sleep(),elapsedTime.microseconds준다8325(이것은잘못된, 주위에 있어야합니다10,000,000).
<답변13>
이것은 현재 시간과 오전 9시 30분의 차이를 찾는 것입니다.
t=datetime.now()-datetime.now().replace(hour=9,minute=30)
<답변14>
@Attaque 기반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
<답변15>
이것은 내 접근 방식입니다.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
<답변16>
다른 방법으로 날짜의 차이를 얻습니다.
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)
따라서 최소 출력을 얻으십시오.
감사해요
<답변17>
내 기능을 확인하고 개선하기 위해 지속적 통합 테스트에 시차를 사용했습니다. 누군가 필요하다면 간단한 코드가 있습니다.
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
<답변18>
그리 길지 않은 시간 간격으로 이 빠른 스니펫이 유용하다는 것을 알 수 있습니다.
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에서 테스트됨
<답변19>
다음은 일반화하거나 함수로 변환하기 쉽고 합리적이고 간단하며 따르기 쉬운 답변입니다.
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
<답변20>
이것은 누군가를 도울 수 있습니다. 찾기가 만료되었는지 여부는이 방법으로 날짜를 계산합니다. 있다dt.seconds그리고dt.microseconds도 가능
from datetime import datetime
# updated_at = "2022-10-20T07:18:56.950563"
def is_expired(updated_at):
expires_in = 7 #days
datetime_format = '%Y-%m-%dT%H:%M:%S.%f'
time_difference = datetime.now() - datetime.strptime(updated_at, datetime_format)
return True if time_difference.days > expires_in else False
<답변21>
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 객체의 종료 시간
datetime.time 개체를 직접 뺄 수 없습니다.
따라서 임의의 날짜를 추가해야 합니다(결합 사용).
또는 (1,1,1) 대신 "오늘"을 사용할 수 있습니다.
도움이 되었기를 바랍니다
반응형
'개발 > Python' 카테고리의 다른 글
| [파이썬] 기존 csv 파일에 pandas 데이터를 추가하는 방법 (0) | 2023.08.12 |
|---|---|
| [파이썬] mat 파일 읽는 방법 (0) | 2023.08.11 |
| [파이썬] 키를 누를때까지 기다리는 방법 (0) | 2023.08.11 |
| [파이썬] 파일 이름에서 확장자 추출하는 방법 (0) | 2023.08.11 |