Come utilizzo il metodo di overloading in Python?

Sto cercando di implementare il sovraccarico del metodo in Python:

class A:
    def stackoverflow(self):    
        print 'first method'
    def stackoverflow(self, i):
        print 'second method', i

ob=A()
ob.stackoverflow(2)

ma l'output è second method 2; simile:

class A:
    def stackoverflow(self):    
        print 'first method'
    def stackoverflow(self, i):
        print 'second method', i

ob=A()
ob.stackoverflow()

dà

Traceback (most recent call last):
  File "my.py", line 9, in <module>
    ob.stackoverflow()
TypeError: stackoverflow() takes exactly 2 arguments (1 given)

Come faccio a farlo funzionare?

È un metodo che sovraccarica non un metodo prioritario . E in Python, fai tutto in un'unica funzione:

class A:

    def stackoverflow(self, i='some_default_value'):    
        print 'only method'

ob=A()
ob.stackoverflow(2)
ob.stackoverflow()

Non puoi avere due metodi con lo stesso nome in Python - e non è necessario.

Vedi la sezione Valori argomenti predefiniti dell'esercitazione Python. Vedi "Minimo stupore" e l'argomento predefinito mutevole per un errore comune da evitare.

Modifica : vedere PEP 443 per informazioni sulle nuove funzioni generiche di invio singolo in Python 3.4.

Puoi anche usare pythonlangutil :

from pythonlangutil.overload import Overload, signature

class A:
    @Overload
    @signature()
    def stackoverflow(self):    
        print 'first method'

    @stackoverflow.overload
    @signature("int")
    def stackoverflow(self, i):
        print 'second method', i

In Python, non fai le cose in questo modo. Quando le persone lo fanno in lingue come Java, generalmente vogliono un valore predefinito (se non lo fanno, generalmente vogliono un metodo con un nome diverso). Quindi, in Python, puoi avere valori predefiniti .

class A(object):  # Remember the ``object`` bit when working in Python 2.x

    def stackoverflow(self, i=None):
        if i is None:
            print 'first form'
        else:
            print 'second form'

Come puoi vedere, puoi usarlo per innescare un comportamento separato piuttosto che avere semplicemente un valore predefinito.

>>> ob = A()
>>> ob.stackoverflow()
first form
>>> ob.stackoverflow(2)
second form

Non puoi, non devi mai e non vuoi davvero.

In Python, tutto è un oggetto. Le classi sono cose, quindi sono oggetti. Così sono i metodi.

C'è un oggetto chiamato Ache è una classe. Ha un attributo chiamato stackoverflow. Può avere solo uno di questi attributi.

Quando scrivi def stackoverflow(...): ..., succede che crei un oggetto che è il metodo e lo assegni stackoverflowall'attributo di A. Se scrivi due definizioni, la seconda sostituisce la prima, nello stesso modo in cui si comporta sempre il compito.

Inoltre, non si desidera scrivere codice che fa il più selvaggio per il genere di cose per le quali viene talvolta utilizzato il sovraccarico. Non è così che funziona la lingua.

Invece di provare a definire una funzione separata per ogni tipo di cosa che potresti ricevere (il che ha poco senso dal momento che non specifichi comunque i tipi per i parametri della funzione), smetti di preoccuparti di cosa sono e inizia a pensare a cosa possono fare .

Non solo non puoi scriverne uno separato per gestire una tupla rispetto a un elenco, ma non vuoi né ne hai bisogno .

Tutto quello che fai è approfittare del fatto che sono entrambi, ad esempio, iterabili (cioè puoi scrivere for element in container:). (Il fatto che non siano direttamente correlati per eredità è irrilevante.)

