स्ट्रिंग के लिए समयबद्धता प्रारूपित करें

Question

मुझे datetime.timedeltaऑब्जेक्ट फॉर्मेट करने में परेशानी हो रही है ।

यहां मैं यह करने की कोशिश कर रहा हूं: मेरे पास वस्तुओं की एक सूची है और ऑब्जेक्ट के वर्ग के सदस्यों में से एक एक टाइमडेल्टा ऑब्जेक्ट है जो किसी ईवेंट की अवधि दिखाता है। मैं उस अवधि को घंटों: मिनटों के प्रारूप में प्रदर्शित करना चाहूंगा।

मैंने ऐसा करने के लिए कई तरह के तरीके आजमाए हैं और मुझे कठिनाई हो रही है। मेरा वर्तमान दृष्टिकोण मेरी वस्तुओं के लिए कक्षा में तरीकों को जोड़ना है जो घंटे और मिनट लौटाते हैं। मैं 3600 तक टाइमडेलटा.सेकंड को विभाजित करके और इसे गोल करके घंटे प्राप्त कर सकता हूं। मुझे शेष सेकंड मिलने और मिनटों में परिवर्तित करने में परेशानी हो रही है।

वैसे, मैं प्रस्तुति के लिए Django टेम्प्लेट के साथ Google AppEngine का उपयोग कर रहा हूं।

Comments

अगर टाइमडेल्टा स्ट्रैपटाइम () विधि के बराबर था, तो अच्छा होगा।

— जेएस।

@JS। यदि आप उपयोग करते हैं तो ठीक है datetime.utcfromtimestamp()। देखें मेरा उत्तर नीचे।

— sjngm

@JS। - 100% सहमत। फिर, __str__की timedeltaकाफी सभ्य है, के रूप में करने का विरोध किया __repr__(यह है कि - मनुष्य के लिए)। उदाहरण के लिए: datetime.timedelta(minutes=6, seconds=41) * 2618 / 48देता है datetime.timedelta(seconds=21871, microseconds=208333), लेकिन str(datetime.timedelta(minutes=6, seconds=41) * 2618 / 48)देता है '6:04:31.208333'जो पढ़ने के लिए काफी ठीक है।

— टॉमस गैंडर

Answer 1

आप बस तारडेल्टा को स्ट्रिंग () के साथ एक स्ट्रिंग में बदल सकते हैं। यहाँ एक उदाहरण है:

import datetime
start = datetime.datetime(2009,2,10,14,00)
end   = datetime.datetime(2009,2,10,16,00)
delta = end-start
print(str(delta))
# prints 2:00:00

Comments

इसके तर्क के रूप में टाइमडेल्टा के साथ str () विधि को कॉल करना अधिक पसंद है।

— जोफॉर्कर

आपको वहां str कॉल की आवश्यकता नहीं है, यह प्रिंट द्वारा स्वचालित रूप से किया जाएगा।

— ज़िट्रैक्स

@Zitrax लेकिन यह आवश्यक है यदि आप डेल्टा को एक और स्ट्रिंग के साथ समतल करने जा रहे हैं। उदाहरण के लिएprint 'some thing ' + str(delta)

— Plinio.Santos

और आवश्यक है जब डेटा प्रकार को 'datetime.timedelta' के रूप में परिभाषित किया गया है और आप इसे इस तरह उपयोग कर रहे हैं ConvertDuration=datetime.timedelta(milliseconds=int(254459))तो आप माइक्रोसेकंड को खेलने से बाहर निकालने के लिए विभाजन का उपयोग करते हैं। से 03: 0 ४३.७,६५,००० मैं प्राप्त कर सकते हैं 00:03:43 बस चलाकरTotalDuration=str(ConvertDuration).split('.', 2)[0]

— DarkXDroid

यह डेल्टा को एक स्ट्रिंग के रूप में प्रिंट कर सकता है, लेकिन यह ओपी के अनुरोध के अनुसार इसे प्रारूपित नहीं करता है।

— दानीद

Answer 2

जैसा कि आप जानते हैं, आप एक timedelta ऑब्जेक्ट से कुल_seconds प्राप्त कर सकते हैं .secondsविशेषता तक पहुँचने के द्वारा ।

पायथॉन बिलियन फ़ंक्शन प्रदान करता है divmod()जो इसके लिए अनुमति देता है:

s = 13420
hours, remainder = divmod(s, 3600)
minutes, seconds = divmod(remainder, 60)
print '{:02}:{:02}:{:02}'.format(int(hours), int(minutes), int(seconds))
# result: 03:43:40

या आप मोडुलो और घटाव के संयोजन का उपयोग करके घंटे और शेष में परिवर्तित कर सकते हैं:

# arbitrary number of seconds
s = 13420
# hours
hours = s // 3600 
# remaining seconds
s = s - (hours * 3600)
# minutes
minutes = s // 60
# remaining seconds
seconds = s - (minutes * 60)
# total time
print '{:02}:{:02}:{:02}'.format(int(hours), int(minutes), int(seconds))
# result: 03:43:40

Comments

नकारात्मक समयबद्धता के लिए आपको पहले संकेत का मूल्यांकन करना चाहिए और फिर करना चाहिए abs(s)।

— mbarkhau

ध्यान दें कि आप वास्तव '%d:%02d:%02d'में आउटपुट स्ट्रिंग में अग्रणी शून्य का उपयोग करना चाहते हैं ।

— शिननोयर

अजगर 2.7 और अधिक से अधिक उपयोग के लिए .total_seconds () विधि

— sk8asd123

.secondsयदि अंतर 24 घंटे या उससे अधिक लंबा हो सकता है तो उपयोग न करें ( .secondsविशेषता उपेक्षा .days)। .total_seconds()इसके बजाय इसके एनालॉग का उपयोग करें या करें ।

— जफ्स ३०'१५

सकारात्मक मतभेदों के लिए, मैं समय-समय पर इसे लागू कर रहा हूं। इस समय को खोजने के लिए धन्यवाद :)

— वुल्फ

Answer 3

>>> str(datetime.timedelta(hours=10.56))
10:33:36

>>> td = datetime.timedelta(hours=10.505) # any timedelta object
>>> ':'.join(str(td).split(':')[:2])
10:30

पासिंग timedeltaके लिए वस्तु str()समारोह अगर हम बस टाइप द्वारा उपयोग किए गए स्वरूपण कोड कहता है print td। चूंकि आप सेकंड नहीं चाहते हैं, इसलिए हम स्ट्रिंग को कॉलन (3 भागों) से विभाजित कर सकते हैं और इसे केवल पहले 2 भागों के साथ वापस रख सकते हैं।

Comments

आपके उत्तर के लिए धन्यवाद joeforker, लेकिन मुझे यकीन नहीं है कि मैं आपकी प्रतिक्रिया को समझता हूं। मुझे डेटाइम - डेटाइम के माध्यम से एक समय डेल्टा मिल रहा है। मैं घंटे नहीं जानता। इसके अलावा, ऐसा लगता है कि आपके उदाहरण में सेकंड शामिल हैं, मैं इसे कैसे निकालूंगा?

— 20:11

इससे कोई फर्क नहीं पड़ता कि आपको टाइमडेल्टा ऑब्जेक्ट कहाँ मिलता है, यह प्रारूपित होगा।

— जोफॉर्कर

यदि यह एक दिन से अधिक लंबा है, तो यह विभाजन / प्रसंस्करण में शामिल होने के बाद "4 दिन, 8:00" जैसे प्रारूपित होगा।

— 20

str(my_timedelta)नकारात्मक संख्याओं के लिए खराब तरीके से काम करता है

— कैटस्कुल

ऐसे दिन भी दिखाता है जब> 24 घंटे, जैसे '4 दिन, 18: 48: 22.330000'। कई तरीकों की सलाह दी यहाँ नहीं है।

— एलेक्सी मार्टीनोव

Answer 4

def td_format(td_object):
    seconds = int(td_object.total_seconds())
    periods = [
        ('year',        60*60*24*365),
        ('month',       60*60*24*30),
        ('day',         60*60*24),
        ('hour',        60*60),
        ('minute',      60),
        ('second',      1)
    ]

    strings=[]
    for period_name, period_seconds in periods:
        if seconds > period_seconds:
            period_value , seconds = divmod(seconds, period_seconds)
            has_s = 's' if period_value > 1 else ''
            strings.append("%s %s%s" % (period_value, period_name, has_s))

    return ", ".join(strings)

Comments

