Moduł wprowadza fundamentalne koncepcje zmiennych i typów danych w Pythonie, stanowiące absolutną podstawę każdego programu. Omówiono w nim cztery podstawowe typy danych (int, float, str, bool), mechanizm dynamicznego typowania oraz zasady nazewnicze zmiennych zgodne ze standardem PEP-8. Materiał szczegółowo wyjaśnia konwersję typów (rzutowanie) za pomocą funkcji int(), float(), str() i bool() oraz pułapki z tym związane (ValueError). Przedstawiono również komunikację z użytkownikiem przez funkcje input() i print(), zaawansowane formatowanie tekstu z użyciem f-stringów oraz metody obróbki danych wejściowych (strip, lower, upper).

Kluczowe zagadnienia modułu:

• Zmienne i typy danych — deklaracja zmiennych, zasady nazewnictwa (snake_case) oraz typy int, float, str, bool i None
• Dynamiczne typowanie i konwersja typów — elastyczność Pythona oraz rzutowanie między typami za pomocą int(), float(), str() i bool()
• Interakcja z użytkownikiem — pobieranie danych przez input(), konwersja w locie i zabezpieczanie przed błędami (try/except, OR)
• Formatowanie tekstu i metody napisów — f-stringi, konkatenacja, len(), strip(), lower(), upper(), replikacja tekstów i chaining
• Zaawansowane techniki operatorskie — przypisanie wielokrotne, swap, shorthand (+=), end/sep w print() i operator in

• Podczas działania niemal każdego programu, zachodzi absolutna potrzeba zapamiętywania napływających informacji w czasie rzeczywistym.
• Wyobraź sobie, że piszesz grę – musisz gdzieś w pamięci maszyny na bieżąco przechowywać i aktualizować liczbę punktów gracza czy jego imię.
• Do tego celu służą Zmienne (ang. variables). Możesz o nich myśleć jako o wirtualnych pudełkach umieszczonych w pamięci RAM komputera.
• Każde takie pudełko posiada swoją unikalną naklejkę z nazwą, dzięki której programista może do niego łatwo sięgnąć i sprawdzić co jest w środku.
• Słowo "zmienna" wprost wskazuje na jej główną cechę: zawartość tego pudełka może (i najczęściej będzie) dynamicznie zmieniać się podczas pracy programu.
• Bez systemu zmiennych programy byłyby całkowicie głuche na interakcję i potrafiłyby jedynie drukować na sztywno zapisane w pliku komunikaty.

• Tworzenie pudełek w Pythonie jest banalnie proste. Nie musisz prosić systemu o zgodę, wystarczy matematyczny znak równości `=`.
• Proces ten nazywamy w żargonie IT deklaracją oraz inicjalizacją zmiennej (lub po prostu "przypisaniem wartości").
• Po lewej stronie znaku równości zawsze, absolutnie bezwzględnie musi znajdować się nazwa zmiennej (np. `punkty`).
• Po prawej stronie podajemy wartość, którą fizycznie wrzucamy do tego pudełka (np. liczbę `100` lub napis `"Tomek"`).
• Gdy Python natrafi na taką instrukcję, pod maską stworzy komórkę w pamięci, podpisze ją i bezpiecznie włoży tam naszą wartość.
• Co najważniejsze, jeśli użyjemy polecenia `print(punkty)`, Python sprawdzi zawartość pudełka i wyświetli `100`, a nie słowo 'punkty'!

# Tworzymy pudełko o nazwie 'punkty' i wrzucamy tam wartość 100:
punkty = 100

# Tworzymy pudełko o nazwie 'gracz' i wrzucamy tam tekst:
gracz = "Tomek"

# Wyciągamy na ekran to, co znajduje się wewnątrz pudełek:
print(gracz)
print(punkty)
            

• Zmienna nie może nazywać się jakkolwiek nam się podoba – istnieją twarde ograniczenia językowe uniemożliwiające uruchomienie programu.
• Nazwa nie może zawierać spacji, nie może zaczynać się od cyfry (np. `1gracz`) i absolutnie nie może być jednym z 35 zarezerwowanych słów kluczowych Pythona (np. `if`, `for`, `class`) ani nazwą wbudowanej funkcji (np. `print`).
• Dodatkowo, dla przypomnienia, Python rozróżnia wielkość liter! Zmienna `wynik` i `WYNIK` to fizycznie dwa oddzielne byty w pamięci.
• Oprócz zakazów, istnieją dżentelmeńskie konwencje (PEP-8). Najważniejsza to `snake_case` – używanie wyłącznie małych liter z podkreśleniem, np. `wiek_gracza`.
• Nigdy nie nazywaj zmiennych literkami (`a = 10`, `b = 5`), ponieważ za dwa tygodnie Ty sam nie będziesz wiedział co robi Twój własny program.
• Nazwa zmiennej musi sama z siebie odpowiadać na pytanie "co jest w środku?".

# DOBRE PRAKTYKI (jasne intencje, małe litery, podkreślniki):
wiek_użytkownika = 25
maksymalne_zdrowie = 100

# KATASTROFALNE PRAKTYKI (spowodują wybuch błędu SyntaxError):
# 1_miejsce = "Janek"  (Zaczyna się od cyfry!)
# wiek gracza = 20     (Posiada zakazaną spację!)
# import = 10          (Używa świętego słowa kluczowego!)
            

• Zastanów się: w jaki sposób komputer wie, że liczbę 10 można dodać do 5, ale słowa "Tomek" nie pomnożymy z sensem przez słowo "Janek"?
• Odpowiedzią na to zagadnienie jest fundament informatyki – każdy obiekt wrzucony do wirtualnego pudełka ma swój określony Gatunek (Typ Danych).
• Gatunki te determinują, na co komputer pozwoli. Liczby pozwolą na arytmetykę, z kolei teksty pozwolą na sprawdzanie dużych liter czy liczenie znaków.
• To właśnie brak zrozumienia różnic między typami leży u podstaw 90% błędów w aplikacjach generowanych przez nowicjuszy.
• Jeśli w jednym pudełku zamkniesz cyfrę `5`, a w drugim tekst `"5"` (w cudzysłowie) – Python potraktuje je zupełnie inaczej.
• Dla Pythona cyfra `5` bez cudzysłowu to czysta matematyka. Cyfra `"5"` z cudzysłowem to nic nie znaczący symbol wizualny, np. znak na drzwiach pokoju.

# Pomieszanie jabłek z gruszkami (różnych gatunków danych):
wiek = 25
imie = "Tomek"

# Ta linia zdetonuje krytyczny błąd TypeError:
# print(imie + wiek) 
# Python zaprotestuje: "Nie potrafię połączyć słów z matematyką!"
            

• Zanurzmy się w klasyfikację. Pierwszym, nieskomplikowanym gatunkiem danych są liczby całkowite, oznaczone w Pythonie skrótem `int` (od ang. Integer).
• Z definicji są to po prostu liczby bez części ułamkowej. Zarówno te pozytywne (1, 10, 500) jak i te znajdujące się głęboko pod ziemią, na minusie (-5, -200).
• Zmienne typu `int` idealnie nadają się do reprezentowania zamkniętych, policzalnych jednostek: liczby żyć w grze, ilość przedmiotów w koszyku czy po prostu wieku użytkownika.
• Ich główną siłą jest to, że wspierają klasyczną, czystą matematykę: dodawanie `+`, odejmowanie `-`, mnożenie `*` i dzielenie `/`.
• Wyróżnikiem Pythona na tle starych języków (np. C) jest to, że nie ma limitu wielkości liczby. Maszyna wygeneruje liczbę `int` tak gigantyczną, na ile pozwoli pamięć RAM!

# Tworzymy i zasilamy w pamięci pudełka typu całkowitoliczbowego (int):
level_gracza = 5
punkty_kredytowe = -150

# Maszyna potrafi w locie policzyć nową wartość i wrzucić do kolejnego:
kolejny_poziom = level_gracza + 1

print("Poziom gracza po awansie wynosi:", kolejny_poziom)
            

• Co w sytuacji, gdy na koncie bankowym mamy 50 złotych i... 99 groszy? Tu do gry wkracza gatunek zwany `float` (z ang. floating point number).
• Po polsku nazywane są zmiennymi zmiennoprzecinkowymi, przeznaczonymi dla ułamków o ograniczonej precyzji (ok. 15–17 cyfr znaczących wg standardu IEEE 754).
• Kluczowa uwaga: środowiska inżynierskie powstały w oparciu o język angielski. W Pythonie części dziesiętne oddzielamy zawsze kropką, nigdy przecinkiem!
• Napisanie `5,99` z polskim przecinkiem zostanie potraktowane jako oddzielenie od siebie dwóch niezależnych wartości w pudełku. Musi to być `5.99`.
• Używamy ich do wyliczania podatków, temperatur w meteorologii, wagi czy po prostu precyzyjnych fizycznych wymiarów.
• Co ciekawe, Python sam z siebie połączy (doda) bezbłędnie liczbę całkowitą `int` z wartością ułamkową `float`.

• Odchodząc od matematyki stajemy przed kolejnym mocarzem: gatunkiem `str` wywodzącym się ze słowa String (dosłownie 'łańcuch znaków').
• Zmienna tekstowa to po prostu zlepek liter, symboli czy spacji, uwięziony bezwzględnie w pojedynczych lub podwójnych cudzysłowach.
• Jeśli zapomnisz o barierach z cudzysłowu, Python spróbuje przeczytać dane słowo jako komendę lub nieistniejącą zmienną (NameError).
• Co potrafi String? Pamiętasz konkatenację (klejenie) za pomocą plusa z poprzedniej lekcji? Tu wraca do gry z potężną siłą.
• Zmienne przechowujące `str` służą do układania imion użytkowników, wyświetlania wiadomości z komunikatora czy przetwarzania haseł (dla komputera hasło "1234" to tekst, nie liczba!).
• Łańcuchy znaków skrywają w sobie dziesiątki gotowych sztuczek, potrafią same m.in. wyliczyć ilość posiadanych znaków czy zamienić małe litery na wielkie.

# Prawidłowo osłonięty łańcuch znaków za pomocą cudzysłowu:
nazwa_gracza = "CyberNinja_99"

# Błąd! Z braku ram z cudzysłowu Python szuka komendy 'Krakow':
# miasto_docelowe = Krakow 

# Konkatenacja z użyciem zadeklarowanych wcześniej pudełek:
print("Zalogował się:" + nazwa_gracza)
            

• Został nam ostatni z czterech podstawowych fundamentów. Najmniejszy, najlżejszy, a często podejmujący najcięższe w systemie decyzje: `bool`.
• Gatunek boolowski działa zero-jedynkowo. Przypomina przełącznik prądu w ścianie. Posiada tylko dwie możliwe wartości: Prawda lub Fałsz.
• W Pythonie wartości te muszą być pisane zawsze z wielkiej litery i bez cudzysłowów: `True` (Prawda) oraz `False` (Fałsz). Są to zablokowane słowa kluczowe.
• Do czego służą? To z ich pomocą sztuczna inteligencja decyduje w kodzie, czy należy przepuścić proces logowania, czy odrzucić dostęp do konta.
• W pudełku zmiennej np. `czy_pelnoletni` wpiszemy `True` gdy gracz potwierdzi swój wiek, po to by odpytać tę wartość 10 linijek niżej.
• Zrozumienie jak używać wartości boolowskich determinuje to, czy programista umie budować skomplikowane i rozbudowane 'rozgałęzienia' kodu.

# Prawidłowa deklaracja wirtualnych przełączników stanów:
gra_ukonczona = False
wczytano_baze = True

# Te słowa to prawda i fałsz (bool), rezerwaty pamięci.
# Z kolei fałszywy napis "True" to zwykły tekst, gatunek (str).
            

• Czasem patrząc w zaawansowany kod lub odbierając niewidoczne jeszcze pakiety od użytkownika mamy pustkę w głowie. Pytamy: czym fizycznie jest to pudełko?
• Python udostępnia nam specjalne szczypce analityczne – wbudowaną funkcję dochodzeniową `type()`.
• Działa ona niczym specjalistyczny skaner. Zamknięta wokół interesującej nas zmiennej prześwietli jej wnętrze i odpowie do jakiego gatunku (`int`, `str`, `float`, `bool`) należy.
• Oczywiście, jeśli wykonasz operację w tle, terminal nic nie wyświetli. Samo wywołanie `type(x)` sprawdzi rodzaj, ale utrzyma go w tajemnicy dla procesora.
• Aby ostatecznie zobaczyć odpowiedź na zewnątrz komputera, używamy znanej już matrioszki – wrzucamy badacza `type` do wnętrza drukarki `print`.
• Dzięki tej technice nigdy nie zgubisz orientacji w tym, dlaczego "5" zachowuje się u Ciebie jak łańcuch z liter, a nie liczba matematyczna.

# Przygotowujemy tajemnicze pudełko z liczbą w cudzysłowie:
zagadka = "999"

# Wywołujemy skaner "type" wewnątrz matrycy "print":
print( type(zagadka) )

# Terminal wyświetli w odpowiedzi: <class 'str'>
# Od razu wiemy, że nie da się tego matematycznie przemnożyć!
            

• Na sam koniec wyliczania gatunków (typów danych) musisz zrozumieć największy technologiczny urok (i bolączkę) pracy z Pythonem – dynamizm.
• W językach rygorystycznych, takich jak `C++` czy `Java`, decydując się, że tworzysz w pudełku liczbę całkowitą (int) zamykasz na kłódkę to pudełko tylko na takie liczby.
• Jeśli w języku C++ do pudełka liczbowego spróbujesz potem wrzucić słowo "banan", cały system brutalnie się roztrzaska na kawałki. Tego typu języki nazywamy *statycznie typowanymi*.
• Python reprezentuje skrajne przeciwieństwo – jest luźny jak letni wiatr i w 100% używa tzw. *typowania dynamicznego*. Co to właściwie oznacza?
• Otóż to nie fizyczne pudełko z tektury ma konkretny gatunek czy typ, lecz wartość, która fizycznie, obiektywnie w nim teraz siedzi.
• Dlatego w Pythonie w pierwszej linijce możesz uznać pudełko `wynik` za `100` (int), by linijkę niżej z premedytacją nadpisać go wpisując tam `"Słowo"` (str). Interpreter pozwoli na to z uśmiechem na twarzy!

# Startujemy: 'dane' trzyma czystą matematykę (int):
dane = 100

# Bez problemu nadpisujemy ją wartością zmiennoprzecinkową (float):
dane = 99.99

# Chwilę później totalna zmiana koncepcji na zwykły string (str):
dane = "Teraz będę pisać tu proste komunikaty!"
            

• Wyobraź sobie sytuację, w której masz pudełko pełne zapisanego tekstu `"100"`. Bardzo zależy Ci jednak na matematycznym przemnożeniu tej wartości przez 2.
• Z pomocą przychodzi fundamentalny mechanizm tzw. rzutowania (ang. type casting).
• Rzutowanie to celowe, siłowe zmuszenie Pythona, aby przekształcił zawartość jednego gatunku na drugi gatunek, o ile to technicznie wykonalne.
• Służą do tego wbudowane narzędzia, których nazwy są identyczne z nazwami gatunków: `int()`, `float()`, `str()`, `bool()`.
• Działają one jak potężne prasy hydrauliczne. Wrzucasz do środka (pomiędzy nawiasy) oporną zmienną, a mechanizm wypluwa Ci świeżo przeformatowaną wersję.
• Dzięki temu z łatwością połączysz świat matematyki i fizyki (int, float) ze światem wizualnych opisów interfejsu (str).

• Gdy otrzymujesz dane zapisane cyfrowo w cudzysłowie (np. z internetu), są one traktowane jako sztywny tekst. Do wejścia w świat matematyki użyj funkcji `int()`.
• Prasa `int()` przyjmie tekst (o ile składa się on wyłącznie z samych cyfr!) i wypluje pełnoprawną matematyczną liczbę całkowitą.
• Co ciekawe, `int()` można też stosować na liczbach zmiennoprzecinkowych (`float`). Co się wtedy dzieje?
• Funkcja brutalnie odetnie całą część ułamkową bez żadnego zaokrąglania. `int(5.99)` zostanie siłowo ścięte do `5`!
• Mechanizm ten jest kluczowy przy pracy z systemami zliczającymi np. ilości wejść, gdzie ułamki ludzkie nie mają prawa bytu.
• Należy jednak uważać na teksty, w których ukryta jest kropka ułamkowa – `int()` może mieć wtedy problem z bezpośrednim zrozumieniem zapisu.

# Na wejściu otrzymujemy niegroźny tekst z cudzysłowami:
pieniadze_tekst = "500"

# Prasa int() miażdży cudzysłowy i uwalnia samą wartość numeryczną:
pieniadze_liczba = int(pieniadze_tekst)

# Teraz wykonanie matematyki nie wyrzuci błędu:
print(pieniadze_liczba + 150)
            

• Analogicznie do prasy `int()`, środowisko oddaje nam do rąk potężne narzędzie inżynierskie: `float()`.
• Prasa ta ma jedno zadanie – przekuć wszystko co dostanie w precyzyjną liczbę zmiennoprzecinkową z obowiązkową dziesiętną kropką na końcu.
• Jeśli weźmiesz zwykłą matematyczną liczbę całkowitą (np. `50`) i przerzucisz przez `float(50)`, w locie stworzysz z niej postać `50.0`.
• Podobnie z tekstami. Tekst `"99.99"` zostanie błyskawicznie obdarty z ochronnego cudzysłowu i posłuży jako materiał na skomplikowane działania trygonometryczne.
• Będzie on tolerancyjny dla tekstów zawierających samą kropkę dziesiętną. Pamiętaj jednak: jeśli w rzucanym tekście podasz polski przecinek, `float()` wybuchnie błędem!
• Przeważnie tej konwersji użyjesz pobierając z banków dane z API i przekształcając je na surowe algorytmy giełdowe.

# Wyobraźmy sobie całkowitoliczbową kwotę:
kwota = 15

# Rzutujemy int -> float (powstaje ułamek z .0):
kwota_dokladna = float(kwota)

# System zaprezentuje 15.0
print("Do zapłaty: ", kwota_dokladna)
            

• Czasem musimy pójść w odwrotną stronę. Masz gotowy matematyczny wynik, ale chcesz go dokleić używając plusa `+` do wizualnego słowa na ekranie.
• Plus, jak wiemy, nie toleruje klejenia tekstów z surowymi liczbami (grozi to TypeError). Wyjściem z tej sytuacji jest prasa `str()`.
• Funkcja `str()` weźmie dowolną z pozoru nienaruszalną liczbę i owinie ją zgrabnie z powrotem w pojedyncze lub podwójne cudzysłowy wizualne.
• Z `100` zrobi `"100"`. Z wartości logicznej `True` zrobi słowo `"True"`. I po problemie.
• Dzięki temu w bezpieczny sposób skleisz finalny komunikat przed wysłaniem go graczowi czy pracownikowi wyświetlającemu okienko popup.
• To narzędzie ratuje życie każdemu początkującemu, kiedy zaczyna on łączyć logikę z prymitywnym interfejsem tekstowym (Terminalem).

# Skomplikowana, giełdowa zmienna ułamkowa (float):
saldo = 14500.75

# Poniższe zdetonowałoby błąd łączenia jabłek z gruszkami (TypeError):
# print("Twoje saldo: " + saldo) 

# Prawidłowe zastosowanie maski str() dla zgodności:
print("Twoje saldo: " + str(saldo))
            

• Z wielką mocą rzutowania wiąże się równie wielkie niebezpieczeństwo. Prasy `int()` i `float()` nie są obdarzone magiczną super-inteligencją.
• Załóżmy, że posiadasz tekst zawierający wyraz `"Tomek"`. Co się stanie, gdy zmusisz prasę `int()` do wydobycia z tego matematyki?
• System wpadnie w gigantyczną panikę, wywołując rzadziej widywany do tej pory ValueError (Błąd Wartości).
• Python krzyknie do nas komunikatem z głębi silnika: *"invalid literal for int() with base 10: 'Tomek'"*.
• Wynika to z faktu, że maszyna nie potrafi z wyrazu "Tomek" stworzyć cyfr – nie ma tam w końcu żadnego schematu numerycznego.
• Z tego powodu przed każdą konwersją programiści implementują skomplikowane zabezpieczenia, o których nauczymy się w przyszłości przy okazji omawiania 'wyjątków'.

# Pozornie niewinne zadeklarowanie pudełka tekstowego z literami alfabetu:
wiek_użytkownika = "Dwadzieścia"

# Próba przemnożenia wymuszająca siłowo wyciągnięcie samych cyfr matematycznych z tekstu:
# W tym miejscu program brutalnie eksploduje wyświetlając czerwoną linię: ValueError.
print( int(wiek_użytkownika) * 2 )
            

• Przechodzimy do momentu, w którym Twój kod ożywa. Do tej pory znaliśmy tylko `print()`, który był jednokierunkową tubą nadawczą komputera w stronę człowieka.
• Pora na odwrotność. Wbudowana funkcja `input()` (z ang. wejście) pozwala otworzyć tunel, przez który użytkownik siedzący przed klawiaturą może wpisać własne dane do systemu.
• Zasada działania jest prosta: wywołanie `input()` zawiesza (zamraża) całkowicie program. Komputer cierpliwie czeka w milczeniu, aż człowiek wpisze ciąg znaków i zatwierdzi go potężnym klawiszem ENTER.
• Aby poinstruować użytkownika co ma w ogóle zrobić, wewnątrz nawiasów `input("Podaj... : ")` możemy wkleić krótki tekst zachęty (tzw. prompt).
• Gdy człowiek uderzy ENTER, `input()` natychmiast zamienia się w to, co zostało wpisane na klawiaturze.
• Najczęściej wyłapujemy to cenne słowo za pomocą... zgadłeś, zwykłego przypisania do nowo utworzonego pudełka (zmiennej).

• Tutaj zaczyna się najciekawsza przeprawa przez typy danych. Załóżmy, że pytasz gracza: "Podaj swój wiek: ". Gracz wpisze na klawiaturze cyfry 25.
• Czy to oznacza, że w Twojej zmiennej wylądowała czysta matematyka (int)? Absolutnie NIE!
• Główna, kardynalna zasada głosi: wszystko, dosłownie WSZYSTKO, co wydostaje się z tunelu funkcji `input()` jest z automatu traktowane jako tekst (str).
• Dla maszyny 25 wpisane na klawiaturze to po prostu symbol dwójki i symbol piątki – `"25"`.
• Jeśli weźmiesz takie surowe `"25"` pobrane z `input()` i spróbujesz do niego dodać liczbę `10`, komputer wyrzuci krytyczny błąd zgodności gatunków (TypeError).
• Dlatego niemal każdemu profesjonalnemu użyciu interfejsu wejścia musi towarzyszyć wspomniany wcześniej mechanizm rzutowania.

# Zatrzymujemy program i prosimy o wpisanie liczby:
wiek_str = input("Ile masz lat? Wpisz liczbę: ")

# Jeśli gracz wpisał 20, w pudełku mamy teraz tekst "20".
# Ten kod poniżej jest NIELEGALNY i wywoła czerwoną lawinę:
# print("Za rok będziesz mieć: " + (wiek_str + 1))
            

• Aby rozwiązać problem matematyczny z poprzedniego slajdu, musimy na bieżąco łamać klątwę tekstową przy pomocy znanej już prasy hydraulicznej `int()`.
• Początkujący robią to często na dwa razy. Najpierw zapisują tekstowy input do pudełka, by linijkę niżej zrzucić to na nowo używając int() do tego samego pudełka.
• Jednak w profesjonalnym świecie Pythona stosuje się zagnieżdżanie – swoiste pakowanie komend "jedna w drugą" z wykorzystaniem klamrowania nawiasami.
• Pisząc `int(input("Wiek: "))` zmuszamy program by na początku wykonał to co w głębi (pobrał tekst użytkownika), po czym od razu przekazał ten surowy tekst prosto do maszyny rzutującej.
• Dzięki takiej "kombosie" zmienna, która wychwytuje te wartości, od pierwszej sekundy swojego istnienia dzierży silną, matematyczną cyfrę `int` (lub ułamek `float`).
• To najbardziej klasyczny widok (wzorzec projektowy), jaki napotkasz analizując cudzy kod.

# Klasyczne zagnieżdżenie - potężne i czytelne:
rok_urodzenia = int(input("Podaj swój rok urodzenia: "))

# Ponieważ rok_urodzenia to już matematyka, działamy z uśmiechem:
aktualny_wiek = 2026 - rok_urodzenia

print("Masz obecnie lat:", aktualny_wiek)
            

• Złóżmy zdobyte puzzle z ostatnich dwudziestu slajdów w jeden funkcjonujący skrypt biznesowy! Zbudujemy mikro-kalkulator podatkowy (VAT).
• Nasz kod będzie musiał spytać pracownika biurowego o cenę towaru bez podatku (tzw. netto).
• Ponieważ ceny posiadają grosze, nie użyjemy kanciastego `int()`, tylko precyzyjnego narzędzia do rzutowania o nazwie `float()`.
• Po pobraniu ceny i jej konwersji, komputer przemnoży ją cichutko w tle przez wskaźnik podatku VAT (np. 23%, czyli 1.23).
• Ostatnim krokiem będzie połączenie tekstów informacyjnych (str) ze świeżo wygenerowaną ceną ułamkową za pomocą znaku zapomnianego przy łączeniu plusa `+`.
• Dzięki konwersji używamy dokładnie tych typów danych (i ich unikalnych mocy), które są nam obiektywnie niezbędne do ukończenia misji.

# Pobranie ceny od klienta z automatycznym rzutowaniem na ułamek (float):
cena_netto = float(input("Podaj cenę towaru (użyj kropki): "))