Mentre @agf aveva ragione con la risposta in passato ora con PEP-3124, abbiamo ottenuto il nostro zucchero di sintassi. Vedi la documentazione di battitura per i dettagli sul @overloaddecoratore, ma nota che questo è davvero solo zucchero di sintassi e IMHO questo è tutto ciò di cui le persone hanno discusso da allora. Personalmente sono d'accordo che avere molteplici funzioni con firme diverse rende più leggibile quindi avere una singola funzione con più di 20 argomenti tutto pronto per un valore di default ( Nonela maggior parte del tempo) e poi dover smanettare con infinite if, elif, elsecatene di scoprire cosa il chiamante vuole davvero che la nostra funzione abbia a che fare con l'insieme di argomenti fornito. Ciò era atteso da tempo dopo lo Python Zen

Bello è meglio che brutto.

e probabilmente anche

Semplice è meglio di complesso.

Direttamente dalla documentazione ufficiale di Python collegata sopra:

from typing import overload
@overload
def process(response: None) -> None:
    ...
@overload
def process(response: int) -> Tuple[int, str]:
    ...
@overload
def process(response: bytes) -> str:
    ...
def process(response):
    <actual implementation>

Scrivo la mia risposta in Python 3.2.1.

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

Come funziona:

1. overloadprende qualsiasi quantità di callable e le memorizza in tupla functions, quindi restituisce lambda.
2. La lambda accetta qualsiasi quantità di argomenti, quindi restituisce il risultato della funzione di chiamata memorizzata nella functions[number_of_unnamed_args_passed]chiamata con argomenti passati alla lambda.

Uso:

class A:
    stackoverflow=overload(                    \
        None, \ 
        #there is always a self argument, so this should never get called
        lambda self: print('First method'),      \
        lambda self, i: print('Second method', i) \
    )

Penso che la parola che stai cercando sia "sovraccarico". Non esiste alcun metodo di sovraccarico in Python. È comunque possibile utilizzare gli argomenti predefiniti, come indicato di seguito.

def stackoverflow(self, i=None):
    if i != None:     
        print 'second method', i
    else:
        print 'first method'

Quando gli passi un argomento, seguirà la logica della prima condizione ed eseguirà la prima istruzione di stampa. Quando non gli passi argomenti, entrerà nella elsecondizione ed eseguirà la seconda istruzione di stampa.

Scrivo la mia risposta in Python 2.7:

In Python, il sovraccarico del metodo non è possibile; se vuoi davvero accedere alla stessa funzione con caratteristiche diverse, ti suggerisco di scegliere il metodo di sostituzione.

class Base(): # Base class
    '''def add(self,a,b):
        s=a+b
        print s'''

    def add(self,a,b,c):
        self.a=a
        self.b=b
        self.c=c

        sum =a+b+c
        print sum

class Derived(Base): # Derived class
    def add(self,a,b): # overriding method
        sum=a+b
        print sum



add_fun_1=Base() #instance creation for Base class
add_fun_2=Derived()#instance creation for Derived class

add_fun_1.add(4,2,5) # function with 3 arguments
add_fun_2.add(4,2)   # function with 2 arguments

In Python, il sovraccarico non è un concetto applicato. Tuttavia, se stai cercando di creare un caso in cui, ad esempio, desideri eseguire un inizializzatore se viene passato un argomento di tipo fooe un altro inizializzatore per un argomento di tipo bar, poiché tutto in Python viene gestito come oggetto, puoi controllare il nome del tipo di classe dell'oggetto passato e scrivere la gestione condizionale in base a quello.

class A:
   def __init__(self, arg)
      # Get the Argument's class type as a String
      argClass = arg.__class__.__name__

      if argClass == 'foo':
         print 'Arg is of type "foo"'
         ...
      elif argClass == 'bar':
         print 'Arg is of type "bar"'
         ...
      else
         print 'Arg is of a different type'
         ...

Questo concetto può essere applicato a più scenari diversi attraverso metodi diversi, se necessario.

In Python, lo faresti con un argomento predefinito.

