8

This Stack Overflow answer states that for the program:

class Parent(object):
    i = 5;
    def __init__(self):
        self.i = 5

    def doStuff(self):
        print(self.i)

class Child(Parent, object):

    def __init__(self):
        super(Child, self).__init__()
        self.i = 7

class Main():

    def main(self):
        m = Child()
        print(m.i) #print 7
        m.doStuff() #print 7

m = Main()
m.main()

Output will be:

$ python Main.py 
7
7

That answer then compares it to a similar program in Java:

The reason is because Java's int i declaration in Child class makes the i become class scope variable, while no such variable shadowing in Python subclassing. If you remove int i in Child class of Java, it will print 7 and 7 too.

What does variable shadowing mean in this case?

wjandrea
  • 28,235
  • 9
  • 60
  • 81
user8174870
  • 81
  • 1
  • 3
  • 5
    This code seems to be from https://stackoverflow.com/a/37657923/8061009. Generally is is a good idea to link to the original, to provide context. – Will Dec 12 '18 at 00:42

3 Answers3

10

What does variable shadowing mean in this case?

Variable shadowing means the same thing in all cases, independent of context. It's defined as when a variable "hides" another variable with the same name. So, when variable shadowing occurs, there are two or more variables with the same name, and their definitions are dependent on their scope (meaning their values may be different depending upon scope). Quick example:

In [11]: def shadowing():
    ...:     x = 1
    ...:     def inner():
    ...:         x = 2
    ...:         print(x)
    ...:     inner()
    ...:     print(x)
    ...:

In [12]: shadowing()
2
1

Note that we call inner() first, which assigns x to be 2, and prints 2 as such. But this does not modify the x at the outer scope (i.e. the first x), since the x in inner is shadowing the first x. So, after we call inner(), and the call returns, now the first x is back in scope, and so the last print outputs 1.

In this particular example, the original author you've quoted is saying that shadowing is not occurring (and to be clear: not occurring at the instance level). You'll note that i in the parent takes on the same value as i in the child. If shadowing occurred, they would have different values, like in the example above (i.e. the parent would have a copy of a variable i and the child would have a different copy of a variable also named i). However, they do not. i is 7 in both the parent and child. The original author is noting that Python's inheritance mechanism is different than Java's in this respect.

wjandrea
  • 28,235
  • 9
  • 60
  • 81
Matt Messersmith
  • 12,939
  • 6
  • 51
  • 52
0

Variable shadowing occurs when a variable declared within a certain scope (decision block, method, or inner class) has the same name as a variable declared in an outer scope. Then the variable in the scope that you are in shadows (hides/masks) the variable in the outer scope.

In the above code the variable i is being initialized in both the super class and the child class. So the initialization in the super class will be shadowed by the initialization in the child and class.

m = Child() #we initialized the child class with i=7
print(m.i) #eventhough we are calling a method in the super class the value of i in the super class is shadowed by the value we initialized the instance of the child class (m)
m.doStuff() #same thing here
Matter
  • 36
  • 4
  • There is no shadowing here; `i` in both the parent and child classes refers to exactly the same instance variable, and the child's assignment to `i` actually overwrites the parent's assignment. In a language where shadowing occurs, the parent's `i` would still exist, and could be accessed by methods of the parent class. – jasonharper Dec 12 '18 at 00:52
  • @jasonharper: Confusingly, there *is* shadowing, but it's not being exercised in any way. `Parent` has a class attribute `i`, but its `__init__` immediately shadows it (with the same value, just to be confusing). It's only in `Child` where the shadowing is more obvious; `Parent.i` and `Child.i` have a value of `5` (as does `parentinstance.i`, but it's a different `5`), but `childinstance.i` is `7`. – ShadowRanger Dec 12 '18 at 01:27
0

In Java, methods and fields are fundamentally different things, operating by entirely different rules. Only methods are inherited by subclasses; fields are specific to the class that declared them. If a subclass declares a field with the same name as one in a parent class, they are entirely unrelated; methods of the parent class continue to access the parent's version, and methods of the child class access its version. This is what is referred to as shadowing. If the parent class actually wanted to make its field available to children, it would have to define getter/setter methods for it.

In Python, there is no such distinction - methods are basically fields whose value happens to be a function. Furthermore, all of the fields from the entire inheritance hierarchy are stored in a single namespace (typically implemented as a dict attribute named __dict__). If the child and parent use the same name for something, they are necessarily referring to the same object.

jasonharper
  • 9,450
  • 2
  • 18
  • 42