Wstęp
Przed pisaniem tej lekcji (jak i poprzednich) stanąłem przed dylematem.
Nie chcę robić kursu jakich wiele, chcę pokazywać biznesową korzyść i praktykę w każdej lekcji, i chcę robić pytona, czasem troszkę PHP i uczyć się c#. Ale, przez to muszę zrobić coś niestandardowego. Zamiast trzy lekcji poświęcić na struktury danych w pythonie, i wiele innych rzeczy, a na kończy przejść do programowania obiektowego, zrobimy to już na lekcjach 4 A i B.
Python posiada bardzo wygodne struktury, które dziś pokażę, ale, ze uzyskać tego typu efekt w c#, musimy stworzyć obiekty, a więc plan jest taki. Dziś sam Python, plus teoria programowania obiektowego, z drobnymi przykładami. Zupełne podstawy. a za tydzień już znów oba języki, i nasz program przeniesiony w świat obiektów.
Zaczynamy
Funkcje – czyli nie powtarzajmy tego samego kodu
Popatrz na kod z lekcji poprzedniej (Python).
- Mamy while True
- Później drukujemy menu
- Obsługa menu za pomocą if .. elif .. else
- Pobieranie wartości: kwota = float(input(„Podaj kwotę przychodu: „).replace(„,”, „.”)) , kwota = float(input(„Podaj kwotę wydatku: „).replace(„,”, „.”))
I tu się zatrzymajmy, mamy dwa razy prawie to samo. Gdyby cały kod miał tak wyglądać, to aplikacje miały by gigantyczne rozmiary. I dlatego właśnie powstały funkcje. Funkcja to sposób, na wykonanie tego samego fragmentu kodu w wielu miejscach.
Funkcje w Pythonie definiujemy słowem kluczowym def, poniżej zrobimy prostą funkcję, która po wywołaniu, będzie dodawała podane wartości.
Po kolei: definicja nagłówka funkcji i przyjmujemy (bez weryfikacji, tylko dla pokazania jakie to proste) dwie wartości, które konwertujemy na float.
def dodaj(x: float,y: float ) -> float: # definiujemy nazwę funkcji i przyjmowane przez nią zmienne x i y typu float oraz informujemy, iz funkcja zwróci typ float
return float(x) + float(y) # słowo klucozwe return oznacza, że funkcja zwróci tą wartośc, czyli w naszym przypadku sumę x i yPowyżej definiujemy funkcję dodaj, następnie w nawiasie podajemy zmienne, które funkcja przyjmie, mamy dwie, x i y. Po dwukropku wskazujemy, iż będą to funkcje typu float. Jest to informacja dla programistów, w pythonie nie ma obowiązku tego podawać, mogło być po prostu def dodaj(x, y): ale tu wskazujemy, również dla nas samych, co ma dostawać funkcja oraz jakiego rodzaju wartość zwracać w return -> float
Słowo kluczowe return kończy działanie funkcji i zwraca do głównego programu wynik jej działania.
W funkcji print wywołaliśmy funkcję dodaj, i przekazaliśmy 2 i 3, one w naszej funkcji zostały przekonwertowane na zmiennoprzecinkowe, i taki też otrzymaliśmy wynik 5.0
O Słownikach słów kilka (a nawet o krotkach)
Znasz już listy […] czyli sposób na zapisaniu wielu wartości w jednej zmiennej, gdzie do poszczególnych wartości odwołujesz się numerem indexu (od zera) – zmienna[0].
Ale, do naszej aplikacji chcielibyśmy przechowywać nie tylko wartość + lub – a i informacje, na co pieniądze były wydane, lub co to za przychód.
Lista jest strukturą zmienną, możemy dodawać dane, kasować, zmieniać, pobierać. Za kilka lekcji zajmiemy się tym głębiej, i zrobimy taką encyklopedyczną, gdzie pokażę różne opcje, ale na razie potrzebujemy dodawać i pobierać wartości.
Kolejną ciekawą strukturą, bardzo często używaną, jest krotka, po angielsku tuple.
Tuple, przechowuje dane tka jak lista, ale definiujemy ją nie w nawiasach kwadratowych a okrągłych, i raz stworzona jest niezmienna.
wydatek = ('Pensja za grudzień 2025', 8000.00) # definicja krotki o dwóch wartościach
print("tytuł wydatku: ", wydatek[0])
print("Kwota: ",wydatek[1])
Próba dodania nowej wartości spowoduje błąd:
To bardzo ważna cecha, dzięki niej, wiemy, że to co tam dodamy, pozostanie niezmienne.
Łącząc listę i krotki, moglibyśmy stworzyć program, który przechowa zarówno wartości, jak i opisy.
wydatki = [('Pensja za grudzień 2025', 8000.00),('Czynsz za grudzień 2025', -1050.23), ('Zajęcia dla dziecka judo', -260.00)]Powyżej mamy listę krotek.
Chcę, żebyś to zrozumiał, listę często używamy właśnie, do przechowywania wielu innych struktur.
Iterujemy pętlą for po elementach listy, i każdy z nich, jest naszą krotką, z dwoma wartościami.
W Pythonie jednak mamy do tego celu lepszą strukturę, w dodatku prawie tożsamą z wszechobecnym w Internecie formatem JSON – do którego wcale niedługo wrócimy. Mowa o słownikach, czyli dict.
Słownik tym się różni od list i krotek, że nie pobieramy zmiennych indexem, a nazwą.
Nasz przykładowy wydatek będzie wyglądał tak:
wydatek = {'tytul':'Pensja za grudzień 2025',
'kwota':8000.00}i teraz zamiast wydatek[0] piszemy wydatek[„tytul’]
Wygodne, i eleganckie a dodatkowo możemy wartości poprawiać. Zanim połączymy to wszystko w jedno, jeszcze jeden element – we wszystkich innych językach zwany case a w pythonie march:
match case – nasza centrala telefoniczna
Nasze menu, obsługiwaliśmy używając if else, działa oczywiście doskonale, ale mamy w pythonie funkcję, która pozwala zbadać wartość zmiennej, i na podstawie wartości podjąć decyzję, co zrobić. Jest w takich zastosowaniach czytelniejsza niż wiele ifów.
wybor = input("Wybierz opcję: ")
match wybor:
case "1":
# Tutaj wywołamy naszą nową funkcję:
case "2":
# I kolejną:
case "3":
# I kolejną:
case "4":
print("Do zobaczenia!")
break # Koniec pętli
case _: # Domyślny przypadek (odpowiednik 'else')
print("Nieznana opcja.")czyli pobieramy wartość i badamy ją w match. Jeśli kliknęliśmy „1” wykonywany jest kod po case „1”.
Czas na nową wersję naszej aplikacji.
Na początku deklarujemy listę historia
historia = [] # Globalna lista słownikówNastępnie pierwszą funkcję, pobierz_kwote
def pobierz_kwote(typ_operacji):
while True:
try:
tekst = input(f"Podaj kwotę {typ_operacji}: ").replace(",", ".")
kwota = float(tekst)
if kwota <= 0:
print("Kwota musi być dodatnia!")
continue
return kwota
except ValueError:
print("Błąd! Wprowadzona wartość nie jest liczbą.")Po kolei:
- definiujemy funkcję pobierz_kwote i przyjmujemy zmienną typ_operacji
- tworzymy pętlę pobierania zmiennej, które działa, dopóki użytkownik nie wprowadzi poprawnej kwoty
- w bloku try pobieramy kwotę z klawiatury do zmiennej tekst
- parsujemy ją do typu float
- jeśli jest mniejsza od zera, prosimy o wartości dodatnie.
- zwracamy wartość: return kwota
Kolejna funkcja, będzie nadrzędna dla powyższej, on ją wywoła.
def dodaj_transakcje(typ):
kwota = pobierz_kwote(typ)
opis = input(f"Podaj opis ({typ}): ")
# Przechowywanie w słowniku
transakcja = {
"typ": typ,
"opis": opis,
# -1 tylko dla wydatków
"kwota": kwota * (-1 if typ == "Wydatek" else 1)
}
historia.append(transakcja)
print(f"Zaksięgowano {typ}: {kwota:.2f} zł.")- Definiujemy funkcję dodaj_transakcje która przyjmuje typ transakcji
- definiujemy zmienną kwota i przypisujemy do niej wynik funkcji zdefiniowanej poprzednio a raczej, wywołujemy funkcję pobierz_kwote, i jej wynik przypisujemy.
- teraz przyjmujemy od użytkownika opis transakcji do zmiennej opis
- tworzymy zmienną transakcja, będącą słownikiem. Dodamy do opisu typ transakcji.
- używamy jednowierszowego ifa, kwota * (-1 if typ == „Wydatek” else 1) czyli czyto to się tak: -1 jeżeli typ to „Wydatek” a w przeciwnym razie 1 – czyli przemnażamy kwotę przez 1 lub -1
- dodajemy naszą transakcję do naszej listy o nazwie historia i informujemy użytkownika o zaksięgowanej kwocie. – kwota:.2f to oznacza zaokrąglenie do dwóch miejsc po przecinku
Teraz funkcja pokazująca historię transakcji
def pokaz_historie():
if not historia:
print("\nHistoria jest pusta.")
return
print("\n--- HISTORIA OPERACJI ---")
suma = 0
licznik = 1
for rekord in historia:
# Odczytujemy ze słownika
print(f"{licznik}. [{rekord['typ']}] {rekord['opis']}: {rekord['kwota']:.2f} zł")
suma += rekord['kwota']
licznik += 1
print(f"---------------------------")
print(f"AKTUALNE SALDO: {suma:.2f} zł")Tu chyba nic nie trzeba tłumaczyć, a jeśli tak to daj znać w komentarzu 😉
I poniżej dodajemy główny kod programu:
print("--- MONITOR BUDŻETU v4.0 ---")
while True:
print("\n--- MENU GŁÓWNE ---")
print("1. Dodaj PRZYCHÓD (+)")
print("2. Dodaj WYDATEK (-)")
print("3. Pokaż bilans i historię")
print("4. Koniec")
wybor = input("Wybierz opcję: ")
match wybor:
case '1':
dodaj_transakcje("Przychód")
case '2':
dodaj_transakcje("Wydatek")
case '3':
pokaz_historie()
case '4':
print("Koniec programu. Do zobaczenia!")
break
case _:
print("Nieznana opcja. Spróbuj ponownie.")Teraz program wygląda dużo czytelniej niż tydzień emu, prawda?
Oto całosć
historia = [] # Globalna lista słowników
def pobierz_kwote(typ_operacji):
while True:
try:
tekst = input(f"Podaj kwotę {typ_operacji}: ").replace(",", ".")
kwota = float(tekst)
if kwota <= 0:
print("Kwota musi być dodatnia!")
continue
return kwota
except ValueError:
print("Błąd! Wprowadzona wartość nie jest liczbą.")
def dodaj_transakcje(typ):
kwota = pobierz_kwote(typ)
opis = input(f"Podaj opis ({typ}): ")
# Przechowywanie w słowniku
transakcja = {
"typ": typ,
"opis": opis,
# Trik księgowego: -1 tylko dla wydatków
"kwota": kwota * (-1 if typ == "Wydatek" else 1)
}
historia.append(transakcja)
print(f"Zaksięgowano {typ}: {kwota:.2f} zł.")
def pokaz_historie():
if not historia:
print("\nHistoria jest pusta.")
return
print("\n--- HISTORIA OPERACJI ---")
suma = 0
licznik = 1
for rekord in historia:
# Odczytujemy ze słownika
print(f"{licznik}. [{rekord['typ']}] {rekord['opis']}: {rekord['kwota']:.2f} zł")
suma += rekord['kwota']
licznik += 1
print(f"---------------------------")
print(f"AKTUALNE SALDO: {suma:.2f} zł")
# --- Główna część programu ---
print("--- MONITOR BUDŻETU v4.0 ---")
while True:
print("\n--- MENU GŁÓWNE ---")
print("1. Dodaj PRZYCHÓD (+)")
print("2. Dodaj WYDATEK (-)")
print("3. Pokaż bilans i historię")
print("4. Koniec")
wybor = input("Wybierz opcję: ")
match wybor:
case '1':
dodaj_transakcje("Przychód")
case '2':
dodaj_transakcje("Wydatek")
case '3':
pokaz_historie()
case '4':
print("Koniec programu. Do zobaczenia!")
break
case _:
print("Nieznana opcja. Spróbuj ponownie.")
Przeanalizuj program dokładnie, i pobaw się.
Podstawy programowania obiektowego – teoria na szybko
Zanim zamkniemy tę lekcję, musimy przygotować grunt pod przyszły tydzień. W Lekcji 4B zrobimy to samo w C# (i zmodernizujemy Pythona), ale wejdziemy w świat Obiektów.
Brzmi groźnie? Spokojnie. Właśnie… prawie to zrobiliśmy w Pythonie, tylko nieświadomie!
Spójrz na nasz słownik:
transakcja = {
"typ": "Wydatek",
"opis": "Biedronka",
"kwota": -50.00
}
To jest zestaw danych. Do tego dopisaliśmy funkcje (np. dodaj_transakcje), które na tych danych operują. W podejściu, które stosowaliśmy dzisiaj, dane (słowniki) i funkcje (logika) latają sobie osobno.
W podejściu obiektowym (OOP – Object Oriented Programming) sklejamy je w jedną całość.
Dwa kluczowe pojęcia: KLASA i OBIEKT
Najłatwiej zrozumieć to na przykładzie wypieków.
- KLASA (Class) to Foremka. Definiuje kształt i właściwości. Foremka sama w sobie nie jest smaczna, nie można jej zjeść. Jest projektem. W programowaniu Klasa mówi: „Każda Transakcja musi mieć Opis, Kwotę i Typ”. Posiada też funkcje, zwane metodami, które obsłużą dodawanie, i podgląd danych (oraz modyfikacje i kasowanie).
- OBIEKT (Object) to Pierniczek. To konkretne ciastko wycięte tą foremką. Możesz ich wyciąć tysiące. Jeden jest posypany cukrem (Przychód), inny polany czekoladą (Wydatek). Każdy jest inny, ale wszystkie mają ten sam kształt narzucony przez foremkę. Jeden obiekt to konkretna transakcja w Lidlu, drugi to konkretna wypłata.
Dlaczego Słownik to za mało? (Zwiastun Lekcji 4B)
W Pythonie słownik jest „elastycznym workiem”. Możesz się pomylić i napisać:
transakcja = {„kwota”: 50, „opis”: „Chleb”}
Zrobiłeś literówkę (opsi zamiast opis). Python tego nie zauważy, dopóki program się nie wywali przy próbie odczytu. Foremka była z gumy i wyszedł krzywy piernik.
W programowaniu obiektowym (szczególnie w C#) tworzymy twardą Klasę Transakcja. Jeśli spróbujesz stworzyć obiekt z literówką w nazwie pola, kompilator uderzy Cię po łapach („Błąd! W tej foremce nie ma miejsca na 'opsi’!”).
Dlatego w następnej lekcji zamienimy nasze luźne słowniki na profesjonalne Klasy – zarówno w C#, jak i w Pythonie.
Przybornik Python – Nowości z Lekcji 4A
Dziś nasz program stał się modułowy. Oto narzędzia, dzięki którym to osiągnęliśmy:
| Komenda / Słowo kluczowe | Co to robi? | Przykład „z życia” |
def nazwa(): | Definiuje nową funkcję. Tworzy „podprogram”. | Przepis w książce kucharskiej. Zamiast pisać go za każdym razem od nowa, mówisz „Patrz strona 5”. |
return wartość | Kończy funkcję i zwraca wynik do miejsca, gdzie została wywołana. | Kelner przynosi gotowe danie z kuchni do stolika. |
{ "klucz": "wartość" } | Tworzy Słownik (dict). Przechowuje dane skojarzone z nazwą (kluczem). | Szafka z szufladami. Każda szuflada ma naklejkę (np. „opis”), żebyś wiedział, co jest w środku. |
krotka = (...) | Tworzy Krotkę (tuple). To lista, której nie można zmienić po utworzeniu. | Zalaminowany dokument. Możesz czytać, ale nie możesz dopisać. |
match zmienna: | Nowoczesna instrukcja sterująca (od Pythona 3.10). Zastępuje wiele if / elif. | Centrala telefoniczna. Łączy konkretny numer wewnętrzny („1”) z działem. |
case '1': | Konkretny przypadek w instrukcji match. | „Jeśli wciśnięto 1, połącz z…” |
Co dalej?
W tej lekcji uporządkowaliśmy kod w Pythonie, tworząc solidną strukturę danych (Słowniki) i logiki (Funkcje).
W Lekcji 4B stworzymy naszą pierwszą prawdziwą Klasę. Zobaczysz, jak „Foremka” pilnuje porządku w danych.
Praca domowa!
- Po pierwsze, Pythona do tej pory pisaliśmy w google colab, czas przejść na własny komputer, pobierz pythona na swój komputer i zainstaluj: https://www.python.org/ftp/python/3.14.0/python-3.14.0-amd64.exe
Na stornie python.org znajdziesz go na wszelkie systemy operacyjne
2. Stwórz własny program, bazujący na tym schemacie, ale realizujący inne zadanie, i przyjmujący inne dane, np książkę kontaktów gdzie będzie lista słowników a w nich osoba, tel, email. Powodzenia!
0 komentarzy