Funkcje: ponowne używanie kodu

Witaj z powrotem.

W poprzedniej lekcji nauczyłeś się słowników.

Twoje programy nauczyły się przechowywać dane strukturalne przez klucze i wartości.

Pisałeś rzeczy takie jak:

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

Bardzo dobrze.

Teraz twoje programy mogą przechowywać dane ze znaczeniem.

Nie tylko losowe wartości unoszące się jak zagubione balony.

Ale teraz mamy kolejny problem.

Co jeśli musimy używać tego samego kodu wiele razy?

Na przykład:

print("Hello, Anna!")
print("Welcome to the program.")
print("Have a nice day!")

Potem później:

print("Hello, Marco!")
print("Welcome to the program.")
print("Have a nice day!")

Potem jeszcze raz:

print("Hello, Sofia!")
print("Welcome to the program.")
print("Have a nice day!")

To działa.

Ale jest powtarzalne.

A powtarzalny kod jest niebezpieczny.

Bo pewnego dnia musisz coś zmienić.

Potem musisz zmienić to w pięciu miejscach.

Potem zapominasz o jednym miejscu.

Potem pojawia się bug.

Potem kawa staje się paliwem awaryjnym.

Funkcje rozwiązują ten problem.

Funkcje pozwalają ponownie używać kodu.

Piszesz kod raz.

Potem wywołujesz go zawsze, kiedy go potrzebujesz.

Bardzo użyteczne.

Bardzo czyste.

Bardzo Python.

Czego się nauczysz

W tej lekcji nauczysz się:

• czym jest funkcja;
• dlaczego funkcje są użyteczne;
• jak stworzyć funkcję przez def;
• jak wywołać funkcję;
• jak działa wcięcie w funkcjach;
• jak używać parametrów;
• jak przekazywać argumenty;
• jak zwracać wartości przez return;
• jaka jest różnica między print() i return;
• jak używać domyślnych wartości parametrów;
• jak działa scope zmiennych;
• jak unikać powtarzanego kodu;
• typowych błędów początkujących;
• jak budować małe programy z funkcjami.

Pod koniec tej lekcji twój kod będzie bardziej uporządkowany.

Mniej powtórzeń.

Więcej struktury.

Mniej katastrof z kopiuj-wklej.

Miejmy nadzieję.

Funkcje są jednym z największych kroków w programowaniu.

Przed funkcjami kod jest długą drogą.

Po funkcjach kod staje się miastem ze znakami.

Nadal można się zgubić.

Ale przynajmniej są znaki.

Czym jest funkcja?

Funkcja to blok kodu, którego można używać wiele razy.

Definiujesz ją raz.

Potem możesz jej używać wiele razy.

Przykład:

def say_hello():
    print("Hello!")

To tworzy funkcję o nazwie:

say_hello

Ale samo stworzenie funkcji jej nie uruchamia.

Aby uruchomić funkcję, musisz ją wywołać:

say_hello()

Pełny przykład:

def say_hello():
    print("Hello!")

say_hello()

Output:

Hello!

Funkcja jest jak mała maszyna.

Budujesz ją raz.

Potem naciskasz przycisk.

Przyciskiem jest wywołanie funkcji.

Bardzo technicznie.

Bardzo przycisk.

Twoja pierwsza funkcja

Utwórz plik:

functions.py

Napisz:

def greet():
    print("Hello from a function!")

greet()

Uruchom:

python functions.py

albo:

python3 functions.py

Output:

Hello from a function!

Ta linia tworzy funkcję:

def greet():

Ta linia należy do funkcji:

    print("Hello from a function!")

Ta linia wywołuje funkcję:

greet()

Ważne:

def tworzy funkcję.
Wywołanie funkcji ją uruchamia.

Jeśli tylko zdefiniujesz funkcję, ale nigdy jej nie wywołasz, nic się nie stanie.

Python jest uprzejmy.

Nie uruchamia funkcji, jeśli go nie poprosisz.

W przeciwieństwie do niektórych ludzi, którzy dają rady bez pytania.

Składnia funkcji

Podstawowa funkcja wygląda tak:

def function_name():
    code_here

Przykład:

def show_menu():
    print("1. Add item")
    print("2. Show items")
    print("q. Quit")

Części:

def              zaczyna definicję funkcji
function_name    nazwa funkcji
()               nawiasy
:                zaczyna ciało funkcji
wcięcie          kod wewnątrz funkcji

