Függvények ebben a kurzusban:

A(z) Függvények fogalomról

A function egy szervezett, újrahasznosítható kódrész, amely egy meghatározott feladat elvégzésére szolgál. A Functions jobb modularitást biztosítanak az alkalmazásodnak, és nagymértékű kódréhasznosítást tesznek lehetővé. A Pythonnak, mint más programozási nyelveknek, vannak beépített függvényei (print, map és így tovább), amelyek azonnal elérhetők. Saját függvényeket is definiálhatsz. Ezeket user-defined functions néven ismerjük. A függvények olyan egyszerű dolgot is csinálhatnak, mint üzenet kiírása a konzolra, de akár egészen összetettek is lehetnek.

Egy függvény belsejében lévő kód végrehajtásához meg kell hívnod a függvényt: ilyenkor a függvény nevét írod le, utána pedig egy zárójelpárt [()]. Adatokat, amelyeket arguments néven ismerünk, úgy adhatsz át a függvénynek, hogy a zárójelek közé teszed őket. Egy függvénydefinícióban nulla vagy több parameters szerepelhet. A parameters határozza meg, milyen argumentumokat fogad el a függvény. Egy paraméter határozza meg, milyen típusú argumentumot kell átadni. Az argumentum a tényleges érték, amelyet a függvény meghívásakor adunk át. A függvények különböző feladatokat láthatnak el attól függően, milyen argumentumokat adunk át a paramétereknek.

Egy függvény a return kulcsszóval értéket is visszaadhat. A függvény által visszaadott értéket return value-nak nevezzük. A visszatérési érték a függvény hívójához kerül vissza.

Létrehozás

A Pythonban a függvényeket a def kulcsszóval hozzuk létre. A függvénydefiníciót a függvény neve és egy zárójelpár [()] követi. A zárójelek között adod meg a paramétereket, vesszővel elválasztva. A csukó zárójel után a kettőspont (:) választja el a függvény szignatúráját a függvény törzsétől.

A függvény törzse egy kódblokk, amely a függvény hívásakor fut le. A függvény törzsét be kell húzni. A behúzás fontos, mert a Python ebből tudja, hol ér véget a kódblokk. A függvényből a return kulcsszóval adhatsz vissza értéket, amelyet aztán a függvény hívója felhasználhat.

def function_name(parameter1, parameter2, ...):
    # function body
    return parameter1 + parameter2

Definiálhatsz függvényt paraméterek és visszatérési érték nélkül is.

def function_name():
    # function body
    pass

Jegyezd meg, hogy a függvénynek még akkor is kell törzs, ha az nem csinál semmit, különben a program futtatása behúzási hibát eredményez:

>>> def my_bodyless_func():
...      

File ~/temp.py:1
    
    ^
IndentationError: expected an indented block

Függvény hívása

Egy függvény meghívásához a függvény nevét írd le, majd utána egy zárójelpárt [()]. A függvénynek átadott paramétereket a zárójelek közé írod, vesszővel elválasztva.

Vegyük a következő függvényt:

def greet():
    print("Hello")

A fenti függvényt a következő szintaxissal hívhatod meg:

>>> greet()
Hello

Paraméterek és argumentumaik

Az argumentumok azok az értékek, amelyeket a függvény hívásakor adunk át neki. Bármilyen adattípusúak lehetnek, akár más függvények vagy osztályok is.

Definiáljunk egy add nevű függvényt, amely összead két számot:

def add(first, second):
    print(first + second)

A first és second paraméterek határozzák meg, milyen argumentumokat fogad el az add függvény. (Meg kell jegyezni, hogy a parameter és argument szavakat gyakran felcserélhetően használják, bár pontatlanul.) Amikor meghívjuk a függvényt, átadjuk neki az argumentumokat. Mindkét paraméterhez át kell adnunk argumentumot, különben TypeError keletkezik.

>>> add(2, 3)
5

