টাইমডেল্টাকে স্ট্রিংয়ে ফর্ম্যাট করুন

275

কোনও datetime.timedeltaবস্তুর ফর্ম্যাট করতে আমার সমস্যা হচ্ছে ।

আমি যা করার চেষ্টা করছি তা এখানে: আমার কাছে অবজেক্টগুলির একটি তালিকা রয়েছে এবং অবজেক্টের শ্রেণির সদস্যদের মধ্যে একটি টাইমডেল্টা অবজেক্ট যা কোনও ইভেন্টের সময়কাল দেখায়। আমি এই সময়কালটি ঘন্টা: মিনিটের বিন্যাসে প্রদর্শন করতে চাই।

এটি করার জন্য আমি বিভিন্ন পদ্ধতির চেষ্টা করেছি এবং আমার অসুবিধা হচ্ছে। আমার বর্তমান পদ্ধতিটি আমার অবজেক্টগুলির জন্য ক্লাসে এমন পদ্ধতি যুক্ত করা যা ঘন্টা এবং মিনিট ফিরে আসে। টাইমডেল্টা.সেকেন্ডগুলি ৩00০০ দিয়ে ভাগ করে এবং গোল করে আমি ঘন্টাগুলি পেতে পারি। বাকি সেকেন্ড পেয়ে এবং এটি কয়েক মিনিটে রূপান্তর করতে আমার সমস্যা হচ্ছে।

উপায় দ্বারা, আমি উপস্থাপনার জন্য জ্যাঙ্গো টেম্পলেটগুলির সাথে গুগল অ্যাপইঙ্গাইন ব্যবহার করছি।

python  string  datetime  format  timedelta 
— mawcs
সূত্র
44
টাইমডেল্টা স্ট্রফটাইম () পদ্ধতির সমতুল্য হলে ভাল হবে।
— জেএস।
@JS। ভাল, আপনি কিছু ব্যবহার করতে পারেন যদি datetime.utcfromtimestamp()। দেখুন আমার উত্তর নিচে।
— sjngm
@JS। - 100% সম্মত। এর পরে, __str__এর timedeltaবেশ শালীন, কারণ বিরোধিতা __repr__(যে - মানুষের জন্য)। উদাহরণস্বরূপ: datetime.timedelta(minutes=6, seconds=41) * 2618 / 48দেয় datetime.timedelta(seconds=21871, microseconds=208333), তবে যা পড়তে মোটামুটি ঠিক str(datetime.timedelta(minutes=6, seconds=41) * 2618 / 48)gives '6:04:31.208333'
— টমাসজ গ্যান্ডার

উত্তর:

213

আপনি কেবল টাইমডেল্টাকে str () দিয়ে স্ট্রিংয়ে রূপান্তর করতে পারেন convert এখানে একটি উদাহরণ:

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
— Parand
সূত্র
13
আরও অনেককে টিআর () পদ্ধতিটি টাইমডেল্টার সাথে যুক্তি হিসাবে কল করা।
— জোফোরকার
12
আপনার সেখানে আরআরটি কল দরকার নেই, এটি স্বয়ংক্রিয়ভাবে মুদ্রণ দ্বারা সম্পন্ন হবে।
— জিট্রাক্স
5
@ জিত্রাটক্স তবে এটি প্রয়োজনীয় যদি আপনি অন্য একটি স্ট্রিংয়ের সাথে ব-দ্বীপটিকে সংযুক্ত করতে যাচ্ছেন। উদাহরণস্বরূপprint 'some thing ' + str(delta)
— প্লিনিও.সান্টোস
12
এবং প্রয়োজনীয় যখন ডেটা টাইপটিকে 'ডেটটাইম.টিমেডেলটা' হিসাবে সংজ্ঞায়িত করা হয় এবং আপনি এটির মতো ব্যবহার করছেন ConvertDuration=datetime.timedelta(milliseconds=int(254459))তখন আপনি কেবল মাইক্রোসেকেন্ডকে খেলতে ছাড়তে বিভক্ত ব্যবহার করবেন use থেকে 03:: 0 43.765000 আমি পেতে পারেন 0:03:43 কেবল চলমান দ্বারাTotalDuration=str(ConvertDuration).split('.', 2)[0]
— DarkXDroid
16
এটি ডেল্টাকে একটি স্ট্রিং হিসাবে মুদ্রণ করতে পারে, তবে ওপি অনুরোধ হিসাবে এটি বিন্যাস করে না।
— ড্যানিড
187

যেমনটি আপনি জানেন, আপনি .secondsগুণমান অ্যাক্সেস করে একটি টাইমডেল্টা অবজেক্ট থেকে মোট_ সেকেন্ডগুলি পেতে পারেন ।

পাইথন অন্তর্নির্মিত ফাংশন সরবরাহ করে divmod()যা এর জন্য অনুমতি দেয়:

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

অথবা আপনি মডুলো এবং বিয়োগফলের সংমিশ্রণ ব্যবহার করে ঘন্টা এবং বাকিগুলিতে রূপান্তর করতে পারেন:

# 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
— জন ফুহী
সূত্র
5
নেতিবাচক টাইমডেল্টাসের জন্য আপনাকে প্রথমে সাইনটি মূল্যায়ন করতে হবে এবং তারপরে এটি করা উচিত abs(s)।
— এমবারখাউ
27
মনে রাখবেন আপনি '%d:%02d:%02d'আউটপুট স্ট্রিংয়ে নেতৃত্বের শূন্যগুলি ব্যবহার করতে চাইবেন ।
— শিননোইয়ার
12
অজগর ২.7 এবং বৃহত্তর ব্যবহারের জন্য। মোট_সেকেন্ডগুলি () পদ্ধতি
— sk8asd123
27
.secondsপার্থক্যটি 24 ঘণ্টার চেয়ে বেশি নেতিবাচক বা লম্বা হতে পারে তা ব্যবহার করবেন না ( .secondsবৈশিষ্ট্য উপেক্ষা করে .days)। .total_seconds()পরিবর্তে ব্যবহার করুন বা এর এনালগ।
— jfs
ইতিবাচক পার্থক্যের জন্য আমি সময়ে সময়ে এটি পুনরায় প্রয়োগ করছি। এই সময় সন্ধান করার জন্য ধন্যবাদ :)
— ওল্ফ
59 
>>> 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

ফাংশনে timedeltaঅবজেক্টটি পাস করা str()একই ধরণের ফর্ম্যাটিং কোডটিকে কল করে যদি আমরা কেবল টাইপ করি print td। যেহেতু আপনি সেকেন্ডটি চান না, আমরা স্ট্রিংটি কলোন দ্বারা বিভক্ত করতে পারি (3 অংশ) এবং কেবল প্রথম 2 অংশের সাহায্যে এটি আবার একসাথে রাখতে পারি।

— joeforker
সূত্র
আপনার উত্তর জোফকারের জন্য ধন্যবাদ, তবে আমি নিশ্চিত না যে আমি আপনার প্রতিক্রিয়াটি বুঝতে পেরেছি। ডেটটাইম - ডেটটাইমের মাধ্যমে আমি একটি সময় ব-দ্বীপ পাচ্ছি। আমি ঘন্টা জানি না। এছাড়াও, দেখে মনে হচ্ছে আপনার উদাহরণে কয়েক সেকেন্ড রয়েছে, আমি কীভাবে এটি সরিয়ে ফেলব?
— mawcs
1
আপনি টাইমডেল্টা অবজেক্টটি কোথায় পাবেন তা বিবেচ্য নয়, এটি একই ফর্ম্যাট করবে।
— জোফোরকার
9
যদি এটি কোনও দিনের চেয়ে বেশি হয় তবে এটি বিভক্ত / প্রক্রিয়াকরণে যোগদানের পরে "4 দিন, 8:00" হিসাবে ফর্ম্যাট হবে।
— জোফোরকার
4
str(my_timedelta)নেতিবাচক সংখ্যার জন্য খারাপভাবে কাজ করে
— ক্যাটসকুল
2
দিনগুলি> 24 ঘন্টা, যেমন '4 দিন, 18: 48: 22.330000' প্রদর্শন করে when এখানে পরামর্শ দেওয়া অনেকগুলি পদ্ধতি নেই।
— আলেক্সি মার্টিয়ানভ
47 
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)
— অ্যাডাম জ্যাকব মুলার
সূত্র
3
সত্যিই চমৎকার, আমি পরিবর্তন সুপারিশ করবে if seconds > period_seconds:করার if seconds >= period_seconds:কিন্তু।
— সিবেেনি
1
এটি নেতিবাচক টাইমডেল্টাসের জন্য খালি স্ট্রিংগুলি ফেরত দেয়, নিশ্চিত না যে এটি উদ্দেশ্যযুক্ত কিনা?
— ডির্ক
31