वास्तव में अच्छा है, मैं फिर भी बदलने if seconds > period_seconds:का सुझाव दूंगा if seconds >= period_seconds:।

— CBenni

यह नकारात्मक समय के लिए खाली तार देता है, यह सुनिश्चित नहीं है कि क्या यह इरादा है?

— डर्क

Answer 5

मैं व्यक्तिगत रूप से इसके लिए humanizeपुस्तकालय का उपयोग करता हूं :

>>> import datetime
>>> humanize.naturalday(datetime.datetime.now())
'today'
>>> humanize.naturalday(datetime.datetime.now() - datetime.timedelta(days=1))
'yesterday'
>>> humanize.naturalday(datetime.date(2007, 6, 5))
'Jun 05'
>>> humanize.naturaldate(datetime.date(2007, 6, 5))
'Jun 05 2007'
>>> humanize.naturaltime(datetime.datetime.now() - datetime.timedelta(seconds=1))
'a second ago'
>>> humanize.naturaltime(datetime.datetime.now() - datetime.timedelta(seconds=3600))
'an hour ago'

बेशक, यह आपको वह जवाब नहीं देता है जिसकी आप तलाश कर रहे थे (जो कि वास्तव में है str(timeA - timeB), लेकिन मैंने पाया है कि एक बार जब आप कुछ घंटों से आगे निकल जाते हैं, तो डिस्प्ले जल्दी अपठनीय हो जाता है।humanize बहुत बड़े मूल्यों के लिए इसका समर्थन है मानव-पठनीय, और अच्छी तरह से स्थानीयकृत भी है।

यह Django के contrib.humanizeमॉड्यूल से प्रेरित है , जाहिरा तौर पर, इसलिए जब से आप Django का उपयोग कर रहे हैं, आपको संभवतः इसका उपयोग करना चाहिए।

Comments

अच्छा, + 1 यद्यपि: humanize.naturaldelta (pd.Timedelta ('- 10sec')) -> '10 सेकंड ': S ...

— ntg

अच्छी तरह से यह है एक 10 सेकंड डेल्टा । :) यह आप समय चाहते हैं , naturaltimeवही है जो आप उपयोग करना चाहते हैं।

— 19

Answer 6

उसके पास पहले से ही एक समयबद्ध वस्तु है तो क्यों नहीं इसकी अंतर्निहित विधि total_seconds () को सेकंड में बदलने के लिए उपयोग करें, फिर घंटे और मिनट प्राप्त करने के लिए divmod () का उपयोग करें?

hours, remainder = divmod(myTimeDelta.total_seconds(), 3600)
minutes, seconds = divmod(remainder, 60)

# Formatted only for hours and minutes as requested
print '%s:%s' % (hours, minutes)

यदि समय डेल्टा के दिन या वर्ष भी हों तो भी यह काम करता है।

Answer 7

यहाँ एक timedeltaवस्तु या नियमित संख्या (सेकंड या मिनट, आदि के रूप में) को एक अच्छी तरह से स्वरूपित स्ट्रिंग में परिवर्तित करने के लिए एक सामान्य उद्देश्य फ़ंक्शन है । मैंने डुप्लिकेट प्रश्न पर mpounsett का शानदार उत्तर लिया , इसे थोड़ा और अधिक लचीला, बेहतर पठनीयता और जोड़ा गया प्रलेखन बनाया।

आप पाएंगे कि यह अब तक का सबसे लचीला जवाब है क्योंकि यह आपको इसकी अनुमति देता है:

1. हार्ड-कोड होने के बजाय मक्खी पर स्ट्रिंग प्रारूप को अनुकूलित करें।
2. एक समस्या के बिना कुछ समय अंतराल को छोड़ दें (नीचे उदाहरण देखें)।

समारोह:

from string import Formatter
from datetime import timedelta