# Function can be called multiple times, with different parameters
>>> add(4, 3)
7
>>> add(5, 6)
11

# Passing an incorrect number of parameters will raise a `TypeError`
>>> add(2)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() missing 1 required positional argument: 'second'

>>> add(2, 3, 4)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: add() takes 2 positional arguments but 3 were given

Visszatérési érték

A visszatérési érték az az érték, amelyet a függvény visszaad a hívójának. A return value bármilyen adattípus lehet, akár más függvények vagy osztályok is. A függvény hívója további műveletekhez használhatja. Ha egy függvény nem ad meg kifejezetten return value-t, a Python értelmező a None értéket adja vissza.

Definiáljunk egy add függvényt:

def add(first, second):
    return first + second

A visszatérési értéket eltárolhatod egy változóban, majd kiírathatod:

>>> result = add(2, 3)
>>> print(result)
5
# Type of result is `int`
>>> type(result)
<class 'int'>

# We can also perform operations on the return value
>>> result * 2
10

# A function without an explicit return value will return `None`
>>> def log(message):
    print(message)

# Hello is printed because of print(message), but return value is `None`
>>> return_value = log("Hello")
Hello
>>> return_value
None

A return használata azonnal kilép a függvényből, és visszaadja az értéket a hívónak.

>>> def show(first, second):
    print(first)
    return first
    print(second)

# second never gets printed, because the function exits after the return statement
>>> show(1, 2)
1

Modularitás

Az összetett programokat kisebb részekre bonthatjuk. Különböző függvényekkel különböző konkrét feladatokat láthatunk el.

Tegyük fel, hogy egy programnak a következő feladatokat kell elvégeznie:

• Egy kör területének kiszámítása
• Egy téglalap területének kiszámítása
• Egy háromszög területének kiszámítása

A programot kisebb részekre bonthatjuk.

def circle_area(radius):
    return 3.14 * radius * radius

def rectangle_area(length, breadth):
    return length * breadth

def triangle_area(base, height):
    return 0.5 * base * height

Most már tetszőleges sorrendben hívhatjuk meg a függvényeket.

>>> circle_area(2)
12.56
>>> triangle_area(2, 3)
3.0
>>> rectangle_area(2, 3)
6
>>> rectangle_area(1, 2) + circle_area(2) + triangle_area(1, 2)
15.56

A változók scope-ja

Ha egy változót (vagy nevet) egy függvényen belül definiálunk, az csak a függvény scope-ján belül lesz elérhető (vagy a helyi névtérben), akkor is, ha a függvény scope-ján kívül létezik egy ugyanilyen nevű változó.

A függvényen kívül, modulszinten definiált változók a global névtérbe tartoznak. Azok a változók, amelyeket függvényen kívül, de egy környező függvényen vagy osztályon belül definiálunk, a nonlocal névtérbe tartoznak.

A Python a LEGB-szabályt (Local, Enclosing, Global, Built-in) használja a változónevek feloldására, amikor egy program fut:

1. Keresés a local (vagy függvény) névtérben.
2. Ha egy név nem található a local névtérben, keresés az enclosing (vagy nonlocal) névtérben.
3. Ha a név nem található a nonlocal/enclosing névtérben, keresés a global névtérben (modulszint).
4. Ha a név nem található a global névtérben, keresés a built-in (program- vagy Python-szintű) névtérben.

Ha a név így sem oldható fel, a Python NameError exception-t dob.

# Global namespace.
general_favorite = "apples"


def alices_favorite():
   # Local namespace.  
   favorite = "cherries"
   
   # This works because Python will eventually find general_favorite in the global namespace.
   # Python will find 'print' in the built-in namespace.
   print(f'Alice has always liked {favorite}, but most people like {general_favorite}.')

   
