Confusing python inheritance

Question

class BaseA(object):
    authors = ['a', 'b']
    author_list = authors

class BaseB(object):
    authors = ['a', 'b']

    def __init__(self, *arg, **kwargs):
        self.author_list = self.authors

class ChildA(BaseA):
    authors = ['c', 'd']

class ChildB(BaseB):
    authors = ['c', 'd']

child_a = ChildA()
child_b = ChildB()
print(child_a.author_list)
print(child_b.author_list)
>>> ['a', 'b']
>>> ['c', 'd']

What's the different of the codes? Why do I get different results?

I'm so confusing why parent author_list attributes don't be override.

Can you tell me the principle of python inheritance?

BrenBarn · Accepted Answer · 2013-01-12 08:09:09Z

Material inside the class block is part of the class itself, and is executed once, when you define the class. Material in __init__ is per-instance, and is executed once per instance, every time you instantiate the class.

In your first example (BaseA), you create a class attribute authors, then create another attribute author_list pointing to the same value. That is it. Nothing else ever happens. The fact that ChildA inherits from BaseA does not cause author_list = authors to be re-executed. author_list was over and done with once BaseA was defined.

In your second example (BaseB), you create a class attribute authors. Then in __init__ you make a new instance attribute pointing at that same value. Since you do this in __init__, it is re-done for each instance. So when you instantiate BaseB, it gets the new attribute.

Note that you are checking the attributes on the instances child_a and child_b. If you check them on the classes (ChildA.author_list and ChildB.author_list), you will see that both have the same value (['a', 'b']). Because your action in ChildB takes place in __init__, it only takes effect when you actually instantiate the class.

coredump · Accepted Answer · 2013-01-12 08:08:23Z

0

The difference is that in the second example, author_list is set when you create an instance of an object.

When you define class BaseA you define the class member author_list and that's that, so when you create an instance of ChildA nothing is happening to author_list. It is just inherited.

When you define BaseB there is no member author_list. That is created as a instance variable when an instance of BaseB is created. So, when you create an instance of ChildB the same thing happens, but since authors is redefined then it will use the new value of authors

answered Jan 12, 2013 at 8:08

coredump

3,1477 gold badges38 silver badges57 bronze badges

3 Comments

chenchiyuan Over a year ago

But in the first example, i override authors, and author_list is equal to authors. Before testing, i think author_list will be override and equal to child authors attributes.

coredump Over a year ago

The author_list = authors gets executed only once as I explained in the post.

chenchiyuan Over a year ago

Thank you! Yes, it only executed once!

mOmOney · Accepted Answer · 2021-01-08 23:11:46Z

In your BaseB __init__ function you are calling the Child's authors, not the Parent's authors. If you wish to call the Parent's authors you would use BaseB.authors instead of self.authors:

class BaseA(object):
    authors = ['a', 'b']
    author_list = authors

class BaseB(object):
    authors = ['a', 'b']

    def __init__(self, *arg, **kwargs):
        self.author_list = BaseB.authors

class ChildA(BaseA):
    authors = ['c', 'd']

class ChildB(BaseB):
    authors = ['c', 'd']

child_a = ChildA()
child_b = ChildB()
print(child_a.author_list)
print(child_b.author_list)
>>> ['a', 'b']
>>> ['a', 'b']

In the case where you would be concatenating the authors of the ParentB and the ChildB then you would use both BaseB.authors and self.authors:

class BaseA(object):
    authors = ['a', 'b']
    author_list = authors

class BaseB(object):
    authors = ['a', 'b']

    def __init__(self, *arg, **kwargs):
        self.author_list = BaseB.authors + self.authors

class ChildA(BaseA):
    authors = ['c', 'd']

class ChildB(BaseB):
    authors = ['c', 'd']

child_a = ChildA()
child_b = ChildB()
print(child_a.author_list)
print(child_b.author_list)
>>> ['a', 'b']
>>> ['a', 'b', 'c', 'd']

Override

class BaseA(object):
    authors = ['a', 'b']
    author_list = authors

class BaseB(object):
    authors = ['a', 'b']

    def __init__(self, *arg, **kwargs):
        self.author_list = self.authors

class ChildA(BaseA):
    authors = ['c', 'd']
    def __init__(self, *arg, **kwargs):
        self.author_list = self.authors

class ChildB(BaseB):
    authors = ['c', 'd']

child_a = ChildA()
child_b = ChildB()
print(child_a.author_list)
print(child_b.author_list)
>>> ['c', 'd']
>>> ['c', 'd']

mOmOney · Accepted Answer · 2021-01-09 05:55:50Z

Recommended way to write your Python code:

class BaseA(object):
    def __init__(self):
        self.authors = ['a', 'b']

class BaseB(object):
    def __init__(self):
        self.authors = ['a', 'b']

class ChildA(BaseA):
    def __init__(self):
        self.authors = ['c', 'd']
    
class ChildB(BaseB):
    def __init__(self):
        self.authors = ['c', 'd']


child_a = ChildA()
child_b = ChildB()
print(child_a.authors)
print(child_b.authors)
>>> ['c', 'd']
>>> ['c', 'd']

Recommended ways to call the Superclass (Base Parent class):

class BaseA(object):
    def __init__(self):
        self.authors = ['a', 'b']

class BaseB(object):
    def __init__(self):
        self.authors = ['a', 'b']

class ChildA(BaseA):
    def __init__(self):
        self.authors = ['c', 'd']
        super().__init__()
    
class ChildB(BaseB):
    def __init__(self):
        self.authors = ['c', 'd']
        BaseB.__init__(self)


child_a = ChildA()
child_b = ChildB()
print(child_a.authors)
print(child_b.authors)
>>> ['a', 'b']
>>> ['a', 'b']

Esoteric superclass call using one underscore at the end of `init (__init_)`:

class BaseA(object):
    def __init__(self):
        self.authors = ['a', 'b']

class BaseB(object):
    def __init__(self):
        self.authors = ['a', 'b']

class ChildA(BaseA):
    def __init_(self):
        self.authors = ['c', 'd']
    
class ChildB(BaseB):
    def __init_(self):
        self.authors = ['c', 'd']


child_a = ChildA()
child_b = ChildB()
print(child_a.authors)
print(child_b.authors)
>>> ['a', 'b']
>>> ['a', 'b']

CAUTION

Using esoteric superclass call results in losing all access to children variables!

Access to methods in the subclass (Child class) will still be accessible, but all access to variables in the subclass (Child class) will be lost completely.

Collectives™ on Stack Overflow

Confusing python inheritance

4 Answers 4

Comments

3 Comments

Override

Comments

Recommended way to write your Python code:

Recommended ways to call the Superclass (Base Parent class):

Esoteric superclass call using one underscore at the end of `init (__init_)`:

CAUTION

Using esoteric superclass call results in losing all access to children variables!

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

4 Answers 4

Comments

3 Comments

Override

Comments

Recommended way to write your Python code:

Recommended ways to call the Superclass (Base Parent class):

Esoteric superclass call using one underscore at the end of __init__ (__init_):

CAUTION

Using esoteric superclass call results in losing all access to children variables!

Comments

Your Answer

Sign up or log in

Post as a guest

Related

Esoteric superclass call using one underscore at the end of `init (__init_)`: