Tworzenie funkcji w Pythonie

Tworzenie funkcji w Pythonie jest jednym z ważnych elementów programowania, który pozwala na organizację kodu w logiczne bloki wielokrotnego użytku. Funkcje umożliwiają uproszczenie skomplikowanych zadań poprzez ich podział na mniejsze fragmenty, co poprawia czytelność kodu.

W tym artykule prezentuję, w jaki sposób definiować funkcje w Pythonie, jak działają ich argumenty oraz w jaki sposób funkcja może zwracać wartość.

Czym są funkcje w Pythonie?

Funkcje w Pythonie to bloki kodu, które wykonują określone zadanie i mogą być wielokrotnie wywoływane w różnych częściach programu. 

Python oferuje m.in.

• funkcje wbudowane, dostępne od razu po uruchomieniu interpretara – przezentujemy je w artykule Python funkcje wbudowane
• funkcje dostępne w modułach w bibliotece standardowej
• funkcje użytkownika, które możemy sami utworzyć.

Tworzenie funkcji w Pythonie – definicja i argumenty funkcji

Funkcja jest blokiem kodu, uruchamianym tylko wtedy, gdy zostanie wywołana. Możemy do niej przekazywać argumenty i może ona zwracać wynik. 

Aby utworzyć funkcję w języku Python tworzymy definicję funkcji, w której umieszczamy:

• nagłówek funkcji obejmujący nazwę funkcji, która pozwoli zidentyfikować funkcję w pozostałej części programu
• nawiasy okrągłe – w nawiasach mogą znajdować się parametry funkcji, które funkcja otrzymuje na początku działania programu. Parametry są opcjonalne
• dwukropek
• ciało funkcji, czyli instrukcje, które mają zostać wykonane. Kod wewnątrz funkcji (ciało funkcji) musi być zapisany z użyciem wcięcia.

def pokaz_saldo():
    print("Aktualne saldo firmy wynosi: 25 000 PLN")

Po wprowadzeniu tego kodu, funkcja zostanie zapisana w pamięci i będzie gotowa do użycia.

W przykładzie:

• za pomocą słowa kluczowego def tworzymy funkcję o nazwie pokaz_saldo()
• ciało funkcji zawiera pojedynczą instrukcję print(), która wyświetla tekst: „Aktualne saldo firmy wynosi: 25 000 PLN”.  W kodzie sama funkcja nie jest jeszcze wywoływana
• funkcja print() wyświetla na ekranie wynik działania funkcji. W tym przypadku jest to tekst: „Aktualne saldo firmy wynosi: 25 000 PLN”
• zwrócenie wyniku następuje dopiero wtedy, gdy funkcja zostanie wywołana.

Wywoływanie funkcji w Pythonie

Wywołanie funkcji powoduje, że Python zaczyna wykonywać kod wewnątrz funkcji.

pokaz_saldo()

W przykładzie wywołujemy utworzoną wcześniej funkcję pokaz_saldo()

def pokaz_stan_zapasow():
    print("Aktualny stan zapasów: 500 sztuk produktu A")

pokaz_stan_zapasow()  # Wywołanie funkcji

W przykładzie:

• definiujemy funkcję o nazwie pokaz_stan_zapasow(), która wyświetla tekst „Aktualny stan zapasów: 500 sztuk produktu A”
• wywołujemy tę funkcję – po wywołaniu funkcji, Python wykonuje zawarty w funkcji kod i wyświetla wynik w konsoli

Utworzone wyżej funkcje są funkcjami bez argumentów. 

Instrukcja return – zwracanie wyników

Instrukcja return pozwala funkcji na zwrócenie wartości do miejsca, w którym została wywołana.

Zwrócone wartości mogą być:

• przechowywane w zmiennych
• wykorzystywane w dalszym kodzie
• używane do obliczeń.

Funkcja kończy swoje działanie, gdy napotka instrukcję return i natychmiast przekazuje określoną wartość.