def our_favorite_fruits():
    # Enclosing or nonlocal namespace.
    yours = "peaches"
    
    def my_favorite():
        # Local namespace.
        mine = "pears"
        
        # This works because Python will eventually find 'yours' in the enclosing/nonlocal namespace.
        print(f'My favorite is {mine}, but you like {yours} instead.')
        
        # This works because Python will eventually find 'general_favorite' in the global namespace.
        print(f'Everyone seems to like {general_favorite}')
    
    # This function is in the local namespace of the 'our_favorite_fruits' function.  
    my_favorite()

    
# This will raise NameError: name 'favorite' is not defined, because the variable favorite is local to alices_favorite.
print(favorite)

Ha egy változónevet a függvény lokális scope-ján kívülről is elérhetővé akarunk tenni (vagy módosítani akarunk egy változót, amelyet a függvény scope-ján kívül definiáltunk), akkor vagy a global, vagy a nonlocal kulcsszót kell használnunk.

A global kulcsszó használatával jelzed a Pythonnak, hogy a keresést a global névtérben kezdje. A változónak adott értékek ekkor a global változót módosítják, ahelyett hogy egy local példányt hoznának létre. Amikor a global kulcsszóval deklarálsz egy változót, a változó hozzáadódik a global névtérhez. Ezért a global kulcsszót óvatosan érdemes használni, mivel egy globális változó hozzáadása vagy módosítása hatással lehet minden más kódra, amely felhasználja az értékét.

A nonlocal kulcsszó arra utasítja a Pythont, hogy a változót a nonlocal vagy környező névtérben keresse, illetve hozza létre. Akkor használjuk, amikor egy függvény egy másik függvényen vagy osztályon belül van beágyazva, és hozzá kell férnie a külső függvény változóihoz és scope-jához.

A függvények mint első osztályú objektumok

A Pythonban a függvények értékül adhatók változóknak, és argumentumként átadhatók más függvényeknek. Visszatérési értékként is használhatók. A függvények bekerülhetnek egy sorozatba is (list, tuple stb.), vagy lehetnek egy dict értékei. A függvények bárhol használhatók, ahol bármely más objektum használható. Ez azért van, mert a függvények első osztályú objektumok. Ennek megfelelően különleges attribútumokkal rendelkeznek, sőt saját egyedi attribútumaik lekérdezését és beállítását is meghatározhatják.

# print is a function

# A function can be assigned to a variable.
>>> function_as_variable = print
>>> function_as_variable("Hello")
Hello
>>> type(fake_print)
<class 'builtin_function_or_method'>

# Functions can be passed as an argument to another function.
>>> def check_print(func):
    func("Hello")
>>> check_print(print)
Hello

# Function can be used as an item in a sequence.
>>> my_list = [print, "Hello"]
>>> my_list[0]("Hello")
Hello

# Functions can be used as a value in a dictionary.
>>> my_dict = {"key": print}
>>> my_dict["key"]("Hello")
Hello

# Functions can be returned from a function.
>>> def return_func():
    return print
>>> return_func()("Hello")
Hello

A függvények más függvényeken belül is beágyazhatók.

def outer():
    num = 10
    
    # This is a nested, or "inner" function.
    def inner():
        print(num)
    
    # Outer function calling inner function
    inner()

A belső függvény hozzáfér a külső függvényben definiált num változóhoz.

>>> outer()
10

Különleges attribútumok

A Pythonban a függvényeknek különleges attribútumaik vannak. Ezek közül néhány:

• __name__: A függvény neve
• __doc__: A függvény dokumentációs stringje
• __module__: A modul, amelyben a függvény definiálva van
• __globals__: A függvény globális változóinak szótára
• __code__: A függvény utasításait tartalmazó kódobjektum

>>> def add(first, second):
      return first + second

# Function name
>>> print.__name__
'print'
>>> len.__name__
'len'
>>> add.__name__
'add'

# Function documentation
>>> abs.__doc__
'Return the absolute value of the argument.'

# Module
>>> len.__module__
'builtins'
>>> add.__module__
'__main__'

A függvényattribútumok teljes listája a Python adatmodell oldalon található.