Comment utiliser la surcharge de méthode en Python?

J'essaie d'implémenter la surcharge de méthode en Python:

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

ob=A()
ob.stackoverflow(2)

mais la sortie est second method 2; De même:

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

ob=A()
ob.stackoverflow()

donne

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

Comment faire fonctionner cela?

C'est une surcharge de méthode et non un remplacement de méthode . Et en Python, vous faites tout cela dans une seule fonction:

class A:

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

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

Vous ne pouvez pas avoir deux méthodes avec le même nom en Python - et vous n'en avez pas besoin.

Consultez la section Valeurs d'argument par défaut du didacticiel Python. Voir «Least Astonishment» et l'argument Mutable Default pour une erreur courante à éviter.

Edit : Voir PEP 443 pour plus d'informations sur les nouvelles fonctions génériques de répartition unique dans Python 3.4.

Vous pouvez également utiliser 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

En Python, vous ne faites pas les choses de cette façon. Quand les gens font cela dans des langages comme Java, ils veulent généralement une valeur par défaut (s'ils ne le font pas, ils veulent généralement une méthode avec un nom différent). Ainsi, en Python, vous pouvez avoir des valeurs par défaut .

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'

Comme vous pouvez le voir, vous pouvez l' utiliser pour déclencher un comportement séparé plutôt que d'avoir simplement une valeur par défaut.

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

Vous ne pouvez pas, jamais besoin et ne voulez pas vraiment.

En Python, tout est un objet. Les classes sont des choses, donc ce sont des objets. Les méthodes aussi.

Il y a un objet appelé Aqui est une classe. Il a un attribut appelé stackoverflow. Il ne peut avoir qu'un seul de ces attributs.

Lorsque vous écrivez def stackoverflow(...): ..., ce qui se passe, c'est que vous créez un objet qui est la méthode et que vous l'assignez à l' stackoverflowattribut de A. Si vous écrivez deux définitions, la seconde remplace la première, de la même manière que l'affectation se comporte toujours.

De plus, vous ne voulez pas écrire de code qui fasse le plus fou des choses pour lesquelles la surcharge est parfois utilisée. Ce n'est pas ainsi que fonctionne la langue.

Au lieu d'essayer de définir une fonction distincte pour chaque type de chose qui pourrait vous être donné (ce qui n'a pas de sens puisque vous ne spécifiez pas de types pour les paramètres de fonction de toute façon), arrêtez de vous soucier de ce que sont les choses et commencez à penser à ce qu'elles peuvent faire .

Non seulement vous ne pouvez pas en écrire un distinct pour gérer un tuple par rapport à une liste, mais vous ne voulez pas ou n'en avez pas besoin .

Tout ce que vous faites est de profiter du fait qu'ils sont tous les deux, par exemple, itérables (c'est-à-dire que vous pouvez écrire for element in container:). (Le fait qu'ils ne soient pas directement liés par héritage n'est pas pertinent.)

Alors que @agf avait raison avec la réponse dans le passé maintenant avec PEP-3124, nous avons obtenu notre sucre de syntaxe. Voir la documentation de frappe pour plus de détails sur le @overloaddécorateur, mais notez que ce n'est vraiment que du sucre de syntaxe et à mon humble avis, c'est tout ce que les gens se disputent depuis. Personnellement , je suis d' accord que d' avoir plusieurs fonctions avec des signatures différentes rend plus lisible ayant alors une fonction unique avec plus de 20 arguments tous ensemble à une valeur par défaut ( la Noneplupart du temps), puis avoir à bricoler en utilisant sans fin if, elif, des elsechaînes pour savoir ce l'appelant veut en fait que notre fonction fasse avec l'ensemble d'arguments fourni. C'était attendu depuis longtemps après le Python Zen

Beau est mieux que laid.

et sans doute aussi

Le simple vaut mieux que le complexe.

Directement à partir de la documentation officielle Python liée ci-dessus:

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>