def strfdelta(tdelta, fmt='{D:02}d {H:02}h {M:02}m {S:02}s', inputtype='timedelta'):
    """Convert a datetime.timedelta object or a regular number to a custom-
    formatted string, just like the stftime() method does for datetime.datetime
    objects.

    The fmt argument allows custom formatting to be specified.  Fields can 
    include seconds, minutes, hours, days, and weeks.  Each field is optional.

    Some examples:
        '{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)
        '{W}w {D}d {H}:{M:02}:{S:02}'     --> '4w 5d 8:04:02'
        '{D:2}d {H:2}:{M:02}:{S:02}'      --> ' 5d  8:04:02'
        '{H}h {S}s'                       --> '72h 800s'

    The inputtype argument allows tdelta to be a regular number instead of the  
    default, which is a datetime.timedelta object.  Valid inputtype strings: 
        's', 'seconds', 
        'm', 'minutes', 
        'h', 'hours', 
        'd', 'days', 
        'w', 'weeks'
    """

    # Convert tdelta to integer seconds.
    if inputtype == 'timedelta':
        remainder = int(tdelta.total_seconds())
    elif inputtype in ['s', 'seconds']:
        remainder = int(tdelta)
    elif inputtype in ['m', 'minutes']:
        remainder = int(tdelta)*60
    elif inputtype in ['h', 'hours']:
        remainder = int(tdelta)*3600
    elif inputtype in ['d', 'days']:
        remainder = int(tdelta)*86400
    elif inputtype in ['w', 'weeks']:
        remainder = int(tdelta)*604800

    f = Formatter()
    desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
    possible_fields = ('W', 'D', 'H', 'M', 'S')
    constants = {'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
    values = {}
    for field in possible_fields:
        if field in desired_fields and field in constants:
            values[field], remainder = divmod(remainder, constants[field])
    return f.format(fmt, **values)

डेमो:

>>> td = timedelta(days=2, hours=3, minutes=5, seconds=8, microseconds=340)

>>> print strfdelta(td)
02d 03h 05m 08s

>>> print strfdelta(td, '{D}d {H}:{M:02}:{S:02}')
2d 3:05:08

>>> print strfdelta(td, '{D:2}d {H:2}:{M:02}:{S:02}')
 2d  3:05:08

>>> print strfdelta(td, '{H}h {S}s')
51h 308s

>>> print strfdelta(12304, inputtype='s')
00d 03h 25m 04s

>>> print strfdelta(620, '{H}:{M:02}', 'm')
10:20

>>> print strfdelta(49, '{D}d {H}h', 'h')
2d 1h

Comments

बहुत अच्छा, साफ कोड! मुझे आश्चर्य है कि इस कोड को

— फॉर्मेटर

Answer 8

मुझे पता है कि यह एक पुराना उत्तर दिया गया प्रश्न है, लेकिन मैं इसके लिए उपयोग करता हूं datetime.utcfromtimestamp()। यह सेकंड की संख्या लेता है और रिटर्न देता है datetimeजिसे किसी अन्य की तरह स्वरूपित किया जा सकता है datetime।

duration = datetime.utcfromtimestamp(end - begin)
print duration.strftime('%H:%M')

जब तक आप काम करना चाहिए समय भागों के लिए कानूनी श्रेणियों में रहते हैं, यानी यह 1234: 35 नहीं लौटाता है क्योंकि घंटे <= 23 हैं।

Comments

आपको print timedelta(seconds=end - begin)इसके बजाय उपयोग करना चाहिए ।

— jfs

@JFSebastian फिर आपको अग्रणी जीरो के साथ मैन्युअल रूप से घंटों को पैड करना होगा।

— sjngm

मैं प्रश्न में गद्दी के बारे में कुछ नहीं देखता हूं। .zfill(8)ज़रूरत पड़ने पर इस्तेमाल करें ।

— jfs

.Total_seconds () कॉल: >>> datetime.utcfromtimestamp ((t2-t1) .total_seconds ())। Strftime ("% H:% M:% S") <<< >>> '00: 00: 00 की आवश्यकता है। 05 '

— cagney

मैं इस समाधान को बहुत पसंद करता हूं, यह आपको प्रारूपण को नियंत्रित करने की अनुमति देता है। ध्यान दें कि आप स्ट्रेट फॉर्मटर का उपयोग इस तरह सीधे कर सकते हैं: "{0:% H}: {0:% M}"। प्रारूप (अवधि)

— पैर की अंगुली

Answer 9

प्रश्नकर्ता विशिष्ट की तुलना में एक अच्छा प्रारूप चाहता है:

  >>> import datetime
  >>> datetime.timedelta(seconds=41000)
  datetime.timedelta(0, 41000)
  >>> str(datetime.timedelta(seconds=41000))
  '11:23:20'
  >>> str(datetime.timedelta(seconds=4102.33))
  '1:08:22.330000'
  >>> str(datetime.timedelta(seconds=413302.33))
  '4 days, 18:48:22.330000'

तो, वास्तव में दो प्रारूप हैं, एक जहां दिन 0 हैं और यह बाहर छोड़ दिया गया है, और एक और जहां पाठ "एन दिन, एच: एम: एस" है। लेकिन, सेकंड में अंश हो सकते हैं, और प्रिंटआउट में कोई अग्रणी शून्य नहीं है, इसलिए कॉलम गड़बड़ हैं।

यहाँ मेरी दिनचर्या है, यदि आप इसे पसंद करते हैं:

def printNiceTimeDelta(stime, etime):
    delay = datetime.timedelta(seconds=(etime - stime))
    if (delay.days > 0):
        out = str(delay).replace(" days, ", ":")
    else:
        out = "0:" + str(delay)
    outAr = out.split(':')
    outAr = ["%02d" % (int(float(x))) for x in outAr]
    out   = ":".join(outAr)
    return out

यह dd: hh: mm: ss प्रारूप के रूप में आउटपुट देता है:

00:00:00:15
00:00:00:19
02:01:31:40
02:01:32:22

मैंने इसमें वर्षों को जोड़ने के बारे में सोचा था, लेकिन इसे पाठक के लिए एक अभ्यास के रूप में छोड़ दिया गया है, क्योंकि आउटपुट 1 वर्ष से अधिक सुरक्षित है:

>>> str(datetime.timedelta(seconds=99999999))
'1157 days, 9:46:39'

Answer 10

मैं ओक्म के रेजर दृष्टिकोण पर गंभीरता से विचार करूंगा:

td = str(timedelta).split('.')[0]

यह माइक्रोसेकंड के बिना एक स्ट्रिंग लौटाता है

यदि आप datetime.timedelta ऑब्जेक्ट को पुनर्जीवित करना चाहते हैं, तो बस यह करें:

h,m,s = re.split(':', td)
new_delta = datetime.timedelta(hours=int(h),minutes=int(m),seconds=int(s))

2 साल में, मैं इस भाषा से प्यार करता हूँ!

Comments

यह दिनों को कवर नहीं करता है

— वाछबेर

Answer 11

मेरी datetime.timedeltaवस्तुएँ एक दिन से अधिक चली गईं। तो यहाँ एक और समस्या है। उपरोक्त सभी चर्चा एक दिन से भी कम समय के लिए होती है। ए timedeltaवास्तव में दिन, सेकंड और माइक्रोसेकंड का एक टपल है। उपरोक्त चर्चा का उपयोग करना चाहिए td.secondsजैसा कि joe ने किया था, लेकिन यदि आपके पास दिन हैं तो यह सेकंड वैल्यू में शामिल नहीं है।

मुझे 2 डेटासेट और प्रिंटिंग दिनों और घंटों के बीच का समय मिल रहा है।

span = currentdt - previousdt
print '%d,%d\n' % (span.days,span.seconds/3600)

Comments

यह भविष्य का प्रमाण समाधान है।

— जिबिन

Answer 12

मैंने ऐसा करने के लिए humanfriendlyअजगर पुस्तकालय का उपयोग किया , यह बहुत अच्छी तरह से काम करता है।

import humanfriendly
from datetime import timedelta
delta = timedelta(seconds = 321)
humanfriendly.format_timespan(delta)

'5 minutes and 21 seconds'

Https://pypi.org/project/humanfriendly/ पर उपलब्ध

Answer 13

ऊपर जो के उदाहरण के मूल्य के बाद, मैं मापांक अंकगणितीय ऑपरेटर का उपयोग करूंगा, इस प्रकार:

td = datetime.timedelta(hours=10.56)
td_str = "%d:%d" % (td.seconds/3600, td.seconds%3600/60)

ध्यान दें कि पायथन डिवीजन डिफ़ॉल्ट रूप से गोल हो जाता है; यदि आप अधिक स्पष्ट होना चाहते हैं, तो उपयुक्त के रूप में math.floor () या math.ceil () का उपयोग करें।

Comments

टाइमडेल्टा पहले से ही जानता है कि कैसे खुद को प्रारूपित करना है, जैसे कि 'some_timedelta' प्रिंट करें।

— 20

हाँ, लेकिन यह एक मनमाना प्रारूप स्ट्रिंग स्वीकार नहीं कर सकता, जो कि माइकल पूछ रहा था। हालाँकि अब मैं इसके बारे में सोचता हूँ कि 3600 डिवीजन मॉड घंटों-सेकंड की धारणा बनाता है जिसके कारण लीप सेकंड में समस्या होती है।

— अल्ट्रानर्ड

हाँ, लेकिन वह एक मनमाना प्रारूप स्ट्रिंग नहीं चाहता है, वह लगभग बिल्कुल डिफ़ॉल्ट व्यवहार चाहता है।

— जोफोरकर

पायथन 3000 में

— रद्दी

+1, लेकिन आप उपयोग करने के लिए उत्तर को संपादित क्यों नहीं करते //? मैं इसे 1 दिन के अंतराल के लिए काम करने के td.total_seconds()बजाय उपयोग करने का सुझाव भी दूंगा .seconds।

— एंटनी हैचकिंस

Answer 14

def seconds_to_time_left_string(total_seconds):
    s = int(total_seconds)
    years = s // 31104000
    if years > 1:
        return '%d years' % years
    s = s - (years * 31104000)
    months = s // 2592000
    if years == 1:
        r = 'one year'
        if months > 0:
            r += ' and %d months' % months
        return r
    if months > 1:
        return '%d months' % months
    s = s - (months * 2592000)
    days = s // 86400
    if months == 1:
        r = 'one month'
        if days > 0:
            r += ' and %d days' % days
        return r
    if days > 1:
        return '%d days' % days
    s = s - (days * 86400)
    hours = s // 3600
    if days == 1:
        r = 'one day'
        if hours > 0:
            r += ' and %d hours' % hours
        return r 
    s = s - (hours * 3600)
    minutes = s // 60
    seconds = s - (minutes * 60)
    if hours >= 6:
        return '%d hours' % hours
    if hours >= 1:
        r = '%d hours' % hours
        if hours == 1:
            r = 'one hour'
        if minutes > 0:
            r += ' and %d minutes' % minutes
        return r
    if minutes == 1:
        r = 'one minute'
        if seconds > 0:
            r += ' and %d seconds' % seconds
        return r
    if minutes == 0:
        return '%d seconds' % seconds
    if seconds == 0:
        return '%d minutes' % minutes
    return '%d minutes and %d seconds' % (minutes, seconds)

for i in range(10):
    print pow(8, i), seconds_to_time_left_string(pow(8, i))


Output:
1 1 seconds
8 8 seconds
64 one minute and 4 seconds
512 8 minutes and 32 seconds
4096 one hour and 8 minutes
32768 9 hours
262144 3 days
2097152 24 days
16777216 6 months
134217728 4 years

Comments

क्या आपने इसे लिखा है? आपने इसका कितना परीक्षण किया?

— थॉमस अहले

मैं अपने कोड में datahaven.net नामक इस कोड का उपयोग कर रहा हूं । यह बहुत अच्छा काम करता है। क्या आपने कोई त्रुटि देखी?

— वेसलिन पेनेव

यह हमेशा अच्छा होता है यदि आप इस तरह के कोड के साथ थोड़ी जानकारी प्रदान कर सकते हैं भारी जवाब :) यह कैसे काम करता है, संभव ताकत और कमजोरियों के एक उदाहरण की तरह।