আমি ব্যক্তিগতভাবে humanizeএটির জন্য লাইব্রেরিটি ব্যবহার করি :

>>> 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'

অবশ্যই, এটি আপনি যে উত্তরটি সন্ধান করেছিলেন ঠিক তা দেয় না (যা সত্যই str(timeA - timeB), তবে আমি খুঁজে পেয়েছি যে একবার আপনি কয়েক ঘন্টা ছাড়িয়ে গেলে প্রদর্শনটি দ্রুত অপঠনযোগ্য হয়ে যায় humanizemuch আরও বড় মানের মানগুলির জন্য সমর্থন আছে) মানব-পঠনযোগ্য, এবং এটিও স্থানীয়ভাবে কার্যকর।

এটি জ্যাঙ্গোর contrib.humanizeমডিউল দ্বারা অনুপ্রাণিত হয়েছে , স্পষ্টতই, সুতরাং যেহেতু আপনি জ্যাঙ্গো ব্যবহার করছেন, আপনার সম্ভবত এটি ব্যবহার করা উচিত।

— anarcat
সূত্র
2
চমৎকার, +1 যদিও: হিউম্যানাইজ.নাটুরাল্ডেল্টা (পিডি। টিমেডেল্টা ('- 10 সেক')) -> '10 সেকেন্ড ': এস ...
— এনটিজি
2
ভাল এটা হল একটি 10 সেকেন্ড ব-দ্বীপ । :) এটি আপনি সময় চান , naturaltimeআপনি কি ব্যবহার করতে চান।
— অ্যারাক্যাট
28

তার ইতিমধ্যে একটি টাইমডেল্টা অবজেক্ট রয়েছে তাই কেন এটি তার অন্তর্নির্মিত পদ্ধতিটি টোটাল সেকেন্ড () এটিকে সেকেন্ডে রূপান্তর করতে ব্যবহার করবেন না, তারপরে ঘন্টা এবং মিনিট পাওয়ার জন্য ডিভোড () ব্যবহার করবেন না? 

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)

সময় বদ্বীপে এমনকি কয়েক দিন বা বছর থাকলেও এটি নির্বিশেষে কাজ করে।

— বিল কিড
সূত্র
23

কোনও timedeltaঅবজেক্ট বা নিয়মিত সংখ্যাকে (সেকেন্ড বা মিনিটের আকারে ইত্যাদি) একটি সুন্দর বিন্যাসিত স্ট্রিংয়ে রূপান্তর করার জন্য এখানে একটি সাধারণ উদ্দেশ্য ফাংশন । আমি সদৃশ প্রশ্নের উপর এমপাউনেসেটের দুর্দান্ত উত্তর নিয়েছি , এটিকে কিছুটা নমনীয়, উন্নত পাঠযোগ্যতা এবং ডকুমেন্টেশন যুক্ত করেছি।

