überladen von Methoden in python

Muss ich anrufen unparameterised Methode first, aber auch parametrisierte first, aber es gibt einen Fehler.

>>> class A:
...     def first(self):
...             print 'first method'
...     def first(self,f):
...             print 'first met',f
...
>>> a=A()
>>> a.first()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: first() takes exactly 2 arguments (1 given)

Ist es möglich, die Methode überladen in Python wie in Java?

Bitte erbt von dem Objekt! Sie wollen nicht wirklich ein old-style Klasse, und du? (Dies wäre ein nicht-Problem in Python 3, aber Ihre print-Anweisungen, Sag mir, dass du mit Python 2.)

InformationsquelleAutor user1272269 | 2012-03-15

overloading python

11

Ihre zweite first Methode ist das überschreiben der original - first Methode. In Python ist es nicht möglich zu erstellen überladenen Methoden auf die gleiche Weise wie in Java.

Allerdings können Sie erstellen Methoden mit optionalen und/oder keyword-basierte Argumente und verarbeiten diese entsprechend. Hier ist ein Beispiel:
```
class A:
    def first(self, f=None):
        if f is not None:
            print 'first met', f
        else:
            print 'first method'
```
Verwendung:
```
a = A()
a.first()
a.first('something')
```
- Ja. Das Standard-argument im Stil von python ist tatsächlich kürzer, und, imo, leichter zu Lesen und zu warten sind dann die Java-Stil Riesen Liste von überschriebenen Methoden mit Abnehmender Zahl der Argumente.
InformationsquelleAutor Platinum Azure
6

Python nicht überladen von Funktionen. Dies ist eine Folge davon ist eine lose typisierte Sprache. Stattdessen können Sie angeben, dass eine unbekannte Anzahl von Argumenten und der Umgang mit Ihrer interpretation in der Funktion der Logik.

Gibt es ein paar Möglichkeiten, wie Sie dies tun können. Sie können angeben, bestimmte optionale Argumente:
```
def func1(arg1, arg2=None):
    if arg2 != None:
        print "%s %s" % (arg1, arg2)
    else:
        print "%s" % (arg1)
```
Aufruf erhalten wir:
```
>>> func1(1, 2)
1 2
```
Oder Sie können angeben, dass eine unbekannte Anzahl von Unbenannte Argumente (d.h. die übergebenen Argumente in einem array):
```
def func2(arg1, *args):
    if args:
        for item in args:
            print item
    else:
        print arg1
```
Aufruf erhalten wir:
```
>>> func2(1, 2, 3, 4, 5)
2
3
4
5
```
Oder Sie können angeben, dass eine unbekannte Anzahl von benannten Argumenten (d.h. die übergebenen Argumente in ein dictionary):
```
def func3(arg1, **args):
    if args:
        for k, v in args.items():
            print "%s %s" % (k, v)
    else:
        print arg1
```
Aufruf erhalten wir:
```
>>> func3(1, arg2=2, arg3=3)
arg2 2
arg3 3
```
Können Sie diese Konstruktionen zu produzieren, die das Verhalten, die Sie waren auf der Suche nach einer überlastung.
- Ihre func1() verhält sich nicht wie ein namens erwarten könnte, wenn es aufgerufen wird als func1(1, 0)
- Ah ja, gut zu fangen. Die änderung vorgenommen.
InformationsquelleAutor cjm

In der Regel können Sie nur definieren Sie eine Methode in einer Klasse mit einem bestimmten Namen. In deinem Beispiel das 2 argument zuerst () - Methode überschrieben haben, das 1-argument der ersten(). Wenn Sie zwei Methoden mit dem gleichen Namen, in python 3 verwenden Sie die functools.singledispatch, und ordnen Sie die Instanz name der Methode auf Ihre statische Methode dispatcher, AUA!

Sagte, dass ich wirklich wie implizite dynamic dispatch in OO-Programmierung, und ich finde es sauberer als schreibt dispatch-Logik in einer Art 'master' first () - Funktion, die monoton ist und spröde Erweiterung.

Frage: fügen Sie eine andere Methode wie A. first(arg).

Wahrscheinlich werden Sie eine Menge lernen über die python-Typ-system, wenn Sie versuchen, dies zu tun!

#!/opt/local/bin/python3.4

from functools import singledispatch;

class A(object):

    # default method handles dispatch for undefined types
    # note reversed positional args to match single dispatch functools
    @singledispatch
    def _first(self,arg):
        raise TypeError("no match for A._first(%s)" % type(arg));

    # adapter maps instance call to (reversed) static method call
    def first(self, arg = None): return A._first(arg, self);

    # def first()
    @_first.register(type(None))
    def _(self,none):
        print("A.first() called");

    # def first(float f)
    @_first.register(float)
    def _(self,f):
        print("A.first(float %s) called" % f);

a = A();
a.first();              # A.first() called
a.first(None);          # A.first() called
a.first(3.14);          # A.first(float 3.14) called

class B(object): pass;
b = B();                
try: a.first(b);        # no match for A._first(<class '__main__.B'>)
except TypeError as ex: print(ex);

Sie sind gut ! gutes Beispiel
Oh, das ist clever 🙂

InformationsquelleAutor Nate

0

Python ist nicht C++ oder Java; Sie können nicht überladen Methoden in der gleichen Weise.

Wirklich, der einzige Weg, das zu tun, was Sie wollen, ist der test für das Vorhandensein oder fehlen des zweiten Parameters:
```
class A:
   def first(self, f=None):
      if f is None:
         print 'first method'
      else:
         print 'first met',f
```
Können Sie noch mehr anspruchsvolle und überprüfen Sie die Art des f aber das kann gefährlich sein, und nicht immer ist "pythonic". (Es sollte jedoch erwähnt werden, dass ein Anwendungsfall für Funktion Anmerkungen in Python 3 ist es, diese Art der "Generische Programmierung".)

InformationsquelleAutor Andrew Jaffe

Während es möglich ist, ein system zu schaffen, das angezeigt wird, um überladene Methoden, es ist ein wenig beteiligt, und in der Regel nicht erforderlich.

Das übliche idiom ist, um eventuell nicht benötigte Parameter standardmäßig auf None etwa so:

class A:
    def first(self, f=None):
        if f is None:
            print 'first method'
        else:
            print 'first met',f

In Ihrem Fall, wo Sie wollen, Verhalten sich anders, je nachdem, ob oder nicht ist dies der erste Aufruf der Methode, das ist, was ich tun würde:

class A:
    def first(self):
        print 'first method'
        self.first = self._first
    def _first(self, f):                   # '_' is convention for private name
        print 'first met',f

und Beispiel-Ausgabe:

a = A()
a.first()
a.first(3)

Drucke:

first method
first met 3

InformationsquelleAutor Ethan Furman

Überprüfen Sie diesen code, wenn es hilfreich ist:

from math import pi

class Geometry:

    def area(self,length = None,breadth = None,side = None,radius = None):
        self.length = length
        self.breadth = breadth
        self.side = side
        self.radius = radius

        if length != None and breadth != None:
            return length * breadth
        elif side != None:
            return side * side
        else:
            return pi * radius * radius

obj1 = Geometry()
print('Area of rectangle is {0}.'.format(obj1.area(length=5,breadth=4)))
print('Area of square is {0}.'.format(obj1.area(side=5)))
print('Area of circle is {0:.6}.'.format(obj1.area(radius=10)))

Die Frage ist, über die Methode überladen in python.

InformationsquelleAutor dhaval.soni195

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.