Python'da yöntem aşırı yüklemesini nasıl kullanabilirim?

Python yöntem aşırı yükleme uygulamak çalışıyorum:

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

ob=A()
ob.stackoverflow(2)

ancak çıktı second method 2; benzer şekilde:

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

ob=A()
ob.stackoverflow()

verir

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

Bunu nasıl yapabilirim?

It yöntemi aşırı yükleme yöntemi değildir basan . Ve Python'da hepsini tek bir işlevde yaparsınız:

class A:

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

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

Python'da aynı ada sahip iki yönteminiz olamaz ve buna gerek yoktur.

Bkz Standart Argüman Değerler Python öğretici bölümüne. Kaçınılması gereken yaygın bir hata için "En Küçük Şaşkınlık" ve Değişken Varsayılan Argüman'a bakınız .

Düzenleme : Python 3.4'teki yeni tek dağıtım genel işlevleri hakkında bilgi için PEP 443'e bakın .

Ayrıca pythonlangutil kullanabilirsiniz :

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

Python'da işleri böyle yapmazsınız. İnsanlar bunu Java gibi dillerde yaptığında, genellikle varsayılan bir değer ister (istemezlerse, genellikle farklı bir ada sahip bir yöntem ister). Yani, Python'da varsayılan değerlere sahip olabilirsiniz .

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'

Gördüğünüz gibi, sen yapabilirsiniz sadece bir varsayılan değer olan yerine farklı davranışa tetiklemek için kullanacağız.

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

Yapamazsınız, asla gerek yoktur ve gerçekten istemezsiniz.

Python'da her şey bir nesnedir. Sınıflar bir şeydir, yani nesnelerdir. Yöntemler de öyle.

ABir sınıf olan bir nesne var . Adlı bir özniteliği vardır stackoverflow. Böyle bir niteliğe sahip olabilir.

Yazdığınızda def stackoverflow(...): ..., yöntem olan bir nesne oluşturmanız ve nesnesinin stackoverflowniteliğine atamanız gerekir A. İki tanım yazarsanız, ikincisi ödevin yerine geçer, ödev her zamanki gibi.

Ayrıca, aşırı yüklenmenin bazen için kullanıldığı şeyleri daha vahşi yapan kod yazmak istemezsiniz. Dil böyle çalışmaz.

Verilebilecek her bir şey türü için ayrı bir işlev tanımlamaya çalışmak yerine (işlev parametreleri için türler belirtmediğiniz için çok az mantıklıdır), şeylerin ne olduğu konusunda endişelenmeyi bırakın ve yapabilecekleri hakkında düşünmeye başlayın .

Bir listeyi ve bir listeyi işlemek için sadece ayrı bir tane yazamazsınız, aynı zamanda istemek veya istemek de gerekmez .

Tek yaptığınız, her ikisinin de örneğin yinelenebilir (yani yazabilirsiniz for element in container:) olmasından yararlanmaktır . (Kalıtımla doğrudan ilişkili olmamaları önemsizdir.)

@Agf geçmişte PEP-3124 ile doğru cevap verirken sözdizimi şekeri aldık. Dekoratörle ilgili ayrıntılar için yazım belgelerine bakın , @overloadancak bunun gerçekten sadece sözdizimi şekeri olduğunu ve IMHO'nun o zamandan beri tartıştığı tüm insanlar olduğunu unutmayın. Şahsen ben farklı imzalara sahip birden fazla işlevi olan daha sonra 20+ argümanlar varsayılan bir değere tüm seti (tek bir fonksiyona sahip daha okunaklı hale getirir konusunda hemfikir Nonesonsuz kullanarak uğraşmak zorunda ardından çoğu zaman) ve if, elif, elseöğrenmek için zincirleri neyi arayan aslında fonksiyonumuzun sunulan argüman setiyle ilgili olmasını ister. Bu Python Zen'den sonra gecikmişti

Güzel, çirkin olmaktan iyidir.

ve tartışmasız olarak

Basit, karmaşık olmaktan iyidir.

Doğrudan bağlantılı resmi Python belgelerinden:

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>

Cevabımı Python 3.2.1'de yazıyorum.

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

Nasıl çalışır:

1. overloadherhangi bir miktarda callables alır ve bunları demet halinde saklar functions, sonra lambda döndürür.
2. Lambda herhangi bir miktarda argüman alır, sonra functions[number_of_unnamed_args_passed]lambda'ya iletilen argümanlar ile çağrılan çağrı işlevinin sonucunu döndürür .