J'écris ma réponse en Python 3.2.1.

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

Comment ça fonctionne:

1. overloadprend n'importe quelle quantité de callables et les stocke dans tuple functions, puis retourne lambda.
2. Le lambda prend n'importe quelle quantité d'arguments, puis retourne le résultat de l'appel de la fonction stockée dans functions[number_of_unnamed_args_passed]appelé avec des arguments passés au lambda.

Usage:

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) \
    )

Je pense que le mot que vous recherchez est «surcharge». Il n'y a pas de surcharge de méthode en python. Vous pouvez cependant utiliser des arguments par défaut, comme suit.

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

Lorsque vous lui passez un argument, il suivra la logique de la première condition et exécutera la première instruction d'impression. Lorsque vous ne lui passez aucun argument, il entre dans la elsecondition et exécute la deuxième instruction d'impression.

J'écris ma réponse en Python 2.7:

En Python, la surcharge de méthode n'est pas possible; si vous voulez vraiment accéder à la même fonction avec des fonctionnalités différentes, je vous suggère d'opter pour le remplacement de méthode.

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

En Python, la surcharge n'est pas un concept appliqué. Cependant, si vous essayez de créer un cas où, par exemple, vous voulez qu'un initialiseur soit exécuté si un argument de type est passé fooet un autre initialiseur pour un argument de type baralors, puisque tout en Python est traité comme objet, vous pouvez vérifier le nom du type de classe de l'objet passé et écrivez la gestion conditionnelle en fonction de cela.

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'
         ...

Ce concept peut être appliqué à plusieurs scénarios différents par différentes méthodes selon les besoins.

En Python, vous feriez cela avec un argument par défaut.

class A:

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

Je viens de tomber sur https://github.com/bintoro/overloading.py pour quiconque pourrait être intéressé.

Depuis le fichier readme du référentiel lié:

overloading est un module qui fournit une répartition des fonctions en fonction des types et du nombre d'arguments d'exécution.

Lorsqu'une fonction surchargée est appelée, le répartiteur compare les arguments fournis aux signatures de fonction disponibles et appelle l'implémentation qui fournit la correspondance la plus précise.

Caractéristiques

La validation des fonctions lors de l'enregistrement et les règles de résolution détaillées garantissent un résultat unique et bien défini lors de l'exécution. Implémente la mise en cache de la résolution des fonctions pour d'excellentes performances. Prend en charge les paramètres facultatifs (valeurs par défaut) dans les signatures de fonction. Évalue les arguments de position et de mot-clé lors de la résolution de la meilleure correspondance. Prend en charge les fonctions de secours et l'exécution de code partagé. Prend en charge le polymorphisme des arguments. Prend en charge les classes et l'héritage, y compris les méthodes de classe et les méthodes statiques.

Python ne prend pas en charge la surcharge de méthodes comme Java ou C ++. Nous pouvons surcharger les méthodes mais ne pouvons utiliser que la dernière méthode définie.

# 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)

Nous devons fournir des arguments optionnels ou * args afin de fournir un nombre différent d'arguments lors de l'appel.

Gracieuseté de https://www.geeksforgeeks.org/python-method-overloading/

Python 3.x inclut une bibliothèque de typage standard qui permet la surcharge de méthodes avec l'utilisation de @overload decorator. Malheureusement, il s'agit de rendre le code plus lisible, car les méthodes décorées @overload devront être suivies d'une méthode non décorée qui gère différents arguments. Vous pouvez en trouver plus ici ici, mais pour votre exemple:

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)

Dans le fichier 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

Dans le fichier Main.py

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

Nous pouvons surcharger la méthode en utilisant multipledispatch

Python a ajouté le décorateur @overload avec PEP-3124 pour fournir du sucre syntaxique pour la surcharge via l'inspection de type - au lieu de simplement travailler avec l'écrasement.

Exemple de code sur la surcharge via @overload de 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

est transformé par le @ overload-decorator en:

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