Funções sobrecarregadas em Python

É possível ter funções sobrecarregadas em Python?

Em C # eu faria algo como

void myfunction (int first, string second)
{
    // Some code
}

void myfunction (int first, string second , float third)
{
    // Some different code
}

E então, quando chamo a função, ela diferencia as duas com base no número de argumentos. É possível fazer algo semelhante em Python?

EDITAR Para as novas funções genéricas de despacho único no Python 3.4, consulte http://www.python.org/dev/peps/pep-0443/

Em geral, você não precisa sobrecarregar funções em Python. Python é tipado dinamicamente e suporta argumentos opcionais para funções.

def myfunction(first, second, third = None):
    if third is None:
        #just use first and second
    else:
        #use all three

myfunction(1, 2) # third will be None, so enter the 'if' clause
myfunction(3, 4, 5) # third isn't None, it's 5, so enter the 'else' clause

em python normal, você não pode fazer o que quiser. existem duas aproximações:

def myfunction(first, second, *args):
    # args is a tuple of extra arguments

def myfunction(first, second, third=None):
    # third is optional

no entanto, se você realmente quiser fazer isso, certamente poderá fazê-lo funcionar (correndo o risco de ofender os tradicionalistas; o). em resumo, você escreveria uma wrapper(*args)função que verifica o número de argumentos e delegados conforme apropriado. esse tipo de "hack" geralmente é feito por meio de decoradores. neste caso, você poderia conseguir algo como:

from typing import overload

@overload
def myfunction(first):
    ....

@myfunction.overload
def myfunction(first, second):
    ....

@myfunction.overload
def myfunction(first, second, third):
    ....

e você implementaria isso fazendo a overload(first_fn) função (ou construtor) retornar um objeto que pode ser chamado, onde o __call__(*args) método faz a delegação explicada acima e o overload(another_fn) método adiciona funções extras que podem ser delegadas.

você pode ver um exemplo de algo semelhante aqui http://acooke.org/pytyp/pytyp.spec.dispatch.html, mas isso está sobrecarregando os métodos por tipo. é uma abordagem muito semelhante ...

ATUALIZAÇÃO: e algo semelhante (usando tipos de argumento) está sendo adicionado ao python 3 - http://www.python.org/dev/peps/pep-0443/

Sim é possivel. Escrevi o código abaixo no Python 3.2.1:

def overload(*functions):
    return lambda *args, **kwargs: functions[len(args)](*args, **kwargs)

Uso:

myfunction=overload(no_arg_func, one_arg_func, two_arg_func)

Observe que o lambda retornado pelas overloadfunções escolhe a função a ser chamada dependendo do número de argumentos não nomeados .

A solução não é perfeita, mas no momento não consigo escrever nada melhor.

Não é possível diretamente. Você pode usar verificações explícitas de tipo nos argumentos fornecidos, embora isso seja geralmente desaprovado.

Python é dinâmico. Se você não tiver certeza do que um objeto pode fazer, tente: e chame um método nele, exceto: erros.

Se você não precisa sobrecarregar com base em tipos, mas apenas em número de argumentos, use argumentos de palavra-chave.

sobrecarregar métodos é complicado em python. No entanto, pode haver uso de passagem de variáveis ​​dict, list ou primitivas.

Eu tentei algo para meus casos de uso, isso pode ajudar aqui a entender as pessoas a sobrecarregar os métodos.

Vamos dar o exemplo de uso em um dos encadeamentos stackoverflow:

um método de sobrecarga de classe com a chamada de métodos de classes diferentes.

def add_bullet(sprite=None, start=None, headto=None, spead=None, acceleration=None):

passe os argumentos da classe remota:

add_bullet(sprite = 'test', start=Yes,headto={'lat':10.6666,'long':10.6666},accelaration=10.6}

OU add_bullet(sprite = 'test', start=Yes,headto={'lat':10.6666,'long':10.6666},speed=['10','20,'30']}

Portanto, o manuseio está sendo alcançado para lista, dicionário ou variáveis ​​primitivas de sobrecarga de método.

experimente para seus códigos