def oblicz_koszt_dostawy(odleglosc):
    if odleglosc <= 10:
        return 15  # koszt dostawy do 10 km
    elif odleglosc <= 50:
        return 30  # koszt dostawy od 10 do 50 km
    else:
        return 50  # koszt dostawy powyżej 50 km

odleglosc = 25
koszt = oblicz_koszt_dostawy(odleglosc)
print("Koszt dostawy na odległość", odleglosc, "km wynosi", koszt, "PLN.")

W przykładzie:

• definicja funkcji – funkcja oblicza koszt dostawy na podstawie podanej odległości. Zawiera trzy warunki określające koszt w zależności od odległości
• przekazywanie argumentu – funkcja jest wywoływana z argumentem odleglosc równym 25. Oznacza to, że chcemy obliczyć koszt dostawy dla odległości 25 km
• sprawdzenie warunków – funkcja sprawdza, do której kategorii kosztów pasuje przekazana odległość:
  • jeśli odległość wynosi 10 km lub mniej, koszt wynosi 15 PLN
  • jeśli odległość mieści się w przedziale 10–50 km, koszt wynosi 30 PLN
  • jeśli odległość przekracza 50 km, koszt wynosi 50 PLN
• zwrócenie wartości – na podstawie spełnionego warunku funkcja zwraca odpowiednią wartość kosztu dostawy
• wyświetlenie wyniku – po obliczeniu wartości, wynik jest wyświetlany na ekranie. Zostaje pokazana informacja o kosztach dostawy oraz podana odległość i cena tj. „Koszt dostawy na odległość 25 km wynosi 30 PLN.”

W przykładzie używamy instrukcji warunkowej. Informacje na ten temat znajdziesz w artykule Python instrukcje warunkowe.

Parametr versus argument w funkcji

Parametry umieszczamy w definicji funkcji podczas jej tworzenia. Są to zmienne określone w definicji funkcji reprezentujące dane, które funkcja ma przyjąć podczas jej wywołania.

Argumenty istnieją podczas wywoływania funkcji. Są to rzeczywiste wartości, przekazywane do funkcji, których funkcja używa do np. dokonania wyliczeń. 

Termin parametr i argument czasami używane są przez programistów zamiennie. 

Tworzenie funkcji z parametrami

Do funkcji możemy przekazywać informacje w formie argumentów. Argumenty wpisujemy w półokrągłych nawiasach po nazwie funkcji i przekazujemy je do parametrów funkcji. Możemy podać jeden argument lub ich większą ilość. Argumenty oddzielamy przecinkami. 

Funkcja z jednym parametrem

Poniżej przykład funkcji z jednym parametrem:

def podziekowanie_klientowi(imie_klienta):
    print("Dziękujemy za zakupy, " + imie_klienta)

podziekowanie_klientowi("Kasia")
podziekowanie_klientowi("Marcin")

W przykładzie:

• tworzymy funkcję o nazwie podziekowanie_klientowi(), która posiada jeden parametr  – imie_klienta
• w ciele funkcji łączony jest tekst „Dziękujemy za zakupy, ” z wartością przekazaną do parametru imie_klienta
• funkcja wyświetla wynik, który jest personalizowany na podstawie przekazanego imienia klienta
• pierwsze wywołanie funkcji przekazuje argument „Kasia”, więc wyświetlony zostaje komunikat „Dziękujemy za zakupy, Kasia”
• drugie wywołanie funkcji przekazuje argument „Marcin”, więc wyświetlony zostaje komunikat „Dziękujemy za zakupy, Marcin”
• każde wywołanie funkcji wygeneruje indywidualny komunikat podziękowania w zależności od przekazanego imienia klienta

Funkcja z wieloma parametrami

W funkcji możesz zdefiniować dowolną ilość parametrów. Poniżej przykład funkcji z dwoma parametrami:

def cena_po_rabacie(cena, rabat):
    cena_po_rabacie = cena - (cena * rabat / 100)
    return cena_po_rabacie

