Comment puis-je utiliser la surcharge de méthode en Python?

Je suis en train de mettre en œuvre la méthode de surcharge 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 la même façon:

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 puis-je faire ce travail?

En Python, penser à des méthodes comme un ensemble spécial de "attributs", et il ne peut qu'être un "attribut" (et donc une méthode) d'un nom à un objet. La dernière méthode remplace toutes les précédentes méthodes. En Java, les méthodes ne sont pas des citoyens de première classe (ils ne sont pas "les attributs des objets"), mais sont plutôt invoqué par "envoi de messages" qui sont statiquement réglés sur le type le plus proche (qui est l'endroit où la surcharge est livré dans).
Voir aussi stackoverflow.com/questions/733264/...
et stackoverflow.com/questions/6434482/python-function-overloading
Pourquoi aucune des réponses à cette question encore été accepté? Cliquez simplement sur le outlied coche sur la gauche de votre favori de réponse...
double possible de les fonctions Surchargées en python?
essayez de lire learnbatta.com/blog/method-overloading-in-python-60

InformationsquelleAutor user1335578 | 2012-04-18

136

C'est la méthode surcharge pas de méthode primordial. Et en Python, vous faire tout cela en 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 les deux méthodes avec le même nom en Python -- et vous n'avez pas besoin d'.

Voir le Valeur Par Défaut Des Arguments section du tutoriel Python. Voir "Moins d'Étonnement" et de la Mutable Argument par Défaut pour une erreur commune à éviter.

Modifier: Voir PEP 443 pour plus d'informations sur le nouveau single de répartition des fonctions génériques en Python 3.4.
- et vous n'avez pas besoin de - à mon humble avis, parfois, il serait très pratique d'avoir la surcharge de méthode, comme par exemple en C++. Ok, il n'est pas "nécessaire", dans le sens qu'il ne peut pas être effectuée à l'aide d'autres constructions - mais cela serait rendre les choses plus facile et plus simple.
- Je suis en désaccord. Apprendre à aimer le canard de frappe et d'écrire chaque méthode de sorte qu'il ne fait qu'une seule chose, et il n'est pas nécessaire pour la surcharge de méthode.
- ouais, j'en ai besoin, parce que j'écris en C++ et donc de penser en C++. compris maintenant
- +1 pour me faire lire à propos de la "commune erreur à éviter" avant je me suis pris
- Je tiens à être en désaccord un peu 😉 ... la surcharge souvent de rendre le code plus propre, parce que vous ne mettez pas la méthode avec trop de if-else pour gérer les différents cas. Dans un sens, l'ensemble des langages fonctionnels utiliser la même idée, c'est à dire de l'argument-pattern-matching. Ce qui veux dire que vous auriez plus petits, plus les méthodes plus propres.. plutôt que de géant illisible ceux.
- C'est le but de l'envoi des fonctions génériques ajouté en Python 3.4, et en lien dans ma réponse.
- nous avons donc explicitement de le faire if:, elif: sur différents arguments passés à la "seul envoi de la fonction générique' dire si nous avons besoin de plusieurs surcharges qui effectuer différentes actions basées sur les différentes ensemble d'arguments?
- Je ne suis pas sûr de ce que vous demandez. Vous n'avez pas besoin de tout ifs à faire l'expédition sur un seul argument à la PEP 443 fonctions génériques. Veuillez lire le document lié.
- Une idée fausse commune: valeur par Défaut des arguments ne sont pas des substituts pour la surcharge. Comparer Velocity(), ce qui représente une vitesse de zéro, et Velocity(x,y,z). Dans ce cadre, le rendant exigible comme Velocity(1,3) n'a pas de sens. De même, Position(x,y,z) vs Position(position).
- Aussi, dites-vous "n'avez pas besoin", ce qui est toujours universellement correcte pour chaque entité dans chaque monde réel et turing langage de programmation complet. Et puis d'introduire PEP 443 avec un coup de tonus. Hmm.
- Les arguments par défaut peut remplacer de nombreux cas d'utilisation de la surcharge et de la logique supplémentaire dans la méthode peut remplacer d'autres. Dans le cas de votre exemple, vous pourriez (et souvent les gens ne) définir les valeurs par défaut de Aucun et inspecter les valeurs de voir ce qui a été transmis. L'omission d'un seul argument n'est pas la seule chose que vous pouvez faire avec des arguments par défaut, et vous pouvez toujours faire un argument d'erreur si les gens l'appellent d'une manière qui ne fait pas de sens.
- Vous n'avez pas besoin de la surcharge de méthode en Python, pas parce que c'est possible de faire des choses par d'autres moyens, mais parce que c'est souvent idiomatique. Le "besoin" est utilisé de façon plus générale que dans l'étroite définition que vous donnez dans vos commentaires sur cette réponse et l'autre en dessous. Aussi loin que PEP 443, il n'existait pas lorsque cette réponse a été écrit à l'origine. J'ai ajouté un peu plus tard dans un edit; je n'ai aucune idée de ce que vous entendez par "un coup de ton" -- je viens de lien et de décrire ce que c'est.
- Je ne suis pas vraiment en cause la (non-) "besoin". C++ n'a pas "besoin", soit, comme le C++ n'a pas "besoin" de pointeurs intelligents, car on pourrait tout gérer la mémoire manuellement. Les surcharges sont juste un autre outil dans la boîte; on pourrait délégué de l'explicite et le ralentissement de la vérification manuelle de l'argument des combinaisons à l'interprète de l'appel niveau de résolution. Comme vous le laissez entendre, il peut être l'outil utilisé pour augmenter de code de la robustesse (parce que quand vous avez une surcharge, l'interprète ne la vérification pour vous).
- Par "effronté", je veux dire que les réponses du genre "c'est pas là parce qu'il n'est pas nécessaire" regardez downlooking pour le lecteur, et que, généralement, de manière injustifiée.
- Quand quelqu'un décrit une fonctionnalité manquante avec "vous n'en avez pas besoin", la dissonance cognitive carillons jusqu'à une centaine de kilomètres. La surcharge est beaucoup plus forte que les valeurs par défaut pour l'amour de dieu. - Fortes, que procéder pour résoudre une myriade d'autres questions, n'existent pas en python parce qu'il est né comme un langage de script, et dernièrement essaie de le changer. Apprécier python comme un bon langage de script, mais n'oubliez pas ce que c'est. Véritable surcharge nécessite de prototypage qui permet de différencier les types, script langs comme le python ne pas le faire et de perdre beaucoup d'élégance et de lisibilité à cause de cela.
- Je pense que l'ensemble de votre commentaire est faux, et montre un manque d'expérience avec la méthode typées dynamiquement des langages comme Python sont utilisés à grande échelle. Cependant, si vous regardez le lien en bas de ma réponse, vous verrez qu'ils Python a exactement la fonction que vous décrivez -- type de répartition -- dans les versions 3.4+.
InformationsquelleAutor agf
46

