Как использовать перегрузку методов в Python?

Я пытаюсь реализовать перегрузку метода в Python:

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

ob=A()
ob.stackoverflow(2)

но выход есть second method 2; так же:

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

ob=A()
ob.stackoverflow()

дает

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

Как мне сделать эту работу?

Это перегрузка метода, а не переопределение метода . А в Python вы делаете все это в одной функции:

class A:

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

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

Вы не можете иметь два метода с одинаковым именем в Python - и вам это не нужно.

Смотрите раздел Значения аргумента по умолчанию в руководстве по Python. См. «Наименьшее изумление» и изменяемый аргумент по умолчанию, чтобы избежать распространенной ошибки.

Редактировать : См. PEP 443 для получения информации о новых универсальных функциях единой диспетчеризации в Python 3.4.

Вы также можете использовать 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

В Python вы так не делаете. Когда люди делают это на таких языках, как Java, они обычно хотят получить значение по умолчанию (если они этого не делают, они обычно хотят метод с другим именем). Таким образом, в Python вы можете иметь значения по умолчанию .

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'

Как видите, вы можете использовать это для запуска отдельного поведения, а не просто для использования значения по умолчанию.

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

Вы не можете, никогда не должны и не хотите этого.

В Python все является объектом. Классы - это вещи, поэтому они являются объектами. Как и методы.

Существует объект с именем, Aкоторый является классом. У него есть атрибут с именем stackoverflow. У него может быть только один такой атрибут.

Когда вы пишете def stackoverflow(...): ..., происходит то, что вы создаете объект, который является методом, и назначаете его stackoverflowатрибуту A. Если вы пишете два определения, второе заменяет первое, так же, как присваивание всегда ведет себя.

Кроме того, вы не хотите писать код, который делает самые разные вещи, для которых иногда используется перегрузка. Это не так, как работает язык.

Вместо того, чтобы пытаться определить отдельную функцию для каждого типа вещей, которые вам могут дать (что в любом случае не имеет смысла, поскольку вы не указываете типы для параметров функции), перестаньте беспокоиться о том, что это такое , и начните думать о том, что они могут сделать .

Вы не только не можете написать отдельный для обработки кортеж против списка, но и не хотите или не должны .

Все, что вы делаете, это пользуетесь тем фактом, что они оба, например, итеративны (то есть вы можете писать for element in container:). (Тот факт, что они не имеют прямого отношения к наследованию, не имеет значения.)

Хотя @agf был прав с ответом в прошлом, теперь с PEP-3124 мы получили наш синтаксический сахар. См. Печатную документацию для получения подробной информации о @overloadдекораторе, но обратите внимание, что это на самом деле просто синтаксический сахар, и ИМХО, это все, о чем люди спорят с тех пор. Лично я согласен , что наличие нескольких функций с разными подписями делает его более удобным для чтения , то имея одну функции с аргументами 20+ всех заданного значения по умолчанию ( Noneбольшую часть времени) , а затем необходимости возиться с помощью бесконечных if, elif, elseцепей , чтобы выяснить , какие вызывающая сторона на самом деле хочет, чтобы наша функция работала с предоставленным набором аргументов. Это было давно пора после Python Zen

Красиво лучше, чем безобразно.

и, возможно, также

Простое лучше, чем сложное.

Прямо из официальной документации по Python, указанной выше:

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>

Я пишу свой ответ на Python 3.2.1.

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

Как это устроено:

1. overloadпринимает любое количество вызываемых элементов и сохраняет их в кортеже functions, а затем возвращает лямбду.
2. Лямбда принимает любое количество аргументов, а затем возвращает результат вызова функции, хранящейся в functions[number_of_unnamed_args_passed]вызываемой, с аргументами, передаваемыми в лямбду.

Использование:

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

Я думаю, что слово, которое вы ищете, это «перегрузка». В питоне нет перегрузки методов. Однако вы можете использовать аргументы по умолчанию следующим образом.

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

Когда вы передаете ему аргумент, он будет следовать логике первого условия и выполнять первый оператор печати. Когда вы передадите ему аргументы без аргументов, он перейдет в elseусловие и выполнит второй оператор print.

Я пишу свой ответ на Python 2.7:

В Python перегрузка методов невозможна; если вы действительно хотите получить доступ к одной и той же функции с различными функциями, я предлагаю вам перейти к переопределению метода.

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 перегрузка не является прикладной концепцией. Однако, если вы пытаетесь создать случай, когда, например, вы хотите, чтобы один инициализатор выполнялся, если передан аргумент типа, fooи другой инициализатор для аргумента типа bar, так как все в Python обрабатывается как объект, вы можете проверить имя типа класса переданного объекта и запись условной обработки, основанной на этом.

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

Эта концепция может быть применена к нескольким различным сценариям с помощью различных методов по мере необходимости.

В Python вы бы сделали это с аргументом по умолчанию.

class A:

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

Просто наткнулся на этот https://github.com/bintoro/overloading.py для всех, кому это может быть интересно.

Из readme связанного репозитория:

Перегрузка - это модуль, который обеспечивает диспетчеризацию функций на основе типов и количества аргументов времени выполнения.

Когда вызывается перегруженная функция, диспетчер сравнивает предоставленные аргументы с доступными сигнатурами функций и вызывает реализацию, которая обеспечивает наиболее точное соответствие.

Характеристики

Проверка функций при регистрации и подробные правила разрешения гарантируют уникальный, четко определенный результат во время выполнения. Реализует кэширование разрешения функции для отличной производительности. Поддерживает необязательные параметры (значения по умолчанию) в сигнатурах функций. Оценивает как позиционные, так и ключевые аргументы при поиске наилучшего соответствия. Поддерживает резервные функции и выполнение общего кода. Поддерживает аргумент полиморфизм. Поддерживает классы и наследование, в том числе методы класса и методы static.

Python не поддерживает перегрузку методов, как Java или C ++. Мы можем перегружать методы, но можем использовать только последний определенный метод.

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

Нам нужно предоставить необязательные аргументы или * args, чтобы предоставить различное количество аргументов при вызове.

Предоставлено https://www.geeksforgeeks.org/python-method-overloading/

Python 3.x включает в себя стандартную библиотеку типов, которая позволяет перегружать методы с помощью декоратора @overload. К сожалению, это должно сделать код более читабельным, так как за декорированными методами @overload должен следовать не декорированный метод, который обрабатывает разные аргументы. Больше можно найти здесь, но для вашего примера:

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

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

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

Мы можем перегрузить метод с помощью multipledispatch

Python добавил декоратор @overload с PEP-3124, чтобы обеспечить синтаксический сахар для перегрузки с помощью проверки типов - вместо того, чтобы просто работать с перезаписью.

Пример кода по перегрузке через @overload из 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

преобразуется @ overload-decorator в:

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