# Wywołanie funkcji
pierwotna_cena = 100
rabat = 20
cena_finalna = cena_po_rabacie(pierwotna_cena, rabat)
print("Cena po rabacie:", cena_finalna)

W przykładzie:

• definiujemy funkcję o nazwie cena_po_rabacie(), która przyjmuje dwa argumenty: cena i rabat
• funkcja oblicza nową cenę po zastosowaniu rabatu – mnoży pierwotną cenę przez procent rabatu, a następnie odejmuje wyliczoną wartość od pierwotnej ceny
• funkcja zwraca obliczoną wartość, czyli cenę po rabacie
• w kodzie do zmiennej pierwotna_cena przypisywana jest wartość 100  a do zmiennej rabat wartość 20. Zmienne te stanowią argumenty funkcji cena_po_rabacie
• wynik wyliczeń jest przypisywany do zmiennej cena_finalna i wyświetlany za pomocą funkcji print().

 

def cena_po_rabacie(cena, rabat):
    cena_po_rabacie = cena - (cena * rabat / 100)
    return cena_po_rabacie

# Wywołanie funkcji
pierwotna_cena = 100
rabat = 20
cena_finalna = cena_po_rabacie(pierwotna_cena,10)
print("Cena po rabacie:", cena_finalna)

Wywołując funkcję, zamiast zmiennej możemy podać wartość, która zostanie wzięta do wyliczeń. W przykładzie zamiast wartości przypisanej do zmiennej rabat wpisujemy liczbę 10. W wyniku otrzymamy cenę pomniejszoną o 10% czyli 90 PLN.

Podawanie argumentów przy wywołaniu funkcji

Jeśli funkcja nie posiada parametrów domyślnych, wywołując ją musimy podać wszystkie parametry, które są w niej zdefiniowane. Przekazywane do funkcji argumenty muszą posiadać taki typ danych, który umożliwi wykonanie zdefiniowanych w funkcji operacji.

W przykładzie poniżej otrzymujemy błąd, gdyż wywołując funkcję, podajemy tylko jeden argument, a w funkcji zdefiniowane są dwa parametry i funkcja oczekuje dwóch argumentów.

W poniższym przykładzie otrzymujemy błąd, gdyż wywołując funkcję, podajemy w zmiennej rabat argument typu str (tekst), a na tekście funkcja nie może dokonać wyliczeń.

Funkcja z domyślnym argumentem

W parametrach funkcji możemy umieszczać domyślne argumenty. Jeśli podamy w funkcji domyślny argument, nie musimy podawać argumentu podczas wywoływania funkcji.

def oblicz_wynagrodzenie(liczba_godzin, stawka_godzinowa=20):
    return liczba_godzin * stawka_godzinowa

# Przykłady użycia:
# 1. Pracownik przepracował 40 godzin, domyślna stawka 20 zł
print(oblicz_wynagrodzenie(40))  # Wynik: 800

# 2. Pracownik przepracował 35 godzin, stawka 25 zł
print(oblicz_wynagrodzenie(35, stawka_godzinowa=25))  # Wynik: 875

W przykładzie:

• funkcja oblicz_wynagrodzenie() wylicza wynagrodzenie pracownika mnożąc ilość przepracowanych godzin razy stawkę godzinową
• w funkcji podajemy do parametru stawka_godzinowa domyślny argument – wartość 20
• w pierwszym przykładzie użycia wywołując funkcję podajemy tylko jeden argument – liczbę przepracowanych godzin
• w drugim przykładzie użycia podajemy obydwa argumenty: podajemy liczbę godzin oraz argument o wartości 25, który zastępuje domyślny argument.

Funkcja z parametrem *args

Jeśli nie wiemy, ile argumentów zostanie przekazanych do funkcji, tworząc funkcję w Pythonie, możemy użyć składni *args (ang. arbitrary arguments):

• *args pozwala funkcji przyjmować dowolną liczbę niezdefiniowanych wcześniej argumentów pozycyjnych
• argumenty przekazane w ten sposób są traktowane jako krotka (tuple) i można je przetwarzać jak inne sekwencje

