Înțelegerea supraîncărcării funcțiilor în Python

Supraîncărcarea funcțiilor este o caracteristică din unele limbaje de programare care vă permite să definiți variații ale aceleiași funcții. Fiecare variantă are același nume, dar implementări diferite, cu semnături unice de funcție.

Această tehnică vă permite să efectuați diferite operații în funcție de tipul și numărul de argumente transmise unei funcții.

Spre deosebire de limbaje precum C++ și Java, Python nu acceptă supraîncărcarea funcțiilor în mod implicit, dar există modalități de a obține o funcționalitate similară.

Cuprins

Cum gestionează Python supraîncărcarea funcției?

În Python, puteți defini aceeași funcție de mai multe ori cu diferiți parametri, tipuri de date sau ambele în fiecare definiție. Cu toate acestea, Python va recunoaște doar ultima definiție a funcției atunci când o apelați. Iată un exemplu:

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

Limbile orientate pe obiecte, cum ar fi Java, suportă adesea supraîncărcarea funcțiilor și metodelor. O metodă este pur și simplu o funcție pe care o definiți în interiorul unei clase.

În codul de mai sus, Python va recunoaște doar a doua definiție a funcției aritmetică() atunci când încercați să o apelați în proiectul dvs. Dacă încercați să apelați funcția cu două argumente așa cum au fost definite mai întâi, veți obține o eroare care spune „lipsesc argumentele poziționale necesare”.

Nu veți primi o eroare când apelați funcția cu patru argumente. Aceasta înseamnă că Python a suprascris funcția cu cea mai recentă instanță. Acesta nu este comportamentul supraîncărcării, așa că trebuie să îl rezolvați.

Astra Pentest revizuit – Scanare ușoară și continuă a vulnerabilităților și conformitate

Deci, Python nu se ocupă de supraîncărcarea funcțiilor în mod implicit, dar există câteva trucuri pe care le puteți folosi pentru a simula comportamentul său în programele dumneavoastră.

Metoda 1: Utilizarea parametrilor opționali sau a argumentelor implicite

Puteți obține supraîncărcare definind o funcție cu argumente implicite. Iată un exemplu:

 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

Această funcție are trei parametri, dar doi dintre ei au valori implicite. Aceasta înseamnă că îl puteți apela cu între unul și trei argumente:

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

Deși această abordare vă permite să apelați funcția în mai multe moduri diferite, nu este foarte eficientă pe termen lung. Iată câteva dintre limitările sale:

Puteți transmite doar argumente care sunt fie numere întregi, fie flotanți.
Nu există nicio schimbare semnificativă în comportamentul funcției. De exemplu, nu îi puteți modifica comportamentul pentru a calcula aria unei forme sau chiar pentru a imprima Hello World.

Metoda 2: Utilizarea argumentelor variabile

Pentru a utiliza argumente variabile pentru supraîncărcarea funcției în Python, ar trebui să includeți parametrul args atunci când definiți funcția. Parametrul args vă permite să transmiteți mai multe argumente poziționale atunci când vă apelați funcția. Iată un exemplu:

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

Funcția de mai sus ia două argumente: un argument obligatoriu numit a și argumentul args, care vă permite să introduceți câte argumente aveți nevoie.

Economisiți timp și bani cu semnăturile digitale

Deși poate lua mai multe argumente, funcția de mai sus poate efectua numai operația de multiplicare pe argumentele variabile, adică argumentele reprezentate de cuvântul cheie args.

Dacă doriți să efectuați mai multe operații, trebuie să introduceți instrucțiuni condiționale în codul dvs., iar acest lucru se poate complica rapid.

Metoda 3: Utilizarea decoratorului de expediere multiplă

Decoratorul de expediere multiplă este o bibliotecă Python care vă permite să definiți mai multe implementări sau instanțe ale unei singure funcții, în funcție de tipul argumentelor acesteia. Aceasta înseamnă că puteți defini aceeași funcție cu diferite tipuri de date și puteți modifica complet comportamentul acesteia.

Pentru a utiliza decoratorul de expediere multiplă, urmați acești pași:

Instalați multipledispath în mediul dvs. Python:

 pip install multipledispatch

Decorează-ți funcția(ele) cu decoratorul @dispatch. Decoratorul @dispatch este un decorator Python care vă permite să implementați dispecerele multiple. Acesta va trimite automat funcția corespunzătoare pe baza argumentelor pe care i le transmiteți. Puteți folosi decoratorul @dispatch urmând acest model:

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

Iată un exemplu care utilizează decoratorul de expediere multiplă pentru supraîncărcarea funcțiilor în Python:

 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']))

Fragmentul de cod de mai sus definește două instanțe ale funcției add(). Prima instanță ia ca argumente două numere întregi și returnează suma lor.

Ce este o diagramă UML și cum se creează una [7 Tools]?

Între timp, a doua versiune a acestei funcții include un întreg și o listă. Acesta adaugă întregul la listă și returnează noua listă.

Această abordare a supraîncărcării funcțiilor în Python vă oferă multă flexibilitate, mai ales dacă trebuie să schimbați comportamentul metodei. Puteți afla mai multe de la documentație de expediere multiplă.

Cea mai bună abordare față de supraîncărcarea funcției în Python

Abordarea pe care o luați pentru supraîncărcarea funcțională ar trebui să depindă de ceea ce încercați să realizați. Dacă vă puteți finaliza sarcina folosind argumente implicite sau variabile, atunci decoratorul de expediere multiplă ar putea fi exagerat. Cu toate acestea, decoratorul de expediere multiplă este de obicei cea mai bună opțiune pentru eficiența și acuratețea sa.

Acest decorator oferă o modalitate curată și flexibilă de a implementa supraîncărcarea funcțiilor în Python. Vă permite să definiți mai multe implementări ale unei singure funcții în funcție de tipul argumentelor acesteia.

Cu această abordare, puteți crea funcții flexibile care pot accepta diferite tipuri de parametri fără a fi nevoie de instrucțiuni condiționale complexe.