class A:

    def stackoverflow(self, i=None):    
        if i == None:
            print 'first method'
        else:
            print 'second method',i

Ho appena trovato questo https://github.com/bintoro/overloading.py per chiunque sia interessato.

Dal readme del repository collegato:

il sovraccarico è un modulo che fornisce l'invio di funzioni in base ai tipi e al numero di argomenti di runtime.

Quando viene invocata una funzione sovraccaricata, il dispatcher confronta gli argomenti forniti con le firme di funzione disponibili e chiama l'implementazione che fornisce la corrispondenza più accurata.

Caratteristiche

La convalida della funzione al momento della registrazione e le regole di risoluzione dettagliate garantiscono un risultato unico e ben definito in fase di esecuzione. Implementa la cache di risoluzione delle funzioni per prestazioni eccezionali. Supporta parametri opzionali (valori predefiniti) nelle firme delle funzioni. Valuta gli argomenti posizionali e delle parole chiave quando si risolve la corrispondenza migliore. Supporta funzioni di fallback ed esecuzione di codice condiviso. Supporta il polimorfismo degli argomenti. Supporta classi ed ereditarietà, inclusi metodi di classe e metodi statici.

Python non supporta il sovraccarico dei metodi come Java o C ++. Potremmo sovraccaricare i metodi ma possiamo usare solo l'ultimo metodo definito.

# First sum method.
# Takes two argument and print their sum
def sum(a, b):
    s = a + b
    print(s)

# Second sum method
# Takes three argument and print their sum
def sum(a, b, c):
    s = a + b + c
    print(s)

# Uncommenting the below line shows an error    
# sum(4, 5)

# This line will call the second sum method
sum(4, 5, 5)

Dobbiamo fornire argomenti opzionali o * arg per fornire un numero diverso di arg su chiamata.

Per gentile concessione di https://www.geeksforgeeks.org/python-method-overloading/

Python 3.x include una libreria di digitazione standard che consente il sovraccarico del metodo con l'uso di @overload decorator. Sfortunatamente, questo serve a rendere il codice più leggibile, poiché i metodi decorati @overload dovranno essere seguiti da un metodo non decorato che gestisca diversi argomenti. Altro può essere trovato qui qui, ma per il tuo esempio:

from typing import overload
from typing import Any, Optional
class A(object):
    @overload
    def stackoverflow(self) -> None:    
        print('first method')
    @overload
    def stackoverflow(self, i: Any) -> None:
        print('second method', i)
    def stackoverflow(self, i: Optional[Any] = None) -> None:
        if not i:
            print('first method')
        else:
            print('second method', i)

ob=A()
ob.stackoverflow(2)

Nel file MathMethod.py

from multipledispatch import dispatch
@dispatch(int,int)
def Add(a,b):
   return a+b 
@dispatch(int,int,int)  
def Add(a,b,c):
   return a+b+c 
@dispatch(int,int,int,int)    
def Add(a,b,c,d):
   return a+b+c+d

Nel file Main.py

import MathMethod as MM 
print(MM.Add(200,1000,1000,200))

Possiamo sovraccaricare il metodo usando multipledispatch

Python ha aggiunto il decoratore @overload con PEP-3124 per fornire zucchero sintattico per il sovraccarico tramite l'ispezione del tipo, invece di lavorare semplicemente con la sovrascrittura.

Esempio di codice per sovraccarico tramite @overload da PEP-3124

from overloading import overload
from collections import Iterable

def flatten(ob):
    """Flatten an object to its component iterables"""
    yield ob

@overload
def flatten(ob: Iterable):
    for o in ob:
        for ob in flatten(o):
            yield ob

@overload
def flatten(ob: basestring):
    yield ob

viene trasformato da @ overload-decorator in:

def flatten(ob):
    if isinstance(ob, basestring) or not isinstance(ob, Iterable):
        yield ob
    else:
        for o in ob:
            for ob in flatten(o):
                yield ob