Argumenty pozycyjne to metoda przekazywania wartości do funkcji, w której:

• wartości są przypisywane do parametrów na podstawie ich kolejności w wywołaniu funkcji
• kolejność argumentów w wywołaniu musi odpowiadać kolejności parametrów w definicji funkcji.

def oblicz_sprzedaz(*args):
    return sum(args)


# Przykłady użycia:
# 1. Jedna transakcja
print(oblicz_sprzedaz(150))  # Wynik: 150

# 2. Kilka transakcji
print(oblicz_sprzedaz(200, 300, 450))  # Wynik: 950

# 3. Brak transakcji (zero sprzedaży)
print(oblicz_sprzedaz())  # Wynik: 0

W przykładzie:

• definiujemy funkcję z parametrem *args, której zadaniem jest sumowanie sprzedaży
• w pierwszym przykładzie wywołania podajemy do funkcji jeden argument
• w drugim przykładzie wywołania podajemy 3 argumenty
• w trzecim przykładzie wywołania nie podajemy żadnego argumentu

Argumenty nazwane

Argumenty nazwane (ang. keyword arguments) to sposób przekazywania argumentów do funkcji w Pythonie, gdzie wartości są przypisywane do konkretnych parametrów za pomocą składni klucz = wartość.

Kolejność argumentów w wywołaniu funkcji nie ma znaczenia, gdyż każdy argument jest przypisany jednoznacznie na podstawie nazwy parametru.

def faktura(klient, kwota, data_platnosci):
    print(f"Faktura dla klienta: {klient}")
    print(f"Kwota do zapłaty: {kwota} PLN")
    print(f"Data płatności: {data_platnosci}")

# Wywołanie funkcji z argumentami nazwanymi
faktura(kwota=500, klient="ABC", data_platnosci="2025-02-28")

#Wynik
# Faktura dla klienta: ABC
# Kwota do zapłaty: 500 PLN
# Data płatności: 2025-02-28

W przykładzie:

• tworzymy funkcję o nazwie faktura(), w której definiujemy parametry klient, kwota, data_platnosci
• wywołujemy funkcję nazywając argumenty nazwami parametrów

Dowolne argumenty nazwane

Dowolne argumenty nazwane (ang. arbitrary keyword arguments)  pozwalają funkcji przyjmować dowolną liczbę argumentów nazwanych. Argumenty przekazujemy w postaci słownika do funkcji.

def zamowienie(**kwargs):
    print("Szczegóły zamówienia:")
    for klucz, wartosc in kwargs.items():
        print(f"{klucz}: {wartosc}")

# Wywołanie funkcji
zamowienie(klient="Jan Kowalski", produkt="Laptop", cena=3000)

# Wynik
# Szczegóły zamówienia:
# klient: Jan Kowalski
# produkt: Laptop
# cena: 3000

W przykładzie:

• funkcja zamowienie() jest zdefiniowana z użyciem **kwargs, co pozwala jej przyjmować dowolną liczbę argumentów nazwanych
• argumenty nazwane, takie jak klient=”Jan Kowalski”, produkt=”Laptop”, cena=3000, są przekazywane do funkcji podczas jej wywołania
• przekazane argumenty są zapisywane w słowniku kwargs, gdzie klucze odpowiadają nazwom argumentów (klient, produkt, cena), a wartości – przekazanym danym („Jan Kowalski”, „Laptop”, 3000)
• pętla for przechodzi przez elementy słownika kwargs, gdzie każda para klucz-wartość jest przetwarzana.

def transakcja(**szczegoly):
    print(szczegoly["klient"])
    print(szczegoly["produkt"])
    print(szczegoly["kwota"])

transakcja(klient="Anna Nowak", produkt="Smartfon", kwota=2500)

# Wynik
# Anna Nowak
# Smartfon
# 2500

W przykładzie:

• funkcja transakcja() jest zdefiniowana z parametrem **szczegoly, co oznacza, że będzie przyjmować dowolną liczbę argumentów nazwanych. Argumenty te będą przechowywane w formie słownika, w którym nazwy argumentów będą kluczami, a przekazane dane będą wartościami
• podczas wywołania funkcji przekazujemy trzy argumenty nazwane: 
  • klient=”Anna Nowak”
  • produkt=”Smartfon”
  • kwota=2500
• argumenty te są przechowywane w słowniku, w którym:
  • „klient” to klucz, a „Anna Nowak” to wartość
  • „produkt” to klucz, a „Smartfon” to wartość
  • „kwota” to klucz, a 2500 to wartość
• funkcja odwołuje się do słownika szczegoly, który zawiera przekazane dane
  • pierwsze print() wypisuje wartość dla klucza „klient”, czyli „Anna Nowak”
  • drugie print() wypisuje wartość dla klucza „produkt”, czyli „Smartfon”
  • trzecie print() wypisuje wartość dla klucza „kwota”, czyli 2500

Przekazywanie listy jako argumentu do funkcji

Do funkcji możemy przekazać jako argument dowolny typ danych (ciąg znaków, liczba, lista, słownik itp.). Wewnątrz funkcji będzie on traktowany jako ten sam typ danych, jaki został przekazany.

def oblicz_kwote_zamowienia(produkty):
    suma = sum(produkty)
    print(f"Łączna kwota zamówienia: {suma} PLN")

produkty = [1000, 2500, 1500]
oblicz_kwote_zamowienia(produkty)

# Wynik: Łączna kwota zamówienia: 5000 PLN

W przykładzie:

• przekazujemy do funkcji listę produktów przypisanych do zmiennej produkty
• funkcja sumuje wartości
• drukujemy wynik za pomocą funkcji print()

Przekazywanie tylko pozycyjnych argumentów

Możemy określić, że funkcja może przyjmować tylko argumenty pozycyjne (ang. Positional-Only Arguments).

Argumenty pozycyjne to takie, których wartości muszą być przekazane w określonej kolejności.

Aby przekazać argumenty pozycyjne dodajemy znak / po definicji argumentów.

def oblicz_koszt_wynajmu(dni, cena_za_dzien, /):
    return dni * cena_za_dzien

# Poprawne wywołanie:
print(oblicz_koszt_wynajmu(3, 150))  # Wynik: 450 PLN

W przykładzie:

• definiujemy funkcję oblicz_koszt_wynajmu()
• podajemy jako argumenty do funkcji liczbę dni wynajmu i cenę za dzień
• funkcja wylicza koszt wynajmu mnożąc liczbę dni wynajmu razy cenę.

Przekazywanie argumentów tylko nazwanych

W funkcji możemy zdefiniować, że ma przyjmować tylko argumenty nazwane (ang. Keyword-Only Arguments). Aby to zrobić, należy dodać znak * przed nazwami argumentów w definicji funkcji.

def rezerwacja(*, imie, data, liczba_osob):
    print(f"Rezerwacja dla {imie} na {data}")
    print(f"Liczba osób: {liczba_osob}")

# Wywołanie:
rezerwacja(imie="Jan Kowalski", data="2025-01-20", liczba_osob=4)

# Wynik
# Rezerwacja dla Jan Kowalski na 2025-01-20
# Liczba osób: 4

W przykładzie:

• funkcja rezerwacja() przyjmuje wyłącznie argumenty nazwane: imie, data i liczba_osob, gdyż wszystkie argumenty znajdują się po znaku * w definicji funkcji
• argumenty muszą być przekazywane przy użyciu nazw np. imie="Jan Kowalski", data="2025-01-15", liczba_osob=4.

Łączenie argumentów tylko pozycyjnych i tylko nazwanych

W funkcji możemy połączyć argumenty tylko pozycyjne i tylko nazwane.

Aby to zrobić:

• wszystkie argumenty przed / w definicji funkcji będą argumentami tylko pozycyjnymi
• wszystkie argumenty po * w definicji funkcji będą argumentami tylko nazwanymi

def oblicz_prowizje(sprzedaz, /, *, stawka=0.1):

    prowizja = sprzedaz * stawka
    print(f"Wartość sprzedaży: {sprzedaz}")
    print(f"Stawka prowizji: {stawka}")
    print(f"Wartość prowizji: {prowizja}")
    return prowizja

# Przykład wywołania:
oblicz_prowizje(5000, stawka=0.1)

# Wynik
# Wartość sprzedaży: 5000
# Stawka prowizji: 0.1
# Wartość prowizji: 500.0

W przykładzie:

• definiujemy funkcję oblicz_prowizje(), która przyjmuje dwa argumenty: sprzedaz (argument pozycyjny) i stawka (argument nazwany z domyślną wartością 0.1)
• wewnątrz funkcji obliczamy prowizję, mnożąc wartość sprzedaży przez stawkę prowizji
• następnie funkcja wyświetla na ekranie wartość sprzedaży, stawkę prowizji oraz obliczoną wartość prowizji, używając funkcji print()
• po wykonaniu obliczeń, funkcja zwraca obliczoną prowizję, chociaż w tym przykładzie nie przechwytujemy tej wartości, bo cała operacja odbywa się poprzez wyświetlanie wyników
• funkcję wywołujemy, przekazując odpowiednią wartość sprzedaży (5000) oraz stawkę prowizji (0.1)

Instrukcja pass

Definicje funkcji nie mogą być puste. Jeśli musimy stworzyć funkcję, która nie ma żadnej zawartości, możemy użyć instrukcji pass, aby uniknąć błędu.

Instrukcja pass w Pythonie jest używana jako "wypełniacz" w sytuacjach, gdy składnia wymaga obecności jakiegoś kodu, ale funkcja, klasa lub blok kodu nie ma jeszcze implementacji.

Dzięki użyciu instrukcji pass kod nie generuje błędu, mimo że nie wykonuje żadnych operacji.

def przetworz_zwrot(klient, produkt):
    pass  # Funkcja do zaimplementowania w przyszłości

Zakres globalny funkcji - zmienne globalne

Zmienne globalne są to zmienne, które są zadeklarowane poza wszystkimi funkcjami, najczęściej na początku programu. Są one dostępne w całym programie, w tym wewnątrz funkcji.

Zmienna globalna nie będzie dostępna w funkcji, jeśli funkcja zawiera zmienną lokalną o takiej samej nazwie, jaką ma zmienna globalna. 

Jeśli chcemy, aby kilka funkcji w programie mogło operować na tych samych danych, ale nie chcemy przekazywać tych danych każdorazowo jako argumentów do funkcji, możemy użyć zmiennych globalnych.

# Zmienne globalne
stawka_vat = 0.23  # 23% VAT

def oblicz_cene_brutto(cena_netto):
    return cena_netto * (1 + stawka_vat)

# Przykład użycia
cena_netto = 100
cena_brutto = oblicz_cene_brutto(cena_netto)

print(f"Cena netto: {cena_netto}")
print(f"Cena brutto: {cena_brutto}")

# Wynik
# Cena netto: 100
# Cena brutto: 123.0

W przykładzie:

• zmienna stawka_vat jest zadeklarowana jako globalna i jest przypisana do niej wartość 0.23. Zmienna ta będzie dostępna w całym programie, w tym również wewnątrz funkcji.
• funkcja oblicz_cene_brutto() jest zdefiniowana z jednym parametrem cena_netto. Zadaniem funkcji jest obliczenie ceny brutto (z VAT) na podstawie podanej ceny netto. Działanie wewnątrz funkcji:
  • odczytuje wartość stawka_vat zdefiniowaną globalnie
  • dodaje 1 + stawka_vat, co w tym przypadku daje 1.23
  • mnoży podaną cenę netto (cena_netto) przez 1.23, aby uzyskać cenę brutto
  • wynik zwraca jako wartość funkcji