# Maszyna w tle kalkuluje dodając 23% polskiego podatku VAT:
cena_brutto = cena_netto * 1.23

# Piękny output z połączeniem str() dla ceny końcowej:
print("Cena brutto do zapłaty wynosi: " + str(cena_brutto) + " zł")
            

• Za nami pierwszy tak potężny fundament inżynierii oparty na języku Python. Bez perfekcyjnego rozumienia pudełek na dane nie pójdziesz dalej!
• Pamiętaj o złotej zasadzie z nazewnictwem (`snake_case`) – nie złość współpracowników bezsensownymi nazwami typu `x` czy `y`. Nadawaj zmiennym jasny kontekst!
• Rozróżniaj gatunki (typy danych) – łączenie tekstu w cudzysłowie (`str`) z surową matematyką (`int`, `float`) to recepta na katastrofę budowlaną.
• Dynamiczne typowanie wybacza nadpisywanie, ale wymaga wyobraźni przestrzennej programisty.
• Komunikuj się swobodnie z użytkownikiem poprzez pętle wejścia-wyjścia (`input` oraz `print`), nie zapominając o siłowym rzutowaniu pobranego tekstu.
• Na kolejnych slajdach wdrożymy znacznie więcej technicznej praktyki, obudowując te fundamentalne koncepcje w potężne, biznesowe mechaniki!

# Mini-ściąga dla programisty:
tekst    = "SuperKod"    # <class 'str'>
calkowite= 150           # <class 'int'>
ulamek   = 3.1415        # <class 'float'>
przelacznik= False       # <class 'bool'>

# Największy kombos lekcji: Zagnieżdżona funkcja rzutująca wejście tekstowe:
wiek = int( input("Wiek: ") )
            

• Zastanawiasz się zapewne: "Czy zawsze muszę używać `str()`, gdy chcę wyświetlić liczbę obok tekstu?". Na szczęście twórcy Pythona przewidzieli łagodniejszą drogę.
• Funkcja drukująca `print()` posiada ukrytą supermoc. Zamiast kleić teksty znakiem plusa `+`, możesz podawać jej wewnątrz nawiasów elementy oddzielone przecinkiem.
• Gdy `print()` widzi przecinki, traktuje każdy element jako odrębny byt (niezależnie od jego typu) i wypluwa je na ekran po kolei.
• Co najważniejsze – w ten sposób znika problem TypeError! Możesz bezpiecznie postawić obok siebie `int`, `str` i `float`, a `print()` sam w tle obuduje je tekstem.
• Jako darmowy bonus, w miejscu każdego przecinka Python automatycznie, sam z siebie, wstawi jedną pojedynczą spację.
• Znak `+` w `print()` to zmuszanie pamięci do fizycznego stworzenia nowego, złączonego łańcucha. Przecinek to luźne, wydajne wypluwanie elementów na ekran.

• Przecinek rozwiązuje wiele problemów, ale przy 10 zmiennych rozrzuconych po zdaniu kod staje się chaotyczny. Tutaj wkracza technologia wprowadzona w Pythonie 3.6 – f-string.
• "F-string" oznacza Formatowany Łańcuch Znaków. Aby go stworzyć, wystarczy postawić malutką literkę `f` bezpośrednio przed pierwszym cudzysłowem!
• Pojawienie się tej literki zamienia zwykły tekst w inteligentny szablon. Wewnątrz tego szablonu możesz otwierać nawiasy klamrowe `{}`.
• Nawiasy klamrowe `{}` to takie małe wrota do przestrzeni Pythona. Wszystko, co w nie wpiszesz, komputer potraktuje jako żywy kod (np. wrzuci tam zmienną)!
• Dzięki temu zapis jest krystalicznie czysty: widzisz naturalnie zbudowane zdanie z eleganckimi lukami na wstrzykiwane dane.
• Co z konwersją? F-string sam używa potężnych mechanizmów rzutowania – bezwzględnie zmieni w locie każde wrzucone `{100}` na bezpieczny tekst w zdaniu.

# Stara, mało czytelna metoda z użyciem przecinków i przerw:
wiek = 30
# print("Jan ma", wiek, "lat.")

# Rewolucja f-string! (Zwróć uwagę na "f" przed cudzysłowem)
zdanie = f"Jan ma {wiek} lat."

print(zdanie)
            

• Połączmy teraz magię f-stringów z wejściem od użytkownika. Dzięki temu stworzymy dynamiczne interfejsy konsolowe bez plątaniny znaków plusa.
• Gracz rejestrując się podaje imię (które wpada w input) oraz klasę postaci. Możesz za pomocą f-stringa zbudować mu całą kartę bohatera.
• Co ciekawe, wewnątrz `{}` nie musisz wpisywać tylko nazwy zmiennej. Możesz tam wrzucić gotowe działanie matematyczne!
• Jeśli napiszesz `{punkty * 2}`, f-string najpierw uruchomi mnożenie z użyciem mocy procesora, wyciągnie wynik, a potem przeklei go do tekstu.
• Z tego powodu na komercyjnym rynku IT i podczas rekrutacji f-stringi są uważane za standard branżowy, w przeciwieństwie do przestarzałego znaku `+`.
• To właśnie takie narzędzia sprawiają, że Python jest powszechnie lubiany za bycie "przyjemnym" i intuicyjnym środowiskiem.

# Interaktywne zbieranie dwóch kluczowych informacji:
imie = input("Podaj imię bohatera: ")
level = int(input("Podaj poziom startowy: "))

# Generowanie karty z obliczeniem 'level * 100' bezpośrednio w tekście!
karta = f"Witaj w grze {imie}! Posiadasz na start {level * 100} złota."

print(karta)
            

• Zdarza się, że potrzebujemy zabezpieczyć nasz program przed niewłaściwą daną, np. gdy użytkownik wpisze hasło składające się tylko z jednego znaku.
• Jak sprawdzić, ile znaków ma wprowadzony z klawiatury tekst? Poznaj wbudowanego detektywa: funkcję `len()` (od ang. length - długość).
• Gdy `len()` otrzyma w objęcia zmienną tekstową (np. `len("Tomek")`), zwróci czystą, matematyczną liczbę całkowitą obrazującą wielkość tego napisu – w tym przypadku `5`.
• Dla Pythona każdy symbol jest znakiem i podlega wliczaniu – wliczane są również spacje, kropki i wykrzykniki!
• Używanie tej funkcji ma gigantyczne zastosowanie przy autoryzacji systemów formularzy internetowych ("Twoje hasło musi mieć przynajmniej 8 znaków").
• Spróbuj kiedyś przepuścić przez `len()` zmienną zawierającą ułamek (float) lub (int) – komputer szybko uświadomi Ci, że liczby nie mają fizycznej długości, lecz wagę matematyczną!

# Pobranie wejścia w postaci surowego tekstu z terminala:
haslo_użytkownika = input("Podaj nowe, silne hasło: ")

# Wyliczenie wielkości i zapisanie jej jako typ (int):
rozmiar_hasla = len(haslo_użytkownika)

print(f"Zanotowano! Twoje nowe hasło składa się z {rozmiar_hasla} znaków.")
            

• Z poprzednich modułów wiesz, że znak `+` może sklejać dwa teksty. Ale czy próbowałeś kiedyś pomnożyć tekst przez wymóg matematyczny, używając `*`?
• Jeśli napiszesz `"Python" * 3`, powstaną trzy identyczne klony tego słowa: `"PythonPythonPython"`. Jest to tzw. zjawisko Replikacji łańcuchów znaków.
• Pozwala to w środowiskach inżynierskich bardzo szybko i tanio graficznie obudowywać interfejsy z użyciem myślników (np. `print("-" * 50)` robi długą ramkę).
• Uwaga! Replikacja zadziała wyłącznie przy połączeniu tekstu (`str`) z liczbą całkowitą (`int`).
• Jeśli spróbujesz pomnożyć tekst przez sam tekst (`"Bum" * "Bum"`) albo przez ułamek (`"Bum" * 3.5`), silnik wyrzuci czerwony `TypeError`. Nie da się stworzyć "pół" litery!
• Ten manewr jest wspaniałą bronią, gdy w połączeniu z `input()` gracz zdecyduje z jak wielu elementów będzie się składał jego np. mur obronny.

# Użytkownik określa skalę budowy (wymagane int()):
rozmiar_muru = int(input("Ile bloków ma mieć mur ochronny? "))

# Wizualny znak bloku (surowy string):
blok = "[#]"

# Wykonujemy replikację – słowo mnożymy 'x' razy:
print(f"Oto twój mur obronny: {blok * rozmiar_muru}")
            

