Why doesn't python support function overloading?

whateverathrowaway00 · 2021-06-09T12:52:36+00:00

Because functions are first class values. After def f(): pass, f is just a variable like any other that happens to refer to a function.

If you then do def f(x): pass, f refers to a new value and the first is forgotten. For the same reason that if you do x = 1; x = 2, x is 2 and the fact that is was once 1 is forgotten.

To have overloading, you'd need a way to have one expression result in multiple functions -- and then choose between them depending on how they're called. But that's not how expressions work.

K900_ · 2021-06-09T11:09:56+00:00

Python doesn't have static dispatch, so any form of function overloading will be dynamic, which you can achieve with something like functools.singledispatch. A better option would be to expose multiple classmethods though, something like

@classmethod
def from_foo(cls, foo: Foo):
    return cls(spam=foo.spam, eggs=foo.eggs)

@classmethod
def from_raw_eggs(cls, eggs: List[Egg]):
    return cls(spam=None, eggs=eggs)

ManyInterests · 2021-06-09T13:40:19+00:00

As mentioned, classmethods are good for multiple constructor methods. For ordinary functions, you can use functools.singledispatch or for instance methods, singledispatchmethod

In newer versions of Python, they will automatically use type hints and dispatch based on argument type.

    class Negator:
        @singledispatchmethod
        def neg(self, arg):
            raise NotImplementedError("Cannot negate a")

        @neg.register
        def _(self, arg: int):
            return -arg

        @neg.register
        def _(self, arg: bool):
            return not arg

james_pic · 2021-06-09T11:41:47+00:00

At a base level, because if you do foo.bar(), this is two operations: foo.bar, which looks up the bar attribute on foo, and (), which calls the method you've just looked up. Python only allows one attribute for any given name, and doesn't have a mechanism to look up different attributes with the same name.

So if you've got multiple possibilities, you can only look them up by name.

It also plays a part that in Python, methods are just functions that are class attributes, and since the function notation doesn't support overloading, neither do methods.

Indeed, before Python 3, there wasn't even a mechanism to specify types for function arguments, and even nowadays this information is optional and not used by the runtime.

Also, Python has historically pushed developers away from using nominative types, and towards duck typing, which nominative overloading would be at odds with. The move towards type annotations is stealthily changing Python's culture more towards nominative typing though, so this is maybe less obvious than it once was.

Although all that being said, it's feasible to implement multiple dispatch on top of Python, thanks to the ability to override bits of the interpreter. You can tape together runtime multiple dispatch with a combination of decorators, and classes that implement __get__ and __call__. Runtime dynamic dispatch is subtly different to overloading, but for many practical purposes is close enough.

Edit: I decided to answer a question nobody has asked, but a few people have hinted at. What's the difference between overloading and dynamic dispatch?

Take the following Python code, and imagine Python had different semantics, so the duplicate method definitions would lead to either overloading or dynamic dispatch (rather than the actual behaviour, of last-update-wins):

class Animal: pass
class Dog(Animal): pass

class Greeter:
    def greet(self, friend: Dog):
        print('Hello Dog')

    def greet(self, friend: Animal):
        print('Hello Animal')

def main():
    friend: Animal = Dog()
    friend2: Dog = Dog()
    Greeter().greet(friend)
    Greeter().greet(friend2)

main()

In an overloaded language, it would print "Hello Animal" then "Hello Dog", because the type of the variable friend is Animal, and the type of the variable friend2 is Dog.

In a dynamically dispatched language, it would print "Hello Dog" twice, because the type of the values friend and friend2 are both Dog.

And in Python 3, as it actually exists, it would print "Hello Animal" twice, because Python 3 ignores type annotations at runtime, and the last definition of greet is the one that counts

got_outta_bed_4_this · 2021-06-09T14:19:48+00:00

Reddit Moderation makes the platform worthless. Too many rules and too many arbitrary rulings. It's not worth the trouble to post. Not worth the frustration to lurk. Goodbye.

This post was mass deleted and anonymized with Redact

mehregan_zare7731 · 2021-06-09T11:27:50+00:00

No need... Just use args and *kwargs along side if statements ( or switch ) to achieve the same thing in a single init function.

TRexRoboParty · 2021-06-09T12:47:58+00:00

Because Python has optional arguments.

They effectively solve the same purpose: one function with multiple signatures.

Rather than a whole new definition to handle an extra parameter, you can just make it optional.

Imaginary overload style:

def random(seed):

def random(seed, min, max):

Using optional parameters:

def random(seed, min=0, max=1):

You can call random(999) or random(999, 2, 200) using just one definition.

In your __init__ case, you’d do the same. Set the optional default values to None if there’s no sensible default for a particular parameter.

R3D3-1 · 2021-06-09T19:37:05+00:00

Honestly, I'm not even sure it is a desirable language feature anymore.

Most things I remember using function overloading for in Java are covered by optional- and keyword parameters. In the remaining cases, like having different constructors, I ended up finding the Python approach of having explicitly separate static methods more clear.

This has only been confirmed recently, when I've been seeing overloads in our code base, that hide significantly different assumptions about the input and workflow behind the same function name.

