Pochopení přetížení funkcí v Pythonu

Přetěžování funkcí je funkce v některých programovacích jazycích, která umožňuje definovat varianty stejné funkce. Každá varianta má stejný název, ale různé implementace s jedinečnými podpisy funkcí.

Tato technika umožňuje provádět různé operace na základě typu a počtu argumentů předávaných funkci.

Na rozdíl od jazyků jako C++ a Java Python ve výchozím nastavení nepodporuje přetěžování funkcí, ale existují způsoby, jak dosáhnout podobné funkčnosti.

Jak Python zvládá přetížení funkcí?

V Pythonu můžete stejnou funkci definovat více než jednou s různými parametry, datovými typy nebo obojím v každé definici. Python však rozpozná pouze poslední definici funkce, když ji zavoláte. Zde je příklad:

 def arithmetics(a, b):
    return a - b
def arithmetics(a, b, c, d):
    return a + b - c * d
print(arithmetics(1, 2, 3, 5)) 
print(arithmetics(1, 2)) 
 

Objektově orientované jazyky, jako je Java, často podporují přetěžování funkcí a metod. Metoda je jednoduše funkce, kterou definujete uvnitř třídy.

Ve výše uvedeném kódu Python rozpozná druhou definici funkce aritmetika() pouze tehdy, když se ji pokusíte volat ve svém projektu. Pokud se pokusíte volat funkci se dvěma argumenty, jak byly definovány jako první, dostanete chybu, která říká „chybějící požadované poziční argumenty“.

Při volání funkce se čtyřmi argumenty se neobjeví chyba. To znamená, že Python přepsal funkci její nejnovější instancí. Toto není chování přetížení, takže to musíte řešit.

Python tedy ve výchozím nastavení nezvládá přetížení funkcí, ale existuje několik triků, které můžete použít k simulaci jeho chování ve vašich programech.

Metoda 1: Použití volitelných parametrů nebo výchozích argumentů

Přetížení můžete dosáhnout definováním funkce s výchozími argumenty. Zde je příklad:

 def arithmetics(a, b=0, c=0):
    """
    Arguments:
    a: The first number.
    b: The second number (optional).
    c: The third number (optional).
    """
    return a - b + c

Tato funkce má tři parametry, ale dva z nich mají výchozí hodnoty. To znamená, že jej můžete volat s jedním až třemi argumenty:

 print(arithmetics(1)) 
print(arithmetics(2, 5)) 
print(arithmetics(10, 3, 4)) 

Ačkoli tento přístup umožňuje volat funkci několika různými způsoby, není z dlouhodobého hlediska příliš efektivní. Zde jsou některá z jeho omezení:

• Můžete předat pouze argumenty, které jsou buď celá čísla nebo plovoucí čísla.
• V chování funkce nedochází k žádné výrazné změně. Nemůžete například změnit jeho chování pro výpočet plochy tvaru nebo dokonce vytisknout Hello World.

Metoda 2: Použití proměnných argumentů

Chcete-li použít proměnné argumenty pro přetížení funkcí v Pythonu, měli byste při definování funkce zahrnout parametr args. Parametr args vám umožňuje předat více pozičních argumentů při volání vaší funkce. Zde je příklad:

 def arithmetics(a, *args):
    """
    Arguments:
    a: The first number.
    *args: A variable number of arguments (optional).
    """
    args_sum = 0
    for num in args:
        args_sum *= num
    return a - args_sum
print(arithmetics(1)) 
print(arithmetics(2, 5)) 
print(arithmetics(10, 3, 4, 2, 4, 6)) 
 

Výše uvedená funkce používá dva argumenty: povinný argument zvaný a a argument args, který vám umožňuje zadat tolik argumentů, kolik potřebujete.

Ačkoli může trvat více argumentů, výše uvedená funkce může provádět operaci násobení pouze s proměnnými argumenty, tj. s argumenty reprezentovanými klíčovým slovem args.

Pokud chcete provádět více operací, musíte do kódu zavést podmíněné příkazy, což se může rychle zkomplikovat.

Metoda 3: Použití dekorátoru pro více odeslání

Dekorátor vícenásobného odeslání je knihovna Pythonu, která vám umožňuje definovat více implementací nebo instancí jedné funkce na základě typu jejích argumentů. To znamená, že můžete definovat stejnou funkci s různými datovými typy a zcela změnit její chování.

Chcete-li použít dekorátor pro vícenásobné odeslání, postupujte takto:

 pip install multipledispatch

 from multipledispatch import dispatch
@dispatch(data type1, data type2, data typeX)
def your_function(a, b, c, x):
    pass
    
 

Zde je příklad, který používá dekorátor vícenásobného odeslání pro přetížení funkcí v Pythonu:

 from multipledispatch import dispatch
@dispatch(int, int)
def add(a, b):
    """
    Arguments:
    a: Any integer.
    b: Any integer.
    """
    return a + b
@dispatch(int, list)
def add(a, b):
    """
    Arguments:
    a: Any integer.
    b: Any Python list.
    """
    b.append(a)
    return b

print(add(1, 2))

print(add(1, [2, 3, 4, 5, 'w', 'done']))
 

Výše uvedený fragment kódu definuje dvě instance funkce add(). První instance bere jako argumenty dvě celá čísla a vrací jejich součet.

Mezitím druhá verze této funkce přijímá celé číslo a seznam. Připojí celé číslo k seznamu a vrátí nový seznam.

Tento přístup k přetěžování funkcí v Pythonu vám poskytuje velkou flexibilitu, zejména pokud potřebujete změnit chování vaší metody. Více se můžete dozvědět z vícenásobná expediční dokumentace.

Nejlepší přístup k přetížení funkcí v Pythonu

Přístup k přetížení funkcí by měl záviset na tom, čeho se snažíte dosáhnout. Pokud můžete dokončit svůj úkol pomocí výchozích nebo proměnných argumentů, může být dekorátor vícenásobného odeslání přehnaný. Vícenásobný dekoratér je však obvykle nejlepší volbou pro svou účinnost a přesnost.

Tento dekorátor poskytuje čistý a flexibilní způsob, jak implementovat přetížení funkcí v Pythonu. Umožňuje definovat více implementací jedné funkce na základě typu jejích argumentů.

S tímto přístupem můžete vytvářet flexibilní funkce, které mohou přijímat různé typy parametrů bez nutnosti složitých podmíněných příkazů.