Anzahl der Nanosekunden (int)

Eine Nanosekundenauflösung reicht für alle aktuellen C-Funktionen aus, und daher kann ein Zeitstempel einfach eine Zahl von Nanosekunden sein, eine ganze Zahl, keine Gleitkommazahl.

Das Format "Anzahl der Nanosekunden" wurde abgelehnt, da es neue spezialisierte Funktionen für dieses Format erfordern würde, da es nicht möglich ist, eine Anzahl von Nanosekunden und eine Anzahl von Sekunden anhand des Objekttyps zu unterscheiden.

128-Bit-Gleitkommazahl

Fügen Sie einen neuen IEEE 754-2008 Quad-Precision Binär-Gleitkommatyp hinzu. Der IEEE 754-2008 Quad-Precision Float hat 1 Vorzeichenbit, 15 Exponentenbits und 112 Mantissenbits. 128-Bit-Float wird von GCC (4.3), Clang und ICC-Compilern unterstützt.

Python muss portabel sein und kann sich daher nicht auf einen Typ verlassen, der nur auf einigen Plattformen verfügbar ist. Beispielsweise unterstützt Visual C++ 2008 keinen 128-Bit-Float, obwohl er zum Erstellen der offiziellen Windows-Ausführbaren verwendet wird. Ein weiteres Beispiel: GCC 4.3 unterstützt __float128 im 32-Bit-Modus unter x86 nicht (aber GCC 4.4 tut es).

Es gibt auch ein Lizenzproblem: GCC verwendet die MPFR-Bibliothek für 128-Bit-Floats, eine Bibliothek, die unter der GNU LGPL-Lizenz vertrieben wird. Diese Lizenz ist mit der Python-Lizenz nicht kompatibel.

datetime.datetime

Der Typ datetime.datetime ist die natürliche Wahl für einen Zeitstempel, da klar ist, dass dieser Typ einen Zeitstempel enthält, während int, float und Decimal rohe Zahlen sind. Es ist ein absoluter Zeitstempel und daher gut definiert. Er bietet direkten Zugriff auf Jahr, Monat, Tag, Stunden, Minuten und Sekunden. Er hat zeitbezogene Methoden wie Methoden zur Formatierung des Zeitstempels als Zeichenkette (z. B. datetime.datetime.strftime).

Das Hauptproblem ist, dass mit Ausnahme von os.stat(), time.time() und time.clock_gettime(time.CLOCK_GETTIME) alle Zeitfunktionen einen unbestimmten Startpunkt und keine Zeitzoneninformationen haben und daher nicht in datetime.datetime konvertiert werden können.

datetime.datetime hat auch Probleme mit der Zeitzone. Beispielsweise können ein datetime-Objekt ohne Zeitzone (unaware) und ein datetime mit Zeitzone (aware) nicht verglichen werden. Es gibt auch ein Reihenfolgeproblem mit der Sommerzeit (DST) bei der doppelten Stunde des Wechsels von DST zu Normalzeit.

datetime.datetime wurde abgelehnt, da es nicht für Funktionen verwendet werden kann, die einen unbestimmten Startpunkt verwenden, wie os.times() oder time.clock().

Für time.time() und time.clock_gettime(time.CLOCK_GETTIME): Es ist bereits möglich, die aktuelle Zeit als datetime.datetime-Objekt zu erhalten durch

datetime.datetime.now(datetime.timezone.utc)

Für os.stat() ist es einfach, ein datetime.datetime-Objekt aus einem decimal.Decimal-Zeitstempel in der UTC-Zeitzone zu erstellen

datetime.datetime.fromtimestamp(value, datetime.timezone.utc)

datetime.timedelta

datetime.timedelta ist die natürliche Wahl für einen relativen Zeitstempel, da klar ist, dass dieser Typ einen Zeitstempel enthält, während int, float und Decimal rohe Zahlen sind. Er kann mit datetime.datetime verwendet werden, um einen absoluten Zeitstempel zu erhalten, wenn der Startpunkt bekannt ist.