• Powiedzieliśmy sobie, że prasy rzutujące to potęga. Co się jednak stanie, gdy użyjemy prasy logicznej `bool()` na typowym inpucie od użytkownika?
• Prasa `bool()` bada każdy obiekt pod kątem tego, czy obiekt ten w ogóle "istnieje" w odczuwalny, sensowny sposób.
• Jeśli wejściem do `bool()` jest całkowicie pusty tekst (wpisany w locie przez zniecierpliwionego ENTER użytkownika, czyli `""`), maszyna uzna to za `False`.
• Każdy inny tekst (nawet tekst ze spacją, albo słowo "Nie") prasa `bool()` zinterpretuje jako twarde `True`, bo tekst jednak obiektywnie, fizycznie zajmuje miejsce.
• Dla liczb zasada jest identyczna: `0` lub ułamkowe `0.0` to zawsze logiczne `False` (Fałsz, bo to cyfrowe NIC). Każda inna, nienullowa liczba (-100, 5, 2.5) to logiczne `True`.
• Mechanizm rzutowania na Prawdę pozwala sprawdzić czy pacjent faktycznie wypełnił rubrykę w okienku formularza medycznego!

• Zejdźmy na chwilę głębiej do trzewi architektury komputera. Czy wiedziałeś, że gatunek `bool` w Pythonie to pod maską klasyczny... typ całkowitoliczbowy (podklasa int)?
• Z punktu widzenia procesora (CPU), wartości logiczne to obudowane słowami twarde zera i jedynki binarne, znane z Matrixa.
• Oznacza to w praktyce programistycznej, że Python pozwala używać słów `True` i `False` bezwzględnie jako liczby w obliczeniach numerycznych!
• Wartość `True` zachowuje się tak, jakby wynosiła równiutkie `1`. Wartość `False` zachowuje się tak, jakby wynosiła równiutkie `0`.
• Wyrzucenie w oknie polecenia `print(True + True)` zaskoczy wielu, generując wynik `2`. Z kolei operacja wymnożenia `100 * False` zaowocuje bolesnym zerem na ekranie.
• Użycie tych specyficznych cech potrafi w skomplikowanych algorytmach zaoszczędzić dziesiątki linijek i tzw. instrukcji warunkowych.

# Zaawansowana, mroczna strona pythona: matematyka boolowska.
wspolczynnik_ryzyka = 50
czy_gracz_ma_tarcze = True

# Skoro True = 1, a False = 0...
# Dodajemy 50 + 1:
ostateczny_wynik = wspolczynnik_ryzyka + czy_gracz_ma_tarcze

print(ostateczny_wynik) # Wyświetli 51 na konsoli
            

• Podczas pracy z żywym klientem w funkcji `input()`, często dochodzi do niezrozumienia wpisywanego zapytania przez nowicjuszy. Użytkownik dopisuje spację.
• Gdy pobierasz zmienną numeryczną: `int(input("Wpisz cyfre: "))` i w terminalu użytkownik naciśnie Spacja-Spacja-Spacja-5-ENTER. Czy wybuchnie błąd?
• Nie! Prasy numeryczne `int()` i `float()` posiadają zaawansowane skanery czyszczące. Bezbłędnie wyrzucą tzw. "białe znaki" z obrzeży i przefiltrują surową piątkę.
• Działa to jednak tylko dla zbędnych spacji "na końcach" lub "z przodu" (ang. trailing/leading whitespaces).
• Jeśli użytkownik zachowa się patologicznie i wpisze do konsoli `5 5` (liczby przeplecione dwiema spacjami w samym sercu), rzutowanie zdezorientuje się i sypnie błyskawicznym błędem ValueError.
• Rozwiązaniem w poważnych systemach jest użycie dodatkowych funkcji zacierających błędy (np. wbudowane metody `replace`), jednak na wczesnym etapie programista musi wierzyć w inteligencję gracza!

# Skrajny przypadek: leniwy gracz z klawiaturą
wiek = int(input("Wiek: "))

# Gracz wpisuje: "   25    " (Spacje z przodu i z tyłu)
# Int() poradzi sobie znakomicie, zamieniając to gładko w czyste 25.

print(f"Twoj wiek to dokładnie {wiek}")
            

• Zastanówmy się nad najgroźniejszym scenariuszem produkcyjnym dla skryptów z udziałem konwersji i funkcji wejścia.
• Kod to klasyczne: `wymiar = float(input("Wpisz wielkosc (w milimetrach): "))`. Czekamy na dane ułamkowe.
• Użytkownik, zdenerwowany skryptem, nic nie naciska, oprócz natychmiastowego brutalnego, agresywnego wciśnięcia klawisza ENTER. Zamyka tunel.
• Dla Pythona, wynikiem `input()` w takim układzie jest całkowicie obnażony tekst – Pusty łańcuch znaków (`""`). Brak czegokolwiek w środku.
• W tym ułamku sekundy, wygłodniała prasa rzutująca `float()` stara się przemieścić "Nic" w świat matematyczny i gwałtownie zatrzymuje silnik.
• Wynikiem tej interakcji jest błąd ValueError. W komercyjnym oprogramowaniu na takie problemy zakłada się systemy pułapek bezpieczeństwa `try/except`.

# KOD O WYSOKIM RYZYKU DEGRADACJI, GDY UŻYTKOWNIK TYLKO UDERZY W ENTER:
waga_przesylki = float(input("Wpisz wagę do rzutowania: "))

# Jeśli wpisał "", float("") nie wygeneruje liczby 0.0! Wygeneruje CRASH.
print(waga_przesylki)
            

• Sprawdźmy nasze logiczne przygotowanie bojowe po tej części modułu budując w pełni złożoną ankietę tworzenia postaci RPG.
• Wykorzystamy dynamiczne zbieranie danych, operacje konwersyjne (rzutowanie na ułamek dla precyzyjnego złota) oraz budowanie wyników przy użyciu eleganckich f-stringów.
• Dodatkowo użyjemy funkcji badawczej `len()`, by obliczyć, jak długie jest pseudo naszej głównej postaci i zaoferować mnożnik.
• Zaobserwuj, jak na małej przestrzeni przeplatają się funkcje wejścia/wyjścia (input/print) ułożone chronologicznie w kodzie (od góry do dołu).
• Jest to sztandarowy przykład proceduralnego, sekwencyjnego ułożenia komend w plikach `.py`. Program nie skacze – czyta linijki tak jak ty: strona za stroną!
• Skrypt po lewej potrafi zaskoczyć użytkownika matematyką i interakcją, sprawiając, że komputer przestaje być bezmyślnym, statycznym widzem!

# 1. Zbieranie z podziałem ról (zmienne tekstowe i rzutowane wartości)
pseudonim = input("Jakie nosisz imię? ")
fundusze = float(input("Podaj startowe oszczędności w dolarach: "))

# 2. Przetworzenie, obliczanie i matematyka z użyciem detektywa 'len'
bonus = len(pseudonim) * 10.5
pieniadze_koncowe = fundusze + bonus

# 3. Potężny zwrot akcji do użytkownika z wykorzystaniem F-STRING()
print(f"Zalogowano postać {pseudonim}. Z uwagi na {len(pseudonim)} liter w nazwie, otrzymujesz bonus!")
print(f"Twoje aktualne saldo u bankiera wynosi dokładnie {pieniadze_koncowe} USD.")
            

• Do tej pory uczyliśmy się, że zmienna to małe pudełko, do którego wrzucamy dane. W przypadku Pythona jest to spore uproszczenie.
• W rzeczywistości środowisko traktuje liczbę (np. `100`) jako wielki fizyczny kamień leżący w pamięci komputera.
• Zmienna to tak naprawdę tylko przyczepiona do tego kamienia samoprzylepna "etykieta" z imieniem!
• Gdy piszesz `x = 100`, program przykleja etykietkę `x` na kamień `100`. Gdy napiszesz zaraz obok `y = x`, na ten SAM wielki kamień przyklejana jest druga etykietka `y`.
• Oszczędza to olbrzymie ilości pamięci RAM w systemach Big Data, bo system nie klonuje 100 gigabajtów danych, lecz jedynie dokleja lekkie karteczki z nazwami.
• Gdy żadna etykietka nie wskazuje na dany kamień z danymi, włącza się specjalny program sprzątający (Garbage Collector) i niszczy osierocony kamień w pył!