Dwukropek jest ważny.

Wcięcie jest ważne.

Python nadal bardzo troszczy się o wcięcia.

Bardzo.

Python widzi wcięcia jak plan budynku.

Jeśli wcięcie jest złe, budynek się zawala.

Cyfrowo.

Wywoływanie funkcji wiele razy

Funkcje można wywoływać wiele razy.

Przykład:

def say_hello():
    print("Hello!")

say_hello()
say_hello()
say_hello()

Output:

Hello!
Hello!
Hello!

Funkcja została napisana raz.

Ale uruchomiła się trzy razy.

To jest siła funkcji.

Bez kopiowania tego samego kodu wszędzie.

Tworzysz jeden blok wielokrotnego użytku.

Potem używasz go, kiedy trzeba.

Bardzo czysto.

Bardzo cywilizowanie.

Bardzo inaczej niż folder o nazwie final_final_REAL_final.py.

Dlaczego funkcje są użyteczne

Funkcje pomagają:

• unikać powtórzeń;
• organizować kod;
• ponownie używać logiki;
• pisać kod łatwiejszy do czytania;
• pisać kod łatwiejszy do zmiany;
• dzielić duże problemy na mniejsze problemy.

Bez funkcji program może stać się jedną długą rzeką kodu.

Straszną rzeką.

Z funkcjami możesz podzielić program na mniejsze części.

Przykład:

pokazać menu
pobrać wybór użytkownika
dodać zadanie
pokazać zadania
zamknąć program

Każda część może stać się funkcją.

To sprawia, że kod jest łatwiejszy do zrozumienia.

Twój przyszły ty ci podziękuje.

Może.

Przyszły ty często jest zmęczony.

Wcięcie w funkcjach

Kod wewnątrz funkcji musi być wcięty.

Poprawnie:

def greet():
    print("Hello!")

Źle:

def greet():
print("Hello!")

Python pokaże:

IndentationError

Wcięte linie należą do funkcji.

Przykład:

def greet():
    print("Hello!")
    print("Welcome!")

print("This is outside the function.")

Tutaj:

print("Hello!")
print("Welcome!")

należą do funkcji.

Ta linia:

print("This is outside the function.")

nie należy do funkcji.

Wcięcie decyduje o przynależności.

Jak dokumenty.

Ale ze spacjami.

Nazwy funkcji

Nazwy funkcji powinny być jasne.

Dobrze:

def show_menu():
    print("Menu")

Dobrze:

def calculate_total():
    print("Calculating...")

Źle:

def x():
    print("Something")

Źle:

def do_stuff():
    print("Stuff")

Używaj nazw, które wyjaśniają, co funkcja robi.

Nazwy funkcji zwykle używają małych liter i podkreśleń:

show_menu
calculate_total
add_product
get_user_name

Ten styl nazywa się snake_case.

Python lubi snake_case.

Nie prawdziwe węże.

Prawdopodobnie.

Parametry

Parametr pozwala funkcji otrzymać dane.

Przykład:

def greet_user(name):
    print(f"Hello, {name}!")

Tutaj:

name

jest parametrem.

To jak zmienna wejściowa dla funkcji.

Teraz wywołaj funkcję:

greet_user("Anna")
greet_user("Marco")
greet_user("Sofia")

Pełny przykład:

def greet_user(name):
    print(f"Hello, {name}!")

greet_user("Anna")
greet_user("Marco")
greet_user("Sofia")

Output:

Hello, Anna!
Hello, Marco!
Hello, Sofia!

Funkcja jest wielokrotnego użytku.

Wiadomość zmienia się zależnie od wartości, którą przekazujesz.

Bardzo użyteczne.

Bardzo czyste.

Dużo mniej kopiuj-wklej.

Argumenty

Kiedy wywołujesz funkcję, wartość, którą przekazujesz, nazywa się argumentem.

Przykład:

def greet_user(name):
    print(f"Hello, {name}!")

greet_user("Anna")

Tutaj:

name

jest parametrem.

A:

"Anna"

jest argumentem.

Proste wyjaśnienie:

parametr = zmienna w definicji funkcji
argument = konkretna wartość przekazana przy wywołaniu funkcji

Ludzie często używają tych słów dość luźno.

Nie panikuj.

Najważniejsza idea to:

Funkcje mogą otrzymywać wartości.

To jest najważniejsze.

Funkcja z dwoma parametrami

Funkcja może mieć więcej niż jeden parametr.

Przykład:

def greet_user(name, city):
    print(f"Hello, {name} from {city}!")

Wywołaj ją:

greet_user("Anna", "Rome")

Pełny przykład:

def greet_user(name, city):
    print(f"Hello, {name} from {city}!")

greet_user("Anna", "Rome")
greet_user("Marco", "Milan")

Output:

Hello, Anna from Rome!
Hello, Marco from Milan!

Kolejność ma znaczenie.

To:

greet_user("Anna", "Rome")

oznacza:

name = Anna
city = Rome

Jeśli je zamienisz:

greet_user("Rome", "Anna")

Output:

Hello, Rome from Anna!

Technicznie poprawne.

Emocjonalnie dziwne.

Funkcje i obliczenia

Funkcje są świetne do obliczeń.

Przykład:

def add_numbers(a, b):
    total = a + b
    print(total)

add_numbers(5, 3)

Output:

8

Tutaj:

a
b

są parametrami.

Ta funkcja dodaje je i wyświetla wynik.

Inny przykład:

def calculate_total(price, quantity):
    total = price * quantity
    print(f"Total: {total:.2f}")

calculate_total(10.00, 3)

Output:

Total: 30.00

To jest użyteczne.

Ale jest lepszy sposób.

Zamiast tylko wyświetlać wynik, możemy go zwrócić.

I tutaj pojawia się return.

Bardzo ważne.

Bardzo funkcyjne.

Zwracanie wartości

Funkcja może zwracać wartość.

Przykład:

def add_numbers(a, b):
    return a + b

result = add_numbers(5, 3)

print(result)

Output:

8

Funkcja:

def add_numbers(a, b):
    return a + b

nie drukuje.

Ona oddaje wynik z powrotem.

Ta linia zapisuje wynik:

result = add_numbers(5, 3)

Potem go drukujemy:

print(result)

To jest bardzo ważne.

Funkcja, która zwraca wartość, jest bardziej elastyczna.

Możesz wydrukować wartość.

Albo ją zapisać.

Albo użyć jej w innym obliczeniu.

Albo przekazać do innej funkcji.

Tutaj funkcje stają się potężne.

print() vs return

To jest bardzo ważne.

print() pokazuje coś na ekranie.

return wysyła wartość z powrotem z funkcji.

Przykład z print():

def add_numbers(a, b):
    print(a + b)

result = add_numbers(5, 3)

print(result)

Output:

8
None

Dlaczego None?

Bo funkcja wydrukowała wynik, ale niczego nie zwróciła.

Teraz przykład z return:

def add_numbers(a, b):
    return a + b

result = add_numbers(5, 3)

print(result)

Output:

8

Prosta zasada:

Używaj print(), żeby coś pokazać.
Używaj return, żeby zwrócić wartość.

To jedna z najważniejszych lekcji dla początkujących.

Bardzo ważna.

Bardzo łatwa do pomylenia.

Bardzo normalna.

Funkcja, która zwraca sumę

Przykład:

def calculate_total(price, quantity):
    return price * quantity

total = calculate_total(25.00, 4)

print(f"Total: {total:.2f}")

Output:

Total: 100.00

Teraz funkcja oblicza.

Główny program decyduje, co zrobić z wynikiem.

To jest czystsze.

Funkcja ma jedno zadanie:

obliczyć sumę

Główny program ma inne zadanie:

pokazać wynik

Ten podział jest dobry.

Bardzo dobry.

Bardzo profesjonalny.

Bardzo “dzisiaj bez spaghetti”.

Domyślne wartości parametrów

Parametr może mieć wartość domyślną.

Przykład:

def greet_user(name="Guest"):
    print(f"Hello, {name}!")

Teraz możesz wywołać:

greet_user("Anna")
greet_user()

Pełny przykład:

def greet_user(name="Guest"):
    print(f"Hello, {name}!")

greet_user("Anna")
greet_user()

Output:

Hello, Anna!
Hello, Guest!

Kiedy przekazujesz imię, Python go używa.

Kiedy nie przekazujesz imienia, Python używa "Guest".

To jest przydatne, kiedy wartość jest opcjonalna.

Wartości domyślne są jak plan awaryjny.

