Python: Why redefinition of a function is not an error? Is there a hackish way to have that feature?

Question

For example:

def foo():
    print 'first foo'
def foo():
    print 'second foo'

foo()

silently produces: second foo

Today I copy/pasted a function definition in the same file and changed a few lines in the body of second definition but forgot to change the function name itself. I scratched my head for a long time looking at the output and it took me a while to figure it out.

How to force the interpreter throw at least a warning at redefinition of a function? Thanks in advance.

Answer 1

How about using pylint?

pylint your_code.py

Let your_code.py be

1 def dup():
2    print 'a'
3 def dup():
4    print 'a'
5
6 dup()

pylint shows

C:  1,0: Missing docstring
C:  1,0:dup: Missing docstring
E:  3,0:dup: function already defined line 1     <--- HERE!!!!
C:  3,0:dup: Missing docstring

...

If you are using Pydev, You can find duplication interactively. When mouseover the second dup, It says Duplicated signature: dup.

Answer 2

It is one of features of Python. Functions are values just as integers, so you can pass them around and rebind to names, just as you would in C++ using function pointers.

Look at this code:

def foo(): # we define function and bind func object to name 'foo'
print "this if foo"

foo()     # >>>this if foo

bar = foo # we bind name 'bar' to the same function object

def foo(): # new function object is created and bound to foo
    print "this is new foo"

foo() # foo now points to new object
# >>>this is new foo
bar() # but old function object is still unmodified:
# >>>this if foo

Thus interpreter works fine. In fact it is common to redefine functions when you are working with interactive interpreter, until you get it right. Or when you use decorators.

If you want to be warned about redefining something in python, you can use 'lint' tools, like pylint (see function-redefined (E0102))

Answer 3

I think it is a similar behaviour for what happens with variables (called identifiers):

In [4]: a = 2

In [5]: a = 3

In [6]: a
Out[6]: 3

you don't see the interpreter whining about a being redefined.

EDIT Somebody commented below and I think it might help clarifying my answer:

[this is due to] function objects are not treated differently from other objects, and that names defined via def aren't treated differently from names defined via other means

See the language reference about def being a reserved identifier.

Answer 4

You need to know python philosophy of object. Everything in python is object. When you create a function, you actually create object of class function and name it as your function name.

When you re-define it you simply replace old object with new one simple as creating new variable of same name.

e.g.

>>> a=10
>>> print a
10
>>> a=20
>>> print a
20

same way you can check class of the function.

 >>> def a():
 ...     pass
 ... 
 >>> a.__class__
 <type 'function'>

which indicates your function is actually a object or variable that can be replaced with any other object variable of same class.

Answer 5

Well, you could check if it exists like this

def foo():
    pass

def check_foo(variable_dict):
    if 'foo' in variable_dict:
        print('Function foo already exists!')
    else:
        print('Function foo does not exist..')

>>> check_foo()
True
>>> del foo
>>> check_foo(locals())
False