Funcții în Python: Cum să apelezi și să scrii funcții

Argumente implicite

Argumentele implicite sunt acelea care iau o valoare prestabilită dacă nu este transmisă nicio valoare a argumentului în timpul apelului funcției. Poți atribui această valoare implicită cu operatorul de atribuire =, exact ca în exemplul următor:

Argumente obligatorii

După cum sugerează și numele, argumentele obligatorii ale unui UDF sunt acelea care trebuie să fie prezente. Aceste argumente trebuie transmise în timpul apelului funcției și în exact ordinea corectă, exact ca în exemplul următor:

Ai nevoie de argumente care să corespundă parametrilor a și b ca să apelezi funcția fără să primești erori. Dacă inversezi a și b, rezultatul nu va fi diferit, dar ar putea fi dacă schimbi plus() astfel:

Argumente cuvânt-cheie

Dacă vrei să te asiguri că apelezi toți parametrii în ordinea corectă, poți folosi argumentele cuvânt-cheie în apelul funcției. Le folosești pentru a identifica argumentele după numele parametrilor. Să luăm exemplul de mai sus pentru a clarifica puțin:

Observă că folosind argumentele cuvânt-cheie, poți de asemenea să inversezi ordinea parametrilor și tot să obții același rezultat când execuți funcția:

Număr variabil de argumente

În cazurile în care nu știi numărul exact de argumente pe care vrei să le transmiți unei funcții, poți folosi următoarea sintaxă cu *args:

Asteriscul (*) este plasat înaintea numelui variabilei care reține valorile tuturor argumentelor variabile fără cuvânt-cheie. Observă aici că ai fi putut la fel de bine să transmiți *varint, *var_int_args sau orice alt nume funcției plus().

Sfat: încearcă să înlocuiești *args cu un alt nume care include asteriscul. Vei vedea că codul de mai sus continuă să funcționeze!

Vezi că funcția de mai sus folosește funcția încorporată Python sum() pentru a aduna toate argumentele transmise lui plus().

Variabile globale vs. locale

În general, variabilele definite în interiorul corpului unei funcții au un domeniu local, iar cele definite în afară au un domeniu global. Asta înseamnă că variabilele locale sunt definite în interiorul unui bloc de funcție și pot fi accesate doar în acea funcție, în timp ce variabilele globale pot fi accesate de toate funcțiile care ar putea fi în scriptul tău:

Vei vedea că vei primi un NameError care spune că name 'total' is not defined când încerci să afișezi variabila locală total care a fost definită în interiorul corpului funcției. Variabila init, pe de altă parte, poate fi afișată fără probleme.

Parametri doar poziționali și doar cuvânt-cheie

Din Python 3.8, poți controla mai bine cum trebuie transmise argumentele folosind doi marcatori speciali în semnătura funcției: / și *. Orice se află înainte de / poate fi transmis doar pozițional; orice se află după * poate fi transmis doar prin cuvânt-cheie.

def greet(name, /, greeting="Hello", *, punctuation="!"):
    print(f"{greeting} {name}{punctuation}")

 Iată cum se vede asta la apel:

greet("Alice")                          # works
greet("Alice", greeting="Hi")           # works
greet("Alice", "Hi", punctuation="?")   # works

greet(name="Alice")                     # TypeError: name is positional-only
greet("Alice", "Hi", "?")               # TypeError: punctuation is keyword-only

De ce ai vrea asta? Două motive principale.

În primul rând, parametrii doar poziționali îți permit să le schimbi numele mai târziu fără a strica codul cuiva — din moment ce nimeni nu are voie să folosească numele parametrului ca și cuvânt-cheie, ești liber să îl schimbi.

În al doilea rând, parametrii doar cuvânt-cheie îi obligă pe apelanți să fie expliciți cu privire la ce transmit, ceea ce face apelurile mai lizibile când ai mai multe opțiuni sau setări opționale.

Pe scurt, sunt o modalitate curată de a impune intenția.

Funcții anonime în Python

Funcțiile anonime sunt numite și funcții lambda în Python pentru că, în loc să le declari cu cuvântul-cheie standard def, folosești cuvântul-cheie lambda.

În blocul DataCamp Light de mai sus, lambda x: x*2 este funcția anonimă sau lambda. x este argumentul, iar x*2 este expresia sau instrucțiunea care este evaluată și returnată. Ce este special la această funcție este că nu are nume, spre deosebire de exemplele pe care le-ai văzut în prima parte a acestui tutorial despre funcții. Dacă ar trebui să scrii funcția de mai sus ca UDF, rezultatul ar fi următorul:

def double(x):
  return x*2

Hai să analizăm un alt exemplu de funcție lambda în care lucrezi cu două argumente:

Folosești funcții anonime când ai nevoie de o funcție fără nume pentru o perioadă scurtă de timp și care este creată la rulare. Contexte specifice în care asta ar fi relevant sunt când lucrezi cu filter(), map() și reduce():

Funcția filter() filtrează, așa cum sugerează și numele, lista de intrare originală my_list pe baza unui criteriu >10. Cu map(), pe de altă parte, aplici o funcție tuturor elementelor listei my_list. În acest caz, înmulțești toate elementele cu 2.

Observă că funcția reduce() face parte din biblioteca functools. Folosești această funcție cumulativ asupra elementelor listei my_list, de la stânga la dreapta, și reduci secvența la o singură valoare, 55, în acest caz.

Folosirea lui main() ca funcție în Python

Dacă ai vreo experiență cu alte limbaje de programare precum Java, știi că funcția main este necesară pentru a executa funcții. După cum ai văzut în exemplele de mai sus, asta nu este neapărat necesar în Python. Totuși, includerea unei funcții main() în programul tău Python poate fi utilă pentru a-ți structura codul logic — toate componentele cele mai importante sunt conținute în această funcție main().

Poți defini ușor o funcție main() și să o apelezi exact cum ai făcut cu toate celelalte funcții de mai sus:

Totuși, așa cum este acum, codul funcției tale main() va fi apelat când o imporți ca modul. Ca să te asiguri că asta nu se întâmplă, apelezi funcția main() când __name__ == '__main__'.

Asta înseamnă că codul din fragmentul de cod de mai sus devine:

Notă că pe lângă funcția __main__, ai și o funcție __init__ care inițializează o instanță a unei clase sau un obiect. Pe scurt, acționează ca un constructor sau inițializator și este apelată automat când creezi o nouă instanță a unei clase. Cu acea funcție, obiectul nou creat este atribuit parametrului self, pe care l-ai văzut mai devreme în acest tutorial. Aruncă o privire la următorul exemplu:

class Dog:
    """A simple Dog class.

    Args:
        legs: Number of legs so that the dog can walk.
        color: The color of the fur.
    """

    def __init__(self, legs: int, color: str) -> None:
        self.legs = legs
        self.color = color

    def bark(self) -> str:
        return "bark" * 2

if __name__ == "__main__":
    dog = Dog(4, "brown")
    print(dog.bark())