What is a clean, pythonic way to have multiple con

问题:

I can\'t find a definitive answer for this. AFAIK, you can\'t have multiple __init__ functions in a Python class. So how do I solve this problem?

Suppose I have an class called Cheese with the number_of_holes property. How can I have two ways of creating cheese-objects...

1. one that takes a number of holes like this: parmesan = Cheese(num_holes = 15)
2. and one that takes no arguments and just randomizes the number_of_holes property: gouda = Cheese()

I can think of only one way to do this, but that seems kinda clunky:

class Cheese():
    def __init__(self, num_holes = 0):
        if (num_holes == 0):
            # randomize number_of_holes
        else:
            number_of_holes = num_holes

What do you say? Is there another way?

回答1:

Actually None is much better for \"magic\" values:

class Cheese():
    def __init__(self, num_holes = None):
        if num_holes is None:
            ...

Now if you want complete freedom of adding more parameters:

class Cheese():
    def __init__(self, *args, **kwargs):
        #args -- tuple of anonymous arguments
        #kwargs -- dictionary of named arguments
        self.num_holes = kwargs.get(\'num_holes\',random_holes())

To better explain the concept of *args and **kwargs (you can actually change these names):

def f(*args, **kwargs):
   print \'args: \', args, \' kwargs: \', kwargs

>>> f(\'a\')
args:  (\'a\',)  kwargs:  {}
>>> f(ar=\'a\')
args:  ()  kwargs:  {\'ar\': \'a\'}
>>> f(1,2,param=3)
args:  (1, 2)  kwargs:  {\'param\': 3}

http://docs.python.org/reference/expressions.html#calls

回答2:

Using num_holes=None as the default is fine if you are going to have just __init__.

If you want multiple, independent \"constructors\", you can provide these as class methods. These are usually called factory methods. In this case you could have the default for num_holes be 0.

class Cheese(object):
    def __init__(self, num_holes=0):
        \"defaults to a solid cheese\"
        self.number_of_holes = num_holes

    @classmethod
    def random(cls):
        return cls(randint(0, 100))

    @classmethod
    def slightly_holey(cls):
        return cls(randint((0,33))

    @classmethod
    def very_holey(cls):
        return cls(randint(66, 100))

Now create object like this:

gouda = Cheese()
emmentaler = Cheese.random()
leerdammer = Cheese.slightly_holey()

回答3:

All of these answers are excellent if you want to use optional parameters, but another Pythonic possibility is to use a classmethod to generate a factory-style pseudo-constructor:

def __init__(self, num_holes):

  # do stuff with the number

@classmethod
def fromRandom(cls):

  return cls( # some-random-number )

回答4:

Why do you think your solution is \"clunky\"? Personally I would prefer one constructor with default values over multiple overloaded constructors in situations like yours (Python does not support method overloading anyway):

def __init__(self, num_holes=None):
    if num_holes is None:
        # Construct a gouda
    else:
        # custom cheese
    # common initialization

For really complex cases with lots of different constructors, it might be cleaner to use different factory functions instead:

@classmethod
def create_gouda(cls):
    c = Cheese()
    # ...
    return c

@classmethod
def create_cheddar(cls):
    # ...

In your cheese example you might want to use a Gouda subclass of Cheese though...

回答5:

Those are good ideas for your implementation, but if you are presenting a cheese making interface to a user. They don\'t care how many holes the cheese has or what internals go into making cheese. The user of your code just wants \"gouda\" or \"parmesean\" right?

So why not do this:

# cheese_user.py
from cheeses import make_gouda, make_parmesean

gouda = make_gouda()
paremesean = make_parmesean()

And then you can use any of the methods above to actually implement the functions:

# cheeses.py
class Cheese(object):
    def __init__(self, *args, **kwargs):
        #args -- tuple of anonymous arguments
        #kwargs -- dictionary of named arguments
        self.num_holes = kwargs.get(\'num_holes\',random_holes())

def make_gouda():
    return Cheese()

def make_paremesean():
    return Cheese(num_holes=15)

This is a good encapsulation technique, and I think it is more Pythonic. To me this way of doing things fits more in line more with duck typing. You are simply asking for a gouda object and you don\'t really care what class it is.

回答6:

One should definitely prefer the solutions already posted, but since no one mentioned this solution yet, I think it is worth mentioning for completeness.

The @classmethod approach can be modified to provide an alternative constructor which does not invoke the default constructor (__init__). Instead, an instance is created using __new__.

This could be used if the type of initialization cannot be selected based on the type of the constructor argument, and the constructors do not share code.

Example:

class MyClass(set):

    def __init__(self, filename):
        self._value = load_from_file(filename)

    @classmethod
    def from_somewhere(cls, somename):
        obj = cls.__new__(cls)  # Does not call __init__
        obj._value = load_from_somewhere(somename)
        return obj

回答7:

The best answer is the one above about default arguments, but I had fun writing this, and it certainly does fit the bill for \"multiple constructors\". Use at your own risk.

What about the new method.

\"Typical implementations create a new instance of the class by invoking the superclass’s new() method using super(currentclass, cls).new(cls[, ...]) with appropriate arguments and then modifying the newly-created instance as necessary before returning it.\"

So you can have the new method modify your class definition by attaching the appropriate constructor method.

class Cheese(object):
    def __new__(cls, *args, **kwargs):

        obj = super(Cheese, cls).__new__(cls)
        num_holes = kwargs.get(\'num_holes\', random_holes())

        if num_holes == 0:
            cls.__init__ = cls.foomethod
        else:
            cls.__init__ = cls.barmethod

        return obj

    def foomethod(self, *args, **kwargs):
        print \"foomethod called as __init__ for Cheese\"

    def barmethod(self, *args, **kwargs):
        print \"barmethod called as __init__ for Cheese\"

if __name__ == \"__main__\":
    parm = Cheese(num_holes=5)

回答8:

Use num_holes=None as a default, instead. Then check for whether num_holes is None, and if so, randomize. That\'s what I generally see, anyway.

More radically different construction methods may warrant a classmethod that returns an instance of cls.

回答9:

I\'d use inheritance. Especially if there are going to be more differences than number of holes. Especially if Gouda will need to have different set of members then Parmesan.

class Gouda(Cheese):
    def __init__(self):
        super(Gouda).__init__(num_holes=10)


class Parmesan(Cheese):
    def __init__(self):
        super(Parmesan).__init__(num_holes=15) 

回答10:

This is how I solved it for a YearQuarter class I had to create. I created an __init__ with a single parameter called value. The code for the __init__ just decides what type the value parameter is and process the data accordingly. In case you want multiple input parameters you just pack them into a single tuple and test for value being a tuple.

You use it like this:

>>> temp = YearQuarter(datetime.date(2017, 1, 18))
>>> print temp
2017-Q1
>>> temp = YearQuarter((2017, 1))
>>> print temp
2017-Q1

And this is how the __init__ and the rest of the class looks like:

import datetime


class YearQuarter:

    def __init__(self, value):
        if type(value) is datetime.date:
            self._year = value.year
            self._quarter = (value.month + 2) / 3
        elif type(value) is tuple:               
            self._year = int(value[0])
            self._quarter = int(value[1])           

    def __str__(self):
        return \'{0}-Q{1}\'.format(self._year, self._quarter)

You can expand the __init__ with multiple error messages of course. I omitted them for this example.

回答11:

class Cheese:
    def __init__(self, *args, **kwargs):
        \"\"\"A user-friendly initialiser for the general-purpose constructor.
        \"\"\"
        ...

    def _init_parmesan(self, *args, **kwargs):
        \"\"\"A special initialiser for Parmesan cheese.
        \"\"\"
        ...

    def _init_gauda(self, *args, **kwargs):
        \"\"\"A special initialiser for Gauda cheese.
        \"\"\"
        ...

    @classmethod
    def make_parmesan(cls, *args, **kwargs):
        new = cls.__new__(cls)
        new._init_parmesan(*args, **kwargs)
        return new

    @classmethod
    def make_gauda(cls, *args, **kwargs):
        new = cls.__new__(cls)
        new._init_gauda(*args, **kwargs)
        return new