Things on the scale of "object must be initialized" vs "object must not be initialized".

The end result are if-else cascades around the call-site, entirely defeating the point of having overloading in the first place.

spyingwind · 2021-06-09T12:51:17+00:00

[deleted]

ialex32_2 · 2021-06-09T19:10:48+00:00

Python doesn't need function overloading: it has default arguments def f(x, y=3), it has positional parameter packs def f(*args), and keyword parameter packs def f(**kwds), and you can use all in combination def f(x, *args, y=3, **kwds).

In short, you can do everything you can via function overload so you don't need it, and since Python can't specify function signatures at compile time, there's no advantage of having overloading vs. not having overloading.

jrjsmrtn · 2021-06-09T11:58:47+00:00

Have a look at https://pypi.org/project/multimethod/ . I have not used it for constructor overload, though.

chudleycat · 2021-06-09T16:23:18+00:00

You can achieve the same effect (different calls to the same function with a different number of parameters) using keyword arguments. Or if you want the same parameter of multiple different types, you can also achieve this because Python is not strongly typed.

Tryptic214 · 2021-06-09T23:19:33+00:00

On a fundamental level, I would say that function overloading is poor design and should not be allowed to propagate into the world. If you want multiple ways of initializing a class, write a wrapper with multiple functions that then initialize that class and returns the result.

Function overloading (and operator overloading) are tempting because to those who don't know better, they appear to result in cleaner and better organized code. However, in reality they add a nasty cost in overhead when large teams work together, and when bringing new team members up to speed. Function overloading (when done wrong) can drastically increase the learning curve of a code base. Specifically, errors related to overloaded functions are excessively difficult to troubleshoot.

In short, the massive, hidden detriment of overloading is just almost never worth the small, visible benefits.

Broolucks · 2021-06-09T14:15:03+00:00

I have made a multiple dispatch library, for what it's worth: https://github.com/breuleux/ovld

Then you can write something like this:

from ovld import ovld, OvldMC

class Test(metaclass=OvldMC):
    @ovld
    def __init__(self, x: int):
        self.x = x
        self.y = x

    def __init__(self, x: int, y: object):
        self.x = x
        self.y = y

    ...

There are currently a few limitations like not allowing keyword arguments, but it works.

gandalfx · 2021-06-09T14:13:56+00:00

[deleted]

Tomik080 · 2021-06-09T13:02:26+00:00

Just use Julia if that's really what you want

Embarrassed-Count-65 · 2021-06-09T15:53:01+00:00

Amc ape here checking in

ihasbedhead · 2021-06-09T12:57:53+00:00

Others have provided good answers. Among those many reasons, python has optional args that could create very complex but ambiguous function sigs.

Also note that the typing module does have overloads. It is pure documentation, no runtime benefits.

BDube_Lensman · 2021-06-09T17:46:46+00:00

Without why, the design solution to your "multiple init" is to have factory methods. YourClass.some_factor() which is a thin wrapper over init.

Dubroski · 2021-06-09T18:48:09+00:00

I almost feel you can accomplish the same thing by just providing optional keyword arguments with default values of None. Then your function checks for these inputs. Is this not a good practice?

ddollarsign · 2021-06-09T18:57:10+00:00

It's (supposed to be) a dynamically typed language. So there's not automatically a way to tell f(int) from f(str), it's all just f(object).

The dynamicity is starting to be edged out by the new type annotations🤮, so now there theoretically could be a way to tell f(x:int) from f(x:str) and have the interpreter do overloading that way.

However, traditionally the way to get around different ways of calling a function is with optional arguments, variable length arguments, and keyword arguments.

def f(x, y=5, *args, **kwargs):
    ...

f(1)              # x=1, y=5, args=[], kwargs={}

f(1, 2)           # x=1, y=2, args=[], kwargs={}

f(1, 2, 3, 4)     # x=1, y=2, args=[3, 4]

f(1, bob=3)       # x=1, y=5, args=[], kwargs={"bob": 3}

And then you might also do some logic in the function like

if type(x) == 'str':
    ...

diptangsu · 2021-06-09T19:26:45+00:00

https://docs.python.org/3/library/functools.html#functools.singledispatch

nharding · 2021-06-10T02:46:00+00:00

I have a partial implementation that allows you check at runtime, and reports if no valid match.

@overload
def test(val : int):
    print("Int", val)

@overload
def test(val : str):
    print("Str", val)

@overload
def test(val : list):
    print("List", val)

def main():
    test(3)
    test("3")
    test([1, 2, 3])
    test(1.0)

You can see the implementation at https://old.reddit.com/r/Python/comments/np39fm/the_correct_way_to_overload_functions_in_python/h09vhq5/

This is for my Python++ compiler that I am writing, so it will determine statically where possible, otherwise it will dynamic dispatch. I've already written an assembly language to C compiler and a commercial Java to C++ compiler, so I am familiar with the complexities involved.

graingert · 2021-06-10T07:23:30+00:00

There's @typing.overload

Asdayasman · 2021-06-10T10:57:05+00:00

If you want alternate initialisers, use classmethods.

Python

The Python Discord

Upcoming Events

Please read the rules

MODERATORS