— थॉमस अहले

ओह। ज़रूर!। आपके लिए एक उदाहरण और जोड़ा। :-)

— वेसलिन पेनेव

सुपर :) यह भी ध्यान दें कि timedeltaऑब्जेक्ट में फ़ील्ड हैं days, secondsऔर microsecondsप्रलेखन द्वारा।

— थॉमस अहले

Answer 15

मुझे काम पर ओवरटाइम गणना के आउटपुट के साथ एक समान समस्या थी। मान को हमेशा HH: MM में दिखाना चाहिए, भले ही यह एक दिन से अधिक हो और मूल्य नकारात्मक हो सकता है। मैंने कुछ दिखाए गए समाधानों को संयोजित किया है और शायद किसी और को यह समाधान उपयोगी लगता है। मुझे एहसास हुआ कि यदि टाइमडेल्टा मान नकारात्मक है, तो डिमॉड विधि के साथ दिखाए गए अधिकांश समाधान बॉक्स से बाहर काम नहीं करते हैं:

def td2HHMMstr(td):
  '''Convert timedelta objects to a HH:MM string with (+/-) sign'''
  if td < datetime.timedelta(seconds=0):
    sign='-'
    td = -td
  else:
    sign = ''
  tdhours, rem = divmod(td.total_seconds(), 3600)
  tdminutes, rem = divmod(rem, 60)
  tdstr = '{}{:}:{:02d}'.format(sign, int(tdhours), int(tdminutes))
  return tdstr

समयसीमा से एचएच: एमएम स्ट्रिंग:

td2HHMMstr(datetime.timedelta(hours=1, minutes=45))
'1:54'

td2HHMMstr(datetime.timedelta(days=2, hours=3, minutes=2))
'51:02'

td2HHMMstr(datetime.timedelta(hours=-3, minutes=-2))
'-3:02'

td2HHMMstr(datetime.timedelta(days=-35, hours=-3, minutes=-2))
'-843:02'

Answer 16

import datetime
hours = datetime.timedelta(hours=16, minutes=30)
print((datetime.datetime(1,1,1) + hours).strftime('%H:%M'))

Comments

3.7 में मुझे

— अट्रैक्शन

Answer 17

इस समस्या के लिए एक सीधा आगे टेम्प्लेट फ़िल्टर। अंतर्निहित फ़ंक्शन int () कभी गोल नहीं होता है। एफ-स्ट्रिंग्स (यानी एफ '') को अजगर 3.6 की आवश्यकता होती है।

@app_template_filter()
def diffTime(end, start):
    diff = (end - start).total_seconds()
    d = int(diff / 86400)
    h = int((diff - (d * 86400)) / 3600)
    m = int((diff - (d * 86400 + h * 3600)) / 60)
    s = int((diff - (d * 86400 + h * 3600 + m *60)))
    if d > 0:
        fdiff = f'{d}d {h}h {m}m {s}s'
    elif h > 0:
        fdiff = f'{h}h {m}m {s}s'
    elif m > 0:
        fdiff = f'{m}m {s}s'
    else:
        fdiff = f'{s}s'
    return fdiff

