Function Overloading in python

Question

So I need to create overload function sum() for adding two numbers, one should take integer values and another float. The input will be only 2 integer numbers for both sum() functions.

How can I distinguish between the first sum() function and second sum() function then? The first sum() function is supposed to be for integer parameters and the second is supposed to be for floating-point. But if the last function is always the one getting called for regardless of whether the parameter is integer or floating-point. I tired different casting but no success

I have for example these function, but can not understand how to overload them

def add(a, b):
    return a + b

def add(a:float, b:float):
    return  a + b

I can not use dispatch() , isintance() or any other modules

Answer 1

Based on your comments, I'm guessing you looked at this geeksforgeeks article. If you look closely, it did not overload the function with a different number of arguments because the last defined function will always be the defined function.

At the end of the day, Python does not do function overloading like in C++ or Java. There is always only one definition for a function. You'll have to parse the inputs in order to decide the behavior within the function itself. I'm a little confused why you can't use isinstance but I suppose you can get around it with type.

Answer 2

If you have a statically typed language, a add function would need variants for each type of thing you want added. The underlying machine code for adding integers is different than floats, and each would need to be in its own function.

Python isn't that way. In python, + is translated to a call to the object's __add__ method and the object itself decides what it means to add. Take your single sum function and you could add integers, floats, and even concatenate strings.

>>> def sum(a, b):
...     return a + b
... 
>>> sum(1, 3)
4
>>> sum(1.1, 3.3)
4.4
>>> sum("foo", "bar")
'foobar'

How about adding million element arrays? It'll do that, too.

>>> import numpy as np
>>> a1 = np.ones((1000,1000), dtype=int)
>>> a2 = np.zeros((1000,1000), dtype=int)
>>> sum(a1, a2)
array([[1, 1, 1, ..., 1, 1, 1],
       [1, 1, 1, ..., 1, 1, 1],
       [1, 1, 1, ..., 1, 1, 1],
       ...,
       [1, 1, 1, ..., 1, 1, 1],
       [1, 1, 1, ..., 1, 1, 1],
       [1, 1, 1, ..., 1, 1, 1]])

Answer 3

Python does not support overloading. The best that you can do is remove any type identifiers from the arguments and use if-else statements to change the function of the method depending on the input types.

For example:

def add(a,b):
    if type(a) == float and type(b) == float:
        pass # add floats
    elif type(a) == int and type(b) == int:
        pass # add ints
    else:
        assert False, 'input error, arguments (a,b) need to both be either a float or an int'

or

class integers():
    def __init__(self) -> None:
        pass    
    @classmethod
    def add(cls,a,b):
        return int(a) + int(b)

class floats():
    def __init__(self) -> None:
        pass
    
    @classmethod
    def add(cls,a,b):
        return float(a) + float(b)


a_float_sum = floats.add(1.0, 2.0)
print(f'{a_float_sum=}')

an_int_sum = integers.add(1, 2)
print(f'{an_int_sum=}')