दो समय के तारों के बीच समय अंतराल की गणना कैसे करें

Question

मेरे पास दो बार, एक शुरुआत और एक स्टॉप टाइम है, 10:33:26 (HH: MM: SS) के प्रारूप में। मुझे दोनों समय के अंतर की आवश्यकता है। मैं पायथन के लिए दस्तावेज़ीकरण देख रहा हूं और ऑनलाइन खोज कर रहा हूं और मुझे लगता है कि यह डेटाइम और / या टाइम मॉड्यूल के साथ कुछ करना होगा। मुझे यह ठीक से काम करने के लिए नहीं मिल रहा है और केवल यह पता लगाने के लिए कि यह कैसे करना है जब एक तारीख शामिल होती है।

अंततः, मुझे कई बार अवधि के औसत की गणना करने की आवश्यकता है। मुझे काम करने के लिए समय का अंतर मिला और मैं उन्हें एक सूची में संग्रहीत कर रहा हूं। मुझे अब औसत की गणना करने की आवश्यकता है। मैं मूल भावों का पता लगाने और फिर मतभेद करने के लिए नियमित अभिव्यक्ति का उपयोग कर रहा हूं।

औसत के लिए, क्या मुझे सेकंड और फिर औसत में बदलना चाहिए?

Comments

क्या आप अपना कोड पोस्ट कर सकते हैं जिसे आपने आज़माया है और हम वहाँ से शुरू कर सकते हैं?

— एंथनी फोर्लोनी

संबंधित: पता करें कि क्या 24 घंटे

— डेटेटाइम के

Answer 1

हां, निश्चित रूप datetimeसे यहां आपकी जरूरत है। विशेष रूप से, strptimeफ़ंक्शन, जो एक टाइम ऑब्जेक्ट में एक स्ट्रिंग को पार्स करता है।

from datetime import datetime
s1 = '10:33:26'
s2 = '11:15:49' # for example
FMT = '%H:%M:%S'
tdelta = datetime.strptime(s2, FMT) - datetime.strptime(s1, FMT)

इससे आपको एक timedeltaवस्तु मिलती है जिसमें दो बार के बीच का अंतर होता है। आप इसके साथ जो चाहें कर सकते हैं, जैसे कि इसे सेकंड में परिवर्तित करना या इसे दूसरे में जोड़ना datetime।

यह एक नकारात्मक परिणाम लौटाएगा यदि अंत समय शुरुआती समय से पहले है, उदाहरण के लिए s1 = 12:00:00और s2 = 05:00:00। यदि आप चाहते हैं कि कोड इस मामले में मध्यरात्रि को पार कर जाए (यानी यह मान लेना चाहिए कि अंत समय प्रारंभ समय से पहले कभी नहीं है), तो आप उपरोक्त कोड में निम्न पंक्तियाँ जोड़ सकते हैं:

if tdelta.days < 0:
    tdelta = timedelta(days=0,
                seconds=tdelta.seconds, microseconds=tdelta.microseconds)

(बेशक आपको from datetime import timedeltaकहीं शामिल करने की आवश्यकता है)। इस उपयोग के मामले को इंगित करने के लिए जेएफ सेबेस्टियन का धन्यवाद।

Comments

days= -2Tdelta ऑब्जेक्ट में कब और उससे अधिक समय तक नकारात्मक समय हैक काम नहीं करेगा ।

— CKM

@ चंद्रेश हां, लेकिन daysप्रश्न में वर्णित के अलावा अतिरिक्त जानकारी (विशेष रूप से, दिनांक) होने के बिना कभी भी -2 या उससे कम नहीं हो सकता है। तो वह स्थिति यहां प्रासंगिक नहीं है।

— डेविड जेड

संकेत: सेकंड में समय डेल्टा प्राप्त करने के लिए आपको कॉल करना होगा tdelta.total_seconds()।

— स्काइ

Answer 2

इसे आज़माएँ - यह अल्पकालिक घटनाओं के समय के लिए कुशल है। यदि किसी चीज़ में एक घंटे से अधिक समय लगता है, तो अंतिम प्रदर्शन शायद कुछ दोस्ताना स्वरूपण चाहेगा।

import time
start = time.time()

time.sleep(10)  # or do something more productive

done = time.time()
elapsed = done - start
print(elapsed)

समय का अंतर बीता हुआ सेकंड की संख्या के रूप में वापस आ गया है।

Comments

यह स्वीकृत उत्तर क्यों नहीं था? यह सरल है, यह एक मूल्य देता है जिसकी तुलना किसी चीज़ से की जा सकती है (क्या मेरी कमान को निष्पादित करने में 2.5 सेकंड से अधिक समय लगा है?) और यह v2.7 में काम करता है

— मावग का कहना है कि मोनिका

@ Mawg क्योंकि यह OPs प्रश्न का उत्तर नहीं देता है। वह पूछ रहा था कि दो अलग-अलग समयों की तुलना वह पहले से ही एक निश्चित प्रारूप में कैसे कर सकता है, न कि अपने कोड में किसी घटना को समय पर कैसे उत्पन्न करें। वे बहुत अलग समस्याएं हैं।

— नाटसकेन

आपको इसका उपयोग नहीं करना चाहिए; इसके बजाय ( time.monotonic()पायथन में) मोनोटोनिक समय का उपयोग करें । time.time()पीछे की ओर जा सकते हैं (उदाहरण के लिए, जब मशीन पर समय बदल जाता है, जिसमें NTP सुधार शामिल हैं)।

— 19

सवाल करने के लिए अप्रासंगिक

— patricktokeeffe

Answer 3

यहां एक समाधान है जो अंतर को खोजने का समर्थन करता है, भले ही अंत समय प्रारंभ समय (आधी रात के अंतराल से अधिक) जैसे कि 23:55:00-00:25:00(आधे घंटे की अवधि) से कम हो:

#!/usr/bin/env python
from datetime import datetime, time as datetime_time, timedelta

def time_diff(start, end):
    if isinstance(start, datetime_time): # convert to datetime
        assert isinstance(end, datetime_time)
        start, end = [datetime.combine(datetime.min, t) for t in [start, end]]
    if start <= end: # e.g., 10:33:26-11:15:49
        return end - start
    else: # end < start e.g., 23:55:00-00:25:00
        end += timedelta(1) # +day
        assert end > start
        return end - start

for time_range in ['10:33:26-11:15:49', '23:55:00-00:25:00']:
    s, e = [datetime.strptime(t, '%H:%M:%S') for t in time_range.split('-')]
    print(time_diff(s, e))
    assert time_diff(s, e) == time_diff(s.time(), e.time())

उत्पादन

0:42:23
0:30:00

time_diff()एक टाइमडेल्टा ऑब्जेक्ट लौटाता है जिसे आप mean()सीधे अनुक्रम में (अनुक्रम के हिस्से के रूप में) पास कर सकते हैं जैसे:

#!/usr/bin/env python
from datetime import timedelta

def mean(data, start=timedelta(0)):
    """Find arithmetic average."""
    return sum(data, start) / len(data)

data = [timedelta(minutes=42, seconds=23), # 0:42:23
        timedelta(minutes=30)] # 0:30:00
print(repr(mean(data)))
# -> datetime.timedelta(0, 2171, 500000) # days, seconds, microseconds

mean()परिणाम भी है timedelta()उद्देश्य यह है कि आप (सेकंड में बदल सकते हैं td.total_seconds()(क्योंकि अजगर 2.7) विधि), घंटे ( td / timedelta(hours=1)(अजगर 3)), आदि

Comments

@JF मुझे आश्चर्य है कि क्या आँकड़े का मतलब और विचरण कार्य सीधे समयबद्ध वस्तु के साथ काम करते हैं? उस पर कोई विचार? इसके अलावा, टाइमडेल्टा ऑब्जेक्ट्स के विचरण की गणना करने के लिए कोई भी मदद उपयोगी होगी।

— CKM

@ चंद्रेश: यह समर्थित नहीं है। आप समयबद्धता के गणितीय आँकड़ों की गणना के लिए सेकंड / माइक्रोसेकंड में परिवर्तित कर सकते हैं।

— 15

Answer 4

पाइथन में समय के अंतर का प्रतिनिधित्व करने वाली संरचना को टाइमडेल्टा कहा जाता है । यदि आपके पास start_timeऔर प्रकार के end_timeरूप में datetimeआप -ऑपरेटर का उपयोग करके अंतर की गणना कर सकते हैं जैसे:

diff = end_time - start_time

आपको इसे कण-कण स्ट्रिंग प्रारूप (उदाहरण से पहले start_time.strftime (...)) में परिवर्तित करने से पहले करना चाहिए। यदि आपके पास पहले से ही स्ट्रिंग प्रतिनिधित्व है, तो आपको इसे स्ट्रीपम विधि का उपयोग करके इसे समय / डेटाइम में बदलने की आवश्यकता है ।

Answer 5

इस साइट का प्रयास करने के लिए कहते हैं:

import datetime as dt
start="09:35:23"
end="10:23:00"
start_dt = dt.datetime.strptime(start, '%H:%M:%S')
end_dt = dt.datetime.strptime(end, '%H:%M:%S')
diff = (end_dt - start_dt) 
diff.seconds/60 

यह फोरम time.mktime () का उपयोग करता है

Comments

सुनिश्चित करें कि यदि आप% P (AM / PM) का उपयोग करते हैं जो आप% H (24 घंटे) के बजाय% I (12 घंटे) का उपयोग करते हैं: docs.python.org/2/library/…

— एंड्रयू

Answer 6

मुझे यह पसंद है कि यह आदमी कैसे करता है - https://amalgjose.com/2015/02/19/python-code-for-calculating-the-difference-between-two-time-stamps । यकीन नहीं होता है कि यह कुछ विपक्ष है।

लेकिन मेरे लिए साफ लगता है :)

from datetime import datetime
from dateutil.relativedelta import relativedelta

t_a = datetime.now()
t_b = datetime.now()

def diff(t_a, t_b):
    t_diff = relativedelta(t_b, t_a)  # later/end time comes first!
    return '{h}h {m}m {s}s'.format(h=t_diff.hours, m=t_diff.minutes, s=t_diff.seconds)

प्रश्न के संबंध में आपको अभी भी उपयोग करने की आवश्यकता है datetime.strptime()जैसा कि पहले दूसरों ने कहा था।

Answer 7

इसे इस्तेमाल करे

import datetime
import time
start_time = datetime.datetime.now().time().strftime('%H:%M:%S')
time.sleep(5)
end_time = datetime.datetime.now().time().strftime('%H:%M:%S')
total_time=(datetime.datetime.strptime(end_time,'%H:%M:%S') - datetime.datetime.strptime(start_time,'%H:%M:%S'))
print total_time

OUTPUT:

0:00:05

Comments

इस उत्तर का मूल छह साल पुराने और अत्यधिक स्वीकृत उत्तर से बिल्कुल अलग नहीं है। क्या आपके पास वास्तव में जोड़ने के लिए कुछ है? पूरी तरह से निरर्थक जवाब प्रस्तुत करने का कोई मतलब नहीं है।

— ब्लैंकनथ

Answer 8

import datetime as dt
from dateutil.relativedelta import relativedelta

start = "09:35:23"
end = "10:23:00"
start_dt = dt.datetime.strptime(start, "%H:%M:%S")
end_dt = dt.datetime.strptime(end, "%H:%M:%S")
timedelta_obj = relativedelta(start_dt, end_dt)
print(
    timedelta_obj.years,
    timedelta_obj.months,
    timedelta_obj.days,
    timedelta_obj.hours,
    timedelta_obj.minutes,
    timedelta_obj.seconds,
)

परिणाम: 0 0 0 0 -47 -37

Answer 9

दोनों timeऔर datetimeएक तिथि घटक है।

आम तौर पर यदि आप केवल उस समय भाग के साथ काम कर रहे हैं जो आप एक डिफ़ॉल्ट तारीख की आपूर्ति करेंगे। यदि आप केवल अंतर में रुचि रखते हैं और जानते हैं कि दोनों समय एक ही दिन हैं तो datetimeआज के लिए निर्धारित दिन के साथ प्रत्येक के लिए निर्माण करें और अंतराल ( timedelta) प्राप्त करने के लिए स्टॉप समय से प्रारंभ को घटाएं ।

Answer 10

डेटाटाइम मॉड्यूल और टाइमडेल्टा ऑब्जेक्ट्स पर एक नज़र डालें। आपको शुरुआत और रुकने के समय के लिए एक डेटाटाइम ऑब्जेक्ट का निर्माण करना चाहिए, और जब आप उन्हें घटाते हैं, तो आपको एक टाइमडेल्टा मिलता है।

Answer 11

यदि आप 24 घंटे से कम है, तो केवल समय में रुचि रखते हैं। आप रिटर्न स्टेटमेंट में आवश्यकतानुसार आउटपुट को फॉर्मेट कर सकते हैं:

import datetime
def elapsed_interval(start,end):
    elapsed = end - start
    min,secs=divmod(elapsed.days * 86400 + elapsed.seconds, 60)
    hour, minutes = divmod(min, 60)
    return '%.2d:%.2d:%.2d' % (hour,minutes,secs)

if __name__ == '__main__':
    time_start=datetime.datetime.now()
    """ do your process """
    time_end=datetime.datetime.now()
    total_time=elapsed_interval(time_start,time_end)