• Znasz już klasyczne przypisywanie danych do jednej zmiennej, linijka po linijce. Jest to jednak żmudne, gdy masz do załadowania pakiet 3 współrzędnych.
• Python udostępnia elegancką mechanikę przypisania wielokrotnego. Możesz użyć przecinków po lewej i prawej stronie znaku równe `=`.
• Pisząc `x, y = 10, 20` sprawiasz, że silnik rozdziela te wartości perfekcyjnie jedna do jednej. `x` dostanie `10`, a `y` dostanie `20`.
• Możesz iść o krok dalej i nadawać tę samą etykietę na jeden duży obiekt: `a = b = c = 100` sprawi, że 3 zmienne zaczną wskazywać na wartość 100.
• Technika ta redukuje w kodzie tak zwany "boilerplate" (kod szablonowy, zanieczyszczający dokument długaśnymi deklaracjami).
• Uważaj! Ilość elementów po prawej stronie musi bezwzględnie odpowiadać ilości etykiet po lewej, inaczej wywołasz błąd ValueError (zbyt wiele lub zbyt mało wartości).

# Szybkie definiowanie współrzędnych gracza w jednym locie:
x, y, z = 0.0, 15.5, -10.2

# Wyświetlanie przy pomocy f-stringa:
print(f"Twoje pozycje to: X:{x}, Y:{y}, Z:{z}")

# Resetowanie statystyk za jednym zamachem:
hp = mana = kondycja = 100
            

• Wyobraź sobie klasyczny problem z dawnych języków programowania: masz zmienną `a` z mieczem oraz zmienną `b` z łukiem. Chcesz zamienić je miejscami w ekwipunku.
• W C++ musiałbyś stworzyć "pustą, tymczasową skrytkę" (tzw. `temp`), włożyć tam miecz, przenieść łuk, i wyjąć miecz ze skrytki. Kosztowało to zawsze 3 linijki kodu.
• Dzięki opisanemu wcześniej mechanizmowi "przypisania wielokrotnego", w Pythonie robimy to w jednej, eleganckiej sekundzie.
• Wystarczy zapisać: `a, b = b, a`. Pod maską silnik zbuduje wirtualną, ulotną skrytkę bez zawracania głowy programiście i podmieni naklejki błyskawicznie.
• To najbardziej rozpoznawalny na świecie "pytoniczny" sposób (Pythonic way) na zamianę (swap) dwóch elementów miejscami.
• Użyjesz tego masowo przy sortowaniu danych statystycznych oraz budowie zaawansowanych algorytmów giełdowych.

# Stan początkowy:
bron_lewa = "Miecz"
bron_prawa = "Tarcza"

# Magiczna zamiana w jednym ruchu!
bron_lewa, bron_prawa = bron_prawa, bron_lewa

# Output: Lewa dłoń trzyma Tarczę, prawa Miecz.
print(f"Lewa dłoń: {bron_lewa}, Prawa dłoń: {bron_prawa}")
            

• Złota zasada optymalnego kodu mówi: nie powtarzaj się na siłę. Jeśli chcesz zwiększyć wynik gracza o `50`, naturalnie napiszesz `wynik = wynik + 50`.
• Klawiatury inżynierów szybko się od tego psuły, więc wprowadzono tak zwane operatory modyfikujące z przypisaniem, nazywane skrótowcami (shorthand).
• Zapis `+= 50` jest całkowicie i absolutnie jednoznaczny ze starym wzorcem. Mówi on maszynie "weź to co jest z lewej i dosyp do tego 50".
• Możesz używać wszystkich operatorów: `+=` (dodaj), `-=` (odejmij), `*=` (pomnóż przez) oraz `/=` (podziel przez).
• Stosowanie skrótowców jest wymogiem do przechodzenia rekrutacji na stanowiska Junior, ponieważ zwiększa to czytelność rozległych skryptów analitycznych.
• Zabieg ten zadziała również dla tekstów `str`! Użycie `+=` na tekście doklei podany znak twardo na sam koniec (np. `slowo += "!"`).

# Punkty na start:
punkty = 100

# Zebranie bonusu - stara szkoła:
# punkty = punkty + 50

# Zebranie bonusu - Pythonic way:
punkty += 50

print(punkty) # 150
            

• Z uwagi na "dynamiczne typowanie", w ogromnych bazach kodu łatwo zgubić wątek i zapomnieć, jakiego w ogóle gatunku jest obsługiwana w danym miejscu zmienna.
• W ratunku przychodzi najważniejsza funkcja testowa środowiska: wbudowany detektyw o nazwie `type()`.
• Wrzucona do niego zmienna wraca w postaci bardzo profesjonalnego komunikatu (np. ``), który krystalicznie wyjaśnia, do jakiej rodziny należy dany obiekt.
• Zazwyczaj detektywa `type()` trzeba objąć dodatkowo w nawiasy wywoławcze `print()`, by ukazał nam swoje śledztwo na głównym ekranie terminala.
• Możesz stosować `type()` tuż po wykonaniu jakiejkolwiek konwersji rzutowania (np. `float()`), by na własne oczy upewnić się, czy operacja prasy zadziałała!
• Korzystanie z logowania i detektywów obniża czas rozwiązywania poważnych problemów projektowych o połowę.

# Tajemnicza dana pobrana z uszkodzonego bankomatu:
niewiadoma = "450.50"

# Prześwietlenie przed próbą kalkulacji (print wypluwa wynik type):
print( type(niewiadoma) )  # Ostrzeżenie! To jest <class 'str'>!

# Szybka naprawa i ponowne prześwietlenie:
naprawiona = float(niewiadoma)
print( type(naprawiona) )  # Sukces! To teraz czyste <class 'float'>.
            

• Podczas nauki `float` i rzutowania spotykamy błąd dziesiątkujący początkujących – jest to tzw. pułapka regionalnego formatowania liczb.
• W Polsce (i wielu krajach Europy) od dziecka uczą nas ułamków używając przecinka: `3,14`. Na całym kontynencie amerykańskim jest to jednak kropka: `3.14`.
• Pamiętaj zawsze: Język Python (i niemal każdy nowoczesny standard IT) został stworzony według normy amerykańskiej!
• Dla komputera dziesiętny znak zmiennoprzecinkowy `float` to zawsze i bezwzględnie kropka (.).
• Jeśli użytkownik w `input()` wpisze polskie "25,50" i rzucisz to w tryby `float()`, system eksploduje zgłaszając natychmiastowo ValueError! Przecinek dla systemu znaczy co innego (rozdzielenie elementów).
• Jedyną linią obrony jest wspomniana metoda czyszcząca `.replace(",", ".")` lub bardzo restrykcyjne instrukcje dla użytkownika w zapytaniu tekstowym.

• Podczas pracy z typem `float` warto zapoznać się z kolejnym powszechnym skrótowcem (shorthand), z którym zetkniesz się w profesjonalnych kodach.
• Matematycy czasem używają skrótu `.5` mając na myśli dokładne `0.5`. Python idealnie rozumie ten amerykański żargon inżynierski!
• Deklarując zmienną numeryczną: `poziom_wody = .75`, środowisko automatycznie potraktuje to jako dodanie niewidzialnego zera na czele (`0.75`).
• Działa to również w drugą stronę: wartość `5.` to dla maszyny precyzyjnie napisane `5.0`.
• Praktyka ta nie jest pochwalana podczas edukacji, ze względu na ukrywanie przed okiem czytającego konkretnych gabarytów wartości.
• Jednak przy ładowaniu plików od zewnętrznych kontrahentów często spotkasz zrzuty wyglądające jak stado kropek – nie panikuj, to po prostu float!

# Skrócony, amerykański zapis ułamka bez wiodącego zera:
wskaznik_szumow = .99

# Prześwietlenie dowodzi, że maszyna doskonale rozumie ten slang:
print(wskaznik_szumow) # Pokazuje: 0.99
print(type(wskaznik_szumow)) # Pokazuje: <class 'float'>
            

• Pudełko (`zmienna`) w Pythonie trzyma jakieś dane. Wiemy już, że 0.0 to nie to samo co puste okienko `""`. A co w sytuacji, w której pudełko ma być całkowicie, sterylnie puste?
• Twórcy środowiska zbudowali specjalny, piąty wielki typ danych o absolutnie wyłącznym celu: `None` (z ang. Żaden/Nikt).
• `None` to specjalny znacznik mówiący: "Ta zmienna oficjalnie istnieje na biurku, ale w tej chwili wyczyszczono jej wartość do zera absolutnego".
• Często na samym początku wielkiego programu tworzysz pudełko `wynik_koncowy = None`, bo na start przecież jeszcze go nie znasz! Etykieta jednak już czeka.
• Typ `None` ma nawet pod lupą `type()` własną rasę w systemie – nazywa się ``.
• Uwaga! Występuje on zawsze z dużej litery, bez cudzysłowów! `None` to nie jest tekst `"None"`. Zrozumienie nicości zapobiegnie milionom błędów.

# Przygotowujemy etykietę, która na początku z założenia nie posiada danych.
baza_danych = None

# Kod skanuje, kalkuluje... 
# I dużo później nadpisuje twardą Nicość właściwym, potężnym słowem (str).
baza_danych = "Załadowano wierszy: 5000"

