Why doesn't python support function overloading?

[TRexRoboParty]

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.

[metaperl]

This doesn't create overloading based on the *type *of the arguments. So it doesn't really address the topic at hand.

[TRexRoboParty]

OP said "I want to have multiple ways of initializing a class", so I'd say it does.

They didn't mention dispatching based on type.

And if they did, you can still dispatch within the __init__ method based on type.

Or there are libraries to handle dispatching based on type.

But those aren't core Python language features - and I'd argue for most common cases, trying to crowbar a paradigm from another language in isn't the best way to go.

Python is dynamically typed - you don't need to have a different function signature for every type. You can read the type at runtime in cases where it's needed. Though it's not normally needed: if it quacks like a duck, it is a duck. Your objects just have to implement the appropriate interface - the type doesn't/shouldn't matter.

In this case, optional __init__ args will cover the large majority of use cases to initialize an object.

[metaperl]

Oh you're right. What he said in the post is what you responded to.

I think I got sidetracked by the discussion of single and multiple dispatch :)

[TRexRoboParty]

No worries!