datetime.timedelta wurde abgelehnt, da es nicht in Float konvertiert werden kann und eine feste Auflösung hat. Ein neuer Standard-Zeitstempeltyp reicht aus, Decimal wird datetime.timedelta vorgezogen. Die Konvertierung eines datetime.timedelta in Float erfordert einen expliziten Aufruf der Methode datetime.timedelta.total_seconds().

Tupel aus ganzen Zahlen

Um C-Funktionen in Python verfügbar zu machen, ist ein Tupel aus ganzen Zahlen die natürliche Wahl zur Speicherung eines Zeitstempels, da die C-Sprache Strukturen mit Ganzzahlfeldern verwendet (z. B. timeval- und timespec-Strukturen). Die Verwendung von nur ganzen Zahlen vermeidet Präzisionsverluste (Python unterstützt Ganzzahlen beliebiger Länge). Das Erstellen und Parsen eines Tupels aus ganzen Zahlen ist einfach und schnell.

Abhängig vom genauen Format des Tupels kann die Auflösung beliebig oder fest sein. Die Auflösung kann so gewählt werden, dass der Präzisionsverlust geringer ist als eine beliebige Grenze wie eine Nanosekunde.

Verschiedene Formate wurden vorgeschlagen

• A: (Zähler, Nenner)
  • Wert = Zähler / Nenner
  • Auflösung = 1 / Nenner
  • Nenner > 0
• B: (Sekunden, Zähler, Nenner)
  • Wert = Sekunden + Zähler / Nenner
  • Auflösung = 1 / Nenner
  • 0 <= Zähler < Nenner
  • Nenner > 0
• C: (intpart, floatpart, base, exponent)
  • Wert = intpart + floatpart / base^exponent
  • Auflösung = 1 / base ^exponent
  • 0 <= floatpart < base ^exponent
  • base > 0
  • exponent >= 0
• D: (intpart, floatpart, exponent)
  • Wert = intpart + floatpart / 10^exponent
  • Auflösung = 1 / 10 ^exponent
  • 0 <= floatpart < 10 ^exponent
  • exponent >= 0
• E: (sec, nsec)
  • Wert = sec + nsec × 10^-9
  • Auflösung = 10 ^-9 (Nanosekunde)
  • 0 <= nsec < 10 ⁹

Alle Formate unterstützen eine beliebige Auflösung, außer Format (E).

Das Format (D) kann den genauen Wert möglicherweise nicht speichern (möglicherweise Präzisionsverlust), wenn die Taktfrequenz beliebig ist und keine Potenz von 2 oder 10 ist. Das Format (C) hat ein ähnliches Problem, aber in diesem Fall ist es möglich, base=Frequenz und exponent=1 zu verwenden.

Die Formate (C), (D) und (E) ermöglichen Optimierungen für die Konvertierung in Float, wenn die Basis 2 ist, und in decimal.Decimal, wenn die Basis 10 ist.

Das Format (A) ist ein einfacher Bruch. Es unterstützt beliebige Präzision, ist einfach (nur zwei Felder), erfordert nur eine einfache Division, um den Gleitkommawert zu erhalten, und wird bereits von float.as_integer_ratio() verwendet.

Um die Implementierung zu vereinfachen (insbesondere die C-Implementierung zur Vermeidung von Integer-Überläufen), kann ein Zähler, der größer als der Nenner ist, akzeptiert werden. Das Tupel kann später normalisiert werden.

Tupel aus ganzen Zahlen wurden abgelehnt, da sie keine arithmetischen Operationen unterstützen.

timespec-Struktur

timespec ist die C-Struktur, die zur Speicherung von Zeitstempeln mit Nanosekundenauflösung verwendet wird. Python kann einen Typ mit derselben Struktur verwenden: (Sekunden, Nanosekunden). Der Einfachheit halber werden arithmetische Operationen auf timespec unterstützt.

Beispiel für einen unvollständigen timespec-Typ, der Addition, Subtraktion und Konvertierung in Float unterstützt