• do zmiennej cena_netto zostaje przypisana wartość 100
• funkcja oblicz_cene_brutto() zostaje wywołana z argumentem cena_netto, który ma wartość 100. Wynik zostaje przypisany do zmiennej cena_brutto
• za pomocą funkcji print() wyświetlana jest cena brutto i cena netto

Zakres lokalny funkcji - zmienne lokalne

Zmienne lokalne to zmienne, które są zadeklarowane wewnątrz funkcji lub bloku kodu i są dostępne tylko w obrębie tej funkcji lub bloku. Po zakończeniu działania funkcji lub bloku kodu, zmienne lokalne przestają istnieć.

Zmienne lokalne nie mają wpływu na zmienne o tej samej nazwie w innych częściach programu np. zmienne globalne.

def oblicz_koszt_produkcji(ilosc_jednostek, koszt_materialu):
    koszt_produkcji = ilosc_jednostek * koszt_materialu  # zmienna lokalna
    return koszt_produkcji

# Wywołanie funkcji
koszt = oblicz_koszt_produkcji(100, 5)
print(f"Koszt produkcji: {koszt}")

# Wynik: Koszt produkcji: 500

W przykładzie:

• tworzymy funkcję o nazwie oblicz_koszt_produkcji(), która ma dwa parametry: ilosc_jednostek - liczba jednostek produkowanych oraz koszt_materialu - koszt materiału na jedną jednostkę
• funkcja oblicza całkowity koszt produkcji mnożąc liczbę jednostek (ilosc_jednostek) przez koszt materiału na jednostkę (koszt_materialu), przypisuje wynik do zmiennej lokalnej koszt_produkcji i zwraca wartość zmiennej koszt_produkcji
• funkcja oblicz_koszt_produkcji() zostaje wywołana z dwoma argumentami: ilosc_jednostek = 100 i koszt_materialu = 5
• na ekranie wyświetlany jest wynik za pomocą funkcji print()

Informacje na temat zmiennych znajdziesz w naszym artykule Python zmienne.

Wywoływanie funkcji przez inną funkcję

Wywoływanie funkcji przez inną funkcję to sposób na tworzenie bardziej zorganizowanego i modularnego kodu, w którym jedna funkcja korzysta z wyników innych funkcji, aby wykonać swoje zadanie. 

def oblicz_podatek(cena):
    return cena * 0.1 # 10% podatek

def oblicz_cene_z_podatkiem(cena):
    podatek = oblicz_podatek(cena) # Wywołanie funkcji oblicz_podatek
    return cena + podatek # Dodanie podatku do ceny

# Wywołanie funkcji głównej
cena_z_podatkiem = oblicz_cene_z_podatkiem(100)
print(f"Całkowita cena z podatkiem: {cena_z_podatkiem}")

# Wynik: Całkowita cena z podatkiem: 110.0

W przykładzie:

• tworzymy funkcję o nazwie oblicz_podatek(), która przyjmuje jeden parametr - cena. Jej zadaniem jest obliczenie podatku od podanej ceny poprzez pomnożenie tej ceny przez 0.1. Funkcja zwraca wynik tego obliczenia za pomocą instrukcji return.
• tworzymy drugą funkcję o nazwie oblicz_cene_z_podatkiem(), która również przyjmuje jeden parametr - cena. Wewnątrz tej funkcji wywoływana jest funkcja oblicz_podatek() z argumentem cena, aby obliczyć kwotę podatku. Wynik wywołania funkcji jest przypisywany do zmiennej lokalnej podatek. Następnie funkcja dodaje wartość podatek do ceny podstawowej (cena) i zwraca wynik.
• funkcja oblicz_cene_z_podatkiem() jest wywoływana z argumentem 100, wykonuje obliczenie i wynik przypisuje do zmiennej cena_z_podatkiem
• funkcja print() wyświetla wynik

Rekursja

Rekursja oznacza, że funkcja wywołuje samą siebie.

