CODEWITHSUNDEEP
pythonpython-3.x
Alok
Alok

Reputation: 2689

Method Overriding?

I saw this particular piece of code:

def g(x,y):
    return x+y
def g(x,y):
    return x*y
x,y=6,7
print (g(x,y))

The output is obviously(but not to me) is 42. Can somebody please explain this behavior? This is method overriding I suppose, but I'm still not getting the flow here.

Upvotes: 0

Views: 767

Answers (8)

M4rtini
M4rtini

Reputation: 13539

If you are familiar with lambda function, also often called anonymous\inline functions, this might clear things up a bit

These two code blocks are essentially equal

def g(x,y):
    return x+y
def g(x,y):
    return x*y

g = lambda x,y:  x+y
g = lambda x,y:  x*y

Upvotes: 0

Pabitra Pati
Pabitra Pati

Reputation: 477

Everything in python is treated as object, whether it be a function name or class name. So, when we define a function using 'def', the memory allocation is done for that method. Then python points the name that we assign to the function, to this allocated memory location. So if we define a method :-

def demo():
    print 'hi'

the memory is allocated for the method, and the name 'demo' is pointed to its memory location as follows :-

enter image description here

Now as described by zoosuck in his second example, when you assign the function name to another variable :-

demo2 = demo # bind to the old one

then in that case, the assigned memory location to demo, is assigned to demo2 as well. So both demo and demo2 points to same location 12506.

print id(demo)   # will print 12506
print id(demo2)  # will print 12506

enter image description here

Now if we modify the above piece of code and in the next line, define a new method with same name demo:-

def demo():
    print 'hi'

demo2 = demo # bind to the old one
demo()       # Will print hi

def demo():
    print "hello"

demo()      # Will print hello
demo2()     # Will print hi

then a completely new memory location 12534 is allocated for this new method, and now demo will point to this new location 12534 instead of pointing to the old one i.e. to 12506. But demo2 is still pointing to the location 12506.

enter image description here

I hope this will give you a clear idea of what is going on and how the method name is over-written.

Upvotes: 1

lqhcpsgbl
lqhcpsgbl

Reputation: 3782

When you define a function, and you redefine it, it will use the last one you defined, even the parameter is different:

def g(x,y):
    return x+y
def g(x,y):
    return x*y
x,y=6,7
print (g(x,y))

def hello():
    return 'hello'
def hello():
    return 'bye'

print hello()

def withone(word):
    return word

def withone():
    return 1==1

print withone('ok')

Output:

42
bye
TypeError: withone() takes no arguments (1 given)

And function name in Python is more like simple variable:

def hello():
    return 'hello'

iamhello = hello # bind to the old one

def hello():
    return 'bye'

print hello() # here is the new guy

print iamhello()

OutPut:

bye
hello

Upvotes: 4

Shady Xu
Shady Xu

Reputation: 5865

Functions and methods are normal objects like any others. So in

def g(x, y):
    return x + y

def g(x, y):
    return x * y

the second object g will override(replace) the first one, just like object a does below:

a = 1
a = 2

The number, type or order of parameters does not make any difference, because Python does not support function/method override and does not allow two functions/methods to have the same name.

Upvotes: 0

Salo
Salo

Reputation: 2126

A Python script is parsed from top till bottom. So anytime the same name of a variable or function or class occurs, it overwrites any definitions that where associated with this name before.

def g(x,z):
    print('first')

def g():
    print('second')

g = 3
print g
print g()

So look at this example which will result in the printout of '3' and then in an Exception: 'TypeError: 'int' object is not callable'

The name g is at first a function with two parameters, then it gets redefined to be a function with no parameters, then it gets redefined to be an int. Which cannot be called obviously :)

Upvotes: 1

Ulrich Eckhardt
Ulrich Eckhardt

Reputation: 17415

g is just a variable. The fact that the object it refers to is a function doesn't make it special in Python, so you can assign and reassign it as you want. In this case, the second assignment (which is what a function definition is) simply replaces the object stored there with a different one.

Upvotes: 0

GLHF
GLHF

Reputation: 4035

Order matters, if names are same,last function you defined is processing. In your case it's;

def g(x,y):
    return x*y

Upvotes: 0

Meridius
Meridius

Reputation: 360

The devil is in the order of function definitions.

This is not technically method overriding as that requires class inheritance, instead it's a result of how python declares and references functions.

When declaring a function, python stores a reference to that function in a variable named after the function definition. (e.g. variable would be "foo" for "def foo():")

By declaring the function twice, the value of that variable gets overwritten by the second definition.

Upvotes: 2

Related Questions