Rzadka rzecz w programowaniu, która brzmi naprawdę pocieszająco.

Argumenty nazwane

Możesz przekazywać argumenty po nazwie.

Przykład:

def describe_product(name, price):
    print(f"{name}: {price:.2f}")

describe_product(name="Keyboard", price=70.00)

Output:

Keyboard: 70.00

To nazywa się używanie keyword arguments.

Może sprawić, że wywołania funkcji będą jaśniejsze.

Szczególnie kiedy jest dużo parametrów.

Przykład:

def create_user(name, age, city):
    print(f"{name}, {age}, {city}")

create_user(name="Anna", age=25, city="Rome")

To jest czytelniejsze niż:

create_user("Anna", 25, "Rome")

Oba sposoby działają.

Argumenty nazwane sprawiają, że znaczenie jest jaśniejsze.

A jasny kod ma mniejsze szanse zaatakować cię później.

Zwykle.

Scope zmiennych

Zmienne stworzone wewnątrz funkcji istnieją tylko wewnątrz tej funkcji.

Przykład:

def greet():
    message = "Hello!"

greet()

print(message)

To daje błąd:

NameError

Dlaczego?

Bo message została stworzona wewnątrz funkcji.

Poza funkcją nie istnieje.

To nazywa się scope.

Scope oznacza:

gdzie zmienna jest dostępna

Zmienna wewnątrz funkcji jest lokalna dla tej funkcji.

Żyje tam.

Nie wychodzi na zewnątrz.

Bardzo prywatna.

Bardzo introwertyczna.

Zmienne lokalne

Przykład:

def calculate_total(price, quantity):
    total = price * quantity
    return total

result = calculate_total(10, 3)

print(result)

Output:

30

Tutaj:

total

istnieje wewnątrz funkcji.

To działa:

return total

bo jesteśmy wewnątrz funkcji.

Ale to nie zadziałałoby:

print(total)

poza funkcją.

Zmienna total jest lokalna.

Jeśli potrzebujesz wyniku poza funkcją, zwróć go.

To jest poprawny sposób.

Nie próbuj kraść lokalnych zmiennych przez okno.

Python zamyka okno.

Funkcja z listą

Funkcje mogą otrzymywać listy.

Przykład:

def show_products(products):
    for product in products:
        print(f"- {product}")

items = ["Keyboard", "Mouse", "Notebook"]

show_products(items)

Output:

- Keyboard
- Mouse
- Notebook

Funkcja otrzymuje listę.

Potem przechodzi przez listę.

To jest bardzo częste.

Funkcje i listy świetnie ze sobą współpracują.

Lista przechowuje wiele wartości.

Funkcja je przetwarza.

Bardzo użyteczne.

Bardzo realne.

Bardzo “to może kiedyś zostać raportem”.

Funkcja, która oblicza sumę listy

Przykład:

def calculate_total(prices):
    total = 0

    for price in prices:
        total += price

    return total

prices = [10.00, 25.50, 5.00]

total = calculate_total(prices)

print(f"Total: {total:.2f}")

Output:

Total: 40.50

Ta funkcja działa z dowolną listą cen.

Przykład:

order_one = [10.00, 20.00]
order_two = [5.50, 7.25, 100.00]

print(calculate_total(order_one))
print(calculate_total(order_two))

Ta sama funkcja działa dla różnych danych.

To jest piękno funkcji.

Piszesz raz.

Używasz ponownie.

Czujesz się lekko potężny.

Funkcja ze słownikiem

Funkcje mogą otrzymywać też słowniki.

Przykład:

def show_user(user):
    print(f"Name: {user['name']}")
    print(f"Age: {user['age']}")
    print(f"City: {user['city']}")

user = {
    "name": "Anna",
    "age": 25,
    "city": "Rome"
}

show_user(user)

Output:

Name: Anna
Age: 25
City: Rome

To jest bardzo użyteczne.

Słownik przechowuje dane strukturalne.

Funkcja je pokazuje albo przetwarza.

Prawdziwe aplikacje robią to ciągle.

Użytkownicy.

Produkty.

Zamówienia.

Profile.

Wszystko staje się łatwiejsze, kiedy funkcje obsługują dane strukturalne.

Bardzo praktyczne.

Bardzo przyjazne backendowi.

Funkcja z listą słowników

Przykład:

def show_products(products):
    for product in products:
        print(f"{product['name']}: {product['price']:.2f}")