En Python, tu ne fais pas les choses de cette façon. Quand les gens ne font que dans des langages comme Java, ils veulent généralement une valeur par défaut (si ils ne le font pas, ils veulent généralement une méthode avec un nom différent). Donc, 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 peut l'utiliser pour déclencher comportement séparé plutôt que de simplement avoir une valeur par défaut.
```
>>> ob = A()
>>> ob.stackoverflow()
first form
>>> ob.stackoverflow(2)
second form
```
- La plupart None est utile lorsque vous souhaitez une mutable valeur par défaut. Comportement distinct doit être dans des fonctions séparées.
- peut également être utile comme une véritable valeur par défaut.
- Oui, mais je faisais allusion à l'utiliser comme une sentinelle de la valeur, qui est la façon dont vous l'utilisez dans votre réponse, et comme je pense que mon commentaire fait clair.
InformationsquelleAutor Chris Morgan
42

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
```
Edit: Avec le soutien officiel de la Surcharge en Python 3, vous pouvez utiliser @surcharge décorateur.
- Je pense que c'est la seule réponse valable à la question. Je double-upvote si je le pouvais.
- c'est bon, mais il ne fonctionne pas sur les matières premières fonctions, juste des méthodes dans une classe.
- Cette fonctionnalité peut également être ajouté. Il n'est pas impossible.
- J'ai fait de l'ajouter à ma propre version, et il semble fonctionner, mais je ne sais pas si j'ai le droit chemin. J'ai également ajouté des fonctionnalités pour permettre une signature à un dictionnaire de sorte que vous pouvez spécifier le nom de l'argument. de cette façon, vous pouvez avoir deux fonctions avec le même type de signatures, mais des noms différents et vous pouvez faire la distinction entre les deux, à condition que les arguments sont nommés.
- Il y a plusieurs façons de le faire. Il y a aussi github.com/bintoro/overloading.py Mais avec Python 3 soutien de la Surcharge, je ne pense pas qu'il y est de toute nécessité pour les bibliothèques tierces plus. docs.python.org/3/library/typing.html#typing.overload
InformationsquelleAutor Ehsan Keshavarzian
25

Vous ne pouvez pas, jamais besoin de et ne veulent pas vraiment.

En Python, tout est objet. Les Classes sont des choses, de sorte qu'ils sont des objets. Sont donc des méthodes.

Il y a un objet appelé A qui 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 de l'attribuer à l' stackoverflow attribut de A. Si vous écrivez deux définitions, le second remplace le premier, de la même manière que la cession se comporte toujours.

En outre, vous ne voulez pas écrire du code qui fait le plus sauvage de la sortes de choses que la surcharge est parfois utilisé pour. Ce n'est pas comment la langue fonctionne.

Au lieu d'essayer de définir une fonction distincte pour chaque type de chose que vous pourriez être donné (qui n'a guère de sens puisque vous n'avez pas à spécifier les types de paramètres de la fonction, de toute façon), cesser de s'inquiéter de ce que les choses sont et commencer à réfléchir sur ce qu'ils peuvent ne.

Non seulement vous ne pouvez pas écrire un document séparé pour gérer un tuple vs une liste, mais aussi ne voulez pas ou besoin de.

Tout ce que vous faire est de profiter du fait qu'ils sont à la fois, par exemple, itérable (c'est à dire que vous pouvez écrire for element in container:). (Le fait qu'ils ne sont pas directement liés par l'héritage est pertinent.)
- TBH, je serais plus prudent avec les "jamais besoin". C'est quelque chose qui peut être marqué sur chaque caractéristique de tout monde réel et turing langage de programmation complet, et n'est donc pas un argument valable. Qui besoins générateurs? Qui besoins classes? Les langages de programmation sont tout sucre syntaxique pour quelque chose de plus concret.
- Pas du tout d'accord. Il se peut que vous "n'aurait jamais dû" ou "n'a jamais voulu", mais il y a suffisamment d'applications où vous avez désespérément envie. Essayez par exemple l'écriture d'un programme qui traite à la fois de Python et des tableaux numpy gracieusement sans salir votre programme avec instanceof du ...
- Basé sur masi réponse, je dirais que "vous ne pouvez pas" est maintenant incorrect et obsolètes. Fondé sur l'existence de la @overload décorateur, je dirais que "ne veulent pas vraiment" est contestable, au mieux. À partir du PEP-3124, "...il est actuellement l'un des courants anti-modèle pour le code Python pour inspecter les types d'arguments...les "évident" de le faire est par le type d'inspection, mais c'est fragile et fermé à l'extension..." il semble Donc que si suffisamment de gens voulaient, qu'il est devenu une partie de Python.
- la norme @overload est pour taper seulement.
- Je ne sais pas comment votre réponse à mon commentaire. Pourriez-vous expliquer?
InformationsquelleAutor Karl Knechtel

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

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

Comment cela fonctionne:

overload prend tout montant de callables et les stocke dans un tuple functions, puis retourne lambda.
Le lambda prend n'importe quel nombre d'arguments,
puis retourne le résultat de l'appel de fonction stockée dans functions[number_of_unnamed_args_passed] appelée avec des arguments passés à la lambda.

Utilisation:

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

InformationsquelleAutor GingerPlusPlus

13

Je pense que le mot que vous cherchez est "surcharge". Il n'y a pas de surcharge de la 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 passez un argument, il suivra la logique de la première condition et exécuter la première instruction print. Lorsque vous le passez pas d'arguments, il va aller dans le else état et exécuter la deuxième instruction print.

InformationsquelleAutor mayhewr

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

En Python, la surcharge de méthode n'est pas possible, si vraiment vous voulez accéder à la même fonction avec des caractéristiques différentes, je vous suggère de passer par la redéfinition 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

bon travail @Matt Merci

InformationsquelleAutor Moorthi Muthu

9

En Python, la surcharge n'est pas un concept appliqué. Toutefois, si vous essayez de créer un cas où, par exemple, vous voulez un initialiseur être effectuée si elle est adoptée un argument de type foo et un autre d'initialiseur pour un argument de type bar alors, puisque tout ce qui est en Python est traité comme un objet, vous pouvez vérifier le nom de l'objet passé en classe du type et de l'écriture conditionnelle de manutention sur cette base.
```
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 à travers différentes méthodes que nécessaire.

