Accept a single string instead of normal parameters

Question

Hello everyone I have a class that works with time, for example you enter two times and you can sum them (for now it doesn't matter that it goes beyond 23:59:59) or multiply them etc. The default input are zeros. There is also a function that returns current time. I can call time = Time() which returns 0:00:00, time = Time(12) returns 12:00:00.

The problem that I have is, I want to call time = Time('now') and it should store there current time using function now(), edits should be done in __init__() (if you don't like now() you can change it). But if i put time_now = '' as first parameter it doesn't work, same when i put it as a last, because when I write time = Time('now') it takes string 'now' and wants to put it to hours.

I know there are time modules which can do this, but this is for learning purposes.

My code:

import random, time

class Time:

    def __init__(self, hours=0, minutes=0, seconds=0, time_now=''):
#       if time_now == 'now':
#           now()
        time = abs(3600*hours + 60*minutes + seconds)
        self.hour = time//3600
        self.min = time//60%60
        self.sec = time%60

    def __repr__(self):
        return '{}:{:02}:{:02}'.format(self.hour,self.min,self.sec)

    def __add__(self, other):
        if isinstance(other, Time):
            return Time(self.hour+other.hour, self.min+other.min, self.sec+other.sec)
        if isinstance(other, int):
            return Time(self.hour, self.min, self.sec+other)

    __radd__ = __add__

    def __sub__(self, other):
        return Time(seconds = self.__int__() - other.__int__())

    def __mul__(self, other):
        return Time(self.hour*other.hour, self.min*other.min, self.sec*other.sec)

    def __int__(self):
        return 3600*self.hour + 60*self.min + self.sec

    def __eq__(self, other):
        return self.__int__() == other.__int__()

    def __lt__(self, other):
        return self.__int__() < other.__int__()

    #writing out hour/min/sec what we want
    def __getitem__(self, key):
        if key == 0:
            return self.hour
        if key == 1:
            return self.min
        if key == 2:
            return self.sec



#time now

def now():
    a=(time.localtime()[3:6])
    return Time(a[0],a[1],a[2])

Answer 1

You can use a call with named parameters: Time(time_now='now'), but that looks too reiterative.
If I was using named parameters, I'd instead change it to a boolean and use something like Time(now=True), which looks a bit cleaner.

But I think a better alternative is to make your "now" objects be constructed from your now() function, which I'd move to a static method:

class Time(object):
    #...
    @classmethod
    def now(cls):
        a=(time.localtime()[3:6])
        return cls(a[0],a[1],a[2])

So you'd construct your now objects like x = Time.now() instead of x = Time('now')

Answer 2

Python doesn't have method overloading, so your only option is to "play" with the arguments:

You can do something that IMHO is very bad (downgraded very bad to meeeeh... so, so after reading @ivan-pozdeev's comments in this answer)

class Time:
    def __init__(self, hours=0, minutes=0, seconds=0, time_now=''):
        if hours == 'now':
            tmp_t = now()
            self.hour = tmp_t.hour
            self.min = tmp_t.min
            self.sec = tmp_t.sec
        else:
            t = abs(3600*hours + 60*minutes + seconds)
            self.hour = t//3600
            self.min = t//60%60
            self.sec = t%60

That... well, that works:

>>> a = Time('now')
>>> print vars(a)
{'sec': 20, 'hour': 15, 'min': 18}
>>>
>>> a = Time(hours=19, minutes=4, seconds=5)
>>> print vars(a)
{'sec': 5, 'hour': 19, 'min': 4}

But that leaves the code in a very weird state. Is very difficult to read. I certainly would try to come with a different approach altogether...

I also changed the time variable within the __init__ to t because that conflicted with the time name from import time

Answer 3

For flexible argument handling beyond what's available with static arguments, you may use *args and/or **kwargs:

def __init__(self, *args, **kwargs):
    a_seq=('hours','minutes','seconds')
    if len(args)>0 and args[0]=='now':
         now_=now()
         self.__dict__.update(a,getattr(now_,a) for a in a_seq)
    else:
        t=0
        for i,a in enumerate(a_seq):
            try: v=args[i]
            except IndexError: v=kwargs.get(a,0)
            else: if a in kwargs: raise TypeError("multiple values given for argument `%s'"%a) 
            t+=v
            t*=60
        for a in a_seq[-1:0:-1]:
            setattr(self,a,t%60)
            t//=60
        setattr(self,a_seq[0],t)

(I renamed the fields to the same names as arguments to make it easier to use reflection. Reflection is used here to eliminate code duplication (without it, it'd be about 1.5 times longer).)

In this particular case, though, BorrajaX's solution is much simpler because the deviation from a normal static argument list here is only minor (in fact, the try-except-else in the 2nd half of my code do nothing but emulate it).

Answer 4

Almost never try to implement your own time module. It's time consuming and defective. Use time or datetime. All your needs are already implemented somehow.