Analyse pratique des chaînes de temps en python

J'ai trouvé le code sur GitHub:

from decimal import Decimal
from datetime import timedelta


def duration(duration_string): #example: '5d3h2m1s'
    duration_string = duration_string.lower()
    total_seconds = Decimal('0')
    prev_num = []
    for character in duration_string:
        if character.isalpha():
            if prev_num:
                num = Decimal(''.join(prev_num))
                if character == 'd':
                    total_seconds += num * 60 * 60 * 24
                elif character == 'h':
                    total_seconds += num * 60 * 60
                elif character == 'm':
                    total_seconds += num * 60
                elif character == 's':
                    total_seconds += num
                prev_num = []
        elif character.isnumeric() or character == '.':
            prev_num.append(character)
    return timedelta(seconds=float(total_seconds))

Très bon exemple de

Vous pouvez utiliser une expression régulière pour extraire les parties d'unité nombre / temps, puis rechercher un multiplicateur dans un dictionnaire. De cette façon, il est un peu plus court et probablement beaucoup plus lisible que votre analyse manuelle et if / elif chain.

def duration(string):
    mult = {"s": 1, "m": 60, "h": 60*60, "d": 60*60*24}
    parts = re.findall(r"(\d+(?:\.\d)?)([smhd])", string)
    total_seconds = sum(float(x) * mult[m] for x, m in parts)
    return timedelta(seconds=total_seconds)

print(duration("2d 4h 13m 5.2s"))
# 2 days, 4:03:05.200000

En tant que fonction:

>>> mult = {"s": 1, "m": 60, "h": 60*60, "d": 60*60*24}
>>> s = "2d 4h 13m 5.2s"
>>> re.findall(r"(\d+(?:\.\d)?)([smhd])", s)
[('2', 'd'), ('4', 'h'), ('3', 'm'), ('5.2', 's')]
>>> sum(float(x) * mult[m] for x, m in _)
187385.2

Cela garantira également que la partie numérique est en fait un nombre valide ( et pas n'importe quelle séquence de chiffres et de points). En outre, cela lèvera une exception si des unités de temps autres que les unités de temps autorisées sont utilisées.

La fonction pourrait être encore optimisée en pré-compilant l'expression régulière avec re.compile en dehors de la fonction. Quand je l'ai testé avec % timeit d'IPython, le mien s'est avéré un peu plus rapide (2,1µs contre 2,8µs pour le vôtre, à la fois sans la création de timedelta et avec juste float au lieu de Decimal ). De plus, je considérerais cela comme plus lisible en ayant un style beaucoup plus déclaratif et moins impératif , mais c'est certainement une question de goût et de préférences.