Kullanımı:

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

Bence aradığınız kelime "aşırı". Python'da aşırı yükleme yöntemi yoktur. Ancak, varsayılan bağımsız değişkenleri aşağıdaki gibi kullanabilirsiniz.

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

Bir argüman ilettiğinizde, ilk koşulun mantığını izler ve ilk print deyimini yürütür. Hiçbir argüman ilettiğinizde, elsekoşula gider ve ikinci print deyimini yürütür.

Cevabımı Python 2.7'de yazıyorum:

Python'da yöntem aşırı yüklenmesi mümkün değildir; farklı işlevlerle aynı işleve gerçekten erişmek istiyorsanız, yöntem geçersiz kılmayı tercih etmenizi öneririm.

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

Python'da aşırı yükleme uygulanan bir kavram değildir. Bununla birlikte, örneğin, bir tür bağımsız değişkenini ve bir tür foobağımsız değişkeni için başka bir başlatıcıyı geçtiyse bir başlatıcı gerçekleştirilmesini istediğiniz bir durum oluşturmaya çalışıyorsanız bar, Python'daki her şey nesne olarak ele alındığından, iletilen nesnenin sınıf türünün adı ve buna dayalı koşullu işlem yazma.

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

Bu kavram, gerektiğinde farklı yöntemlerle birden fazla farklı senaryoya uygulanabilir.

Python'da bunu varsayılan bir argümanla yaparsınız.

class A:

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

İlgilenebilecek herkes için bu https://github.com/bintoro/overloading.py ile karşılaştım .

Bağlantılı deponun benioku dosyasından:

aşırı yükleme, çalışma zamanı argümanlarının türlerine ve sayısına göre işlev gönderilmesini sağlayan bir modüldür.

Aşırı yüklenmiş bir işlev çağrıldığında, dağıtım programı sağlanan bağımsız değişkenleri kullanılabilir işlev imzalarıyla karşılaştırır ve en doğru eşleşmeyi sağlayan uygulamayı çağırır.

Özellikleri

Kayıt sırasında işlev doğrulaması ve ayrıntılı çözümleme kuralları çalışma zamanında benzersiz, iyi tanımlanmış bir sonucu garanti eder. Mükemmel performans için işlev çözünürlüğü önbelleği uygular. İşlev imzalarında isteğe bağlı parametreleri (varsayılan değerler) destekler. En iyi eşleşmeyi çözerken hem konumsal hem de anahtar kelime bağımsız değişkenlerini değerlendirir. Yedek fonksiyonları ve paylaşılan kodun yürütülmesini destekler. Argüman polimorfizmini destekler. Sınıf yöntemleri ve statik yöntemler dahil olmak üzere sınıfları ve kalıtımı destekler.

Python, Java veya C ++ gibi aşırı yükleme yöntemini desteklemez. Yöntemleri aşırı yükleyebiliriz, ancak yalnızca en son tanımlanan yöntemi kullanabiliriz.

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

Arama sırasında farklı sayıda bağımsız değişken sağlamak için isteğe bağlı bağımsız değişkenler veya * bağımsız değişkenler sağlamalıyız.

Https://www.geeksforgeeks.org/python-method-overloading/ adresinden nezaket

Python 3.x, @overload dekoratör kullanılarak yöntem aşırı yüklenmesine izin veren standart yazma kütüphanesini içerir. Ne yazık ki, bu kodu daha okunabilir kılmaktır, çünkü @overload dekore edilmiş yöntemlerin farklı argümanları işleyen dekore edilmemiş bir yöntem izlemesi gerekecektir. Daha fazlasını burada bulabilirsiniz, ancak örneğiniz için:

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)

MathMethod.py dosyasında

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

Main.py dosyasında

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

Multipledispatch kullanarak yöntemi aşırı yükleyebiliriz

Python , sadece üzerine yazma ile çalışmak yerine, tip denetimi yoluyla aşırı yükleme için sözdizimsel şeker sağlamak için @ overload dekoratörünü PEP-3124 ile ekledi .

PEP-3124'ten @overload üzerinden aşırı yükleme ile ilgili kod örneği

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

@ aşırı yük dekoratörü tarafından şu şekilde dönüştürülür:

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