আপনি এটি দেখতে পারবেন যেহেতু এটি এখন পর্যন্ত এখানে সবচেয়ে নমনীয় উত্তর find

  1. স্ট্রিং ফর্ম্যাটটি হার্ড-কোডেড হওয়ার পরিবর্তে ফ্লাইতে কাস্টমাইজ করুন।
  2. কোনও সমস্যা ছাড়াই নির্দিষ্ট সময়ের ব্যবধান ছেড়ে দিন (নীচে উদাহরণ দেখুন)।

ফাংশন:

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)

ডেমো:

>>> 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
— MarredCheese
সূত্র
খুব সুন্দর, ক্লিন কোড! আমি অবাক হই যে এই কোডটি কীভাবে
— বিন্যাসে
17

আমি জানি যে এটি একটি পুরানো উত্তরযুক্ত প্রশ্ন, তবে আমি এটির datetime.utcfromtimestamp()জন্য ব্যবহার করি । এটি সেকেন্ডের সংখ্যা নেয় এবং এটির datetimeমতো দেয় যা অন্যগুলির মতো ফর্ম্যাট করা যায় datetime।

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

যতক্ষণ আপনি সময়ের অংশগুলির জন্য আইনী সীমাতে থাকেন যতক্ষণ না এটি কাজ করা উচিত, যেমন এটি ঘন্টা = 12 = 35 হিসাবে 1234: 35 ফেরায় না।

— sjngm
সূত্র
2
print timedelta(seconds=end - begin)পরিবর্তে আপনি ব্যবহার করা উচিত ।
— jfs
@ জেফাসেবাস্টিয়ান তারপরে আপনাকে নেতৃস্থানীয় শূন্যগুলি সহ ঘন্টাগুলি ম্যানুয়ালি প্যাড করতে হবে।
— sjngm
আমি প্রশ্নের মধ্যে প্যাডিং সম্পর্কে কিছুই দেখতে পাচ্ছি। .zfill(8)আপনার প্রয়োজন হলে ব্যবহার করুন ।
— jfs
1
একটি .টোটাল_সেকেন্ডস () কলটির প্রয়োজন: >>> ডেটটাইম.টুকফ্রোমটাইমস্ট্যাম্প ((t2-t1) .টোটাল_সেকেন্ডস ())। স্ট্রফটাইম ("% এইচ:% এম:% এস") <<< >>> '00: 00: 05 '
— ক্যাগনি
2
আমি এই সমাধানটিকে অনেক বেশি পছন্দ করি, এটি আপনাকে ফর্ম্যাটিং নিয়ন্ত্রণ করতে দেয়। দ্রষ্টব্য আপনি সরাসরি স্ট্র্যাম্টারটিও এর মতো ব্যবহার করতে পারেন: "{0:% H}: {0:% M}"। ফর্ম্যাট (সময়কাল)
— পায়ের আঙ্গুল
15

প্রশ্নকর্তা টিপিকালটির চেয়ে আরও ভাল ফর্ম্যাট চান:

  >>> 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'

সুতরাং, সত্যিই দুটি ফর্ম্যাট আছে, একটি যেখানে দিন 0 হয় এবং এটি বাদ পড়ে যায় এবং অন্যটি যেখানে "n দিন, h: m: s" লেখা থাকে। তবে, সেকেন্ডে ভগ্নাংশ থাকতে পারে এবং মুদ্রণগুলিতে কোনও অগ্রণী শূন্য নেই, সুতরাং কলামগুলি অগোছালো।

আপনি যদি এটি পছন্দ করেন তবে এখানে আমার রুটিন:

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

এটি আউটপুটটি ডিডি: hh: মিমি: এসএস ফর্ম্যাট হিসাবে প্রদান করে:

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

আমি এর সাথে বছর যুক্ত করার কথা ভেবেছিলাম, তবে এটি পাঠকের জন্য অনুশীলন হিসাবে ছেড়ে দেওয়া হয়েছে, যেহেতু আউটপুটটি 1 বছরেরও বেশি সময় নিরাপদ রয়েছে:

>>> str(datetime.timedelta(seconds=99999999))
'1157 days, 9:46:39'
— কেভিন জে রাইস
সূত্র
15

আমি এখানে ওসামের রেজার পদ্ধতির গুরুত্ব সহকারে বিবেচনা করব:

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

এটি মাইক্রোসেকেন্ড ছাড়াই একটি স্ট্রিং প্রদান করে

আপনি যদি ডেটটাইম.টিমেডেল্টা অবজেক্টটি নতুন করে তৈরি করতে চান তবে কেবল এটি করুন:

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

2 বছর, আমি এই ভাষা ভালবাসি!

— Pyrotherm
সূত্র
5
এটি দিনগুলি
— notেকে
13

আমার datetime.timedeltaজিনিসগুলি একটি দিনের চেয়েও বেশি গেল। সুতরাং এখানে আরও একটি সমস্যা। উপরের সমস্ত আলোচনা এক দিনেরও কম ধরে নিয়েছে। এ timedeltaআসলে দিন, সেকেন্ড এবং মাইক্রোসেকেন্ডগুলির একটি টুপল। উপরোক্ত আলোচনাকে td.secondsজো হিসাবে ব্যবহার করা উচিত , তবে আপনার যদি কিছু দিন থাকে তবে এটি সেকেন্ডের মানতে অন্তর্ভুক্ত থাকে না।

আমি 2 তারিখের সময় এবং মুদ্রণের দিন এবং ঘন্টাগুলির মধ্যে বেশিরভাগ সময় পাচ্ছি।

span = currentdt - previousdt
print '%d,%d\n' % (span.days,span.seconds/3600)
— অ্যালেক্স এল
সূত্র
এটিই ভবিষ্যতের প্রমাণ সমাধান।
— জীবন
11

আমি এটি করার জন্য humanfriendlyপাইথন লাইব্রেরিটি ব্যবহার করেছি , এটি খুব ভালভাবে কাজ করে।

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

'5 minutes and 21 seconds'

Https://pypi.org/project/humanfriendly/ এ উপলব্ধ

— ধীরাজ গুপ্ত
সূত্র
7

উপরের জো উদাহরণ অনুসরণ করে, আমি এইভাবে মডুলাস গাণিতিক অপারেটরটি ব্যবহার করব:

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

দ্রষ্টব্য যে পাইথনের পূর্ণসংখ্যা বিভাগটি ডিফল্টরূপে গোল হয়; আপনি যদি আরও সুস্পষ্ট হতে চান তবে উপযুক্ত হিসাবে ম্যাথ.ফ্লুর () বা ম্যাথ.সিল () ব্যবহার করুন।