InformationsquelleAutor S. Gamgee

En Python, vous devrez faire 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

InformationsquelleAutor John Gaines Jr.

5

Viens de tomber sur ce https://github.com/bintoro/overloading.py pour quelqu'un qui peut être intéressé.

À partir du référentiel lié readme:

la surcharge est un module qui fournit la fonction d'envoi basé sur
les types et le nombre de runtime arguments.

Quand une fonction surchargée est invoquée, le répartiteur compare les
les arguments fournis à la disposition des signatures de fonction et appelle la
mise en œuvre la plus précise match.

Caractéristiques

Fonction de validation lors de l'inscription et de la résolution détaillée des règles
la garantie d'un unique, résultat bien défini au moment de l'exécution. Met en œuvre
résolution de fonction de mise en cache pour une grande performance. Prend en charge en option
les paramètres (valeurs par défaut) dans la fonction de signatures. Évalue à la fois
la position et les arguments mots-clefs lors de la résolution de la meilleure correspondance.
Prend en charge de secours fonctions et l'exécution de code partagé. Prend en charge
l'argument de polymorphisme. Prend en charge les classes et l'héritage, y compris
classmethods et staticmethods.

InformationsquelleAutor Mark Lawrence
4

Tandis que @agf a droit à la réponse dans le passé maintenant, avec PEP-3124 nous avons eu notre syntaxe sugger. Voir en tapant la documentation pour plus de détails sur le @overload décorateur mais note que c'est vraiment juste la syntaxe sugger et à mon avis c'est tout, les gens se disputer à ce sujet depuis. Personnellement, je suis d'accord que le fait d'avoir de multiples fonctions avec différentes signatures rend plus lisible que d'avoir une seule fonction avec 20+ arguments tous ensemble pour une valeur par défaut (None la plupart du temps) et puis d'avoir à bricoler à l'aide d'interminables if, elif, elsechaînes de savoir ce que l'appelant veut vraiment que notre fonction pour faire avec la série d'arguments. Cela, il est plus que temps suivant le Python Zen