print(baza_danych)
            

• Zastanawiałeś się kiedyś co chroni fundamentalne narzędzia środowiska (jak `print()`, `str()` czy `input()`) przed pomyłkowym zniszczeniem przez użytkownika? NIC.
• W dynamicznym języku Python możesz dosłownie wziąć magiczną funkcję `print` i nadpisać ją traktując jak zwykłą etykietę dla ułamka... np. `print = 50.5`!
• Efekt? Całkowite odcięcie komputera od głównego mechanizmu wizualnego! Narzędzie bezpowrotnie traci swoje "magiczne funkcje" i staje się w tym skrypcie bezużyteczną liczbą.
• To jest najpopularniejszy krytyczny błąd pisania po omacku. Tworzysz `input = 20`, a linijkę dalej próbujesz prosić o dane: `input("Podaj... ")`. Maszyna padnie martwa od błędu `TypeError`.
• Jak się chronić? Najlepsze edytory IDE kolorują wbudowane narzędzia unikalnym (często pomarańczowym lub fioletowym) kolorem.
• NIGDY, w żadnym wypadku nie nazywaj swoich pudełek (zmiennych) słowami świecącymi się w Twoim edytorze kodu na jaskrawe barwy wbudowanych komend!

# ZBRODNIA - Nadpisanie narzędzia drukującego twardą cyfrą!
# print = 10 

# Poniższe wywoła teraz brutalny błąd: TypeError: 'int' object is not callable
# print("Ten tekst nigdy się nie pojawi!")
            

• Masz za sobą głębokie ugruntowanie podstawowej i średnio-zaawansowanej mechaniki zmiennych oraz konwersji w języku Python.
• Jesteś świadom nie tylko jak rzutować teksty z funkcji `input()`, ale także jak badać zmienne skanerem `type()`, układać zdania przez `f-string` i stosować ostateczną Nicość – `None`.
• Przekraczamy punkt, w którym dane przestają być tylko biernym zapisem, a stają się płynącą po środowisku rzeką decyzyjną.
• Ostatnie 10 slajdów tego modułu poświęcimy rygorystycznemu połączeniu tej wiedzy w zaawansowane pętle weryfikacyjne i zbadamy krawędzie systemu pod kątem skrajnych danych brzegowych.
• Pamiętaj o zabezpieczaniu systemów przed regionalnymi i tekstowymi pułapkami (np. białe spacje). Ufaj swoim `f-stringom` i stosuj rzetelne rzutowanie tak wcześnie, jak to możliwe (tzw. Zagnieżdżanie)!

# Połączenie zaawansowanej wiedzy w 3 linijkach:
x, y, badany = 10, 20, None # Wielokrotne + None
x, y = y, x                 # Potężny, błyskawiczny SWAP!

print(f"Zamiana: X={x}, Y={y}. Stan Badany: {type(badany)}")
            

• Powiedzieliśmy sobie, że wpisanie głupot w `int(input())` wywala czerwony błąd `ValueError` i niszczy program. Przyszedł czas na pierwszą linię obrony.
• W profesjonalnych systemach używa się bloku `try` (spróbuj) oraz `except` (wyjątek). Jest to swoista tarcza antybalistyczna dla Twojego kodu.
• Python próbuje wykonać podejrzany kod zamknięty pod słowem `try:`. Jeśli wszystko przebiegnie pomyślnie, omija resztę tarczy i kod leci dalej.
• Ale uwaga! Jeśli pod `try` nastąpi eksplozja typu `ValueError`, program nie zostaje zniszczony. Siła wybuchu jest pochłaniana i aktywuje się bezpieczny blok `except`.
• W bloku `except` programista definiuje plan awaryjny – np. wypisanie do użytkownika "Ej, to nie jest liczba!".
• To właśnie ta mechanika ratuje portale bankowe i systemy medyczne przed totalnym zawaleniem podczas przypadkowej literówki pracownika.

• Zastanawiałeś się, jak programy robią "wartości domyślne"? Np. "Podaj imię [Domyślnie: Gość]: ". Jeśli gracz kliknie tylko ENTER, zostanie "Gościem".
• Możemy to zakodować krótko i pięknie. Używamy do tego słówka logicznego `or` (lub) w połączeniu z faktem, że pusty `input` to po prostu fałsz (`False`).
• Zapisując `imie = input("Imię: ") or "Gość"`, zmuszasz maszynę do błyskawicznej decyzji opartej na logice.
• Jeśli użytkownik wpisze "Tomek", pudełko po lewej jest Pełne (True), więc maszyna od razu bierze Tomka. Słówko `or` przerywa szukanie.
• Jeśli użytkownik uderzy tylko w ENTER, pudełko po lewej to Pustka (False). Maszyna przechodzi wtedy za słowo `or` i potulnie przypisuje "Gościa"!
• Wzorzec ten (tzw. Short-circuit evaluation) jest masowo używany przy budowie dynamicznych stron WWW.

# Szybkie pobieranie, z natychmiastowym planem awaryjnym (B) po słówku 'or':
nazwa_gracza = input("Wpisz nickname (lub zignoruj): ") or "Nieznajomy_Wojownik"

# Jeśli poleci ENTER, system elegancko wyświetli powitanie awaryjne:
print(f"Logowanie... Witaj na serwerze, {nazwa_gracza}!")
            

• Używanie pojedynczych cudzysłowów na startujące ekrany powitalne (np. wielkie Menu Gry ze spisem kontrolnym) jest katorgą. Wymaga wpisywania znaków enter `\n` wszędzie.
• W Pythonie, jeśli chcesz zachować strukturę tekstu (tak, jak w prawdziwym notatniku z zachowanymi enterami), używaj Trzech Cudzysłowów z rzędu: `"""`.
• Wszystko, co znajdzie się między początkowymi `"""` a końcowymi `"""` będzie wyglądało identycznie w kodzie, jak i później na docelowym ekranie.
• Narzędzie to nazywa się "Docstring" lub zwyczajnym tekstem wielolinijkowym (Multiline String). Idealnie służy do rysowania ASCII Artów oraz okienek pomocy!
• Co ciekawe, na samym początku takiego bloku możesz nadal wstawić literę `f` i stworzyć wielolinijkowy f-string `f"""`. Będzie on reagował na nawiasy klamrowe `{}`!
• Profesjonaliści wykorzystują je masowo w konsolach, by powiadomić użytkownika przed wpisaniem newralgicznych danych za pomocą `input()`.

# Przygotowanie potężnego, wielolinijkowego interfejsu startowego:
menu = """
==============================
      WITAJ W BANKU PY!     
==============================
[1] Sprawdź Saldo
[2] Wyślij Przelew
[3] Zamknij Konto
"""

print(menu)
wybor = input("Wybierz opcję (1-3): ")
            

• Mówiliśmy wcześniej, że rzutowanie `int()` samo potrafi zetrzeć niewidzialne spacje. Ale co, gdy rzutowania NIE robimy i przyjmujemy czysty, surowy tekst od klienta?
• Pojawia się ogromny kłopot, gdy gracz do `input()` wpisze hasło "Tajne" po czym przez pomyłkę kliknie Spację i zatwierdzi ENTEREM: `"Tajne "`.
• Dla maszyny `"Tajne"` oraz `"Tajne "` to dwa kompletnie, obiektywnie różne światy (inna ilość znaków pod skanerem `len()`). Rejestracja legnie w gruzach.
• Ostatnią zaporą bezpieczeństwa przed analizą str jest doklejenie metody `.strip()` ("zetrzyj / ogołóć").
• Metoda ta, przyklejona do pudełka tekstowego (lub po prostu do wywołania funkcji wejścia), bezlitośnie obcina wszelkie białe znaki po obu stronach napisu!
• Jest to podstawa podstaw każdego inżyniera, gdy przetwarza tzw. nieufne dane od użytkownika (Sanitization).

# Brudny input. Gracz przypadkowo naciska na końcu znak Tabulatora i Spację!
zebrane_dane = "   Skarb  "

# Użycie maszyny wycierającej:
czyste_dane = zebrane_dane.strip()

# Output wynosi równe 5 (samo słowo Skarb). Brudy zostały zniszczone.
print(len(czyste_dane))
            