— UltraNurd
সূত্র
টাইমডেল্টা ইতিমধ্যে কীভাবে নিজেকে ফর্ম্যাট করতে জানে, যেমন 'মুদ্রণ কিছু_মাখা।'
— জোফোরকার
হ্যাঁ, তবে এটি একটি স্বেচ্ছাসেবী বিন্যাসের স্ট্রিং গ্রহণ করতে পারে না, যা মাইকেল যা জিজ্ঞাসা করেছিল। যদিও এখন আমি এটি সম্পর্কে 3600 বিভাগ মোডকে ঘন্টা-সেকেন্ড অনুমান করি যা লিপ সেকেন্ডে সমস্যা সৃষ্টি করে।
— আল্ট্রা নুরড
হ্যাঁ, তবে তিনি একটি স্বেচ্ছাসেবী বিন্যাসের স্ট্রিং চান না, তিনি প্রায় ঠিক ডিফল্ট আচরণ চান।
— জোফোরকার
2
ভুলে যাবেন না // পাইথনে 3000 কেটে বিভাগের জন্য
— জোফোরকার
3
+1, তবে আপনি // ব্যবহারের উত্তরটি সম্পাদনা করছেন না কেন? আমি এটিকে 1 দিনের ব্যবধানে কাজ করার td.total_seconds()পরিবর্তে ব্যবহার করার পরামর্শ দিই suggest .seconds
— অ্যান্টনি হ্যাচকিন্স
4 
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
— ভেসেলিন পেনেভ
সূত্র
আপনি কি এটি লিখেছেন? আপনি এটি কতটা পরীক্ষা করেছেন?
— টমাস আহলে
আমি এই প্রকল্পটি আমার প্রকল্পে ডেটাহ্যাভন.নেট ব্যবহার করছি । এটি বেশ সূক্ষ্ম কাজ করে। আপনি কোন ত্রুটি দেখতে পেয়েছেন?
— ভেসেলিন পেনেভ
আপনি যদি এমন কোড ভারী উত্তর দিয়ে কিছুটা তথ্য সরবরাহ করতে পারেন তবে সর্বদা দুর্দান্ত :) এটি কীভাবে কাজ করে তার সম্ভাব্য শক্তি এবং দুর্বলতার একটি উদাহরণের মতো।
— থমাস আহলে
1
উহু. অবশ্যই !. আপনার জন্য একটি উদাহরণ যুক্ত করেছে। :-)
— ভেসেলিন পেনেভ
সুপার :) এছাড়াও যে বিজ্ঞপ্তি timedeltaবস্তুর ক্ষেত্র রয়েছে days, secondsএবং microsecondsডকুমেন্টেশন দ্বারা।
— টমাস আহলে
4

কাজের সময় ওভারটাইম গণনার আউটপুট নিয়ে আমার একই সমস্যা ছিল similar মানটি সর্বদা এইচএইচ: এমএম তে প্রদর্শিত হওয়া উচিত, এমনকি যখন এটি এক দিনের চেয়ে বেশি হয় এবং মানটি নেতিবাচক হয়। আমি দেখানো সমাধানগুলির কয়েকটি সংযুক্ত করেছি এবং অন্য কেউ এই সমাধানটিকে দরকারী বলে মনে করছেন। আমি বুঝতে পেরেছি যে টাইমডেল্টা মানটি যদি নেতিবাচক হয় তবে ডিভোড পদ্ধতিতে প্রদর্শিত বেশিরভাগ সমাধান বাক্সের বাইরে চলে না:

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

টাইমডেল্টা থেকে এইচএইচ: এমএম স্ট্রিং:

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'
— nealtz
সূত্র
4 
import datetime
hours = datetime.timedelta(hours=16, minutes=30)
print((datetime.datetime(1,1,1) + hours).strftime('%H:%M'))
— Slex
সূত্র
2
৩.7-এ আমি অ্যাট্রিবিউটআরার পেয়েছি: 'ডেটটাইম.টিমেডেল্টা' অবজেক্টটির কোনও '
— timeআরফটাইম
4

এই সমস্যার জন্য একটি সোজা ফরোয়ার্ড টেম্পলেট ফিল্টার। অন্তর্নির্মিত ফাংশন int () কখনই গোল হয় না। এফ স্ট্রিংস (অর্থাত্ f '') এর জন্য অজগর 3.6 প্রয়োজন।

@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
— প্যাট্রিক
সূত্র
3 
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)

এটি উত্পাদন করবে:

>>> from datetime import timedelta
>>> localize_timedelta(timedelta(days=3660, minutes=500))
'10 years 10 days 8 hours 20 minutes'
— আর্টেম ভাসিলেভ
সূত্র
আমার মতে সর্বাধিক এক, দৈর্ঘ্যের দিক থেকে এবং এটি কী কী কভার করে
— Dici
1

দয়া করে এই ফাংশনটি পরীক্ষা করে দেখুন - এটি টাইমডেল্টা অবজেক্টটিকে স্ট্রিং 'এইচএইচ: এমএম: এসএস' এ রূপান্তর করে

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)
— MobilePro.pl
সূত্র
1

এক রৈখিক. যেহেতু টাইমডেল্টাস ডেটটাইমের স্ট্রফটাইম সরবরাহ করে না, তাই সময়সীমাটি একটি ডেটটাইমে ফিরিয়ে আনুন এবং স্টেফটাইম ব্যবহার করুন।

