गायब datetime.timedelta.to_seconds() -> पायथन में तैरते हैं?

Question

मैं समझता हूँ कि सेकंड और माइक्रोसेकंड शायद दक्षता कारणों के लिए datetime.timedelta में अलग से प्रतिनिधित्व कर रहे हैं, लेकिन मैं सिर्फ इस सरल समारोह लिखा है:

def to_seconds_float(timedelta): 
    """Calculate floating point representation of combined 
    seconds/microseconds attributes in :param:`timedelta`. 

    :raise ValueError: If :param:`timedelta.days` is truthy. 

     >>> to_seconds_float(datetime.timedelta(seconds=1, milliseconds=500)) 
     1.5 
     >>> too_big = datetime.timedelta(days=1, seconds=12) 
     >>> to_seconds_float(too_big) # doctest: +ELLIPSIS 
     Traceback (most recent call last): 
     ... 
     ValueError: ('Must not have days', datetime.timedelta(1, 12)) 
    """ 
    if timedelta.days: 
     raise ValueError('Must not have days', timedelta) 
    return timedelta.seconds + timedelta.microseconds/1E6 

यह time.sleep या select.select के लिए एक मूल्य गुजर जैसी चीजों के लिए उपयोगी है। datetime.timedelta इंटरफ़ेस के इस हिस्से की तरह कुछ क्यों नहीं है? मुझे कुछ कोने का मामला याद आ रहा है। समय प्रतिनिधित्व में इतने सारे गैर-स्पष्ट कोने के मामले लगते हैं ...

मैंने कुछ परिशुद्धता पर उचित शॉट रखने के लिए दिन को खारिज कर दिया (मैं वास्तव में गणित एटीएम को काम करने के लिए बहुत आलसी हूं, इसलिए ऐसा लगता है एक उचित समझौता ;-)।

Answer 1

एक पाइथन फ्लोट में लगभग 15 महत्वपूर्ण अंक हैं, इसलिए सेकेंड 86400 (दशमलव बिंदु के बाईं ओर 5 अंक) तक और माइक्रोसॉन्ड को 6 अंकों की आवश्यकता होती है, आप दिनों को अच्छी तरह से शामिल कर सकते हैं (कई वर्षों तक के लायक) परिशुद्धता के नुकसान के बिना।

एक अच्छा मंत्र "पीआई सेकंड एक नैनोसेन्टरी है" - प्रति 100 वर्षों के बारे में 3.14E9 सेकंड, यानी प्रति वर्ष 3E7, इसलिए प्रति वर्ष 3E13 माइक्रोसेकंड। मंत्र अच्छा है क्योंकि यह यादगार है, भले ही आपको थोड़ी मानसिक अंकगणित करने की आवश्यकता होती है (लेकिन, पालक की तरह, यह आपके लिए अच्छा है - आपको चुस्त और सतर्क रखता है! -)।

datetime का डिज़ाइन दर्शन कुछ हद तक कम से कम है, इसलिए यह आश्चर्य की बात नहीं है कि यह कई संभावित सहायक विधियों को छोड़ देता है जो सरल अंकगणितीय अभिव्यक्तियों को उबालते हैं।

Answer 2

परिशुद्धता के लिए आपकी चिंता गलत है। यहाँ एक सरल दो लाइनर मोटे तौर पर गणना करने के लिए कितने साल आप क्या एक IEEE754 64-बिट नाव में precsion के 53 बिट के बचा है में निचोड़ कर सकते हैं:

>>> import math 
>>> 10 ** (math.log10(2 ** 53) - math.log10(60 * 60 * 24) - 6)/365.25 
285.42092094268787 
>>> 

दौर बंद के लिए बाहर देखो; सबसे छोटी गैर-शून्य संख्याएं जोड़ें:

return timedelta.seconds + timedelta.microseconds/1E6 + timedelta.days * 86400