• Podobny błąd w interfejsie następuje, gdy prosisz: "Napisz 'tak', aby potwierdzić". Użytkownik jednak wpisuje dumnie: "TAK", "Tak", lub nawet "tAK".
• Kod, który oczekiwał "tak" przepuści tego użytkownika przez błędne wrota, bo dla procesora małe 't' to pod maską zupełnie inny kod cyfrowy niż wielkie 'T'.
• Na ratunek przychodzą wbudowane prasy kształtujące wielkość liter: `.lower()` (zrób wszystko małe) oraz `.upper()` (zrób wszystko wielkie).
• Przyczepiając je do zmiennej tekstowej ujednolicasz jej formę, dzięki czemu nigdy więcej nie będziesz musiał ręcznie obsługiwać kilkunastu kombinacji słowa "TaK".
• Ciekawostką branżową jest metoda `.title()`, która bez wysiłku przerabia pierwszy znak każdego słowa w zdaniu na wielką literę (idealne dla formatowania nagłówków książek!).
• Każdy nowoczesny bank aplikuje `.lower()` do twojego podanego adresu email podczas logowania.

# System autoryzacyjny bomby w grze fabularnej:
decyzja = input("Rozbroić ładunek? Wpisz rozbroj: ")

# Gracz wpisał spanikowany: "ROZBROJ"
# Maszyna przed wejściem na algorytm zgniata to na małe literki!
decyzja_pewna = decyzja.lower()

print(decyzja_pewna) # Wynikiem w konsoli jest malutkie "rozbroj".
            

• Załóżmy, że użytkownik miał wpisać w puste okienko rozbudowany esej lub krótki post na forum na temat gadów, a my chcemy go ocenić z tego zadania.
• Czytanie po jednym słowie byłoby powolne. Python wyposażony jest w bezlitosny mechanizm lokalizacyjny: słowo kluczowe `in` (z ang. wewnątrz).
• Jeżeli zapiszesz zdanie: `"wąż" in tekst_użytkownika`, system błyskawicznie, jak najdoskonalszy radar poszuka ciągu liter W-Ą-Ż w pudełku `tekst_użytkownika`.
• Co ważne, mechanizm operuje zawsze rzutując wynik na koncepcję logiki: zwróci matematyczną prawdę `True`, jeśli wąż tam siedzi, oraz twardy fałsz `False`, jeśli wąż uciekł.
• W przyszłych modułach `in` będzie odpowiedzialne za decyzyjność skryptów (np. "Jeśli słowo ukarz jest we wpisie, daj bana na serwerze!").
• Możesz połączyć ten mechanizm ze słówkiem odwracającym - kod `"bomba" not in bagaz` wypluje na ekran szczęśliwe `True` (bezpieczny!).

• Profesjonalni programiści nie znoszą przepisywać jednej zmiany w trzech oddzielnych liniach kodów. Kochają proces tzw. "Łańcuchowania" (Method Chaining).
• Zauważyliśmy wcześniej przy konwersji, że zagnieżdżamy prasy matematyczne w sobie: `int(input())`. Ale co z funkcjami czyszczącymi z kropką, typu `.strip()`?
• Ponieważ `input()` zwraca od zawsze tekst (`str`), możemy dokleić metodę kropki tuż po uderzeniu w zamknięty nawias inputu! `input().strip()` to w pełni dozwolony zapis!
• Idąc dalej – skoro wynikowy wyczyszczony obiekt to dalej tekst, dlaczego nie skleić do tego od razu standaryzatora małych liter? Otrzymasz kombo: `.strip().lower()`.
• Zapis ten przypomina budowanie rurociągu: Dane wpadają z lewej (Terminal), lecą na prawo do czyszczenia (spacje), a na wylocie do pudełka są mielone na miazgę małych liter.
• Z takim wpisem gracz może używać klawiatury całkowicie nieostrożnie, my dostajemy na tacy brylantowy input.

# Trójstopniowy rurociąg budowlany Pythona:
# 1. Pobierz dane 
# 2. Ogołoć ze śmieci (.strip) 
# 3. Wyślij małe litery (.lower)
haslo = input("Hasło (nie zwracaj uwagi na duże litery): ").strip().lower()

# Czysta poezja w logach systemu:
print(f"Wyłapane, sterylne ziarno hasła to: {haslo}")
            

• Zbliżając się do końca kursu na temat Wejścia/Wyjścia, musisz opanować kontrolę nad wrodzonym instynktem podstawowej funkcji `print()`.
• Z założenia, każde uderzenie `print()` powoduje wysłanie tekstu na ekran i automatyczne wstawienie wciśnięcia ENTER. Kolejny print wypisze się twardo linijkę niżej.
• Jeżeli chcemy stworzyć linię ładowania lub wyświetlać liczby obok siebie z odstępem czasu (np. pasek HP postaci w konsoli), musimy podmienić wbudowany instynkt.
• Dodanie na końcu funkcji specjalnego tajnego argumentu `, end=""` nakazuje Pythonowi nie wciskać ENTERa po jej wykonaniu. Kursor zostaje natychmiast na tej samej linii.
• Jeżeli wypisujemy po przecinku wiele zmiennych: `print(A, B, C)`, wiemy, że funkcja przedzieli je spacją. Chcesz myślniki? Użyj tajemniczego argumentu `, sep="-"`.
• Modyfikacja `end` i `sep` ("separator") otwiera drzwi do profesjonalnej stylizacji logów systemowych oraz hakerskich aplikacji terminalowych w czarnym oknie.

# Standardowy separator to spacja. Tutaj podmieniamy ją na potrójną tyldę:
print("DyskC:", "Uzytkownicy", "Pliki", sep="~~~")

# Powstrzymujemy enter. 3 niezależne printy skleją się w jednej wielkiej linii:
print("Ładuję...", end="")
print(" Nadal ładuję...", end="")
print(" Zakończono!")
            

• Z używaniem czyszczących metod z kropką (tzw. String Methods) łączy się klątwa początkujących inżynierów.
• Jeśli napiszesz tylko suche: `tekst.lower()`, system odwali genialną robotę, wydobędzie litery, zmieni je na małe... po czym w milisekundę umrą one i znikną z RAMu!
• Dlaczego? Pamiętaj, metoda to akcja produkująca NOWY gotowy produkt rzucany w powietrze. W Pythonie typ tekstowy (str) jest NIETYKALNY – nie może być wewnątrz zmieniony z definicji.
• Z tego powodu, jeśli używasz np. `.strip()` by ogołocić brzegi, musisz bezwzględnie wziąć efekt i złapać go do nowego pudełka: `czysty_tekst = brudny_tekst.strip()`.
• Alternatywnie (o ile brudny tekst nie jest nam do niczego potrzebny) można bez strachu i oporów zgnieść etykietę i nałożyć z powrotem na stary obiekt: `tekst = tekst.lower()`.
• Nie złapanie efektu modyfikacji to przyczyna 80% pytań studentów "Dlaczego system ignoruje moje polecenia?!".

# Pudełko zawiera brudny, górski diament
kamien = "   Bryła_Złota   "

# PONIŻEJ AKCJA DONIKĄD (Wynik rzucony w pustą próżnię!):
# kamien.strip() 

# AKCJA PRAWIDŁOWA: Maszyna wyrzeźbiła produkt, i przypisaliśmy na niego naklejkę.
skarb = kamien.strip()
            

• Dotarliśmy do potężnego egzaminu kończącego ten fundamentalny blok wiedzy. Utkamy system generujący login na podstawie bezładnie wpisanego inputu pracownika biurowego.
• Użyjemy połączonej magii: bezpieczne wejście tekstowe wyczyszczone od zewnątrz rurą wydechową: `.strip().lower()`.
• Pojawi się prasa hydrauliczna `float()` potężnie formatująca kwotę podatku rzuconą przez biuro.
• Zamkniemy ekran podglądu lśniącym nowością F-Stringiem z wstrzykniętą informacją logistyczną o wielkości znaków (wyłapaną na froncie detektywem `len()`).
• Stworzony przez Ciebie skrypt, mimo małych gabarytów (poniżej 10 linii), posiada głęboką obronę anty-kolidującą i nie zawiesi się, o ile w okno wejdą ułamki liczbowe.
• Przetworzyłeś wejście, zamieniłeś w użyteczne dane i zbudowałeś interfejs, tworząc w głowie zalążek logicznego algorytmu decyzyjnego.

# Czyste logowanie bez ukrytych błędów białych znaków!
nazwisko = input("Podaj nazwisko klienta: ").strip().lower()
id_num = input("Podaj 4 cyfry tajnego ID: ").strip()

# Odbieramy ułamkowy VAT (Uwaga! Bez tarczy try/except kropka to wymóg!)
wplacono = float(input("Zaksięgowano pieniądze (np. 120.50): "))

# Algorytmiczne generowanie unikalnego klucza w jednym ciosie.
print(f"""
   === WYGENEROWANA KARTA DOSTĘPU ===
  > USER: user_{nazwisko}_{id_num}
  > STAN: Zasilenie gotówkowe ({wplacono} EUR).
  > SEC: Klucz zbudowany z {len(nazwisko) + len(id_num)} znaków bazowych.
=========================================
""")