Moduł trzeci wprowadza trzy fundamentalne kategorie operatorów w Pythonie: arytmetyczne, relacyjne i logiczne. W części arytmetycznej omówiono wszystkie podstawowe działania matematyczne (+, -, *, /, //, %, **) wraz ze skróconymi operatorami przypisania oraz regułami priorytetów według zasady PEMDAS. W zakresie operatorów relacyjnych poznajemy sposoby porównywania wartości (==, !=, >, <, >=, <=) oraz łańcuchowanie warunków, a także pułapki związane z porównywaniem tekstów i liczb zmiennoprzecinkowych. Część logiczna wprowadza bramki and, or i not wraz z koncepcją Truthy i Falsy oraz operatorem członkostwa in. Materiał kończy się praktycznymi przykładami łączenia wszystkich trzech typów operatorów w złożone wyrażenia decyzyjne.

Kluczowe zagadnienia modułu:

• Operatory arytmetyczne i priorytety — PEMDAS, nawiasy, kierunkowość od lewej do prawej (wyjątek: potęgowanie od prawej)
• Dzielenie i modulo — / zawsze zwraca float, // obcina ułamek, % zwraca resztę z dzielenia
• Operatory relacyjne — ==, !=, >, <, >=, <=, porównywanie tekstów (case-sensitive), łańcuchowanie warunków
• Operatory logiczne — and, or, not z hierarchią NOT > AND > OR, short-circuit, Truthy i Falsy
• Zastosowania praktyczne — walidacja danych, sprawdzanie parzystości (%), fallback przez OR, operator in do wyszukiwania w tekstach

• Witamy w części trzeciej kursu! Po opanowaniu rzutowania typów i pobierania danych, czas tchnąć w nie życie za pomocą matematyki.
• W Pythonie, matematyka to tzw. operacje arytmetyczne. Są one tak naturalne, jak korzystanie ze szkolnego kalkulatora.
• Podstawowymi elementami każdego silnika są operator dodawania (znak `+`) oraz operator odejmowania (znak `-`).
• Możesz ich używać bezpośrednio na "surowych liczbach" (tzw. hardcoding) np. `5 + 10`, ale ich prawdziwa moc objawia się w łączeniu zmiennych.
• Gdy dodajesz zmienne (np. `atak + bonus`), system operuje wyłącznie na wartościach schowanych wewnątrz pudełek, po czym podaje ostateczny wynik.
• Pamiętaj, że operacje matematyczne należy zawsze zapisać z jednej, lewej strony na drugą, prawą, np. przypisując sumę do nowego pudełka.

• Mnożenie zapisujemy w IT nie za pomocą "x", ani kropki, lecz za pomocą tzw. gwiazdki (asterisk) - `*`. Przykład: `wynik = 10 * 20`.
• Standardowe dzielenie w Pythonie oznaczane jest symbolem prawego ukośnika, czyli tzw. "slash" - `/`.
• Kryje się tutaj jednak ogromna inżynieryjna pułapka! Dawniej system uważał, że 10 / 2 to twarde `5` (typ `int`). Było to spuścizną po starych językach (np. C).
• W najnowszym Pythonie wprowadzono wielką, ratującą życie reformę: ZWYKŁE dzielenie (/) zawsze, bezwzględnie zwraca ułamek (`float`)!
• Oznacza to, że jeśli napiszesz z pozoru proste `wynik = 10 / 2`, detektyw `type()` powiadomi Cię, że wynikiem jest zmiennoprzecinkowe `5.0`.
• Ta zmiana zabezpieczyła programistów przed niezauważalną utratą danych (np. przy dzieleniu 5 / 2 dawniej ucinano wynik na 2. Zamiast tego dostajemy dzisiaj poprawne 2.5).

# Szybkie przeliczenie zasobów:
zloto = 100
podzial_lupow = zloto / 2

# Output wyniesie "50.0", a nie twarde "50"! Typem będzie float.
print(f"Każdy wojownik dostaje: {podzial_lupow} szt. złota.")
            

• Skoro zwykłe dzielenie `/` zostało zamienione w ułamek float (np. `5.0`), co ma zrobić programista, który buduje grę, w której można rozdawać jabłka w całości (bez krojenia ich na `0.5`)?
• Aby odciąć ułamek na siłę, używamy operatora dzielenia całkowitego, zapisywanego podwójnym slashem: `//` (tzw. "Floor division").
• Zadaniem tego potężnego narzędzia jest wykonanie matematyki i totalne obcięcie (a nie zaokrąglenie!) wszystkiego, co stoi po kropce. Zwraca czystego integera.
• Jeśli wydasz maszynie rozkaz `wynik = 10 // 3`, wynikiem będzie surowa liczba `3`. Co z resztą ułamkową `.333`? Przepada ona w matematyczną nicość.
• Narzędzie to jest wykorzystywane do operacji dyskretnych (niepodzielnych) – np. liczenia rzędów w pikselach monitora lub ilości pełnych pakietów do wysyłki.
• To powrót do starej, klasycznej szkoły C++ ukryty w Pythonie pod podwójnym symbolem. Używaj go rozważnie!

# Mamy 100 naboi i magazynki na 30 kulek:
kule = 100
magazynek = 30

# Użycie // odetnie resztę z ułamka. Liczy się tylko PEŁNA ilość:
pelne_magazynki = kule // magazynek

print(f"Żołnierz załadował pod korek {pelne_magazynki} magazynki.")
            

• Podczas używania ucinającego dzielenia całkowitego `//`, ucinałeś resztę, a ta bezpowrotnie przepadała.
• Co jednak w przypadku kryptografii lub układania obiektów, gdzie zależy nam wyłącznie na odzyskaniu odciętej reszty? Wtedy wkracza gwiazda programowania: operator Modulo (`%`).
• Znak procenta w Pythonie NIE znaczy "wylicz procent podatku". Oznacza on matematyczne wyliczenie: "podziel, weź i daj mi tylko resztę".
• Przykład: Mamy `10 % 3`. Trójka mieści się w dziesiątce 3 razy (to daje 9). Różnica to 1. Zatem z logiki wynika że modulo zwraca precyzyjne `1`!
• To narzędzie jest fundamentem wielu inżynieryjnych cudów. Używa się go np. by sprawdzić, czy numer PESEL jest poprawny lub do budowy rotacyjnych szyfrów (jak szyfr Cezara).
• Jeśli weźmiesz liczbę i wyciągniesz `modulo % 10`, zawsze, bezwarunkowo uzyskasz samą ostatnią cyfrę uciętą z dowolnie wielkiej kwoty!

# Wyobraźmy sobie układanie jabłek po 3 do skrzynek.
# Interesuje nas tylko i wyłącznie jedno: Ile sztuk zostanie samotnie na stole?
luzne_jablka = 10 % 3 

# Output wyniesie magiczne 1 (czyli jedna sierota na stole):
print(f"Na stole zostało luźnych jabłek: {luzne_jablka}")
            

• Skoro wiesz już, że modulo `%` zwraca resztę z dzielenia, pomyśl co się stanie, gdy podzielisz dowolną liczbę w systemie matematycznym przez `2`.
• Jeśli liczba jest równa i idealnie parzysta (np. 10, 4, 100), podzieli się idealnie na dwie połówki. Reszta na tacy wyniesie równe Zero!
• Jeśli liczba jest w jakikolwiek sposób nieparzysta (np. 11, 7, 5), po podzieleniu na dwa zbiory, zawsze pozostanie na tacy magiczna jedynka (`1`) jako reszta.
• W inżynierii to najkrótszy, najszybszy i najszerzej doceniony algorytm rozróżniający parzystość liczb: `liczba % 2`!
• Jeżeli wynik tego równania to 0, odpalasz graczowi parzysty efekt np. miganie ekranu. Jeżeli to 1, odpalasz inny.
• Jest to podstawa podstaw każdego kursu algorytmicznego. Modulo jest cichym i bezlitosnym bohaterem optymalizacji.

# Symulator kości. Losujemy liczbę:
rzut = 7

# System analityczny bada resztę:
anomalia = rzut % 2

# Zobaczymy tutaj 1! Zatem programista wie, że rzut był nieparzysty.
print(f"Rezultat detektora reszty: {anomalia}")
            

• W językach takich jak C++ czy Java, aby podnieść liczbę do kwadratu lub sześcianu, musiałeś skorzystać z funkcji bibliotecznej (np. `pow()`), podczas gdy Python ma to wbudowane w składnię.
• Python został skrojony pod matematyków zajmujących się sztuczną inteligencją, wbudowano więc dla nich w sam rdzeń operator potęgowania: Podwójną Gwiazdkę `**`.
• Aby podnieść 5 do potęgi drugiej, piszemy błyskawiczne i naturalne: `5 ** 2`. Silnik dokona bezwzględnego obliczenia na 25.
• Co wybitne, mechanizm ten akceptuje ułamki i zaawansowane skoki matematyczne! Zapis `9 ** 0.5` bezbłędnie przeprowadzi symulację ... "pierwiastka kwadratowego"!
• Python nie marnuje zasobów. Jeśli potrzebujesz podstawowej inżynierii wektorowej, robisz to natywnymi (wbudowanymi) znaczkami pod rządem jednej linii.
• Tym samym unikamy powielania zmiennych typu `wynik = zasieg * zasieg * zasieg * zasieg`. Piszemy precyzyjnie: `wynik = zasieg ** 4`.

• Przypomnijmy powielane do znudzenia rozwiązanie z drugiego modułu: tzw. "Shorthand Assignment" (skrócone operacje z przypisaniem).
• Nigdy nie rozpisuj pełnego zdania `hp = hp - 15` jeżeli odnosisz rany! Język ten powstał po to, by usunąć zbędny kod ze ścieżki i dbać o zdrowie klawiatury inżyniera.
• Używaj krótkiego uderzenia: `hp -= 15`. Mówi to środowisku: "Chwyć pudełko z lewej, odejmij od zawartości twarde 15 i upchnij nową wartość z powrotem!".
• Działa to dosłownie dla każdego, ze znanych wam dziś symboli matematycznych.
• Możesz odciąć część ułamkową za jednym uderzeniem używając podwójnego ucięcia i równa się: `punkty //= 3`.
• Możesz zapisać cykliczny ogranicznik modulo używając precyzyjnego połączonego kombo `sekundy %= 60`.

# Aktualizowanie stanu serwera (Shorthandy z Modulo!):
minuty = 125

# Ograniczenie zegara do 60 za pomocą skrócenia operatorów:
minuty %= 60

print(f"Zegar cyklicznie powrócił na: {minuty}m.") # Pozostało czyste 5m.
            

• Zastanawiałeś się, dlaczego Python wywala taktyczne błędy (TypeError) na nieodpowiednie mieszanie obiektów? Odpowiedzią jest proces zwany "Przeciążaniem Operatorów".
• System uczy swoje symbole różnych zachowań w zależności od materiału. Plus `+` postawiony przed liczbami dokona kalkulacji i zwróci `15`.
• Jednak ten sam fizyczny znak plusa `+` osadzony między Tekstami dokona sklejenia (zespawania) dwóch słów, znanego jako "Konkatenacja": `"A" + "B"` złoży słowo `"AB"`.
• To tutaj gubi się większość nowicjuszy po braku opanowania rzutowania z `input()`! Jeżeli w zapytaniu użyjesz `5 + "5"`, środowisko zatrzyma się z obawy przed zniszczeniem danych. System nie wie czy chcesz w wyniku `10`, czy słowa `"55"`. Musisz mu stanowczo określić zasady wkładając tekst do hydraulicznej prasy `int("5")`!
• Co zadziwiające, możesz użyć z tekstami Mnożenia `*`. Powielenie `"Wrr" * 3` zduplikuje tekst na potrójne wycie `"WrrWrrWrr"`.
• Pamiętaj! Nigdy nie używaj plusa `+` do sklejania pięknych komunikatów na ekran dla użytkownika. Masz już technologię przyszłości - uderzające klamrami `f-stringi`!

# Złe: Użycie starego "spawania" by połączyć kod to prośba o TypeError,
# jeśli imie to str a poziom to numeryczny int.
# print("Witaj " + imie + " na poziomie: " + poziom) # MOŻLIWY FATAL ERROR!

# Poprawne: F-string naturalnie izoluje logikę i dba o automatyczne ujednolicanie (rzutowanie za kulisami).
print(f"Witaj {imie} na poziomie: {poziom}.")
            

• Powtórzmy jak mantrę najważniejsze prawidło z punktu widzenia inżyniera kodu - operacje arytmetyczne nie są wszechmogące.
• Największym, sztandarowym powodem awarii serwerów jest tzw. niechciana mutacja (Type Mixing).
• Użytkownik uderza przez formularz w klawisz `2`. Ponieważ formularz HTML to okno tekstowe, Python ładuje nam pod etykietę napis wprost `"2"`.
• Nasz wewnętrzny system próbuje przeliczyć podatek obronny: `obliczenia = dane_usera / 100`. I w tym ułamku milisekundy wygrywa logika komputera!
• Sztuczna Inteligencja procesora powiadamia nas czerwoną czcionką: TypeError! "Próbujesz podzielić tekst przez 100? Tego się nie da zrobić. Niszczę proces...".
• Zablokowanie tego błędu leży wyłącznie na barkach programisty konstruującego rurociąg za pomocą `int()` i obrony w klatce `try/except`. Maszyna sama niczego nie domyśli.

# Mroczne wideo dla każdego początkującego:
kod_pocztowy = "80" 
sektor = 100

# Poniższe zgłosi przeraźliwy: TypeError: unsupported operand type(s) for +: 'str' and 'int'
# finalny_kod = kod_pocztowy + sektor
            

• Zbierzmy naszą solidną wiedzę o matematyce zamykając ją w małym środowisku proceduralnym. Wczujmy się w rolę twórców kalkulatora krytycznych obrażeń (RPG).
• Szybkie użycie potężnych i bezlitosnych znaków `*` czy `//` decyduje o elegancji stworzonego rurociągu wewnątrz kodu gry.
• Możesz odciąć brzydkie "ułamki" bez użycia int, zaprzęgając zaledwie potężne cięcie przez `//`. Modyfikujesz w locie z pomocą potężnego przypisania `*=`.
• Takie matematyczne węzły, łączące ze sobą kilkanaście krótkich słów, zastępują potężne linijki skryptów, a przy tym są nadal idealnie zjadliwe dla czytelnika z ulicy (tzw. clean code).
• Matematyka wbudowana w f-string pozwala pominąć uciążliwe trzymanie wszystkiego w dodatkowych pudełkach!
• Na następnych slajdach sprawdzimy co nastąpi, jeśli wszystkie omawiane u nas wbudowane znaki ułożymy bezpardonowo obok siebie w jednej koszmarnie długiej walce linijkowej!

# Procedura testowa walki
baza_obrazen = 50
krytyczny_mnoznik = 1.5

# Cios w plecy nakłada skrótowe wymnożenie obrażeń w rdzeniu tej zmiennej:
baza_obrazen *= krytyczny_mnoznik  # HP rośnie do ułamkowego: 75.0

# Odbicie od zbroi ucina wszystko twardym potrójnym wejściem z użyciem // 
baza_obrazen //= 2 # 75.0 podcięte na pół daje 37.0! // z floatem zwraca float, ale obcina część ułamkową wyniku.

print(f"W system loguje się końcowy strzał na równe {baza_obrazen} DMG. Obrażenia resztkowe Modulo to {baza_obrazen % 10}.")
            

• Zdarza się, że w jednej linijce kodu spotkają się ze sobą ułamki, mnożenie, potęgi i potężne dodawanie. Co zrobi procesor? Czy policzy wszystko chaotycznie od lewej do prawej?
• Absolutnie nie! Python to wysoce restrykcyjny kalkulator. Posiada on wbudowaną tabelę hierarchii, zwaną Priorytetem Operatorów (Operator Precedence).
• W matematyce amerykańskiej uczy się na ten temat prostej mnemoniki: PEMDAS. Oznacza ona kolejność rygorystycznego rozwiązywania układów matematycznych.
• Rozwija się to jako: Parentheses (Nawiasy), Exponents (Potęgowanie), Multiplication (Mnożenie), Division (Dzielenie), Addition (Dodawanie), Subtraction (Odejmowanie).
• To Święty Graal matematyki inżynieryjnej. Kiedy Python napotka gęsty wzór, natychmiast poszuka nawiasów, potem załatwi potęgi, zlikwiduje mnożenia, a dodawanie zostawi na sam koniec.
• Niezrozumienie tej jednej zasady to pewna katastrofa przy liczeniu np. średnich ocen, lub w architekturze finansowej (gdzie podatki naliczane są z błędną kolejnością!).

• Zapewne widziałeś masę memów i zagadek w Internecie pytających o wynik prostego działania: `2 + 2 * 2`. Ludzie często odpowiadają 8.
• Python śmieje się z takich odpowiedzi. Jako doskonała maszyna PEMDAS, wie, że Mnożenie (M) stoi w hierarchii znacznie wyżej niż Dodawanie (A).
• Dlatego w wyrażeniu `2 + 2 * 2`, silnik zamraża pierwszą dwójkę, dokonuje brutalnego obliczenia sekcji z gwiazdką (`2 * 2 = 4`), a dopiero potem "rozmraża" plusa, dając sumę `2 + 4`.
• Wynikiem bezwzględnie, za każdym razem, będzie twarde `6`! I to `6` powędruje do nowo powstającej zmiennej `wynik`.
• Choć wydaje się to banalne, ta sama pułapka pojawia się przy dodawaniu pensji: `wynik = baza + premia * mnoznik`. Premia wystrzeli w kosmos i doda się do bazy.
• Sztuczna inteligencja zawsze faworyzuje znaki z górnej strefy priorytetów.

# Wyliczenie punktów pancerza po nałożeniu buffa:
baza_def = 10
tarcza = 5
mnoznik_magii = 3

# Tutaj maszyna wymnoży tarcza * mnoznik_magii (5 * 3 = 15). Potem doda 10.
obrona_calkowita = baza_def + tarcza * mnoznik_magii

print(f"Twoja obrona wyniosła {obrona_calkowita}!") # Rezultat to precyzyjne 25.
            

• Co w sytuacji, gdy naprawdę, z głębi serca pragniemy, by w tym zagadkowym memie `2 + 2` wykonało się jako absolutnie pierwsze, by ostateczny wynik mógł wynieść mityczne 8?
• Aby ugiąć sztuczną inteligencję procesora do własnej woli programisty, wprowadzamy tarcze absolutne: Okrągłe Nawiasy `()` (Parentheses).
• Nawiasy siedzą na lśniącym, absolutnym tronie (litera P z tabeli PEMDAS). Zmuszają silnik Pythona, by rzucił absolutnie wszystko czym się zajmuje i natychmiast przeliczył to, co jest zamknięte w ich klatce.
• Zapisanie wzoru jako `(2 + 2) * 2` rozwiązuje nasz dylemat na wieki. Wynikiem nawiasu staje się potężne `4`, wymnożone następnie na zewnątrz do wartości `8`.
• Złota zasada inżynierów: nawet jeśli nie jesteś pewny, jak zachowa się skomplikowany wzór z dzieleniem – używaj nawiasów. Są one całkowicie darmowe.
• Dzięki nim, piszesz kod "Idiotoodporny" (Fool-proof). Nie zostawiasz miejsca na błędy.

# Obliczanie średniej arytmetycznej ucznia (3 testy). 
# Musimy zsumować wyniki najpierw, więc używamy tarcz bez namysłu!
test1 = 80
test2 = 90
test3 = 100

# Bez nawiasów, system podzieliłby tylko test3 na 3. Gigantyczny, straszliwy błąd.
srednia = (test1 + test2 + test3) / 3

print(f"Średnia ocen studenta wynosi: {srednia}")
            

• Z wyjątkiem wspaniałych nawiasów z poprzedniego slajdu, to właśnie operator Potęgowania `**` dzierży koronę w matematyce naturalnej (litera E - Exponents).
• Uruchamia on procesy gigantycznego powiększania liczb jeszcze długo przed tym, zanim proste Mnożenie `*` chociażby zdąży się obudzić do działania.
• Oznacza to zawirowania, jeśli w jednym kodzie stoi: `wynik = 3 * 2 ** 3`. Mnożenie grzecznie czeka. Baza dwójki szybuje w kostkę (wynik 8), a potem jest wymnożona przez trójkę (dając 24).
• Częstym uciskiem w kodach w fizyce kosmicznej jest pomylenie potęgowania i mnożenia bez nawiasu przy wyliczaniu pędów prędkości - jest to najdroższy matematycznie wypadek w historii ludzkości.
• Jeśli kiedykolwiek chcesz pomnożyć bazę zanim nastąpi gigantyczne potęgowanie do kwadratu, musisz to zamknąć klasycznie: `(3 * 2) ** 3`. Da nam to gigantyczne 216!
• Edukuj i badaj wzory by zapobiegać wyciekom logicznym w kodzie, których nie pokaże Ci błąd SyntaxError (dla maszyny to przecież idealny wzór!).

# Wyliczenie nieśmiertelnego promienia eksplozji granatu
zasieg_bazowy = 5
wspolczynnik = 2

# Maszyna podnosi w kosmos wspolczynnik^3 (8), a następnie mnoży razy bazę (5).
totalna_destrukcja = zasieg_bazowy * wspolczynnik ** 3 

print(f"Obrażenia obszarowe na serwerze: {totalna_destrukcja}")
            

• Opanowałeś tworzenie nawiasów okrągłych. W potężnych funkcjach statystycznych wzory są jednak ekstremalnie duże (przypominają fraktale!). Posiadają ułamki wewnątrz ułamków.
• W Pythonie w takiej sytuacji powielamy po prostu te same okrągłe tarcze! Tworzymy tzw. Kaskadowe (Zagnieżdżone) nawiasy, wkładając jedne w drugie na wzór cebuli `((()))`.
• Jak działa kompilator, patrząc na taki twór z setkami nawiasów? Szuka absolutnie najgłębszego, rdzewiejącego wewnątrz, małego nawiasu i od niego startuje reakcję wybuchową.
• Po rozwiązaniu jądra, ucieka do góry powłoki i przelicza nawiasy powierzchowne, aż nie wydostanie się na równe pole bitwy z plusem i minusem.
• Zabieg ten pozwala w mgnieniu oka napisać ułamek matematyczny ze skomplikowaną górą i dołem: `wynik = (a + (b * c)) / (x - (y * z))`.
• Edytory IDE wspomagają nas podświetlając konkretne klatki cebuli po kliknięciu. Jeżeli brakuje jednej sztuki, środowisko krzyczy słynnym `SyntaxError` (Błąd Złamanej Składni).

# Wzór na skomplikowane punkty ataku w starym RPG: 
# System rusza od środka! Wyliczy 2*3, doda do 10, i następnie wszystko na pół!
skutecznosc_ataku = ( (10 + (2 * 3)) / 2 )

# Wynik ostateczny to perfekcyjne 8.0
print(skutecznosc_ataku)
            

• Zastanów się, co stanie się z równaniem, w którym dwa symbole walczą ramię w ramię o absolutnie ten sam priorytet! Na przykład wyborne uderzenie `100 / 10 * 5`.
• W systemie PEMDAS, mnożenie i dzielenie są na identycznie tym samym szczeblu hierarchii. Nie ma tutaj szefa i podwładnego.
• W takich momentach język programowania ucieka do swojej instynktownej formy odczytywania księgi, czyli do kierunkowości (ang. Associativity).
• Dla operatorów matematycznych (plusa, minusa, dzielenia, mnożenia) środowisko zawsze rusza powoli i stanowczo Od Lewej Krawędzi do Prawej.
• Zatem w `100 / 10 * 5`, maszyna wpadnie na slash, przedzieli setkę na dziesiątkę (uzyska `10.0`), a dopiero ten uzyskany blok potraktuje na koniec uderzeniem pioruna razy 5, zrzuciwszy wynik `50.0`.
• Gdyby środowisko działało od Prawej (50 do podziału 100), rezultat przepadłby na liczbie 2. Kierunkowość "W Lewo" jest fundamentalna dla obliczeń inżynieryjnych.

• A co jeśli obok siebie stoją bliźniacze potęgi (nasze Królewny Matematyki)? Mamy ekstremalny wpis: `2 ** 3 ** 2`.
• Wydawałoby się (według chronologii ułożenia i czytania na głos), że system z lewej zrobi `2 ** 3` (czyli 8), po czym potraktuje to w górę na kwadrat (64). Niestety - fałsz!
• Potęgowanie `**` posiada w Pythonie legendarny i śmiercionośny Wyjątek Składniowy. Jest to jeden z niewielu znaków ocenianych kaskadowo Od Prawej w Lewo.
• Dlatego dla maszyny, zapis `2 ** 3 ** 2` to w wirtualnych domyślnych nawiasach skrajnie inna wartość oznaczająca `2 ** (3 ** 2)`.
• Maszyna odepchnie się w prawo, zagnieździ potęgę z trójki u góry (dając olbrzymie 9), a następnie obniży stawkę i walnie główną lewą dwójkę potęgą dziewiątą, oddając gigantyczne `512`!
• Różnica pomiędzy fałszywym (lewym) `64`, a prawdziwym algorytmem `512` jest tak ogromna, że potrafi zamienić statki wyliczające stery w chmurę plazmy po wejściu w atmosferę!

# Demonstracja działania wyjątku odczytywania od prawej w potęgach:
reakcja_lancuchowa = 2 ** 3 ** 2 

# Output wynosi gigantyczne 512! Silnik najpierw wymęczył z prawej (3 do kwadratu = 9).
print(reakcja_lancuchowa)
            

• Sprawdźmy jak bezbłędne używanie priorytetów nawiasów wspiera masowe obliczenia. Jesteśmy w trakcie projektowania potężnej gry fantasy (np. Wiedźmina).
• Aby obliczyć punkty odbitych obrażeń, system musi odciąć pancerz przeciwnika od bazy ciosu. Jednak zanim odetnie pancerz, chcemy, żeby ten zmniejszył się ze względu na rozbicie!
• Formuła w głowie "Atak odjąć pancerz dzielony przez 2 razy uderzenie". Zapisany sucho: `atak - pancerz / 2 * uderzenie` spowoduje, że dzielenie i mnożenie zmieli parametry, zanim odejmiesz sam atak!
• Dlatego stosujemy wirtuozerię chronologii, budując potężne tamy ochronne: `atak - ((pancerz / 2) * uderzenie)`. Środek oblicza zmiażdżony pancerz, potem uderzenie i dopiero całościowy moduł pomniejszy ostateczne zdrowie gracza.
• Bądź architektem swojego kodu, a nie obserwatorem chaosu wyplutego z terminala. Ostateczna wizja musi zgadzać się ze wzorcem inżynierskim.
• Każdy system balistyczny buduje w nawiasach obronne sekcje grawitacji. Zmienne zostaw z dala od matematyki z "gołym pędzlem".

# Wyciąg z profesjonalnego wzoru na zadawanie ran od broni palnej (FPS):
obrazenia_bazowe = 200
kamizelka = 50
wspolczynnik_zmniejszenia = 0.8

# Ustalenie priorytetu: najpierw odejmujemy zbroję od kuli, potem wszystko osłabiamy dla balansu!
wynik_ostateczny = (obrazenia_bazowe - kamizelka) * wspolczynnik_zmniejszenia

print(f"Zadano równe {wynik_ostateczny} ran w klatkę piersiową!") # Wyszło 120.0
            

• Możliwość pisania skomplikowanych wzorów w jednej linii niesie ze sobą plagę znaną w branży pod skrótowym określeniem "Spaghetti Code" (Kod jak wymiociny / plątanina nitek).
• Zapis `x=a*b+c/d**2-e` bez cienia spacji to zbrodnia, za którą zespół na froncie obetnie pensję. Chociaż maszyna natychmiast to rozwiąże, inżynier obok połamie zęby i zejdzie mu tydzień na debagowaniu tego tworu.
• Dlatego "Instrukcja Stylu" języka Python, czyli dokument PEP-8, rzuca wytyczne dotyczące czyszczenia matematyki - należy używać luźnych białych przestrzeni (spacji) wokół twardych operatorów najniższego priorytetu (plus, minus).
• Wysoki priorytet (gwiazdki) można lepić bliżej siebie, aby optycznie ukazywać wyższość: `x = a*b + c / d**2 - e`. Widać tutaj gołym okiem skupiska wysp.
• Ostatnią, chwalebnie docenianą w branży techniką jest zwyczajne wrzucenie kilku "wspomagających nawiasów", pomimo, że nie są wymagane do matematycznego obejścia!
• Wzór `x = (a * b) + (c / d**2) - e` pozwala odzyskać wiarę w jakość czytanej formuły i obniża frustrację dla programistów czytających go po 3 latach od Twojego odejścia z firmy.

# KOD "SPAGHETTI" (Nieczytelna plątanina bez oddechu):
# r=b*b-4*a*c

# KOD WZORCOWY (Wyraźnie wydzielone "wyspy" priorytetów):
r = (b * b) - (4 * a * c)
            

• Przeszliśmy przez kompletne załamanie matematycznych reguł wewnątrz języka programowania omijając ogromną stertę błędów typu `TypeError`.
• Wiesz już, dlaczego podział 10 na 2 to złośliwe z zewnątrz `5.0` i jak skrótowo ukrócić ułamek cięciem z podwójnej podłogi `//`. Wiesz, gdzie skrywa się klucz cyklicznych reszt (Modulo `%`).
• Potęgi `**` szanują królewską pozycję za tarczami nawiasów w systemie ułożeń, atakując zdradliwie jako nieliczne od prawicy do lewicy.
• Za chwilę, wejdziemy na wyższy, decyzyjny poziom istnienia algorytmów sztucznej inteligencji. Naszym zadaniem będzie nauczenie maszyny, by sama zaczęła "pytać, szukać i decydować" o rozmiarze zbadanych ułamków.
• Zobaczymy tam starcie operatorów Relacyjnych, rzucając liczbom na pożarcie gigantyczne słowa True oraz False!
• Dbaj o nawiasy i optyczną higienę swojego kodu, zamykaj kaskady matematyczne, tak, aby system nigdy nie dokonał samosądu według chronologicznej lewizny i prawicy!

# Pełen wirtuozyjny pokaz ostatecznego wyliczania priorytetów (kalkulacja reszty z puli po nałożeniu bazy)
# System rozwiąże potęgę na prawicy (4), podzieli na równe (2.0), doda bazę (22.0) i wytnie z tego % 5.0 (da równe 2.0).
wynik_ostateczny = (20 + 8 / 2 ** 2) % 5

print(f"Rezultat wirtuozerii matematycznej to: {wynik_ostateczny}")
            

• Matematyka służy do twardego liczenia (zwracając int/float). Jednak co ma zrobić program, by podjąć decyzję, czy otworzyć drzwi wejściowe, gdy podano kod PIN?
• W tym momencie na scenę wkraczają "Operatory Relacyjne" (Porównania). Ich zachowanie drastycznie różni się od matematyki.
• Zamiast produkować wyniki w postaci surowych cyfr, one zawsze, bez wyjątku, zadają systemowi pytanie (np. "Czy ta liczba jest większa od tej?").
• W odpowiedzi, wirtualny detektyw wewnątrz Pythona wydaje wyrok absolutny: zwraca jedną z dwóch wartości typu boolean: `True` (Prawda) lub `False` (Fałsz).
• Operatory relacyjne to fundament powstawania tzw. "Bram Logicznych", a tym samym pierwszych objawów Sztucznej Inteligencji - zdolności maszyny do wybierania różnych ścieżek!
• W nadchodzących slajdach uzbroimy nasz kod w zdolność wyczuwania stanu otoczenia.

• Mamy zaszczyt przedstawić błąd, który popełnia 100% nowicjuszy i około 50% profesjonalistów każdego dnia. Zrozumienie go to przepustka do IT.
• Pojedynczy znak równości `=` (Przypisanie) absolutnie NIE ZNACZY "czy to się równa". Mówi on do systemu brutalne: "Weź prawą stronę i na siłę wepchnij do pudełka po lewej!".
• Jeżeli chcesz zapytać maszyny: "Hej, czy zmienna X równa się zmiennej Y?", musisz użyć operatora Równości: Podwójnego Znaku Równa Się `==`.
• Dopiero znak `==` zamienia środowisko w cierpliwego sędziego, który delikatnie waży na wadze lewą i prawą stronę, po czym wypluwa werdykt `True` lub `False`.
• Zapisując instrukcję `haslo = "123"` po prostu zmieniasz hasło. Zapisując z kolei `haslo == "123"` pytasz system, czy podane hasło jest właściwe!
• Ta drobna wizualnie różnica dzieli pracujące programy lotnicze od spektakularnych katastrof budowlanych.

# Zły kod (Programowanie siłowe, brak pytania):
wiek = 18 # To deklaracja. Pudełko "wiek" nosi liczbę 18.

# Dobry kod (Systemie, sprawdź i wydaj wyrok):
odpowiedz = (wiek == 18) 

# Output wyniesie czyste i piękne "True":
print(f"Weryfikacja pełnoletności: {odpowiedz}")
            

• Skoro wiesz już, że podwójne `==` pyta o idealną zbieżność obiektów, warto poznać jego czarnego brata - operator z wykrzyknikiem: `!=`.
• W informatyce wykrzyknik to tzw. logiczne "NOT" (Nie/Zaprzeczenie). Operator `!=` zadaje pytanie: "Czy wartości RÓŻNIĄ SIĘ od siebie?".
• Bramka wydaje z siebie potężne `True`, jeżeli elementy obok NIE są identyczne.
• Przykład? `10 != 5` (Czy 10 jest różne od 5?). Silnik entuzjastycznie wykrzykuje `True`! Obie cyfry to dwie różne istoty.
• Używamy go najczęściej przy filtrach blokujących np. `if uzytkownik != "admin"`. Zablokuje on każdego szarego człowieka i przepuści wyłącznie twórcę systemu.
• W matematyce starszej ten znak zapisywano jako `<>`, jednak we współczesnym Pythonie 3 ta wariacja została wyłączona. Pozostajemy wierni wykrzyknikowi `!=`.

# Analiza bezpieczeństwa zamka biometrycznego:
skan_palca = "kod_009"
baza_szefa = "kod_001"

# System skanuje czy palec różni się od odcisku szefa?
zagrozenie = (skan_palca != baza_szefa)

# Ponieważ kody się różnią, zagrożenie wyniesie "True" (Alarm!):
print(f"Podniesienie alarmu naruszenia: {zagrozenie}")
            

• Dla liczb idealnymi operatorami relacji są kątowe znaczki Mniejsze/Większe: `<` oraz `>`.
• Zostały one bezpośrednio odziedziczone z algebry szkoły podstawowej. Ostrze strzałki celuje zawsze w element, który chcemy traktować jako "Mniejszy".
• Zapytanie `10 > 5` rzuci wyrok `True` (bo dyszka dumnie pnie się wyżej).
• Kryje się tu jednak bardzo częsta pułapka matematyczna - co wyjdzie z testu `5 > 5`? Wynikiem będzie twarde `False`!
• Zwykły operator `>` oznacza, że liczba musi bezwzględnie przeskoczyć wartość na szali by wywołać obwód. Sama zbieżność (wylądowanie na pięciu) to dla ostrza zbyt mało.
• Operatorów tych używa się przy detekcji zderzeń (hitbox), aby sprawdzać, czy punkt na ekranie wniknął do wnętrza kwadratu kolizji przeciwnika!

# System obronny bazy:
odleglosc_od_celu = 1200
zasieg_dziala = 1500

# Czy statek kosmiczny wszedł bezpiecznie w promień śmierci radaru?
namierzanie = odleglosc_od_celu < zasieg_dziala

# Output wynosi True, ponieważ 1200 jest ostro mniejsze od zadeklarowanego pola obrony 1500.
print(f"Działo obronne uruchomione: {namierzanie}")
            

• Wielu inżynierów borykało się ze zgryzem: "Jak zapytać o wiek 18 lat bez pisania pokracznego `wiek > 17`?". Ratunkiem są tak zwane "Operatory Połączone" (Inclusive Operators).
• Zestawiają one ostry grot ze znakiem równości: `>=` (Większe BĄDŹ równe) oraz `<=` (Mniejsze BĄDŹ równe). Znak równości wędruje na pozycję drugą.
• Taki operator staje się bramką "lubiącą kompromisy". Pytanie `5 >= 5` wyrzuci przepiękne `True`, ponieważ pomimo bycia brakiem większości, cyfra zaliczyła warunek twardej równości.
• Operatory elastyczne to filar zabezpieczeń portali. Kod weryfikacji na serwerze to w 99% `if wiek >= 18` (czyli wpuszczaj każdego o dorosłym stażu).
• Używa się ich przy progach pętli odliczających – "kręć kierownicą dopóki skręt jest `<="` 100 stopni". Kiedy czujnik zrówna się z blokadą (100), pętla wciąż wykona ostatnie zadanie przed blokadą!
• To narzędzie całkowicie leczy ze szkolnych błędów przesunięcia o jedno miejsce (`off-by-one errors`).

# Weryfikator promili (limit to absolutne 0.2)
odczyt = 0.2

# Sprawdzamy kompromisowo - wynik 0.2 uruchomi bramkę kary True!
kara_odebrania = (odczyt >= 0.2)

print(f"Wdrożyć utratę statusu? {kara_odebrania}")
            

• Poznaliśmy zachowanie znaków relacji z wpuszczonymi liczbami. Ale co się stanie, gdy zażyczysz sobie porównania na typie string (`str`)?
• W środowisku Python słowa i litery to zbiory potężnych wartości binarnych. Pytanie `"Admin" == "admin"` nie sprawdza ludzkiego znaczenia słowa, bada ono ich wagę matematyczną w tabeli ASCII!
• Dlatego dla maszyny znak "A" to kod wagi 65, a literka "a" to kod o wadze 97. Pytanie `"Admin" == "admin"` zwróci brutalne `False`!
• To główny powód irytacji początkujących: "Podałem poprawne imię, dlaczego mój bot nie reaguje?". Ponieważ maszyna jest obłąkana na punkcie wielkości liter (Case-Sensitive).
• Zawsze wspieraj porównania tekstów narzędziami ujednolicającymi z części 2, mianowicie z ucięciem `.lower()`. Wtedy `"Admin".lower() == "admin"` rzuci zbawienne `True`!
• Ciekawostka: możesz pytać maszynę literami o relacje alfabetyczne `"B" > "A"`. System zwróci tu `True`, ponieważ wartość numeryczna "B" leży po prostu dalej w tabeli.

• Skoro w świecie Tekstów brakuje miłosierdzia i jedno małe uchybienie łamie wynik operatora, co w przypadku twardych rywali: Floatów i Intów?
• Jeżeli wrzucisz na obwód weryfikacyjny równanie relacyjne pytając komputera: `5.0 == 5`, co wymyśli maszyna? Odrzuci bo typy są inne?
• Mamy dla was rewolucyjną nowinę! W tym jednym specyficznym przypadku system okazuje wybitną empatię. Python wypluje wielkie `True`!
• Bramki relacyjne potrafią we własnym zakresie spłaszczyć w locie `float` by przetestować jego "istotę matematyczną". 5.0 to tak po prostu okrojona ułamkowo piątka.
• Nie przejmuj się zatem, że wynik funkcji (np. zwykłego matematycznego `/`) wrzuca Ci brzydki, uparty typ `float`. Kiedy zderzy się ze zmiennymi brzegowymi `int`, obrona bramy puści bez narzekania.
• Musisz oczywiście pilnować skrawków danych - jeżeli gdzieś zagubiła się wroga jedynka (`5.0001 == 5`), empatia się wyłącza na rzecz fizycznego detektora `False`.

# Wyliczenie reszt z zaawansowanych łupów (wynik zwraca floata z wewnątrz!):
zasob_po_dzieleniu = 100 / 2 # Produkuje twarde zmiennoprzecinkowe 50.0

# System konfrontacji jest niewzruszony i akceptuje ludzki int po prawej.
czy_to_polowa = (zasob_po_dzieleniu == 50)

print(f"Empatyczny system uznał weryfikację za: {czy_to_polowa}") # True
            

• Sprawdzanie jednej prawdy to podstawa. Prawdziwa moc rodzi się w sprawdzaniu widełek! Jesteśmy inżynierami portalu: Użytkownik musi mieć między 18 a 65 lat.
• W prehistorycznym C++ czy JavaScript inżynier napisałby: `if (wiek >= 18 && wiek <= 65)`. Twór obrzydliwy i bardzo nieczytelny.
• Python wspiera inżynierię znaną z podręczników matematycznych: Chaining Relacyjny (Łączenie Operacji)!
• Możesz po prostu skompresować wszystko na jednym oddechu od strony zmiennej po środku: `18 <= wiek <= 65`.
• System podziurawi na chwilę ten wzór, w ułamku sekundy podstawi `wiek`, zweryfikuje lewą połówkę, prawą połówkę i zwróci magiczne, łączne `True` jeżeli gracz zmieścił się w bramkach bezpieczeństwa!
• To jest najszybsza i najbardziej rekomendowana z optymalizacji używanych na świecie do sprawdzania koordynat w silnikach (np. "Czy wróg widoczny mieści się w moich obiektywach kamery?").

# Wyliczenie bezpiecznej sfery temperatury wektorowej rdzenia [Celsius]
temperatura = 85

# Wytłoczony wzór matematyczny, połączony i skompresowany.
stan_stabilny = 50 <= temperatura <= 90

# Temperatura 85 znajduje się perfekcyjnie pośrodku. Silnik zwróci bezpieczne True!
print(f"Rdzeń znajduje się w normie widełkowej: {stan_stabilny}")
            

• Zastanawiałeś się kiedyś, jak strony internetowe "złoszczą się", gdy podasz im w formularzu rejestracji login składający się z zaledwie z "ab", informując że wymuszają co najmniej 8 liter?
• Robią to stosując potężną synergię (połączenie sił dwóch funkcji)! Sprowadzają string do bezwzględnych cyfr długości przy pomocy wbudowanego inspektora Pythona: funkcji `len()`.
• Zapisując instrukcję `len("ab")`, narzędzie wchodzi wgłąb paczki wyciągając matematyczne równe pudełko cyfrowe: `2` (bo wyraz ten posiada tylko 2 znaki fizyczne).
• Następnie uzbrojony w cyfrę kodder wchodzi prosto w operator relacyjny! `len("ab") >= 8` (Czyli w tłumaczeniu przez system: `2 >= 8`!).
• Odpowiedzią silnika staje się nagłe, stanowcze `False` i wielka, czerwona blokada pojawia się przed nosem klienta na ekranie komputera.
• Podstawowe bezpieczeństwo haseł na całym globie zbudowano właśnie na tym bezwzględnie trywialnym połączeniu inspektora liter z ostrzem większości.

# Moduł rejestracji bazy korporacyjnej
podane_haslo = "qwertyuiop" # 10 Znaków. Twardy i groźny materiał.

# Bramka relacyjna przyjmuje do klatki detektywa, a ten ocenia i niszczy intruza:
przepustka = len(podane_haslo) >= 8

print(f"Status nadania silnego uwierzytelnienia: {przepustka}") # Przepustka wydana (True)!
            

• Złożymy teraz naszą wiedzę w zwarty monolit inżynieryjny, przygotowujący grunt pod wejście operatorów warunkowych if/else na scenę decyzyjności maszyn.
• Wiemy że funkcja wejściowa `input()` rodzi bałagan rzucając w rury systemu tekst ucięty spacyjnie. Wiesz, że `float()` wymusza obwód matematyczny radzący sobie w razie W z kropkami dziesiętnymi.
• Sprowadzasz bałagan poprzez operator relacyjny (najczęściej potężny, podwójny i ostry `==` dla liter, albo tolerancyjny wyznaczający limit `>=` dla pieniędzy i cyfr).
• Na wyjściu z tej procedury otrzymujemy maleńkie pigułki deweloperskie o twardym typie o nazwie Boleans: `True` albo `False`.
• Nawet jeżeli w kodzie połączysz ze sobą miliony cyfr i skomplikowanych zagnieżdżeń nawiasowych, ostateczny wyrok zapytania połączony w f-stringu to dla maszyny tylko jedno z tych wielkich, zbawiennych słów.
• Tak oto wkroczyliśmy ze sfery suchych i uciążliwych poleceń "Maszyno, pomnóż", w strefę wielkich decyzji logicznych "Maszyno... zbadaj!".

# Moduł Ostrzegania Reaktywnego: Zbudowany z inputem sanitacyjnym
# Zakładamy że user w ciemności rzucił na front słowo "  AdMIN  "
login_z_bazy = "  AdMIN  "

# Procesor czyści go paskudnymi łańcuchami .strip().lower(), odzyskując perłę "admin"
odkute_dane = login_z_bazy.strip().lower()

# Sędzia uderza wielkim młotkiem z mosiądzu relacyjnego ==:
logowanie_udane = (odkute_dane == "admin")

print(f"Logika biznesowa zweryfikowana z rezultatem: {logowanie_udane}!") # Sukces, True!
            

• Na poprzednich slajdach zbudowaliśmy bramki wpuszczające gracza, jeśli ma `>= 18` lat, albo jeśli podał poprawne hasło `== "tajne"`. Zwracały one urocze `True` lub `False`.
• W rzeczywistości, systemy bankowe i gry komputerowe nigdy nie bazują na JEDNYM warunku. Musisz mieć 18 lat ORAZ posiadać bilet ORAZ nie być na czarnej liście.
• Aby połączyć te wszystkie małe "Prawdy" (Boleany) w jeden gigantyczny rurociąg decyzyjny, język Python oferuje zaledwie trzy potężne angielskie słowa.
• Są to Operatory Logiczne (Bramki Booleowskie): `and` (I / Oraz), `or` (Lub), oraz `not` (Nie / Przeciwieństwo).
• Operatory te nie wykonują żadnej matematyki. One żywią się wyłącznie stanem rzeczy (`True`/`False`). Przyjmują Prawdę i Fałsz od operatorów relacyjnych, mielą to i wypluwają ostateczny, końcowy Wyrok.
• Używa się ich do budowania skomplikowanych testów w pętlach i zabezpieczeń w algorytmach Sztucznej Inteligencji.

• Pierwszym słowem władzy w Pythonie jest potężne `and` (pol. i / oraz). W klasycznej elektronice nazywa się to bramką koniunkcyjną.
• Bramka `and` posiada bezwzględną dewizę: Wszystko musi być Prawdą, innej opcji nie przyjmuję. Odrzuca kompromisy.
• Jeżeli powiesz maszynie: "Przepuść mnie jeśli wymóg 1 jest Prawdą `and` wymóg 2 jest Prawdą", to Python przepuści cię, uderzając w `True` tylko jeśli oba warunki lśnią światłem `True`.
• Jeśli podasz chociaż JEDNĄ usterkę (jeden obwód zweryfikuje się na `False`), bramka `and` natychmiast zatrzymuje operację! Dla niej, nawet `True and True and False and True` to w rezultacie jedno wielkie `False`.
• To narzędzie wysoce restrykcyjne. Używane zawsze podczas procedury logowania: login musi być poprawny `AND` hasło musi być poprawne. Oba jednocześnie, bez wyjątków.
• Python ewaluuje `and` leniwie od lewej: Jeśli na starcie wpadnie na `False`, w ogóle nie sprawdzi reszty kabli by oszczędzić prąd (Short-Circuiting)!

# Surowy symulator warunków atmosferycznych
wymagany_wiek = 18
wymagany_sprzet = True

# Obie składowe muszą świecić na "True", aby brama opadła!
dostep = (wymagany_wiek >= 18) and (wymagany_sprzet == True)

print(f"System pozwolił na ekspedycję ratunkową: {dostep}")
            

• Zastanów się nad przykładem gry RPG. Chcesz pozwolić graczowi uderzyć toporem w ogra. Kiedy może to zrobić?
• Zasada 1: Gra musi upewnić się, że masz wyekwipowaną broń.
• Zasada 2: Musisz mieć na celowniku ogra, który w ogóle jeszcze żyje (jego HP jest większe od zera).
• Zasada 3: Musisz znajdować się dostatecznie blisko wroga (np. Zasięg `<` 5 metrów).
• Twój wirtualny system użyje wspaniałego, potrójnego kombo `and`. Jeśli choć jeden z tych warunków to kłamstwo (np. jesteś za daleko), maszyna nie pozwoli zadać rany.
• Dzięki krótkim obwodom (short-circuit), w ułamku mikrosekundy system odrzuci `False` nie angażując mocy obliczeniowej na resztę zapytania. Jest to gigantyczna optymalizacja wielkich światów 3D.

# Logika biznesowa ciosu specjalnego
bron_w_reku = True
hp_wroga = 150
dystans = 8

# Wymagany dystans to <= 5. Maszyna potknie się o dystans rzucając False.
# (Wroga pomija, bo nie ma sensu sprawdzać HP dla chybionego ciosu!)
mozna_atakowac = (bron_w_reku == True) and (dystans <= 5) and (hp_wroga > 0)

print(f"Gracz zadaje cios: {mozna_atakowac}") # Zostanie zablokowany (False)
            

• Skoro bramka `and` wymaga absolutnie wszystkiego, jak programujemy systemy bardziej ugodowe? Poznajmy bramkę OR (Lub).
• W matematyce dyskretnej zwana jest "Alternatywą". Posiada ona zupełnie przeciwną, niemalże łagodną dewizę: Wystarczy mi jedna jedyna prawda, a wpuszczę Cię do środka!.
• System korzystający z `or` zapyta: "Daj mi spełniony Warunek 1, a jeśli go nie masz, to pokaż że chociaż Warunek 2 działa".
• Wystarczy jedna raca odpalona na szczere `True`, by całe gigantyczne rusztowanie oceniło się na `True`. Reakcja ułoży się na `False` TYLKO WTEDY, gdy wszystkie z postawionych warunków okazały się oszustwem.
• Używamy tego przy obsłudze e-sklepów: np. zniżka aplikuje się, gdy gracz posiada Kupon Promocyjny, `OR` gracz posiada konto Premium, `OR` robi duże zakupy za ponad 500 PLN.
• Podobnie jak `and`, bramka OR odznacza się lenistwem. Gdy system sprawdza ułożone od lewej do prawej `or`, z chwilą gdy wpadnie na pierwsze ocalające go `True`, po prostu puszcza program dalej i nie czyta reszty poleceń.

# Weryfikacja darmowej dostawy:
kwota_koszyka = 150
czy_premium = False

# Program pyta, czy klient ma Premium, LUB kwotę > 200. Niestety, klient nie ma żadnej z tych rzeczy.
darmowa_dostawa = (czy_premium == True) or (kwota_koszyka >= 200)

print(f"Klient otrzymuje gratis na transport: {darmowa_dostawa}") # Niestety False!
            

• Zauważ, że bardzo często program musi radzić sobie z beztroskim użytkownikiem. Ludzie wpisują słowa na masę różnych sposobów!
• Gracz poproszony o wpisanie komendy "wyjdz" może wpisać: "Wyjdz", "WYJDZ", a nawet wcisnąć guzik ucieczki.
• Dlatego silnik gier stosuje bramkę `or` by rozpoznać te dziwne warianty.
• `if akcja == "wyjdz" or akcja == "q":` zamyka program z wyczuciem dla lenistwa ludzi.
• Uwaga techniczna - unikaj błędu logicznego: Nie można pisać `if akcja == "wyjdz" or "q"`. Brzmi to dobrze tylko po polsku. Python dla drugiego członu uzna samo słowo "q" za obiekt True i warunek zawsze będzie spełniony! Należy ZAWSZE od zera zadawać pełne pytanie po operatorze OR.
• Prawidłowa instrukcja brzmi twardo: Zmienna A jest równa Opcji Pierwszej `or` Zmienna A jest równa Opcji Drugiej.

# Symulacja obsługi wpisania słowa przez konsolę
wpis_usera = "quit"

# Błędne: wpis_usera == "wyjdz" or "quit" (DLA PYTHON "quit" OZNACZA ZAWSZE PRAWDE!)
# Poprawne wywołanie alternatywy dla obu ścieżek:
zamykamy = (wpis_usera == "wyjdz") or (wpis_usera == "quit") or (wpis_usera == "q")

print(f"Został nadany protokół wyłączania maszyn: {zamykamy}")
            

• Ostatni filar "Wielkiej Trójcy Logiki" to tajemnicze słowo `not` (Negacja / Zaprzeczenie). Jest to bardzo groźny rewolucjonista w systemie.
• Działa dokładnie odwrotnie niż operator relacyjny `!=`. Bramka `not` jest cichym rebeliantem. Nigdy nie ocenia dwóch zmiennych z lewej i prawej...
• `not` podchodzi dyskretnie do gotowej, sformowanej Prawdy (True) albo do sformowanego Fałszu (False) i uderzeniem młota Zmienia ich obwód na ODWROTNY!
• Wyrok `not True` natychmiast wydrukuje bezwzględne `False`!
• Wyrok `not False` wyciąga z czeluści piekielnych absolutne, promienne `True`!
• Używa się go namiętnie jako przełącznika (Switch / Toggle), np. wciskając guzik podświetlenia nocnego: "Niech podświetlenie = NOT(podświetlenie)". Żarówka zgaśnie, by kliknięcie później znów wrócić na `True`.

• Do czego "nie potrzebujemy" negacji `not`? Na pewno nie do pisania brzydkich kodów pokroju `if not wiek == 18`. To obrzydliwe. Po to mamy wykrzyknik i równa się, by pisać piękne `wiek != 18`!
• Domeną dla słówka `not` jest odwracanie wskaźników booleanowskich (czyli zmiennych które same w sobie przechowują w pudełku True lub False).
• Na serwerach tworzy się stany flag (Flags). Np. flaga systemowa `czy_zamrozone = False`. Oznacza to, że silnik chodzi bez problemu.
• W pewnym momencie nadużycie CPU w kosmosie odpala algorytm mrożenia systemu bezpieczeństwa.
• Użycie zaledwie jednego uderzenia w klawisze: `not czy_zamrozone` powoduje odpalenie obwodu ratunkowego, nie musimy analizować kodu przez `czy_zamrozone == False`. `not` zrobi to błyskawicznie.
• Nawiasy wokół elementu traktowanego młotem `not` nie są wymagane technicznie, ale potężnie poprawiają czytelność w długich równaniach `not (warunek A and warunek B)`.

# Status broni w ekwipunku gracza 
czy_przeladowano = False

# Program strzelecki wyzwala akcję JEŻELI BROŃ NIE JEST ZAŁADOWANA
# not wyceluje w "False" i odwróci ujemną energię tworząc ratunkowe "True"!
wymus_przeladowanie = not czy_przeladowano

print(f"Brak pocisku na bębnie! Odpal pętle ładowania: {wymus_przeladowanie}!")
            

• Tak jak arytmetyka ma swojego króla Priorytetów (PEMDAS), tak Świat Cyfrowy Logiki również podlega ścisłej hierarchii odczytu poleceń.
• Co stanie się, gdy inżynier ułoży w jedną, gęstą linię kombo bramek: `True or True and False`? Jak zinterpretuje to rdzeń maszyny?
• Logika Boole'a ma wbitą żelazną hierarchię (od najwyższego): `not` (Zawsze działa pierwsze!), potem wchodzi `and`, a na samym końcu odpalane są paski `or`.
• Zatem w `True or True and False`, sztuczna inteligencja nie rzuci się od lewej oceniając `or`. Zatrzyma operację, odszuka władcę - operator `and`!
• Zbada więc jądro: połączy ułamek `True and False`, który siłą wciągania da ostatecznie bolesne `False`. Wynik wciągnięcia jest zrzucony w dół.
• Dopiero wtedy silnik odpali ocalałą resztkę ułamka: początkowe `True` połączy przez `or` z marnym `False`. Brama otworzy przepustkę na ratunkowe `True`!

# Klasyczne zagięcie wyliczeniowe z rozmów o pracę dla programistów:
obwod_glowny = False or True and not True

# 1. NOT zamienia ostatnie True na -> False
# 2. AND miesza środek: (True and False) -> False
# 3. OR na końcu: (False or False) -> FATALNE FALSE!

print(f"Bramka logiki przetrwała wybuch? {obwod_glowny}")
            

• Widziałeś na poprzednim slajdzie, z jaką nieprawdopodobną prędkością rdzeń Pythona zmasakrował nieuporządkowane dane logiczne w imię wbudowanej hierarchii.
• Aby połączyć dwa twarde stany `and` obok pojedynczego ustępstwa `or` bez wyrywania sobie włosów z głowy, ponownie wzywamy ratunek ze strefy matematyki: Nawiasy `()`.
• Zapisując procedurę bezpieczeństwa lotu ucinamy macki środowisku `and`: `wymogi = (silnik == True and waga < 100) or awaria == True`.
• Zawsze upewnij się optycznie co jest trzonem zabezpieczeń! Czysty obwód `and` w objęciach nawiasu jest przeliczony absolutnie w izolacji, stając się jednym wielkim filarem mostu.
• Nawet jeżeli jesteś w 100% pewny wbudowanego priorytetu operatorów logicznych... uśmiechnij się i dodaj nawiasy dla osoby, która przejmie Twój projekt w przyszłym kwartale.
• To jest wyznacznik standardu PEP-8 i Clean Code, który odróżnia pisarza tekstów o kodowaniu od realnego Inżyniera Architekta.

# Zastosowanie nawiasów ocala całe operacje i zapobiega katastrofom.
# Klient przejdzie przez ochronę kiedy: Jest z dyrekcji, ALBO ma status gościa I zaproszenie!
czy_dyrektor = False
czy_gosc = True
ma_zaproszenie = True

# Brama używa szczelnego buforowania w nawiasach!
zabezpieczenie_wejscia = czy_dyrektor or (czy_gosc and ma_zaproszenie)

print(f"System wpuszcza wizytatora: {zabezpieczenie_wejscia}")
            

• Zakończyliśmy przeprawę przez najbardziej hermetyczną część Pythona: Operatory Logiczne. Znasz już potrójną więź sterującą zachowaniem obwodów maszyn!
• `AND` to mur nie do przebicia: niszczy wszystkie starania, jeśli choć jeden z kabli wyśle słabeuszowskie `False`. Używamy go do potężnych obostrzeń.
• `OR` to koło ratunkowe - wpuszcza rzekę, jeżeli z całego oceanu śmieci uratuje się jedna świecąca dioda `True`. Przydaje się przy omijaniu pułapek dla ułomnego inputu użytkowników.
• `NOT` działa w cieniu, odwracając po chamsku wartości o 180 stopni z pominięciem jakiejkolwiek skomplikowanej dyskusji i pytania operatora równego.
• Ostatnią fazą szkoleniową w tym pliku będzie zapoznanie ze skrajnościami. Użyjemy znaku przypisania, znaku nierówności i bramki logicznej obok potężnej matematyki, budując jeden algorytm filtrujący.
• W ostatnim rozdziale połączysz kropki wszystkich dotychczas omawianych symboli klawiatury!

# System analizujący logikę po wypłacie (kompleksowy pokaz):
stan_konta = 500
ma_raty = True

# Status wolności finansowej: ponad 100 i NIE ma_raty (odwrócenie negacją!)
wolnosc_finansowa = (stan_konta > 100) and (not ma_raty)

# Niestety "and" łamie zęby na odwróconym "False" dla rat! Maszyna zgłasza błąd wolności.
print(f"Gracz ma oszczędności bez limitów w banku: {wolnosc_finansowa}")
            

• Zanim połączymy wszystkie systemy na koniec modułu, zniszczmy najpaskudniejszy nawyk początkujących.
• Jeśli masz w systemie flagę `czy_zyje = True`, wielu nowicjuszy sprawdzając jej stan użyje kodu: `czy_zyje == True`.
• Co na to Python? Zgodnie z algebrą podstawi: `True == True` i wyrzuci wynik... `True`. Skoro odpowiedź to i tak wylosowana na początku wartość, PO CO to pisać?
• To dosłowne masło maślane! Jeśli badasz flagi Boolean, zignoruj operator `==`. Po prostu użyj samej zmiennej!
• Nigdy nie pisz `(czy_zyje == True) and (atak == False)`. Prawdziwy inżynier Pythona zapisze to elegancko: `czy_zyje and not atak`.
• Ten jeden zabieg uodparnia Twój kod na śmiechy na rozmowie kwalifikacyjnej.

• Ostatnią wielką tajemnicą bramek logicznych w Pythonie jest zjawisko zwane "Truthy i Falsy".
• Co się stanie, jeżeli rzucisz do weryfikacji bramce `and` słowo, zamiast twardego Booleana? Np. `"Janek" and True`.
• Python posiada wbudowany obwód oceny masy: Wszystko co jest "puste" jest traktowane jako naturalne `False`!.
• Liczba zero `0`, pusty string `""`, brak danych `None` - obwody uderzą w to i ocenią jako twardy, obezwładniający Fałsz. Oceniamy te zjawiska terminem "Falsy".
• Cała reszta - dowolny string `"a"`, liczba rzucona jako waga `-5`, czy ułamek `0.001` - wszystko co posiada najmniejszą gęstość i masę jest ewaluowane jako wygrywające "Truthy" (odpowiednik True).
• Dlatego możesz sprawdzać, czy użytkownik w ogóle podał imię po prostu wprowadzając samo imię do weryfikatora!

# Wyobraź sobie logikę opartą tylko na zjawisku Truthy / Falsy
odp_uzytkownika = "" # Użytkownik wcisnął enter i nic nie podał
kasa = 0 # Zero gotówki

# Oceniamy surowe obiekty, nie używając znaków równego!
czy_wpisano = bool(odp_uzytkownika) # Wynik: False (bo tekst był pusty)
czy_biedny = not kasa # Kasa to Falsy (False), więc 'not False' rzuca w kosmos wielkie: True!

print(f"Użytkownik bez grosza i bez imienia został przyjęty: {czy_biedny}")
            

• Dzięki poznaniu leniwej natury bramek i wchłonięciu zjawiska Truthy/Falsy, otwiera się przed Tobą słynny wzorzec z korporacyjnych repozytoriów kodu.
• Program pyta o imię: `imie = input()`. Gdy użytkownik uderza twardy ENTER, powstaje pusty string `""`. Z poprzedniego slajdu wiemy, że to paskudne natywne `False`.
• Możemy uratować profil takiego złośliwego użytkownika w locie przy pomocy bramki ratunkowej `or`!
• Zapiszemy `profil = input() or "Nieznajomy"`. Jak to rozegra się w procesorze?
• Jeśli input wypluje mroczne `""` (Fałsz), obwód `or` pójdzie w prawo i uratuje sytuację, rzucając na stół drugą stronę barykady: radosny tekst `"Nieznajomy"`. I to to twarde Truthy zagnieździ się w zmiennej profil!
• Jest to najpiękniejszy wbudowany na świecie system nadawania tzw. Domyślnych Wartości (Default Fallbacks).

# System Fallback na operatorze logicznym

# Symulacja: Pusty string "" wyprodukowany po cichu przez usera:
ukryty_input = ""

# Or odrzuca Fałsz, podążając po kablu bezpieczeństwa z domyślnym tytulem:
tytul_gracza = ukryty_input or "Gnom"

print(f"Witaj w Karczmie, przyjacielu. Będę zwał Cię: {tytul_gracza}!") # "Gnom"!
            

• Podczas pracy z wielkimi stringami powraca koszmar wyszukiwania. Chcemy sprawdzić czy mail jest z "gmail". Mając operator równości, musielibyśmy napisać `== "gmail.com"`, ale email jest przecież gigantyczny: "jan@gmail.com"!
• Rozwiązaniem w Pythonie jest tzw. Operator Członkostwa (Membership Operator). To malutkie angielskie słowo kluczowe `in` (w).
• Zachowuje się ono w obwodach IDEALNIE jak poznany wcześniej operator porównania. Zwraca absolutne i stanowcze `True` albo `False`.
• `"@" in adres_email` wejdzie z mikroskopem do gigantycznej taśmy tekstu. Będzie przesuwał się klatka po klatce. Kiedy natrafi na znak uderzy w dzwon: rzucając piękne `True`!
• Możesz połączyć go z rewolucjonistą, mianowicie z `not`. Pytanie `"mafia" not in czat_serwera` to ubezpieczenie, że dane słowo ABSOLUTNIE nie znajduje się na podglądzie, emitując zielone światło `True` do startu przesyłu wiadomości.

# Szybki filtr bezpieczeństwa domeny
email_baza = "dyrektor_naczelny@korpo.pl"

# Logika biznesowa wyszukuje twardej domeny w tekście:
autoryzacja_firmy = "@korpo.pl" in email_baza

print(f"Adres wewnętrzny zweryfikowany: {autoryzacja_firmy}") # Mamy True!
            

• Najwyższym stopniem inżynierii przed wprowadzeniem Pętli IF, jest połączenie operatora matematycznego na uwięzi operatora relacyjnego.
• Zapamiętaj to raz na zawsze: w programowaniu aby określić Parzystość liczby, nigdy nie dzielisz w locie. Odpadasz operator reszty z dzielenia: Modulo (`%`) przez 2!
• Wynikiem `cyfra % 2` jest ZAWSZE tylko i wyłącznie matematyczne zero (brak reszty, parzysta) albo jedynka (reszta jeden, nieparzysta).
• Teraz wkracza operator relacyjny `==`. Przypinasz go z drugiej strony pisząc `cyfra % 2 == 0`.
• Ten mechanizm powołuje do życia czysty filtr Booleaowski! Każda udręczona, potężna liczba (np. miliony w księgowości) wpadnie w wirnik, wyciągając na zewnątrz maleńkie `True` (tak, parzysta), albo `False` (błąd wpłaty)!
• Stosujemy to do renderowania co drugiego wiersza tabeli w banku na szaro. Skrypt pyta o linijkę: "Jest parzysta? Zatem wypluj szarość!".

# Ustalanie zmiany nocnej w fabryce: Zmiany dzienne (1), noce (0 / parzyste)
zmiana_systemu = 12488

# Podział reszty do kwadratu - wymuszenie sprawdzenia z brakiem odpadu (0)
zmiana_nocna = (zmiana_systemu % 2 == 0)

print(f"Sygnalizatory powiadomione o wejściu w mrok: {zmiana_nocna}") # True
            

• Zbliżając się do końca, uderzamy w najcięższy kaliber ostrzegawczy na całym świecie w IT, psujący wyceny giełdowe i obroty księgowości.
• Zapytajmy środowisko matematyczne używając relacji: `czy_zbiezne = (0.1 + 0.2 == 0.3)`. Intuicja krzyczy, że to absolutne `True`.
• Okrutna prawda objawi się na konsoli krzycząc twarde, wielkie `False`! Wynik z tego równania po lewej to tak naprawdę w systemie binarnym: `0.30000000000000004`.
• Komputery są wybitnie głupie przy zamianie fizycznych ułamków dziesiętnych na obwody składowe prądu (Zero-Jedynkowe Bity). W obwodzie zostaje mikroskopijny ślad błędu. Sędzia pod postacią ułamek `==` jest bezwzględny: to ułamki różniące się o kwant miliardowej. Rzuci Odrzucenie.
• Dlatego inżynierowie gier w C++, Pythonie, Java - nigdy nie testują floata z floatem obwodem równości `==`. Używają w takich momentach bibliotek spłaszczających.

• Zbierzmy wszystko z ostatnich czterech dziesiątek slajdów w jedno ostateczne równanie decyzyjne - z użyciem bramek relacji i logiki.
• Zabezpieczanie gier zaczyna się od odczytania Inputu do Twardej Liczby (`int()`), następnie sprawdzenia czy ranga wejściowa pasuje do widełek relacji (`<= 5`).
• Dodajemy wbudowaną negację operatora członkostwa (`not in`), aby powstrzymać na stałe zbanowanych IP graczy od wbicia w serwery.
• Gdy cały ten galimatias przeleci przez matematyczny priorytet środowiska w nawiasach: otrzymujemy wyjście w postaci czystej Pigułki: Flagowej wartości `True`.
• Tak rodzą się silniki, które pod maską potrafią przetrawić setki gigabajtów tekstu i wysłać jeden prosty impuls decyzyjny otwierający bramy.

# Centralny system decyzyjny Wejścia Wymiarowego:
skan_zlych = "Wirus_X, RootKit, Exploit"

# Skan gracza (Wymagany minimalny level 5, uodpornienie na bana)
input_gracza = "8" # Przylatuje jako Falsy text z sieci!
nazwa_gracza = "RootKit" # Przemyca skrypt!

# Konwersja na liczby -> Młot Relacji (WiększyRówny) -> Logika (Koniunkcja AND na filtrze z listy IN)
bramka_akceptacji = (int(input_gracza) >= 5) and (nazwa_gracza not in skan_zlych)

# Operacja odrzuca wejście! Co prawda gracz miał twardy wyższy level, ale AND upadł na obecności w czarnej liście!
print(f"Status nadania wstępu: {bramka_akceptacji}") # False!
            

• Zanim porzucisz ten plik, spójrz na błąd, za który odpowiada co drugi crashe serwerów w firmach technologicznych, oparty na małym zmęczeniu palców dewelopera.
• Pisałeś przez dwie godziny wyliczenia algebry oparte na `=`, na przykład `saldo = 100`, `odsetki = 50`. Potem przenosisz się w strefę flag i piszesz: `czy_ubogi = saldo = 0`. Co zaszło w pamięci ram?
• Wywołałeś koszmar tak zwanego: "Przypisania łańcuchowego". Przypisałeś ZERO do zmiennej Saldo (Niszcząc majątek w banku!), po czym to niszczycielskie ZERO powędrowało do flaki "czy_ubogi", na zawsze psując obie strony systemu!
• NIGDY, pod żadnym pozorem nie wplataj samotnego znaku równości `=` w obręb obwodów zapytania czy warunków logicznych. Równanie do spłaszczania leży ODDZIELNIE u władcy równań na górze bloku, relacje kłębią się oddzielnie na dolnym trzonie z `==` i logiką.

# Ostrzeżenie wizualne:
# Źle:  zepsute = (pojazd = 0)  <-- Katastrofa, resetujesz prędkość pojazdu do zera przed weryfikacją!
# Źle:  wynik == 15             <-- Odrzucone przez interpreter. Równanie lewituje bez zapisu!

# Perfekcyjnie.
pojazd = 150                # 1. Zbudowanie bazy z cegieł i matematyki (pojedyncze =)
wyrok_sadu = (pojazd > 90)  # 2. Ewaluacja we wrażliwych strefach bramek (ostro > i relacje).

print(f"Mandat nadany: {wyrok_sadu}") # Uratowałeś posadę jako Architekt IT.
            

• Zbudowałeś właśnie fundament całej wiedzy komputerowej. Wiesz jak pędzić prąd w matematykę (arytmetyka), jak testować go z granicami (porównania) oraz jak łączyć setki testów w jedno światło (logika).
• Ale co jeśli kod relacyjny urósł tak bardzo, że nie potrafisz odczytać go własnymi oczami? Co jeśli rzeka `and`, `or` i nawiasów zablokowała Twój własny ekran rozciągając linijkę do 120 znaków?
• Standard branżowy PEP-8 rzuca linę ratunkową: Jeżeli test logiczny zaczyna wchodzić na drugą stronę pokoju, złam ten kod za pomocą symbolu rzeki `\ `(Backslash na końcu linii).
• Dzięki temu rozbijesz jedną bezwzględną linię decyzyjną na wielki, czytelny obelisk matematyczny, nie uszkadzając jego logiki przetwarzania przez program.

# Monstrum bez złamań (Morderca inżynierów)
# zgoda = (wiek >= 18) and (imie != "") and (not jest_botem) and (karta == True)

# Piękny monolit standardu PEP-8. Wszystkie testy czytają się niczym poezja w jednym obwodzie:
zgoda = (wiek >= 18) \
    and (imie != "") \
    and (not jest_botem) \
    and (karta) # Skasowaliśmy wbudowane == True, tak jak mówiliśmy!
            

• Ukończyłeś właśnie moduł 3! Nabyłeś moce potrzebne by wyrwać sztuczną inteligencję z ram bezmózgiego liczenia.
• Zaopatrzony w Operatory Arytmetyczne (`+ - * / // ** %`), stałeś się władcą zasobów i matematyki, odcinając od życia twarde, brudne liczby.
• Zaopatrzony w Operatory Relacyjne (`== != > < >= <=`), stałeś się władcą bram i testów. Nikt nie wejdzie do klubu i żaden pocisk nie ominie celu bez Twojego zapytania.
• Zaopatrzony w Operatory Logiczne (`and or not`), stałeś się dyrektorem, który z marnych pytań plecie wielki, bezpieczny wyrok dla całego serwera z użyciem magii nawiasów.
• To wszystko co tutaj napisałeś i wyliczyłeś... to tak zwane WYRAŻENIA (Expressions). Wyrażenia jednak same w sobie nic nie otwierają, potrafią tylko lśnić w pudełku wydrukowane na `True` albo `False`.
• W kolejnym, Czwartym Module podrzucimy te pudełeczka Prawdy pod bramki Warunków Konstrukcyjnych IF (Jeżeli). Zmusimy w ten sposób program by dosłownie, fizycznie pominął kilkaset linii nieczytanego kodu, udając, że maszyna podjęła samowolną decyzję z Twoich klocków obwodu!