Answer 18

from django.utils.translation import ngettext

def localize_timedelta(delta):
    ret = []
    num_years = int(delta.days / 365)
    if num_years > 0:
        delta -= timedelta(days=num_years * 365)
        ret.append(ngettext('%d year', '%d years', num_years) % num_years)

    if delta.days > 0:
        ret.append(ngettext('%d day', '%d days', delta.days) % delta.days)

    num_hours = int(delta.seconds / 3600)
    if num_hours > 0:
        delta -= timedelta(hours=num_hours)
        ret.append(ngettext('%d hour', '%d hours', num_hours) % num_hours)

    num_minutes = int(delta.seconds / 60)
    if num_minutes > 0:
        ret.append(ngettext('%d minute', '%d minutes', num_minutes) % num_minutes)

    return ' '.join(ret)

यह उत्पादन करेगा:

>>> from datetime import timedelta
>>> localize_timedelta(timedelta(days=3660, minutes=500))
'10 years 10 days 8 hours 20 minutes'

Comments

मेरी राय में neatest एक, लंबाई की और के मामले में यह क्या शामिल किया गया

— Dici

Answer 19

कृपया इस फ़ंक्शन को जांचें - यह टाइमडेल्टा ऑब्जेक्ट को स्ट्रिंग 'एचएच: एमएम: एसएस' में परिवर्तित करता है।

def format_timedelta(td):
    hours, remainder = divmod(td.total_seconds(), 3600)
    minutes, seconds = divmod(remainder, 60)
    hours, minutes, seconds = int(hours), int(minutes), int(seconds)
    if hours < 10:
        hours = '0%s' % int(hours)
    if minutes < 10:
        minutes = '0%s' % minutes
    if seconds < 10:
        seconds = '0%s' % seconds
    return '%s:%s:%s' % (hours, minutes, seconds)

Answer 20

एक लाइन। चूँकि टाइमडेल्टस डेटाइम के स्ट्रेटटाइम की पेशकश नहीं करते हैं, इसलिए टाइमडेलटा को डेटाइम में वापस लाएँ, और स्टाइपटाइम का उपयोग करें।

