जवाबों:
>>> 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)) (पांच के बजाय एक पठनीय रेखा) के रूप में लिखा जा सकता है ।
पायथन 2.7 में नई timedeltaउदाहरण विधि है .total_seconds()। पायथन डॉक्स से, यह इसके बराबर है (td.microseconds + (td.seconds + td.days * 24 * 3600) * 10**6) / 10**6।
संदर्भ: http://docs.python.org/2/library/datetime.html#datetime.timedelta.total_neconds
>>> 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')) # secondsTypeError: '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डेटाइम ऑब्जेक्ट हैं , तो पायथन 3 में उनके बीच समय का अंतर खोजने के लिए:
from datetime import timedelta
time_difference = a - b
time_difference_in_minutes = time_difference / timedelta(minutes=1)पहले पायथन संस्करणों पर:
time_difference_in_minutes = time_difference.total_seconds() / 60यदि a, bभोले डेटाइम ऑब्जेक्ट हैं जैसे कि datetime.now()तब तक लौटाए गए तो परिणाम गलत हो सकता है यदि ऑब्जेक्ट अलग-अलग यूटीसी ऑफसेट जैसे डीएसटी संक्रमण के आसपास या अतीत / भविष्य की तारीखों के लिए स्थानीय समय का प्रतिनिधित्व करते हैं। अधिक जानकारी: पता लगाएँ कि क्या 24 घंटे डेटाइम - पाइथन के बीच से गुज़रे हैं ।
विश्वसनीय परिणाम प्राप्त करने के लिए, यूटीसी समय या टाइमज़ोन-जागरूक डेटाटाइम ऑब्जेक्ट का उपयोग करें।
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(पायथन (after - before) // timedelta(seconds=3600)
केवल दिनों की संख्या ज्ञात करने के लिए: समयसीमा में एक 'दिन' विशेषता होती है। आप बस इसे क्वेरी कर सकते हैं।
>>>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:52return 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 / 60mktime()एक इनपुट के रूप में स्थानीय समय की अपेक्षा करता है। स्थानीय समय शायद अस्पष्ट है और mktime()इस मामले में गलत उत्तर दे सकता है। का प्रयोग करें 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@ बहुत बढ़िया जवाब के आधार पर , मैं डेटाटाइम अंतर कैलकुलेटर के छोटे सरलीकृत संस्करण का प्रस्ताव करता हूं:
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]मैंने इसे दोहराए जाने वाले कार्यों की घोषणा से बचने के लिए बदल दिया है, सुंदर प्रिंट डिफ़ॉल्ट अंतराल को हटा दिया और मिलीसेकंड, सप्ताह और आईएसओ महीनों के लिए समर्थन जोड़ा (मन के महीनों में नंगे केवल अनुमानित होते हैं, यह धारणा के आधार पर कि हर महीने बराबर है 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