Belle est mieux que laid.

et sans doute aussi

Simple est mieux que complexe.

Directement à partir de l'officiel de la documentation Python lié ci-dessus:
```
@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>
```
InformationsquelleAutor masi
3

Python ne prend pas en charge la surcharge de méthode comme le Java ou le C++. On peut surcharger les méthodes, mais ne peut utiliser 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 avons besoin de fournir des arguments optionnels ou *args, afin de fournir un nombre différent de args sur appel.

Courtoisie de la part de https://www.geeksforgeeks.org/python-method-overloading/

InformationsquelleAutor Atihska
2

Python 3.x intègre en standard de frappe de la bibliothèque qui permet pour la surcharge de méthode avec l'utilisation de @surcharge de décorateur. Malheureusement, c'est pour rendre le code plus lisible, comme l' @surcharge décorées méthodes devront être suivies par un non-décoré de la méthode qui gère les différents arguments.
Plus peut être trouvé ici ici mais pour ton 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)
```
- Le "la" à la fin de votre réponse me fait penser que vous n'avez pas fini d'écrire votre réponse. Veuillez modifier votre réponse pour le compléter.
InformationsquelleAutor nickthefreak

Dans MathMethod.py fichier

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 Main.py fichier

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

On peut surcharger une méthode en utilisant multipledispatch

Cela nécessite l'utilisation de multipledispatch paquet (pypi.org/project/multipledispatch), ce qui n'est pas partie de python de base.

InformationsquelleAutor Mahabubuzzaman

Vous devez vous connecter pour publier un commentaire.