Darmowa lekcja Lekcja 3 z 3 ok. 40 min

Funkcje i pierwszy kompletny program

Funkcje pozwalają nadać nazwę kawałkowi kodu i używać go wielokrotnie. To ostatni element układanki — po tej lekcji złożysz zmienne, warunki, pętle i funkcje w pierwszy naprawdę użyteczny program.

W tej lekcji nauczysz się: czym są funkcje, jak definiować własne słowem def, jak przekazywać im dane (parametry) i odbierać wyniki (return). Na koniec zbudujesz kompletny kalkulator napiwków, który rozmawia z użytkownikiem.

Czym jest funkcja?

Funkcja to nazwany blok kodu, który możesz uruchamiać wielokrotnie. Znasz już funkcje wbudowane — print(), type(), range(). Własną funkcję definiuje się słowem def, a jej treść — jak zawsze w Pythonie — wcięciem:

def przywitaj():
    print("Cześć! Miło Cię widzieć.")

przywitaj()
przywitaj()

Ważna różnica: zdefiniowanie funkcji jej nie uruchamia — dopiero wywołanie, czyli nazwa z nawiasami, wykonuje zawarty w niej kod. Dzięki temu raz napisany fragment możesz odpalać dowolnie wiele razy, w dowolnym miejscu programu.

Po co w ogóle dzielić kod na funkcje? Po pierwsze — przeciwko powtórzeniom: gdy ta sama logika pojawia się w kilku miejscach, wydzielasz ją do funkcji i poprawkę wprowadzasz raz. Po drugie — czytelność: dobra nazwa (np. oblicz_napiwek) mówi, co robi kod, bez zaglądania do jego wnętrza. Po trzecie — łatwiejsze sprawdzanie: mały, odseparowany fragment łatwo przetestować na kilku przykładach.

Parametry — dane wejściowe funkcji

Funkcja staje się naprawdę użyteczna, gdy przyjmuje dane z zewnątrz. Wartości wpisane w nawiasach przy definicji to parametry:

def przywitaj(imie):
    print("Cześć,", imie + "!")

przywitaj("Ania")
przywitaj("Marek")

Przy każdym wywołaniu podajesz inną wartość, a funkcja zachowuje się nieco inaczej — bez kopiowania ani jednej linii.

return — funkcja zwraca wynik

print() tylko pokazuje coś na ekranie. Gdy chcesz, by funkcja oddalała wynik do dalszych obliczeń, używasz instrukcji return:

def pole_kwadratu(bok):
    return bok * bok

wynik = pole_kwadratu(5)
print(wynik)             # 25
print(pole_kwadratu(3))  # 9

To kluczowa różnica: wartość zwróconą przez return możesz zapisać w zmiennej i używać dalej. Tekst wypisany przez print() „ucieka" na ekran i program nie może już go wykorzystać.

Zapamiętaj jeszcze dwie rzeczy: return natychmiast kończy działanie funkcji — kod wpisany pod nim w tej samej funkcji nigdy się nie wykona. A funkcja bez return zwraca specjalną wartość None, co na początku nauki bywa zaskoczeniem.

Jak program rozmawia z użytkownikiem: input()

Funkcja input() zatrzymuje program i czeka, aż użytkownik coś wpisze i naciśnie Enter. Ma jedną pułapkę: zawsze zwraca tekst (str), nawet jeśli ktoś wpisze samą liczbę. Dlatego przed obliczeniami trzeba dokonać konwersji:

odpowiedz = input("Podaj liczbę: ")
print(type(odpowiedz))  # <class 'str'>

liczba = float(odpowiedz)  # konwersja tekstu na liczbę
print(liczba * 2)

float() zamienia tekst na liczbę dziesiętną, a int() — na całkowitą. Bez tej zamiany "5" * 2 dałoby tekst "55", a nie liczbę 10.

Projekt: kalkulator napiwków

Czas złożyć wszystko razem. Program pyta o kwotę rachunku, procent napiwku i liczbę osób, a następnie oblicza napiwek, sumę do zapłaty i kwotę na osobę. Zauważ, że obliczenia mieszkają w funkcjach, a „rozmowa" z użytkownikiem — w głównej części programu:

def oblicz_napiwek(rachunek, procent):
    napiwek = rachunek * procent / 100
    return napiwek

def podziel_rachunek(kwota, osoby):
    return kwota / osoby

rachunek = float(input("Podaj kwotę rachunku (zł): "))
procent = float(input("Jaki napiwek chcesz zostawić (%): "))
osoby = int(input("Ilu jesteście?: "))

napiwek = oblicz_napiwek(rachunek, procent)
suma = rachunek + napiwek
na_osobe = podziel_rachunek(suma, osoby)

print("Napiwek:", round(napiwek, 2), "zł")
print("Razem do zapłaty:", round(suma, 2), "zł")
print("Każdy płaci:", round(na_osobe, 2), "zł")

Prześledź kolejność: najpierw definicje funkcji, potem trzy pytania do użytkownika, następnie wywołania funkcji i na końcu wypisanie wyników. Funkcja round(x, 2) zaokrągla liczbę do dwóch miejsc po przecinku — przy pieniądzach to niemal zawsze dobry pomysł.

Taka budowa — małe funkcje robiące jedną rzecz — to nawyk, który procentuje w każdym większym projekcie. Warto go wynieść z lekcji IKO Kursy i stosować od pierwszego własnego programu.

Ćwiczenie (15 minut): rozbuduj kalkulator o własną funkcję.
  1. Napisz funkcję przelicz_na_euro(kwota_pln), która przyjmie kurs 4.30 i zwróci kwotę w euro (kwota_pln / 4.30).
  2. Użyj jej na końcu programu, by wypisać rachunek także w euro.
  3. Dla chętnych: dodaj funkcję ocen_napiwek(procent), która zwróci tekst — „skromny", „standardowy" albo „hojny" — używając if / elif / else.

Rozwiązanie wzorcowe pierwszego kroku:

def przelicz_na_euro(kwota_pln):
    kurs = 4.30
    return kwota_pln / kurs

print("Rachunek w euro:", round(przelicz_na_euro(suma), 2))

Najważniejsze pojęcia z tej lekcji

  • def
  • parametr
  • wywołanie funkcji
  • return
  • input()
  • float() / int()
  • round()
Podsumowanie: funkcje porządkują kod w nazwane bloki, parametry dostarczają im dane, a return oddaje wynik. Połączone z input() pozwalają pisać programy, które naprawdę rozmawiają z użytkownikiem. To koniec wprowadzającej części kursu — kolejne moduły pojawią się wraz z rozwojem platformy, a najlepsze, co możesz teraz zrobić, to przepisać wszystkie przykłady własnymi słowami.