Argument ja parameeter

Funktsiooni kirjeldamise ja kasutamisega käivad (tihti) kaasas mõisted nagu argument ja parameeter. Parameetrid on eriliiki muutujad (Muutuja programmeerimises) (nimelised kohad arvutimälus väärtuste salvestamiseks), mida kasutatakse andmete sissetoomiseks funktsiooni. Üks põhjus, miks parameetrit nimetatakse eriliiki muutujaks, seisneb selles, et see muutuja ei saa oma väärtust omistuslauses, nagu tavalise muutuja puhul. Parameetrid kirjeldatakse funktsiooni defineerimisel selle päisereas sulgude sees. Parameetrid saavad oma väärtused funktsiooni poole pöördumisel argumentidelt. Argumendiks võib olla konstant, muutuja, funktsiooniviide või avaldis. Võib öelda, et argumendid on funktsiooni sisendväärtused ehk väärtused, millega funktsiooni poole pöördutakse. Kui argumendiks on avaldis või funktsiooniviide, asutakse funktsiooni täitma alles siis, kui avaldise ja funktsiooniviite väärtused on leitud.

Attention

Kuigi avaldis koosneb tüüpiliselt operandidest, operaatoritest (tehtemärkidest) ja sulgudest, loetakse avaldiseks (erijuhuna) ka vaid konstanti, muutujat, funktsiooniviidet.

Vahel kasutatakse kirjanduses mõistete argument ja parameeter asemel mõisteid tegelik parameeter (actual parameter) ja formaalne parameeter (formal parameter).

Järgnevas näites on kirjeldatud kahe parameetriga funktsioon addition, mis liidab parameetrite a ja b väärtused ja prindib need konsoolaknas. Funktsiooni kirjeldus koosneb siin kahest reast: päisereast, mis algab võtmesõnaga def ja funktsiooni kehast, mis algab taandega.

# Here, a and b are called "parameters" (or "formal parameters")
def addition(a: int ,b: int):
    print(a + b)

# Here, 5 and 7 are called "arguments" (or "actual parameters")
addition(5, 7)  # --> Prints 12 to the console

Selleks, et kirjeldatud funktsioonist ka mingit kasu oleks, tuleb see välja kutsuda (käivitada). Täpsemalt, funktsiooni käivitamiseks tuleb selle poole pöörduda selle kirjelduses antud nimega ning argumentidega (kui funktsiooni kirjelduses on parameetrid esitatud). Eelnevas koodis esitab funktsiooni poole pöördumist (ka funktsiooni väljakutset) addition(5, 7). Kui programm asub rida (pöördumislauset) addition(5, 7) täitma antakse esimese argumendi väärtus 5 parameetrile a ja teise argumendi väärtus 7 parameetrile b.

def greeting():
    print("Welcome to python, pal.")

# If we want to execute the defined print(), we should call the function
greeting() # --> Prints "Welcome to python, pal." to the console

Pärast funktsiooni sees oleva koodi käivitamist funktsioon võib (aga ei pea) tagastada väärtuse - see võib olla number, sõne, list vms.

# A function which returns something
def func(parameters):
    # Some code
    return [expression]

Ja siis üleval olev näide on ümberkirjutatav kujul

def func() -> str:
    return "Welcome to python, pal."

# The function returns the string "Welcome to python, pal.", and we print it to the console
print(func()) # --> Welcome to python, pal.

Veel mõni näide. Olgu meil lihtne kalkulaator, mis liidab kokku kaks arvu:

# Variables
first_num = 5
second_num = 7

result = first_num + second_num

# Prints 12 to the console
print(result)

Ilma funktsioonita käivitub kood lihtsalt skripti käivitamisel. Kui aga paneme antud koodi funktsiooni calc() sisse, siis selleks, et funktsiooni sees olevat koodi käivitada, tuleb seda funktsiooni kutsuda:


        # no pec


        # You can also edit the code
        def calc() -> int:
            """
            Calculate the sum of 5 and 7.

            :return: sum of two given numbers
            """
            # Variables
            first_num = 5
            second_num = 7
            result = first_num + second_num
            return result

        # Calling a function
        print(calc()) # --> 12

Interpretaator (interpreter) (programmikoodi tõlkiv ja täitev programm) vaatab algul pythoni (sise)funktsiooni print() sisse. Kuna print asub meie funktsiooni kirjeldusest väljaspool ning on ilma taaneteta, näeb interpretaator funktsiooni kutset ja pöördub selle poole. Pärast funktsiooni sees oleva koodi käivitamist, calc() tagastab kahe arvu summa, mis on antud juhul 12, ja meie prindime selle summa. Meie funktsiooni tagastatavaks väärtuseks on alati 12, kuna liidetavad arvud on määratud funktsiooni sees (5 ja 7) ja neid saab muuta ainult otseselt (panna näiteks first_num = 10, siis saame tulemuseks 10 + 7 = 17 vms).

See ei ole eriti mugav. Õnneks saab funktsioon sisse võtta ka argumente:

def calc(first_num: int, second_num: int) -> int:
    """
    Calculate the sum of two numbers.

    :param first_num: first number
    :param second_num: second number
    :return: sum of two given numbers
    """
    result = first_num + second_num

    return result

# Calling the function with two arguments.
print(calc(5, 7))  # Prints 12
print(calc(25, 39))  # Prints 64

Ehk põhimõtteliselt funktsiooni parameetrid on samad muutujad, millele antakse väärtused funktsiooni väljakutsumisel. Pöörake tähelepanu, et viimase näite korral IDE võib kuvada teile hoiatuse - local variable result is redundant. Tal on õigus (IDE always knows it better, just deal with it). Viisakas oleks ümber kirjutada meie funktsioon kujul:


        # no pec


        def calc(first_num: int, second_num: int) -> int:
            """
            Calculate the sum of two numbers.

            :param first_num: first number
            :param second_num: second number
            :return: sum of two given numbers
            """
            return first_num + second_num

        # Calling the function with two arguments.
        print(calc(5, 7))  # Prints 12

Ehk result muutujat pole vaja, säästame veidi arvutimälu.

Üks funktsioon saab välja kutsuda (käivitada) ka teisi funktsioone. Näiteks, soovime, et meie kalkulaator liidaks kahe sisendarvu summale nende korrutise. Selleks loome eraldi funktsiooni:


        # no pec


    # Creating a new function, which multiplies two numbers and returns the product
    def multiply(first_num: int, second_num: int) -> int:
        """
        Multiply two numbers.

        :param first_num: first number
        :param second_num: second number
        :return: the result of multiplying two given numbers
        """
        return first_num * second_num


    # Calling the multiply() function inside our main function calc():
    def calc(first_num: int, second_num: int) -> int:
        """
        Calculate the sum of two numbers and their multiplication.

        :param first_num: first number
        :param second_num: second number
        :return: sum of two numbers + their multiplication result
        """
        return first_num + second_num + multiply(first_num, second_num)

    # Calling the function with two arguments
    print(calc(2, 3))  # --> 11
    print(calc(5, 5))  # --> 35

Kui funktsioon tagastab mingi väärtuse, saab selle väärtuse salvestada muutujasse ja teha sellega kõike, mida on võimalik ühe muutujaga teha.


        # no pec


    def repeat(word: str, times: int) -> str:
        """
        Repeat a word  amount.

        :param word: a word to repeat
        :param times: how many times parameter  is repeated
        :return: string, where word  is repeated  times
        """
        return word * times

    # Saving the return value into variable 
    # People do so to make their code easier to read
    repeated_word = repeat("a", 3)
    print(repeated_word)  # --> aaa

    # From technical point of view it isn't necessary to save the return value into variable
    print(repeat("abc", 4) == "abcabcabcabc")  # --> True
    print(repeat("Python is easy. ", 1) + "Try Haskell")  # --> Python is easy. Try Haskell