products = [
    {"name": "Keyboard", "price": 70.00},
    {"name": "Mouse", "price": 25.00},
    {"name": "Notebook", "price": 5.50}
]

show_products(products)

Output:

Keyboard: 70.00
Mouse: 25.00
Notebook: 5.50

To mocny schemat.

Znasz już listy.

Znasz już słowniki.

Teraz otaczasz je funkcjami.

Tak programy stają się uporządkowane.

Struktury danych przechowują dane.

Funkcje pracują z danymi.

Bardzo ważna idea.

Bardzo software.

Typowy błąd: zapomnienie nawiasów

Źle:

def greet():
    print("Hello!")

greet

To nie wywołuje funkcji.

Poprawnie:

greet()

Nawiasy wywołują funkcję.

Bez nawiasów tylko odwołujesz się do funkcji.

Python mówi:

Tak, ta funkcja istnieje.

Ale jej nie uruchamia.

Wywołanie funkcji potrzebuje nawiasów.

Małe kółka.

Duża odpowiedzialność.

Typowy błąd: zapomnienie dwukropka

Źle:

def greet()
    print("Hello!")

Poprawnie:

def greet():
    print("Hello!")

Definicje funkcji potrzebują dwukropka.

Python kocha dwukropki.

Warunki potrzebują dwukropków.

Pętle potrzebują dwukropków.

Funkcje potrzebują dwukropków.

Python praktycznie buduje małą kolekcję dwukropków.

Szanuj ją.

Typowy błąd: złe wcięcie

Źle:

def greet():
print("Hello!")

Poprawnie:

def greet():
    print("Hello!")

Ciało funkcji musi być wcięte.

Jeśli wcięcie jest złe, Python daje:

IndentationError

To nie Python dramatyzuje.

On naprawdę nie wie, co należy do funkcji.

Wcięcie to struktura.

Znowu.

Zawsze znowu.

Typowy błąd: zapomnienie return

Źle:

def add_numbers(a, b):
    total = a + b

result = add_numbers(5, 3)

print(result)

Output:

None

Dlaczego?

Bo funkcja niczego nie zwraca.

Poprawnie:

def add_numbers(a, b):
    total = a + b
    return total

result = add_numbers(5, 3)

print(result)

Output:

8

Jeśli potrzebujesz wartości poza funkcją, zwróć ją.

Nie tylko ją obliczaj.

Obliczenie uwięzione wewnątrz funkcji jest jak pizza za szybą.

Ładnie wygląda.

Nie jest użyteczne.

Typowy błąd: kod po return

Kiedy Python dochodzi do return, funkcja się kończy.

Przykład:

def test():
    return "Done"
    print("This will not run")

message = test()

print(message)

Output:

Done

Ta linia się nie wykona:

print("This will not run")

Bo jest po return.

return natychmiast wychodzi z funkcji.

Bardzo ważne.

Wszystko po return w tym samym bloku jest ignorowane.

Jak rada po tym, jak ktoś już zamknął drzwi.

Typowy błąd: zbyt wiele odpowiedzialności

Zła funkcja:

def do_everything():
    print("Show menu")
    print("Ask user")
    print("Add product")
    print("Calculate total")
    print("Send email")

Ta funkcja robi za dużo.

Lepiej:

def show_menu():
    print("Menu")

def add_product():
    print("Add product")

def calculate_total():
    print("Calculate total")

Dobra funkcja zwykle robi jedną jasną rzecz.

Nie zawsze idealnie.

Ale próbuj.

Funkcje powinny być wystarczająco małe, żeby dało się je zrozumieć.

Jeśli funkcja robi się ogromna, może trzeba ją podzielić.

Jak pizzę.

Ale z kodem.

Mini program: funkcja powitania

Utwórz plik:

greeting_function.py

Napisz:

def greet_user(name):
    print(f"Hello, {name}!")
    print("Welcome to the program.")

user_name = input("What is your name? ")

greet_user(user_name)

Przykład:

What is your name? Anna

Output:

Hello, Anna!
Welcome to the program.

Ten program używa:

• definicji funkcji;
• parametru;
• inputu użytkownika;
• wywołania funkcji.

Prosty.

Ale ważny.

Nie piszesz już tylko kodu liniowego.

Organizujesz zachowanie.

Bardzo dobrze.

Mini program: kalkulator sumy

