अजगर समारोह मिनट, घंटे, और दिन

Question

में सेकंड कन्वर्ट करने के लिए

प्रश्न: एक प्रोग्राम है जो सेकंड के एक नंबर दर्ज करने के लिए उपयोगकर्ता पूछता लिखें, और काम करता है:

• एक में 60 सेकंड रहे हैं मिनट। यदि उपयोगकर्ता द्वारा दर्ज किए गए सेकंड की संख्या 60 से अधिक या बराबर है, तो प्रोग्राम को कई सेकंड में मिनटों की संख्या प्रदर्शित करनी चाहिए।

• एक घंटे में 3600 सेकंड हैं। यदि उपयोगकर्ता द्वारा दर्ज किए गए सेकंड की संख्या 3600 से अधिक या बराबर है, तो प्रोग्राम को कई सेकंड में घंटों की संख्या प्रदर्शित करनी चाहिए।

• एक दिन में 86400 सेकंड हैं। यदि उपयोगकर्ता द्वारा दर्ज किए गए सेकंड की संख्या 86400 से अधिक या बराबर है, तो प्रोग्राम को कई सेकंड में दिनों की संख्या प्रदर्शित करनी चाहिए।

क्या मैं अब तक है:

def time(): 
    sec = int(input ('Enter the number of seconds:'.strip()) 
    if sec <= 60: 
     minutes = sec // 60 
     print('The number of minutes is {0:.2f}'.format(minutes)) 
    if sec (<= 3600): 
     hours = sec // 3600 
     print('The number of minutes is {0:.2f}'.format(hours)) 
    if sec <= 86400: 
     days = sec // 86400 
     print('The number of minutes is {0:.2f}'.format(days)) 
    return 

Answer 1

यह दूसरी तरह के आसपास सेकेंड की जरूरत है, और यह समय फोन नहीं है के रूप में घटाकर करो; वहाँ उस नाम का कोई पैकेज है:

def sec_to_time(): 
    sec = int(input ('Enter the number of seconds:'.strip())) 

    days = sec/86400 
    sec -= 86400*days 

    hrs = sec/3600 
    sec -= 3600*hrs 

    mins = sec/60 
    sec -= 60*mins 
    print days, ':', hrs, ':', min, ':', sec 

Answer 2

यह घ दिन, ज घंटे, मीटर मिनट, और रों सेकंड में n सेकंड में परिवर्तित कर देंगे।

from datetime import datetime, timedelta 

def GetTime(): 
    sec = timedelta(seconds=int(input('Enter the number of seconds: '))) 
    d = datetime(1,1,1) + sec 

    print("DAYS:HOURS:MIN:SEC") 
    print("%d:%d:%d:%d" % (d.day-1, d.hour, d.minute, d.second)) 

Answer 3

पहली नज़र में, मैं लगा divmod तेजी से किया जाएगा, क्योंकि यह एक सिंगल स्टेटमेंट और एक अंतर्निहित समारोह है, लेकिन timeit अन्यथा दिखाने के लिए लगता है। इस छोटे से उदाहरण पर विचार करें जब मैं एक लूप में उपयोग के लिए सबसे तेज़ तरीका समझने की कोशिश कर रहा था, जो लगातार एक गोबेल idle_add में चलता है जो एक प्रगति बार लेबल को अद्यतन करने के लिए एक मानव पठनीय समय में एक सेकंड को विभाजित करता है।

import timeit 

def test1(x,y, dropy): 
    while x > 0: 
     y -= dropy 
     x -= 1 

     # the test 
     minutes = (y-x)/60 
     seconds = (y-x) % 60.0 

def test2(x,y, dropy): 
    while x > 0: 
     y -= dropy 
     x -= 1 

     # the test 
     minutes, seconds = divmod((y-x), 60) 

x = 55  # litte number, also number of tests 
y = 10000 # make y > x by factor of drop 
dropy = 7 # y is reduced this much each iteration, for variation 

print "division and modulus:", timeit.timeit(lambda: test1(x,y,dropy)) 
print "divmod function:",  timeit.timeit(lambda: test2(x,y,dropy)) 

निर्मित divmod समारोह अविश्वसनीय रूप से धीमी सरल विभाजन और मापांक उपयोग की तुलना में लगता है।

division and modulus: 12.5737669468 
divmod function: 17.2861430645 

Answer 4

यह टिडबिट ग्रैन्युलरिटी की विभिन्न डिग्री के लिए विलुप्त समय प्रदर्शित करने के लिए उपयोगी है।

मुझे व्यक्तिगत रूप से लगता है कि दक्षता के प्रश्न यहां व्यावहारिक रूप से अर्थहीन हैं, जब तक कि काफी कुछ अक्षम नहीं किया जा रहा है। समयपूर्व अनुकूलन बहुत बुराई की जड़ है। यह इतना तेज़ है कि यह कभी भी आपका चोक पॉइंट नहीं होगा।

intervals = (
    ('weeks', 604800), # 60 * 60 * 24 * 7 
    ('days', 86400), # 60 * 60 * 24 
    ('hours', 3600), # 60 * 60 
    ('minutes', 60), 
    ('seconds', 1), 
    ) 

def display_time(seconds, granularity=2): 
    result = [] 

    for name, count in intervals: 
     value = seconds // count 
     if value: 
      seconds -= value * count 
      if value == 1: 
       name = name.rstrip('s') 
      result.append("{} {}".format(value, name)) 
    return ', '.join(result[:granularity]) 

..और इस सभ्य उत्पादन प्रदान करता है:

In [52]: display_time(1934815) 
Out[52]: '3 weeks, 1 day' 

In [53]: display_time(1934815, 4) 
Out[53]: '3 weeks, 1 day, 9 hours, 26 minutes' 

Answer 5

इन कार्यों काफी कॉम्पैक्ट हैं और केवल मानक अजगर 2.6 और बाद का उपयोग करें।

def ddhhmmss(seconds): 
    """Convert seconds to a time string "[[[DD:]HH:]MM:]SS". 
    """ 
    dhms = '' 
    for scale in 86400, 3600, 60: 
     result, seconds = divmod(seconds, scale) 
     if dhms != '' or result > 0: 
      dhms += '{0:02d}:'.format(result) 
    dhms += '{0:02d}'.format(seconds) 
    return dhms 


def seconds(dhms): 
    """Convert a time string "[[[DD:]HH:]MM:]SS" to seconds. 
    """ 
    components = [int(i) for i in dhms.split(':')] 
    pad = 4 - len(components) 
    if pad < 0: 
     raise ValueError('Too many components to match [[[DD:]HH:]MM:]SS') 
    components = [0] * pad + components 
    return sum(i * j for i, j in zip((86400, 3600, 60, 1), components)) 

और यहां उनके साथ जाने के लिए परीक्षण हैं। मैं अपवादों का परीक्षण करने के लिए एक सरल तरीका के रूप में pytest पैकेज का उपयोग कर रहा हूँ।

import ddhhmmss 

import pytest 


def test_ddhhmmss(): 
    assert ddhhmmss.ddhhmmss(0) == '00' 
    assert ddhhmmss.ddhhmmss(2) == '02' 
    assert ddhhmmss.ddhhmmss(12 * 60) == '12:00' 
    assert ddhhmmss.ddhhmmss(3600) == '01:00:00' 
    assert ddhhmmss.ddhhmmss(10 * 86400) == '10:00:00:00' 
    assert ddhhmmss.ddhhmmss(86400 + 5 * 3600 + 30 * 60 + 1) == '01:05:30:01' 
    assert ddhhmmss.ddhhmmss(365 * 86400) == '365:00:00:00' 


def test_seconds(): 
    assert ddhhmmss.seconds('00') == 0 
    assert ddhhmmss.seconds('02') == 2 
    assert ddhhmmss.seconds('12:00') == 12 * 60 
    assert ddhhmmss.seconds('01:00:00') == 3600 
    assert ddhhmmss.seconds('1:0:0') == 3600 
    assert ddhhmmss.seconds('3600') == 3600 
    assert ddhhmmss.seconds('60:0') == 3600 
    assert ddhhmmss.seconds('10:00:00:00') == 10 * 86400 
    assert ddhhmmss.seconds('1:05:30:01') == 86400 + 5 * 3600 + 30 * 60 + 1 
    assert ddhhmmss.seconds('365:00:00:00') == 365 * 86400 


def test_seconds_raises(): 
    with pytest.raises(ValueError): 
     ddhhmmss.seconds('') 
    with pytest.raises(ValueError): 
     ddhhmmss.seconds('foo') 
    with pytest.raises(ValueError): 
     ddhhmmss.seconds('1:00:00:00:00') 

Answer 6

seconds_in_day = 86400 
seconds_in_hour = 3600 
seconds_in_minute = 60 

seconds = int(input("Enter a number of seconds: ")) 

days = seconds // seconds_in_day 
seconds = seconds - (days * seconds_in_day) 

hours = seconds // seconds_in_hour 
seconds = seconds - (hours * seconds_in_hour) 

minutes = seconds // seconds_in_minute 
seconds = seconds - (minutes * seconds_in_minute) 

print("{0:.0f} days, {1:.0f} hours, {2:.0f} minutes, {3:.0f} seconds.".format(
    days, hours, minutes, seconds)) 

Answer 7

#1 min = 60 
#1 hour = 60 * 60 = 3600 
#1 day = 60 * 60 * 24 = 86400 

    x=input('enter a positive integer: ') 

    t=int(x) 

    day= t//86400 
    hour= (t-(day*86400))//3600 
    minit= (t - ((day*86400) + (hour*3600)))//60 
    seconds= t - ((day*86400) + (hour*3600) + (minit*60)) 
    print(day, 'days' , hour,' hours', minit, 'minutes',seconds,' seconds') 

Answer 8

datetime में (स्ट्रिंग के रूप में) सेकंड बदलने के लिए, यह भी मदद कर सकता है। आपको दिन और सेकंड की संख्या मिलती है। सेकंड को और मिनटों और घंटों में परिवर्तित किया जा सकता है।

from datetime import datetime, timedelta 
sec = timedelta(seconds=(input('Enter the number of seconds: '))) 
time = str(sec) 

Answer 9

मुझे पूरा यकीन नहीं है कि आप इसे चाहते हैं, लेकिन मेरे पास एक समान कार्य था और शून्य होने पर फ़ील्ड को हटाने के लिए आवश्यक था। उदाहरण के लिए, 86401 सेकंड "1 दिन, 0 घंटे, 0 मिनट, 1 सेकंड" के बजाय "1 दिन, 1 सेकंड" दिखाएंगे। वह निम्नलिखित कोड करता है।

def secondsToText(secs): 
    days = secs//86400 
    hours = (secs - days*86400)//3600 
    minutes = (secs - days*86400 - hours*3600)//60 
    seconds = secs - days*86400 - hours*3600 - minutes*60 
    result = ("{} days, ".format(days) if days else "") + \ 
    ("{} hours, ".format(hours) if hours else "") + \ 
    ("{} minutes, ".format(minutes) if minutes else "") + \ 
    ("{} seconds, ".format(seconds) if seconds else "") 
    return result 

संपादित करें: थोड़ा बेहतर संस्करण जो शब्दों के बहुवचन को संभालता है।

def secondsToText(secs): 
    days = secs//86400 
    hours = (secs - days*86400)//3600 
    minutes = (secs - days*86400 - hours*3600)//60 
    seconds = secs - days*86400 - hours*3600 - minutes*60 
    result = ("{0} day{1}, ".format(days, "s" if days!=1 else "") if days else "") + \ 
    ("{0} hour{1}, ".format(hours, "s" if hours!=1 else "") if hours else "") + \ 
    ("{0} minute{1}, ".format(minutes, "s" if minutes!=1 else "") if minutes else "") + \ 
    ("{0} second{1}, ".format(seconds, "s" if seconds!=1 else "") if seconds else "") 
    return result 

EDIT2: (। माफ करना, पर्याप्त नहीं प्रतिनिधि टिप्पणी करने के लिए) एक gist बनाई गई है कि है कि कई भाषाओं

Answer 10

में पैच Mr.B's answer, हम समय की राशि के आधार पर चर के विवरण का स्तर लौट सकते हैं। उदाहरण के लिए, हम कहते हैं नहीं "1 सप्ताह, 5 सेकंड", हम बस कहते हैं कि "1 सप्ताह":

def display_time(seconds, granularity=2): 
    result = [] 

    for name, count in intervals: 
     value = seconds // count 
     if value: 
      seconds -= value * count 
      if value == 1: 
       name = name.rstrip('s') 
      result.append("{} {}".format(value, name)) 
     else: 
      # Add a blank if we're in the middle of other values 
      if len(result) > 0: 
       result.append(None) 
    return ', '.join([x for x in result[:granularity] if x is not None]) 

कुछ नमूना इनपुट:

for diff in [5, 67, 3600, 3605, 3667, 24*60*60, 24*60*60+5, 24*60*60+57, 24*60*60+3600, 24*60*60+3667, 2*24*60*60, 2*24*60*60+5*60*60, 7*24*60*60, 7*24*60*60 + 24*60*60]: 
    print "For %d seconds: %s" % (diff, display_time(diff, 2)) 

... इस उत्पादन रिटर्न:

For 5 seconds: 5 seconds 
For 67 seconds: 1 minute, 7 seconds 
For 3600 seconds: 1 hour 
For 3605 seconds: 1 hour 
For 3667 seconds: 1 hour, 1 minute 
For 86400 seconds: 1 day 
For 86405 seconds: 1 day 
For 86457 seconds: 1 day 
For 90000 seconds: 1 day, 1 hour 
For 90067 seconds: 1 day, 1 hour 
For 172800 seconds: 2 days 
For 190800 seconds: 2 days, 5 hours 
For 604800 seconds: 1 week 
For 691200 seconds: 1 week, 1 day