super().__init__(...) 和默认值

Question

Preamble

This is a rather basic question, I realize, but I haven't been able to find a sturdy reference for it, which would likely be a mixture of technical details and best practices for well-behaved classes.

Question

When a parent and child class both define the same initialization parameter, but with default values, what's the best way to get sane behavior when the child class is created?

My assumptions are:

• Classes only accept named parameters , I don't need to deal with positional arguments. That simplifies many things, both theoretically in reasoning about situations and practically in taking arguments from external config files, etc.
• __init__ methods may be more sophisticated than just setting self.foo = foo for their arguments - they may transform it before storing, use it to set other params, etc. and I'd like to be as respectful of that as possible.
• Subclasses never break the interfaces of their parents, both for __init__ parameters and for attributes. Having a different default value is not considered "breaking".
• Classes should never have to be aware of their subclasses, they should just do things in "reasonable ways" and it's up to subclasses to ensure everything still works properly. However, it's sometimes necessary to modify a superclass to be "more reasonable" if it's doing things that aren't amenable to being subclassed - this can form a set of principles that help everyone get along well.

Examples

In general, my idea of a "best practice" template for a derived class looks like this:

class Child(Parent):
    def __init__(self, arg=1, **kwargs):
        self.arg = arg
        super().__init__(**kwargs)

That works well in most situations - deal with our stuff, then delegate all the rest to our superclass.

However, it doesn't work well if arg is shared by both Child and Parent - neither the caller's argument nor the Child default are respected:

class Parent:
    def __init__(self, arg=0):
        self.arg = arg


class Child(Parent):
    def __init__(self, arg=1, **kwargs):
        self.arg = arg
        super().__init__(**kwargs)


print(Child(arg=6).arg)
# Prints `0` - bad

A better approach is probably for Child to acknowledge that the argument is shared:

class Parent:
    def __init__(self, arg=0):
        self.arg = arg


class Child(Parent):
    def __init__(self, arg=1, **kwargs):
        super().__init__(arg=arg, **kwargs)


print(Child(arg=6).arg)
# Prints `6` - good
print(Child().arg)
# Prints `1` - good

That successfully gets the defaults working according to expectations. What I'm not sure of is whether this plays well with the expectations of Parent . So I think my questions are:

• If Parent.__init__ does some Fancy Stuff with arg and/or self.arg , how should Child be set up to respect that?
• In general does this require knowing Too Much about the internals of Parent and how self.arg is used? Or are there reasonable practices that everyone can follow to draw that part of the interface contract in a clean way?
• Are there any specific gotchas to keep in mind?

Answer 1

Parent.__init__ only expects that the caller may choose to omit an argument for the arg parameter. It doesn't matter if any particular caller ( Child.__init__ , in this case) always provides an argument, nor does it matter how the caller produces the value it passes.

Your third example is what I would write, with the addition that Parent.__init__ itself also uses super().__init__ : it doesn't assume that it's the end of whatever MRO is in force for its self argument.

class Parent:
    def __init__(self, arg=0, **kwargs):
        super().__init__(**kwargs)
        self.arg = arg


class Child(Parent):
    def __init__(self, arg=1, **kwargs):
        super().__init__(arg=arg, **kwargs)