Convivial format de l'heure en Python?

Le code a été publié initialement sur un blog "Python Joli fonction de la Date" (http://evaisse.com/post/93417709/python-pretty-date-function)

Il est reproduit ici que le blog compte a été suspendu, et la page n'est plus disponible.

def pretty_date(time=False):
    """
    Get a datetime object or a int() Epoch timestamp and return a
    pretty string like 'an hour ago', 'Yesterday', '3 months ago',
    'just now', etc
    """
    from datetime import datetime
    now = datetime.now()
    if type(time) is int:
        diff = now - datetime.fromtimestamp(time)
    elif isinstance(time,datetime):
        diff = now - time
    elif not time:
        diff = now - now
    second_diff = diff.seconds
    day_diff = diff.days

    if day_diff < 0:
        return ''

    if day_diff == 0:
        if second_diff < 10:
            return "just now"
        if second_diff < 60:
            return str(second_diff) + " seconds ago"
        if second_diff < 120:
            return "a minute ago"
        if second_diff < 3600:
            return str(second_diff / 60) + " minutes ago"
        if second_diff < 7200:
            return "an hour ago"
        if second_diff < 86400:
            return str(second_diff / 3600) + " hours ago"
    if day_diff == 1:
        return "Yesterday"
    if day_diff < 7:
        return str(day_diff) + " days ago"
    if day_diff < 31:
        return str(day_diff / 7) + " weeks ago"
    if day_diff < 365:
        return str(day_diff / 30) + " months ago"
    return str(day_diff / 365) + " years ago"

Dans la recherche de la même chose avec la condition supplémentaire que manipuler des dates futures, j'ai trouvé ceci:
http://pypi.python.org/pypi/py-pretty/1

Exemple de code (de site):

from datetime import datetime, timedelta
now = datetime.now()
hrago = now - timedelta(hours=1)
yesterday = now - timedelta(days=1)
tomorrow = now + timedelta(days=1)
dayafter = now + timedelta(days=2)

import pretty
print pretty.date(now)                      # 'now'
print pretty.date(hrago)                    # 'an hour ago'
print pretty.date(hrago, short=True)        # '1h ago'
print pretty.date(hrago, asdays=True)       # 'today'
print pretty.date(yesterday, short=True)    # 'yest'
print pretty.date(tomorrow)                 # 'tomorrow'

La réponse Sam Smith lien est bon, et je l'ai utilisé pendant un an ou deux, mais je pense qu'il pourrait être amélioré de plusieurs façons:

• C'est agréable d'être en mesure de définir chaque unité de temps, en termes de la précédente unité, au lieu d'avoir la "magie" des constantes comme 3600, 86400, etc. disséminés un peu partout dans le code.
• Après beaucoup d'utilisation, je trouve que je ne veux pas aller à l'unité suivante tout à fait avec tant d'ardeur. Exemple: deux 7 jours et 13 jours affiche "1 semaine", je préfère le voir "7 jours" ou "13 jours" à la place.

Voici ce que je suis venu avec:

def PrettyRelativeTime(time_diff_secs):
    # Each tuple in the sequence gives the name of a unit, and the number of
    # previous units which go into it.
    weeks_per_month = 365.242 / 12 / 7
    intervals = [('minute', 60), ('hour', 60), ('day', 24), ('week', 7),
                 ('month', weeks_per_month), ('year', 12)]

    unit, number = 'second', abs(time_diff_secs)
    for new_unit, ratio in intervals:
        new_number = float(number) / ratio
        # If the new number is too small, don't go to the next unit.
        if new_number < 2:
            break
        unit, number = new_unit, new_number
    shown_num = int(number)
    return '{} {}'.format(shown_num, unit + ('' if shown_num == 1 else 's'))

Remarquez comment chaque n-uplet dans intervals est facile à interpréter et contrôler: un 'minute' est 60 secondes; un 'hour' est 60 minutes; etc. La seule fudge est le réglage de weeks_per_month à sa valeur moyenne, compte tenu de la demande, qui doit être fine. (Et notez que c'est clairement un coup d'œil à ce que la dernière des trois constantes de multiplier à 365.242, le nombre de jours par an).

Un inconvénient à ma fonction, c'est qu'il ne fait rien en dehors de la "## unités" modèle: "Hier", "tout à l'heure", etc. sont à droite. Puis de nouveau, l'affiche originale n'a pas demandé ces termes de fantaisie, donc je préfère ma fonction pour sa concision et à la lisibilité de ses constantes numériques. 🙂

Il est humaniser le paquet:

>>> from datetime import datetime, timedelta
>>> import humanize # $ pip install humanize
>>> humanize.naturaltime(datetime.now() - timedelta(days=1))
'a day ago'
>>> humanize.naturaltime(datetime.now() - timedelta(hours=2))
'2 hours ago'

Il prend en charge la localisation l10n, l'internationalisation i18n:

>>> _ = humanize.i18n.activate('ru_RU')
>>> print humanize.naturaltime(datetime.now() - timedelta(days=1))
день назад
>>> print humanize.naturaltime(datetime.now() - timedelta(hours=2))
2 часа назад

J'ai écrit détaillé sur le blog pour la solution sur http://sunilarora.org/17329071
J'ai écris un rapide extrait ici.

from datetime import datetime
from dateutil.relativedelta import relativedelta

def get_fancy_time(d, display_full_version = False):
    """Returns a user friendly date format
    d: some datetime instace in the past
    display_second_unit: True/False
    """
    #some helpers lambda's
    plural = lambda x: 's' if x > 1 else ''
    singular = lambda x: x[:-1]
    #convert pluran (years) --> to singular (year)
    display_unit = lambda unit, name: '%s %s%s'%(unit, name, plural(unit)) if unit > 0 else ''

    #time units we are interested in descending order of significance
    tm_units = ['years', 'months', 'days', 'hours', 'minutes', 'seconds']

    rdelta = relativedelta(datetime.utcnow(), d) #capture the date difference
    for idx, tm_unit in enumerate(tm_units):
        first_unit_val = getattr(rdelta, tm_unit)
        if first_unit_val > 0:
            primary_unit = display_unit(first_unit_val, singular(tm_unit))
            if display_full_version and idx < len(tm_units)-1:
                next_unit = tm_units[idx + 1]
                second_unit_val = getattr(rdelta, next_unit)
                if second_unit_val > 0:
                    secondary_unit = display_unit(second_unit_val, singular(next_unit))
                    return primary_unit + ', '  + secondary_unit
            return primary_unit
    return None

Vous pouvez le télécharger et l'installer à partir du lien ci-dessous. Il devrait être plus utile pour vous. Il a été la prestation de l'utilisateur message amical à partir de la deuxième année.

C'est bien testé.

https://github.com/nareshchaudhary37/timestamp_content

Étapes ci-dessous pour l'installer dans votre virtuel env.

git clone https://github.com/nareshchaudhary37/timestamp_content
cd timestamp-content
python setup.py