यह न केवल ओपी के अनुरोधित प्रारूप घंटे को प्राप्त कर सकता है: मिनट, अब आप डेटाइम के स्ट्रैपटाइम की पूर्ण स्वरूपण शक्ति का लाभ उठा सकते हैं, क्या आपकी आवश्यकताओं को किसी अन्य प्रतिनिधित्व में बदलना चाहिए।

import datetime
td = datetime.timedelta(hours=2, minutes=10, seconds=5)
print(td)
print(datetime.datetime.strftime(datetime.datetime.strptime(str(td), "%H:%M:%S"), "%H:%M"))

Output:
2:10:05
02:10

यह उस झुंझलाहट को भी हल करता है जो समयबद्धता को एच: एमएम: एसएस के बजाय एचएच: एमएम: एसएस के रूप में स्ट्रिंग्स में स्वरूपित किया जाता है, जो मुझे इस समस्या की ओर ले जाता है, और जो समाधान मैंने साझा किया है।

Answer 21

यदि आपके पास पहले से ही एक समयबद्ध ओब्ज है तो बस उस ओब्ज को स्ट्रिंग में परिवर्तित करें। स्ट्रिंग के अंतिम 3 अक्षर निकालें और प्रिंट करें। यह सेकंड के हिस्से को काट देगा और इसे बाकी के प्रारूप घंटे: मिनट में प्रिंट करेगा।

t = str(timedeltaobj) 

print t[:-3]

Comments

-3 काम नहीं करता है, बेहतर उपयोगprint t.split('.')[0]

— एवगेनीकोलाकोव

Answer 22

यदि आपके पास IPythonआपके पैकेज (आपके पास ) होना चाहिए, तो उसके पास (अब, वैसे भी) अवधि के लिए एक बहुत अच्छा फॉर्मेटर है (फ्लोट सेकंड में)। इसका उपयोग विभिन्न स्थानों पर किया जाता है, उदाहरण के लिए %%timeसेल मैजिक द्वारा । मुझे लघु अवधि के लिए इसका प्रारूप पसंद है:

>>> from IPython.core.magics.execution import _format_time
>>> 
>>> for v in range(-9, 10, 2):
...     dt = 1.25 * 10**v
...     print(_format_time(dt))

1.25 ns
125 ns
12.5 µs
1.25 ms
125 ms
12.5 s
20min 50s
1d 10h 43min 20s
144d 16h 13min 20s
14467d 14h 13min 20s

Answer 23

t1 = datetime.datetime.strptime(StartTime, "%H:%M:%S %d-%m-%y")

t2 = datetime.datetime.strptime(EndTime, "%H:%M:%S %d-%m-%y")

return str(t2-t1)

के लिए:

StartTime = '15:28:53 21-07-13'
EndTime = '15:32:40 21-07-13'

रिटर्न:

'0:03:47'

Answer 24

आपकी मदद के लिए सभी को शुक्रिया। मैंने आपके कई विचारों को लिया और उन्हें एक साथ रखा, मुझे पता है कि आप क्या सोचते हैं।

मैंने कक्षा में दो तरीकों को इस तरह जोड़ा:

def hours(self):
    retval = ""
    if self.totalTime:
        hoursfloat = self.totalTime.seconds / 3600
        retval = round(hoursfloat)
    return retval

def minutes(self):
    retval = ""
    if self.totalTime:
        minutesfloat = self.totalTime.seconds / 60
        hoursAsMinutes = self.hours() * 60
        retval = round(minutesfloat - hoursAsMinutes)
    return retval

मेरे django में मैंने इसका इस्तेमाल किया (राशि एक वस्तु है और यह एक शब्दकोष में है):

<td>{{ sum.0 }}</td>    
<td>{{ sum.1.hours|stringformat:"d" }}:{{ sum.1.minutes|stringformat:"#02.0d" }}</td>

Comments

थोड़ी लंबी है। मैं सुझाव दूंगा: डीएचएचएम (सेल्फ): रिटर्न ':'। ज्वाइन (str (td)। एसपीएलआईटी (':') [: 2]) <td> {{sum.1.hhmm}} </ td

— joeforker

बस docs.python.org/release/2.5.2/lib/datetime-timedelta.html

— टॉम