class timespec(tuple):
    def __new__(cls, sec, nsec):
        if not isinstance(sec, int):
            raise TypeError
        if not isinstance(nsec, int):
            raise TypeError
        asec, nsec = divmod(nsec, 10 ** 9)
        sec += asec
        obj = tuple.__new__(cls, (sec, nsec))
        obj.sec = sec
        obj.nsec = nsec
        return obj

    def __float__(self):
        return self.sec + self.nsec * 1e-9

    def total_nanoseconds(self):
        return self.sec * 10 ** 9 + self.nsec

    def __add__(self, other):
        if not isinstance(other, timespec):
            raise TypeError
        ns_sum = self.total_nanoseconds() + other.total_nanoseconds()
        return timespec(*divmod(ns_sum, 10 ** 9))

    def __sub__(self, other):
        if not isinstance(other, timespec):
            raise TypeError
        ns_diff = self.total_nanoseconds() - other.total_nanoseconds()
        return timespec(*divmod(ns_diff, 10 ** 9))

    def __str__(self):
        if self.sec < 0 and self.nsec:
            sec = abs(1 + self.sec)
            nsec = 10**9 - self.nsec
            return '-%i.%09u' % (sec, nsec)
        else:
            return '%i.%09u' % (self.sec, self.nsec)

    def __repr__(self):
        return '<timespec(%s, %s)>' % (self.sec, self.nsec)

Der timespec-Typ ähnelt dem Format (E) von Tupeln ganzer Zahlen, mit dem Unterschied, dass er Arithmetik und Konvertierung in Float unterstützt.

Der timespec-Typ wurde abgelehnt, da er nur Nanosekundenauflösung unterstützt und jede arithmetische Operation implementiert werden muss, während der Decimal-Typ bereits implementiert und gut getestet ist.

Fügen Sie ein String-Argument hinzu, um den Rückgabetyp anzugeben

Fügen Sie ein String-Argument zu Funktionen hinzu, die Zeitstempel zurückgeben, z. B.: time.time(format=”datetime”). Ein String ist erweiterbarer als ein Typ: Es ist möglich, ein Format anzufordern, das keinen Typ hat, wie z. B. ein Tupel aus ganzen Zahlen.

Diese API wurde abgelehnt, da sie implizit Module importieren musste, um Objekte zu instanziieren (z. B. import datetime, um datetime.datetime zu erstellen). Der Import eines Moduls kann eine Ausnahme auslösen und langsam sein, ein solches Verhalten ist unerwartet und überraschend.

Fügen Sie ein globales Flag hinzu, um den Zeitstempeltyp zu ändern

Ein globales Flag wie os.stat_decimal_times(), ähnlich wie os.stat_float_times(), kann hinzugefügt werden, um den Zeitstempeltyp global festzulegen.

Ein globales Flag kann Probleme mit Bibliotheken und Anwendungen verursachen, die Decimal anstelle von Float erwarten. Decimal ist nicht vollständig kompatibel mit Float. float+Decimal löst beispielsweise einen TypeError aus. Der Fall os.stat_float_times() ist anders, da ein int in Float konvertiert werden kann und int+float float ergibt.

Fügen Sie ein Protokoll zum Erstellen eines Zeitstempels hinzu

Anstatt zu hart codieren, wie Zeitstempel erstellt werden, kann ein neues Protokoll zum Erstellen eines Zeitstempels aus einem Bruch hinzugefügt werden.

Beispielsweise würde time.time(timestamp=type) die Klassenmethode type.__fromfraction__(numerator, denominator) aufrufen, um ein Zeitstempelobjekt vom angegebenen Typ zu erstellen. Wenn der Typ das Protokoll nicht unterstützt, wird ein Fallback verwendet: type(numerator) / type(denominator).

Eine Variante ist die Verwendung eines „Konverter“-Callbacks zum Erstellen eines Zeitstempels. Beispiel für die Erstellung eines Float-Zeitstempels

def timestamp_to_float(numerator, denominator):
    return float(numerator) / float(denominator)