def oblicz_koszt_dostawy(oplata, ilosc):
    if ilosc == 0:  # Warunek zakończenia rekurencji
        return 0  # Brak produktów, brak kosztów dostawy
    else:
        # Rekurencyjne wywołanie dla kolejnych produktów
        return oplata + oblicz_koszt_dostawy(oplata, ilosc - 1) 
         
# Wywołanie funkcji
koszt_dostawy = oblicz_koszt_dostawy(10, 2)
print(f"Całkowity koszt dostawy: {koszt_dostawy}")

# Wynik: Całkowity koszt dostawy: 20

W przykładzie:

• funkcja sprawdza, czy liczba produktów (ilosc) wynosi 0. Jeśli tak, zwraca 0, co kończy rekurencję
• jeśli liczba produktów nie wynosi 0, funkcja wywołuje samą siebie, zmniejszając wartość w zmiennej ilosc o 1 i dodając koszt jednego produktu (oplata) do wyniku
• funkcja oblicz_koszt_dostawy() jest uruchamiana z argumentami oplata = 10 i ilosc = 2
• przy pierwszym wywołaniu liczba produktów (ilosc) wynosi 2, więc funkcja wywołuje się ponownie z ilosc = 1
• przy drugim wywołaniu liczba produktów wynosi 1, więc funkcja wywołuje się ponownie z ilosc = 0
• przy trzecim wywołaniu liczba produktów wynosi 0, więc funkcja zwraca 0 i kończy rekurencję
• wynik końcowy, czyli 20 jest przypisywany do zmiennej koszt_dostawy

Funkcje anonimowe - funkcja lambda

Funkcje lambda w Pythonie to anonimowe funkcje, które są definiowane za pomocą słowa kluczowego lambda. Są to funkcje jednowierszowe, które mogą zawierać dowolną liczbę argumentów, ale tylko jedno wyrażenie, które jest natychmiastowo zwracane.

Funkcje lambda są szczególnie przydatne, gdy potrzebujemy funkcji do prostych operacji, które mają być użyte w jednym miejscu np. w funkcjach, takich jak map(), filter() czy sorted(). Funkcje lambda są przydatne w sytuacjach, w których nie chcemy definiować pełnej funkcji za pomocą def.

produkty = [50, 150, 200, 80]

# Funkcja lambda obliczająca rabat
rabat = lambda cena: cena * 0.9 if cena > 100 else cena

# Obliczanie rabatu dla każdego produktu
produkty_z_rabatem = list(map(rabat, produkty))

print(produkty_z_rabatem)

W przykładzie funkcja ma wykonać obliczenie rabatu dla każdego produktu:

• funkcja lambda sprawdza, czy cena produktu przekracza 100 zł
  • jeśli tak, stosuje rabat 10%, czyli mnoży cenę przez 0.9
  • jeśli cena jest mniejsza lub równa 100 zł, cena pozostaje bez zmian

Zasady tworzenia nazw funkcji

Nazwy funkcji powinny być opisowe, zaczynać się od czasowników i jasno wskazywać do czego dana funkcja służy np. oblicz_podatek, pobierz_dane.

Tworząc nazwy funkcji powinniśmy starać się:

• używać nazw, które jasno opisują, do czego funkcja służy np. oblicz_podatek, a nie funkcja1
• zaczynać nazwę od czasownika np. zapisz_dane, pobierz_informacje
• używać jednej konwencji w całym projekcie np. snake_case
• nie używać słów kluczowych zarezerwowanych dla Pythona, takich jak if, class, return
• stosować krótkie i zwięzłe nazwy np. oblicz_podatek, a nie oblicz_podatek_stosowany_w_naszej_firmie

Funkcje, zmienne i inne elementy języka Python omawiamy dokładnie na ponad 100 ćwiczeniach w trakcie kursu Python od podstaw. Zapraszamy na wspólne ćwiczenia. 

Rafał Lelusz

Programista Python, C#

Udostępnij wpis: