Zaman çizelgesini dizeye biçimlendir

Bir datetime.timedeltanesneyi biçimlendirmekte sorun yaşıyorum .

İşte yapmaya çalıştığım şey: Nesnelerin bir listesi var ve nesne sınıfının üyelerinden biri bir olayın süresini gösteren bir timedelta nesnesidir. Bu süreyi saat: dakika biçiminde görüntülemek istiyorum.

Bunu yapmak için çeşitli yöntemler denedim ve zorlanıyorum. Şu anki yaklaşımım, saatler ve dakikalar döndüren nesnelerim için sınıfa yöntemler eklemektir. Ben timedelta.seconds 3600 ile bölerek ve yuvarlayarak saatleri elde edebilirsiniz. Kalan saniyeleri alıp dakikalara çevirmekte zorlanıyorum.

Bu arada, sunum için Django Şablonları ile Google AppEngine kullanıyorum.

Zaman çizelgesini str () ile bir dizeye dönüştürebilirsiniz. İşte bir örnek:

import datetime
start = datetime.datetime(2009,2,10,14,00)
end   = datetime.datetime(2009,2,10,16,00)
delta = end-start
print(str(delta))
# prints 2:00:00

Bildiğiniz gibi, .secondsözniteliğe erişerek bir timedelta nesnesinden total_seconds değerini alabilirsiniz .

Python aşağıdakileri sağlayan yerleşik işlevi divmod()sağlar:

s = 13420
hours, remainder = divmod(s, 3600)
minutes, seconds = divmod(remainder, 60)
print '{:02}:{:02}:{:02}'.format(int(hours), int(minutes), int(seconds))
# result: 03:43:40

veya modulo ve çıkarma kombinasyonunu kullanarak saat ve kalan süreye dönüştürebilirsiniz:

# arbitrary number of seconds
s = 13420
# hours
hours = s // 3600 
# remaining seconds
s = s - (hours * 3600)
# minutes
minutes = s // 60
# remaining seconds
seconds = s - (minutes * 60)
# total time
print '{:02}:{:02}:{:02}'.format(int(hours), int(minutes), int(seconds))
# result: 03:43:40

>>> str(datetime.timedelta(hours=10.56))
10:33:36

>>> td = datetime.timedelta(hours=10.505) # any timedelta object
>>> ':'.join(str(td).split(':')[:2])
10:30

Geçme timedeltanesneyi str()fonksiyonu basitçe yazarsanız kullanılan aynı biçimlendirme kodu çağırır print td. Saniyeler istemediğiniz için, dizeyi iki nokta üst üste (3 parça) ile bölebilir ve yalnızca ilk 2 parça ile tekrar birleştirebiliriz.

def td_format(td_object):
    seconds = int(td_object.total_seconds())
    periods = [
        ('year',        60*60*24*365),
        ('month',       60*60*24*30),
        ('day',         60*60*24),
        ('hour',        60*60),
        ('minute',      60),
        ('second',      1)
    ]

    strings=[]
    for period_name, period_seconds in periods:
        if seconds > period_seconds:
            period_value , seconds = divmod(seconds, period_seconds)
            has_s = 's' if period_value > 1 else ''
            strings.append("%s %s%s" % (period_value, period_name, has_s))

    return ", ".join(strings)

Ben şahsen bunun için humanizekütüphaneyi kullanıyorum :

>>> import datetime
>>> humanize.naturalday(datetime.datetime.now())
'today'
>>> humanize.naturalday(datetime.datetime.now() - datetime.timedelta(days=1))
'yesterday'
>>> humanize.naturalday(datetime.date(2007, 6, 5))
'Jun 05'
>>> humanize.naturaldate(datetime.date(2007, 6, 5))
'Jun 05 2007'
>>> humanize.naturaltime(datetime.datetime.now() - datetime.timedelta(seconds=1))
'a second ago'
>>> humanize.naturaltime(datetime.datetime.now() - datetime.timedelta(seconds=3600))
'an hour ago'

Tabii ki, tam olarak aradığınız cevabı vermiyor (ki, aslında str(timeA - timeB), ama birkaç saatin ötesine geçtiğinizde, ekranın hızla okunamaz hale geldiğini humanizefark ettim. insan tarafından okunabilir ve aynı zamanda iyi lokalizedir.

Görünüşe göre Django contrib.humanizemodülünden ilham alıyor , bu yüzden Django'yu kullandığınız için muhtemelen bunu kullanmalısınız.

Zaten bir timedelta nesnesi var, bu yüzden neden saniyeye dönüştürmek için yerleşik yöntemini total_seconds () kullanmıyorsunuz, sonra saat ve dakika almak için divmod () 'u kullanmıyorsunuz?

hours, remainder = divmod(myTimeDelta.total_seconds(), 3600)
minutes, seconds = divmod(remainder, 60)

# Formatted only for hours and minutes as requested
print '%s:%s' % (hours, minutes)

Bu, zaman deltasında günler veya yıllar olsa bile çalışır.

Burada, bir timedeltanesneyi veya normal bir sayıyı (saniye veya dakika biçiminde) güzel biçimlendirilmiş bir dizeye dönüştürmek için genel amaçlı bir işlev vardır . Çektiğim mpounsett fantastik cevabı biraz daha esnek, gelişmiş okunabilirliği ve katma belgeleri yapılmış, yinelenen bir soru üzerine.

Size şu anda izin verdiğinden, buradaki en esnek cevap olduğunu göreceksiniz:

1. Dize biçimini, sabit kodlanmak yerine anında özelleştirin.
2. Belirli zaman aralıklarını sorunsuz bir şekilde bırakın (aşağıdaki örneklere bakın).

İşlev:

from string import Formatter
from datetime import timedelta

def strfdelta(tdelta, fmt='{D:02}d {H:02}h {M:02}m {S:02}s', inputtype='timedelta'):
    """Convert a datetime.timedelta object or a regular number to a custom-
    formatted string, just like the stftime() method does for datetime.datetime
    objects.

    The fmt argument allows custom formatting to be specified.  Fields can 
    include seconds, minutes, hours, days, and weeks.  Each field is optional.

    Some examples:
        '{D:02}d {H:02}h {M:02}m {S:02}s' --> '05d 08h 04m 02s' (default)
        '{W}w {D}d {H}:{M:02}:{S:02}'     --> '4w 5d 8:04:02'
        '{D:2}d {H:2}:{M:02}:{S:02}'      --> ' 5d  8:04:02'
        '{H}h {S}s'                       --> '72h 800s'

    The inputtype argument allows tdelta to be a regular number instead of the  
    default, which is a datetime.timedelta object.  Valid inputtype strings: 
        's', 'seconds', 
        'm', 'minutes', 
        'h', 'hours', 
        'd', 'days', 
        'w', 'weeks'
    """

    # Convert tdelta to integer seconds.
    if inputtype == 'timedelta':
        remainder = int(tdelta.total_seconds())
    elif inputtype in ['s', 'seconds']:
        remainder = int(tdelta)
    elif inputtype in ['m', 'minutes']:
        remainder = int(tdelta)*60
    elif inputtype in ['h', 'hours']:
        remainder = int(tdelta)*3600
    elif inputtype in ['d', 'days']:
        remainder = int(tdelta)*86400
    elif inputtype in ['w', 'weeks']:
        remainder = int(tdelta)*604800

    f = Formatter()
    desired_fields = [field_tuple[1] for field_tuple in f.parse(fmt)]
    possible_fields = ('W', 'D', 'H', 'M', 'S')
    constants = {'W': 604800, 'D': 86400, 'H': 3600, 'M': 60, 'S': 1}
    values = {}
    for field in possible_fields:
        if field in desired_fields and field in constants:
            values[field], remainder = divmod(remainder, constants[field])
    return f.format(fmt, **values)

Demo:

>>> td = timedelta(days=2, hours=3, minutes=5, seconds=8, microseconds=340)

>>> print strfdelta(td)
02d 03h 05m 08s

>>> print strfdelta(td, '{D}d {H}:{M:02}:{S:02}')
2d 3:05:08

>>> print strfdelta(td, '{D:2}d {H:2}:{M:02}:{S:02}')
 2d  3:05:08

>>> print strfdelta(td, '{H}h {S}s')
51h 308s

>>> print strfdelta(12304, inputtype='s')
00d 03h 25m 04s

>>> print strfdelta(620, '{H}:{M:02}', 'm')
10:20

>>> print strfdelta(49, '{D}d {H}h', 'h')
2d 1h

Bunun eski bir cevap sorusu olduğunu biliyorum, ama bunun için kullanıyorum datetime.utcfromtimestamp(). Saniye sayısını alır ve datetimediğer formatlar gibi biçimlendirilebilen bir döndürür datetime.

duration = datetime.utcfromtimestamp(end - begin)
print duration.strftime('%H:%M')

Zaman bölümleri için yasal aralıklarda kaldığınız sürece, bu çalışmalıdır, yani saat <= 23 olduğu için 1234: 35 döndürmez.

Soru soran, tipik olandan daha güzel bir format istiyor:

  >>> import datetime
  >>> datetime.timedelta(seconds=41000)
  datetime.timedelta(0, 41000)
  >>> str(datetime.timedelta(seconds=41000))
  '11:23:20'
  >>> str(datetime.timedelta(seconds=4102.33))
  '1:08:22.330000'
  >>> str(datetime.timedelta(seconds=413302.33))
  '4 days, 18:48:22.330000'

Yani, aslında iki biçim vardır, biri günler 0 ve dışarıda bırakılırken diğeri "n gün, h: m: s" metninin olduğu. Ancak, saniyelerde kesirler olabilir ve çıktılarda önde gelen sıfır yoktur, bu nedenle sütunlar dağınıktır.

İşte benim rutinim, eğer isterseniz:

def printNiceTimeDelta(stime, etime):
    delay = datetime.timedelta(seconds=(etime - stime))
    if (delay.days > 0):
        out = str(delay).replace(" days, ", ":")
    else:
        out = "0:" + str(delay)
    outAr = out.split(':')
    outAr = ["%02d" % (int(float(x))) for x in outAr]
    out   = ":".join(outAr)
    return out

bu çıktıyı dd: ss: dd: ss biçiminde döndürür:

00:00:00:15
00:00:00:19
02:01:31:40
02:01:32:22

Buna yıl eklemeyi düşündüm, ancak çıktı 1 yıldan fazla olduğu için bu okuyucu için bir egzersiz olarak kaldı:

>>> str(datetime.timedelta(seconds=99999999))
'1157 days, 9:46:39'

Burada Occam'ın Razor yaklaşımını ciddiye alacağım:

td = str(timedelta).split('.')[0]

Bu, mikrosaniye olmadan bir dize döndürür

Datetime.timedelta nesnesini yeniden oluşturmak istiyorsanız, şunu yapın:

h,m,s = re.split(':', td)
new_delta = datetime.timedelta(hours=int(h),minutes=int(m),seconds=int(s))

2 yıl içinde, bu dili seviyorum!

Benim datetime.timedeltanesneleri bir günden daha fazla gitti. İşte bir başka sorun daha var. Yukarıdaki tüm tartışmalar bir günden az sürüyor. A timedeltaaslında birkaç gün, saniye ve mikrosaniyedir. Yukarıdaki tartışma td.secondsjoe'nin yaptığı gibi kullanılmalıdır , ancak günleriniz varsa saniye değerine dahil DEĞİLDİR.

2 tarih ile baskı gün ve saatleri arasında bir süre alıyorum.

span = currentdt - previousdt
print '%d,%d\n' % (span.days,span.seconds/3600)

Bunu humanfriendlyyapmak için python kütüphanesini kullandım, çok iyi çalışıyor.

import humanfriendly
from datetime import timedelta
delta = timedelta(seconds = 321)
humanfriendly.format_timespan(delta)

'5 minutes and 21 seconds'

Boş https://pypi.org/project/humanfriendly/

Joe'nun yukarıdaki örnek değerini takiben, modül aritmetik operatörünü kullanırdım:

td = datetime.timedelta(hours=10.56)
td_str = "%d:%d" % (td.seconds/3600, td.seconds%3600/60)

Python'daki tamsayı bölümünün varsayılan olarak aşağı yuvarladığını unutmayın; daha açık olmak istiyorsanız, uygun şekilde math.floor () veya math.ceil () kullanın.

def seconds_to_time_left_string(total_seconds):
    s = int(total_seconds)
    years = s // 31104000
    if years > 1:
        return '%d years' % years
    s = s - (years * 31104000)
    months = s // 2592000
    if years == 1:
        r = 'one year'
        if months > 0:
            r += ' and %d months' % months
        return r
    if months > 1:
        return '%d months' % months
    s = s - (months * 2592000)
    days = s // 86400
    if months == 1:
        r = 'one month'
        if days > 0:
            r += ' and %d days' % days
        return r
    if days > 1:
        return '%d days' % days
    s = s - (days * 86400)
    hours = s // 3600
    if days == 1:
        r = 'one day'
        if hours > 0:
            r += ' and %d hours' % hours
        return r 
    s = s - (hours * 3600)
    minutes = s // 60
    seconds = s - (minutes * 60)
    if hours >= 6:
        return '%d hours' % hours
    if hours >= 1:
        r = '%d hours' % hours
        if hours == 1:
            r = 'one hour'
        if minutes > 0:
            r += ' and %d minutes' % minutes
        return r
    if minutes == 1:
        r = 'one minute'
        if seconds > 0:
            r += ' and %d seconds' % seconds
        return r
    if minutes == 0:
        return '%d seconds' % seconds
    if seconds == 0:
        return '%d minutes' % minutes
    return '%d minutes and %d seconds' % (minutes, seconds)

for i in range(10):
    print pow(8, i), seconds_to_time_left_string(pow(8, i))


Output:
1 1 seconds
8 8 seconds
64 one minute and 4 seconds
512 8 minutes and 32 seconds
4096 one hour and 8 minutes
32768 9 hours
262144 3 days
2097152 24 days
16777216 6 months
134217728 4 years

İş yerinde fazla mesai hesaplamasının çıktısıyla benzer bir sorun yaşadım. Değer, bir günden büyük olsa ve değer negatif olabilse bile her zaman SS: DD olarak görünmelidir. Gösterilen çözümlerden bazılarını birleştirdim ve belki başka biri bu çözümü faydalı buluyor. Timedelta değeri negatifse, divmod yöntemiyle gösterilen çözümlerin çoğunun kutudan çıkmadığını fark ettim:

def td2HHMMstr(td):
  '''Convert timedelta objects to a HH:MM string with (+/-) sign'''
  if td < datetime.timedelta(seconds=0):
    sign='-'
    td = -td
  else:
    sign = ''
  tdhours, rem = divmod(td.total_seconds(), 3600)
  tdminutes, rem = divmod(rem, 60)
  tdstr = '{}{:}:{:02d}'.format(sign, int(tdhours), int(tdminutes))
  return tdstr

timedelta to HH: MM dizesi:

td2HHMMstr(datetime.timedelta(hours=1, minutes=45))
'1:54'

td2HHMMstr(datetime.timedelta(days=2, hours=3, minutes=2))
'51:02'

td2HHMMstr(datetime.timedelta(hours=-3, minutes=-2))
'-3:02'

td2HHMMstr(datetime.timedelta(days=-35, hours=-3, minutes=-2))
'-843:02'

import datetime
hours = datetime.timedelta(hours=16, minutes=30)
print((datetime.datetime(1,1,1) + hours).strftime('%H:%M'))

Bu sorun için düz bir şablon filtresi. Yerleşik int () işlevi hiçbir zaman yukarı yuvarlanmaz. F-Dizeleri (yani f '') python 3.6 gerektirir.

@app_template_filter()
def diffTime(end, start):
    diff = (end - start).total_seconds()
    d = int(diff / 86400)
    h = int((diff - (d * 86400)) / 3600)
    m = int((diff - (d * 86400 + h * 3600)) / 60)
    s = int((diff - (d * 86400 + h * 3600 + m *60)))
    if d > 0:
        fdiff = f'{d}d {h}h {m}m {s}s'
    elif h > 0:
        fdiff = f'{h}h {m}m {s}s'
    elif m > 0:
        fdiff = f'{m}m {s}s'
    else:
        fdiff = f'{s}s'
    return fdiff

from django.utils.translation import ngettext

def localize_timedelta(delta):
    ret = []
    num_years = int(delta.days / 365)
    if num_years > 0:
        delta -= timedelta(days=num_years * 365)
        ret.append(ngettext('%d year', '%d years', num_years) % num_years)

    if delta.days > 0:
        ret.append(ngettext('%d day', '%d days', delta.days) % delta.days)

    num_hours = int(delta.seconds / 3600)
    if num_hours > 0:
        delta -= timedelta(hours=num_hours)
        ret.append(ngettext('%d hour', '%d hours', num_hours) % num_hours)

    num_minutes = int(delta.seconds / 60)
    if num_minutes > 0:
        ret.append(ngettext('%d minute', '%d minutes', num_minutes) % num_minutes)

    return ' '.join(ret)

Bu aşağıdakileri üretecektir:

>>> from datetime import timedelta
>>> localize_timedelta(timedelta(days=3660, minutes=500))
'10 years 10 days 8 hours 20 minutes'

Lütfen bu işlevi kontrol edin - timedelta nesnesini 'HH: MM: SS' dizesine dönüştürür

def format_timedelta(td):
    hours, remainder = divmod(td.total_seconds(), 3600)
    minutes, seconds = divmod(remainder, 60)
    hours, minutes, seconds = int(hours), int(minutes), int(seconds)
    if hours < 10:
        hours = '0%s' % int(hours)
    if minutes < 10:
        minutes = '0%s' % minutes
    if seconds < 10:
        seconds = '0%s' % seconds
    return '%s:%s:%s' % (hours, minutes, seconds)

Bir astar. Zaman çizelgeleri datetime'ın stftime değerini sunmadığından, zaman çizelgesini bir datetime geri getirin ve stftime kullanın.

Bu sadece OP'nin istenen formatını elde etmekle kalmaz Saat: Dakika, artık gereksinimleriniz başka bir temsile dönüştüğünde, tarih saatinin kullanım süresinin tam biçimlendirme gücünden yararlanabilirsiniz.

import datetime
td = datetime.timedelta(hours=2, minutes=10, seconds=5)
print(td)
print(datetime.datetime.strftime(datetime.datetime.strptime(str(td), "%H:%M:%S"), "%H:%M"))

Output:
2:10:05
02:10

Bu aynı zamanda zaman çizelgelerinin dizelere HH: MM: SS yerine H: MM: SS olarak biçimlendirildiği ve beni bu soruna ve paylaştığım çözüme yönlendirdiği rahatsızlığı da çözüyor.

Zaten bir timedelta obj'niz varsa, o nesneyi dizeye dönüştürün. Dizenin son 3 karakterini kaldırın ve yazdırın. Bu, saniye bölümünü kesecek ve geri kalanını Saat: Dakika biçiminde yazdıracaktır.

t = str(timedeltaobj) 

print t[:-3]

IPythonPaketlerinize sahip olmanız durumunda (yapmanız gerekir), (şimdiye kadar, zaten) süreler için çok güzel bir biçimlendiriciye sahiptir (float saniyeler içinde). Bu çeşitli yerlerde kullanılır, örneğin %%timehücre büyüsü tarafından . Kısa süreler için ürettiği biçimi seviyorum:

>>> from IPython.core.magics.execution import _format_time
>>> 
>>> for v in range(-9, 10, 2):
...     dt = 1.25 * 10**v
...     print(_format_time(dt))

1.25 ns
125 ns
12.5 µs
1.25 ms
125 ms
12.5 s
20min 50s
1d 10h 43min 20s
144d 16h 13min 20s
14467d 14h 13min 20s

t1 = datetime.datetime.strptime(StartTime, "%H:%M:%S %d-%m-%y")

t2 = datetime.datetime.strptime(EndTime, "%H:%M:%S %d-%m-%y")

return str(t2-t1)

İçin böylece:

StartTime = '15:28:53 21-07-13'
EndTime = '15:32:40 21-07-13'

İadeler:

'0:03:47'

Yardımlarınız için herkese teşekkürler. Fikirlerinizin çoğunu alıp bir araya getirdim, ne düşündüğünüzü bana bildirin.

Sınıfa böyle iki yöntem ekledim:

def hours(self):
    retval = ""
    if self.totalTime:
        hoursfloat = self.totalTime.seconds / 3600
        retval = round(hoursfloat)
    return retval

def minutes(self):
    retval = ""
    if self.totalTime:
        minutesfloat = self.totalTime.seconds / 60
        hoursAsMinutes = self.hours() * 60
        retval = round(minutesfloat - hoursAsMinutes)
    return retval

Benim django bu kullandım (sum nesnesidir ve bir sözlüktür):

<td>{{ sum.0 }}</td>    
<td>{{ sum.1.hours|stringformat:"d" }}:{{ sum.1.minutes|stringformat:"#02.0d" }}</td>