এটি কেবল ওপি'র অনুরোধ করা ফর্ম্যাটটি অর্জন করতে পারে না: ঘন্টাগুলি, মিনিটগুলি, এখন আপনি ডেটটাইমের স্ট্রাইফটাইমের সম্পূর্ণ ফর্ম্যাটিং শক্তিটি অর্জন করতে পারেন, আপনার প্রয়োজনীয়তা অন্য উপস্থাপনায় পরিবর্তিত হওয়া উচিত। 

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

এই বিরক্তিও সমাধান করে যে টাইমডেল্টাস এইচ এইচ: এমএম: এসএসের পরিবর্তে স্ট্রিংগুলিতে এইচ: এমএম: এসএস হিসাবে ফর্ম্যাট হয় যা আমাকে এই সমস্যার দিকে নিয়ে যায় এবং আমি যে সমাধানটি ভাগ করে নিয়েছি।

— বিল গালে
সূত্র
0

আপনার যদি ইতিমধ্যে একটি টাইমডেল্টা আপত্তি থাকে তবে কেবল সেই আপত্তিটিকে স্ট্রিংয়ে রূপান্তর করুন। স্ট্রিং এবং মুদ্রণের শেষ 3 টি অক্ষর সরান। এটি সেকেন্ডের অংশটি কেটে ফেলবে এবং এর বাকি অংশগুলি ঘন্টা: মিনিট ফর্ম্যাটে মুদ্রণ করবে।

t = str(timedeltaobj) 

print t[:-3]
— সিমা
সূত্র
-3 কাজ করে না, আরও ভাল ব্যবহারprint t.split('.')[0]
— EvgenyKolyakov
0

যদি IPythonআপনার প্যাকেজগুলিতে থাকে (আপনার উচিত), এটির (এখন অবধি, যাইহোক) স্থিতিকালগুলির জন্য একটি দুর্দান্ত ফরম্যাটর রয়েছে (ফ্লোট সেকেন্ডে)। এটি বিভিন্ন জায়গায় ব্যবহৃত হয়, উদাহরণস্বরূপ %%timeসেল যাদু দ্বারা। আমি এটি সংক্ষিপ্ত সময়ের জন্য উত্পাদিত ফর্ম্যাটটি পছন্দ করি:

>>> 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
— পিয়ের ডি
সূত্র
-3 
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)

অনেক দূরে:

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

আয়:

'0:03:47'
— Aviad
সূত্র
-10

সাহায্যের জন্য সবাইকে ধন্যবাদ। আমি আপনার অনেকগুলি ধারণা নিয়েছি এবং সেগুলি একসাথে রেখেছি, আপনি কী ভাবছেন তা আমাকে জানান।

আমি ক্লাসে এর মতো দুটি পদ্ধতি যুক্ত করেছি:

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

আমার জাঙ্গোতে আমি এটি ব্যবহার করেছি (যোগফলটি বস্তুটি এবং এটি অভিধানে রয়েছে):

<td>{{ sum.0 }}</td>    
<td>{{ sum.1.hours|stringformat:"d" }}:{{ sum.1.minutes|stringformat:"#02.0d" }}</td>
— mawcs
সূত্র
এটি কিছুটা দীর্ঘ। আমি প্রস্তাব দেব: ডিএফ এইচএমএম (স্ব): প্রত্যাবর্তন ':'। জয়েন (টিআর (টিডি) .স্প্লিট (':') [: 2]) <td> {.1 Sum.1.hhmm}} </td>
— joeforker
1
— টম
আমাদের সাইট ব্যবহার করে, আপনি স্বীকার করেছেন যে আপনি আমাদের কুকি নীতি এবং গোপনীয়তা নীতিটি পড়েছেন এবং বুঝতে পেরেছেন ।
Licensed under cc by-sa 3.0 with attribution required.