Gemeinsame Konverter können von den Modulen time, datetime und anderen bereitgestellt werden, oder vielleicht ein spezielles „hires“-Modul. Benutzer können ihre eigenen Konverter definieren.

Ein solches Protokoll hat eine Einschränkung: Die Zeitstempelstruktur muss einmal festgelegt werden und kann später nicht mehr geändert werden. Beispielsweise würde das Hinzufügen einer Zeitzone oder des absoluten Startpunkts des Zeitstempels die API brechen.

Der Protokollvorschlag wurde als übertrieben für die Anforderungen angesehen, aber die vorgeschlagene spezifische Syntax (time.time(timestamp=type)) erlaubt es, dies später einzuführen, wenn zwingende Anwendungsfälle entdeckt werden.

Fügen Sie neue Felder zu os.stat hinzu

Um die Erstellungs-, Änderungs- und Zugriffszeit einer Datei mit Nanosekundenauflösung zu erhalten, können drei Felder zur os.stat()-Struktur hinzugefügt werden.

Die neuen Felder können Zeitstempel mit Nanosekundenauflösung sein (z. B. Decimal) oder der Nanosekundenteil jedes Zeitstempels (int).

Wenn die neuen Felder Zeitstempel mit Nanosekundenauflösung sind, wäre das Befüllen der zusätzlichen Felder zeitaufwändig. Jeder Aufruf von os.stat() wäre langsamer, auch wenn os.stat() nur aufgerufen wird, um zu prüfen, ob eine Datei existiert. Ein Parameter kann zu os.stat() hinzugefügt werden, um diese Felder optional zu machen, die Struktur hätte eine variable Anzahl von Feldern.

Wenn die neuen Felder nur den Bruchteil (Nanosekunden) enthalten, wäre os.stat() effizient. Diese Felder wären immer vorhanden und somit auf Null gesetzt, wenn das Betriebssystem keine Untersekundenauflösung unterstützt. Das Aufteilen eines Zeitstempels in zwei Teile, Sekunden und Nanosekunden, ähnelt dem timespec-Typ und dem Tupel aus ganzen Zahlen und hat somit dieselben Nachteile.

Das Hinzufügen neuer Felder zur os.stat()-Struktur löst das Nanosekundenproblem in anderen Modulen (z. B. im time-Modul) nicht.

Fügen Sie ein boolesches Argument hinzu

Da wir nur einen neuen Typ (Decimal) benötigen, kann ein einfaches boolesches Flag hinzugefügt werden. Beispiel: time.time(decimal=True) oder time.time(hires=True).

Ein solches Flag würde einen versteckten Import erfordern, was als schlechte Praxis gilt.

Die boolesche Argument-API wurde abgelehnt, da sie nicht „pythonisch“ ist. Die Änderung des Rückgabetyps mit einem Parameterwert wird einem booleschen Parameter (einem Flag) vorgezogen.

Fügen Sie neue Funktionen hinzu

Fügen Sie neue Funktionen für jeden Typ hinzu, Beispiele

• time.clock_decimal()
• time.time_decimal()
• os.stat_decimal()
• os.stat_timespec()
• usw.

Das Hinzufügen einer neuen Funktion für jede Funktion, die Zeitstempel erstellt, dupliziert viel Code und wäre eine Wartungsqual.

Fügen Sie ein neues Modul namens hires hinzu

Fügen Sie ein neues Modul namens „hires“ mit derselben API wie das time-Modul hinzu, mit dem Unterschied, dass es Zeitstempel mit hoher Auflösung zurückgibt, z. B. decimal.Decimal. Das Hinzufügen eines neuen Moduls vermeidet die Verknüpfung von Low-Level-Modulen wie time oder os mit dem decimal-Modul.

Diese Idee wurde abgelehnt, da sie die meisten Codes des time-Moduls duplizieren müsste, eine Wartungsqual wäre und Zeitstempel in anderen Modulen als time verwendet werden. Beispiele: signal.sigtimedwait(), select.select(), resource.getrusage(), os.stat() usw. Das Duplizieren des Codes jedes Moduls ist nicht akzeptabel.