Utwórz plik:

total_calculator.py

Napisz:

def calculate_total(price, quantity):
    return price * quantity

price = float(input("Price: "))
quantity = int(input("Quantity: "))

total = calculate_total(price, quantity)

print(f"Total: {total:.2f}")

Przykład:

Price: 25
Quantity: 4

Output:

Total: 100.00

Ten program używa:

• funkcji z parametrami;
• return;
• inputu;
• konwersji typu;
• formatowanego outputu.

Bardzo praktyczne.

Bardzo sklepowe.

Bardzo “to kiedyś może stać się fakturą”.

Ostrożnie.

Faktury przyciągają podatki.

Mini program: funkcja średniej

Utwórz plik:

average_function.py

Napisz:

def calculate_average(numbers):
    total = 0

    for number in numbers:
        total += number

    return total / len(numbers)

scores = []

score_count = int(input("How many scores? "))

for number in range(1, score_count + 1):
    score = float(input(f"Score {number}: "))
    scores.append(score)

average = calculate_average(scores)

print(f"Average: {average:.2f}")

Przykład:

How many scores? 3
Score 1: 80
Score 2: 90
Score 3: 70

Output:

Average: 80.00

Ten program łączy:

• listy;
• pętle;
• funkcje;
• input;
• return;
• obliczenia.

Bardzo dobra praktyka dla początkujących.

To prawdziwy schemat.

Zbierz dane.

Przekaż dane do funkcji.

Otrzymaj wynik.

Pokaż wynik.

Czysto.

Użytecznie.

Wystarczająco profesjonalnie, żeby przestraszyć kod spaghetti.

Praktyka

Utwórz plik:

practice_functions.py

Napisz program, który:

• definiuje funkcję calculate_discount;
• otrzymuje price i discount_percent;
• zwraca cenę po rabacie;
• pyta użytkownika o cenę i rabat;
• wyświetla końcową cenę.

Przykładowe rozwiązanie:

def calculate_discount(price, discount_percent):
    discount_amount = price * discount_percent / 100
    final_price = price - discount_amount
    return final_price

price = float(input("Price: "))
discount = float(input("Discount percent: "))

final_price = calculate_discount(price, discount)

print(f"Final price: {final_price:.2f}")

Przykład:

Price: 100
Discount percent: 20

Output:

Final price: 80.00

To bardzo użyteczne.

Rabaty są wszędzie.

Sklepy ich używają.

Klienci je lubią.

Developerzy je obliczają.

Księgowi je sprawdzają.

Każdy ma rolę.

Bardzo uporządkowany chaos.

Mini wyzwanie

Utwórz plik:

task_manager_functions.py

Twój program powinien:

• zacząć od pustej listy tasks;
• zdefiniować funkcję show_menu;
• zdefiniować funkcję add_task;
• zdefiniować funkcję show_tasks;
• używać pętli while True;
• pozwalać użytkownikowi dodawać zadania;
• pozwalać użytkownikowi pokazywać zadania;
• pozwalać użytkownikowi wyjść.

Przykładowe rozwiązanie:

tasks = []

def show_menu():
    print("----- Task Manager -----")
    print("1. Add task")
    print("2. Show tasks")
    print("q. Quit")

def add_task(tasks):
    task = input("Task: ")
    tasks.append(task)
    print("Task added.")

def show_tasks(tasks):
    if len(tasks) == 0:
        print("No tasks yet.")
    else:
        print("Tasks:")

        for task in tasks:
            print(f"- {task}")

while True:
    show_menu()

    choice = input("Choose an option: ").lower()

    if choice == "1":
        add_task(tasks)
    elif choice == "2":
        show_tasks(tasks)
    elif choice == "q":
        print("Goodbye.")
        break
    else:
        print("Unknown option.")

To lepsza wersja task managera.

Dlaczego?

Bo kod jest zorganizowany w funkcje.

Każda funkcja ma zadanie:

show_menu      pokazuje menu
add_task       dodaje zadanie
show_tasks     pokazuje wszystkie zadania

Główna pętla staje się łatwiejsza do czytania.

O to chodzi w funkcjach.

Sprawiają, że programy są łatwiejsze do organizacji.

Mniej chaosu.

Więcej struktury.

Nadal Python.

Extra challenge: funkcje dla produktów

Utwórz plik:

product_functions.py

Zbuduj program z tymi funkcjami:

create_product()
show_product(product)
calculate_total(products)

Każdy produkt powinien być słownikiem z:

name
price
quantity

Przykładowy pomysł:

def create_product():
    product = {
        "name": input("Name: "),
        "price": float(input("Price: ")),
        "quantity": int(input("Quantity: "))
    }

    return product

def show_product(product):
    total = product["price"] * product["quantity"]
    print(f"{product['name']}: {product['quantity']} x {product['price']:.2f} = {total:.2f}")

def calculate_total(products):
    total = 0

    for product in products:
        total += product["price"] * product["quantity"]

    return total

products = []

product_count = int(input("How many products? "))

for number in range(1, product_count + 1):
    print(f"Product {number}")
    product = create_product()
    products.append(product)

print("----- Products -----")

for product in products:
    show_product(product)

total = calculate_total(products)

print(f"Total: {total:.2f}")

To wyzwanie łączy:

• funkcje;
• listy;
• słowniki;
• pętle;
• input;
• zwracane wartości;
• obliczenia.

To poważny Python dla początkujących.

Mała logika sklepu.

Dane strukturalne.

Kod wielokrotnego użytku.

Bardzo mocne.

Bardzo użyteczne.

Bardzo “zaczynasz budować prawdziwe rzeczy”.

Checklist dla początkujących

Kiedy twoja funkcja nie działa, sprawdź:

Czy użyłem def?
Czy dodałem nawiasy?
Czy dodałem dwukropek?
Czy wciąłem ciało funkcji?
Czy wywołałem funkcję?
Czy przekazałem poprawną liczbę argumentów?
Czy dobrze napisałem nazwę funkcji?
Czy użyłem return, jeśli potrzebuję wartości z powrotem?
Czy nie mylę print() i return?
Czy zmienna jest lokalna dla funkcji?
Czy umieściłem kod po return?
Czy funkcja nie robi zbyt wielu rzeczy?

Funkcje są potężne.

Ale wprowadzają nowe błędy.

To normalne.

Na początku funkcje wyglądają jak dodatkowa praca.

Potem pewnego dnia piszesz program bez funkcji i czujesz ból.

Wtedy rozumiesz.

Rozwój jest piękny.

I lekko irytujący.

Podsumowanie

Dzisiaj nauczyłeś się:

• funkcje są blokami kodu wielokrotnego użytku;
• def tworzy funkcję;
• wywołanie funkcji ją uruchamia;
• ciało funkcji musi być wcięte;
• parametry pozwalają funkcjom otrzymywać dane;
• argumenty to wartości przekazywane do funkcji;
• funkcje mogą mieć wiele parametrów;
• return zwraca wartość;
• print() pokazuje wartość, ale jej nie zwraca;
• domyślne wartości parametrów są możliwe;
• argumenty nazwane mogą zwiększyć czytelność wywołań;
• zmienne wewnątrz funkcji są lokalne;
• funkcje mogą otrzymywać listy;
• funkcje mogą otrzymywać słowniki;
• funkcje mogą pracować z listami słowników;
• dobra funkcja zwykle robi jedno jasne zadanie;
• funkcje pomagają organizować programy i zmniejszać powtórzenia.

To ogromny krok.

Twój kod może teraz być czystszy.

Bardziej wielokrotnego użytku.

Bardziej uporządkowany.

Mniej kopiuj-wklej.

Mniej chaosu.

Funkcje są jednym z głównych narzędzi, które zmieniają skrypty początkujących w prawdziwe programy.

Nie piszesz już tylko komend.

Tworzysz zachowanie wielokrotnego użytku.

To poważny postęp.

Bardzo Python.

Bardzo następny poziom.

Następna lekcja

W następnej lekcji nauczymy się plików.

Pliki pozwalają twoim programom zapisywać dane.

Teraz, kiedy program się kończy, dane znikają.

Bardzo smutne.

Bardzo tymczasowe.

Z plikami możesz zapisać dane na dysku i odczytać je później.

Na przykład:

zapisać zadania
wczytać zadania
zapisać kontakty
czytać notatki
pisać raporty

To bardzo ważne.

Bo programy stają się dużo bardziej użyteczne, kiedy pamiętają rzeczy.

Pamięć to siła.

Chyba że zapisałeś zły plik.

Wtedy pamięć to dramat.

Bardzo edukacyjny dramat.