Moduł wprowadza w świat programowania w języku Python – od podstawowych definicji i historii języka, przez instalację interpretera na trzech głównych systemach operacyjnych, aż po pierwsze uruchomienie kodu. Poznasz środowisko terminalowe, interaktywny tryb REPL oraz najważniejsze narzędzia programisty: edytory VS Code i IDLE. Nauczysz się korzystać z funkcji print() i jej parametrów (sep, end, znaki specjalne), a także pisać komentarze, unikać typowych błędów składniowych oraz stosować dobre praktyki formatowania kodu zgodne ze standardem PEP-8. Moduł kończy się praktycznymi ćwiczeniami utrwalającymi zdobytą wiedzę.

Kluczowe zagadnienia modułu:

• Instalacja i konfiguracja środowiska — Python 3, terminal, REPL i edytory VS Code/IDLE
• Funkcja print() i formatowanie wyjścia — parametry sep, end, znaki specjalne \n i \t, łączenie i powtarzanie tekstów
• Komentarze i błędy — komentarze jednoliniowe i wieloliniowe, SyntaxError, NameError, czytanie komunikatów błędów
• Dobre praktyki programistyczne — wcięcia, wielkość liter, konwencja snake_case, struktura programu, słowa kluczowe
• Ćwiczenia praktyczne — wizytówka, ASCII art, obliczenia i formatowanie konsoli

• Programowanie to w gruncie rzeczy wydawanie komputerowi precyzyjnych poleceń, krok po kroku.
• Możesz to porównać do tworzenia szczegółowego przepisu kulinarnego dla osoby, która nigdy wcześniej nie gotowała.
• Musisz przewidzieć każdą sytuację i podać dokładne instrukcje: 'Weź jajko', 'Rozbij jajko', 'Wrzuć na patelnię'.
• Komputer przypomina niezwykle posłusznego, ale całkowicie pozbawionego samodzielności kucharza.
• Kod źródłowy, który piszesz w edytorze, jest właśnie tym przepisem, tłumaczonym później na język zrozumiały dla maszyny.
• Dzięki temu możemy automatyzować rutynowe zadania, analizować ogromne ilości danych czy tworzyć skomplikowane gry i aplikacje.

• Podobnie jak my posługujemy się różnymi językami (polskim, angielskim, hiszpańskim), komputery mogą wykonywać instrukcje napisane w wielu różnych językach programowania.
• Każdy z tych języków ma swoje specyficzne zastosowanie i został stworzony z myślą o rozwiązywaniu konkretnych problemów.
• Na przykład JavaScript to król przeglądarek internetowych, Java dominuje w ogromnych systemach korporacyjnych i bankowych, a C++ jest niezastąpiony przy tworzeniu wydajnych gier trójwymiarowych.
• Python wyróżnia się na tym tle niezwykłą wszechstronnością – można w nim zrobić niemal wszystko.
• Dodatkowo, jego składnia jest bardzo zbliżona do naturalnego języka angielskiego, co czyni go wyjątkowo czytelnym.
• Dzięki temu programiści mogą skupić się na rozwiązywaniu problemu, a nie na walce ze skomplikowaną gramatyką języka programowania.

• Python od samego początku projektowany był z myślą o maksymalnej prostocie i elegancji.
• Jego składnia została tak przemyślana, aby kod wyglądał niemal jak zwykłe zdania w języku angielskim.
• Brak nadmiaru nawiasów i skomplikowanych symboli sprawia, że nauka podstaw przebiega niezwykle szybko.
• Z tego powodu uniwersytety i szkoły na całym świecie uznają Pythona za najlepszy język pierwszego wyboru do nauki programowania.
• Niech jednak nie zmyli Cię jego prostota – to niezwykle potężne i wydajne narzędzie.
• Jego możliwości doceniają najwięksi giganci technologiczni: Google wykorzystuje go w swoich algorytmach, NASA w analizie danych kosmicznych, a Netflix do zarządzania potężną infrastrukturą.

• Początki Pythona sięgają przełomu lat 80. i 90., kiedy to holenderski programista Guido van Rossum rozpoczął nad nim pracę podczas przerw świątecznych.
• Pierwsza oficjalna wersja ujrzała światło dzienne w lutym 1991 roku i od razu wzbudziła spore zainteresowanie.
• Wielu ludzi mylnie zakłada, że nazwa języka nawiązuje do gatunku groźnego węża – pytona.
• W rzeczywistości Guido van Rossum był wówczas wielkim fanem brytyjskiej grupy komediowej i ich kultowego programu 'Latający Cyrk Monty Pythona'.
• Chcąc nadać swojemu nowemu dziełu nazwę krótką, unikalną i nieco tajemniczą, zdecydował się właśnie na słowo 'Python'.
• Twórca przez wiele lat pełnił zaszczytną (i żartobliwą) funkcję BDFL, czyli 'Dobrotliwego Dyktatora na Całe Życie', kierując rozwojem języka aż do 2018 roku.

• Podczas nauki oraz przeglądania starszych poradników w Internecie często natkniesz się na wzmianki o dwóch wersjach: Python 2 i Python 3.
• Python 2 był niezwykle popularny przez kilkanaście lat, jednak zawierał pewne fundamentalne ograniczenia architektoniczne, których nie dało się naprawić bez zepsucia zgodności.
• Z tego powodu podjęto odważną decyzję o stworzeniu Pythona 3 – nowszej, lepszej wersji, która jednak nie była w pełni zgodna ze swoim poprzednikiem.
• Proces migracji całego świata IT z 'dwójki' na 'trójkę' był długi i momentami bolesny, ale ostatecznie zakończył się sukcesem.
• Od 1 stycznia 2020 roku Python 2 został oficjalnie uznany za przestarzały i nie otrzymuje już nawet aktualizacji bezpieczeństwa.
• Obecnie w nowo powstających projektach komercyjnych oraz w tym kursie korzystamy wyłącznie z nowoczesnego Pythona 3.

• Python jest często określany jako tak zwany 'szwajcarski scyzoryk' w świecie języków programowania.
• Jego główną domeną, w której obecnie nie ma sobie równych, jest sztuczna inteligencja (AI) oraz uczenie maszynowe (Machine Learning).
• Święci również triumfy w dziedzinie Data Science, gdzie analitycy wykorzystują go do przetwarzania i wizualizacji gigantycznych zbiorów danych.
• Dzięki bogatemu ekosystemowi bibliotek, za jego pomocą niezwykle łatwo jest napisać proste skrypty automatyzujące nudne, codzienne zadania biurowe.
• Python doskonale sprawdza się również w budowie nowoczesnych i potężnych aplikacji internetowych (backendu).
• Na przykład cała logika początkowej wersji Instagrama czy backend serwisu Spotify zostały zbudowane właśnie w oparciu o frameworki pythonowe.

• Aby zacząć przygodę z Pythonem na systemie Windows, musisz najpierw pobrać i zainstalować jego oficjalny interpreter.
• Interpreter to specjalny program, który czyta napisany przez Ciebie kod i na bieżąco tłumaczy go na niezrozumiały dla człowieka język maszynowy.
• Instalator znajdziesz zawsze w sekcji 'Downloads' na oficjalnej stronie domowej projektu: python.org.
• Podczas uruchamiania kreatora instalacji, na samym pierwszym ekranie na dole znajduje się niepozorne, ale niezwykle ważne pole wyboru: 'Add python.exe to PATH'.
• Zaznaczenie tej opcji jest absolutnie krytyczne, gdyż informuje ono system Windows, gdzie ma szukać języka Python przy używaniu konsoli.
• Pominięcie tego kroku skutkuje bardzo popularnym błędem o 'nierozpoznanym poleceniu' podczas prób uruchamiania własnych programów z terminala.

# Instalacja Pythona to proces typu 'Next -> Next -> Finish'.
# Pamiętaj o zaznaczeniu opcji 'Add python.exe to PATH'!

# Po pomyślnej instalacji otwórz terminal (np. cmd.exe) i wpisz:
python --version

# Jeśli instalacja powiodła się, a PATH został dodany,
# terminal odpowie np. Python 3.12.0
            

• W przeciwieństwie do Windowsa, systemy uniksowe (takie jak macOS i różnego rodzaju dystrybucje Linuxa) zazwyczaj posiadają Pythona zainstalowanego fabrycznie.
• Dzieje się tak, ponieważ wiele wbudowanych narzędzi systemowych opiera swoje działanie właśnie na skryptach napisanych w tym języku.
• Problem polega jednak na tym, że domyślnie instalowana jest często przestarzała wersja (czasami nawet porzucony już Python 2).
• Dlatego zawsze dobrą praktyką jest ręczne doinstalowanie najnowszej, w pełni wspieranej wersji stabilnej 3.x.
• Na systemie macOS najwygodniej jest to zrobić za pomocą niezwykle popularnego menedżera pakietów o nazwie Homebrew.
• Z kolei na dystrybucjach Linuxa bazujących na Debianie (np. Ubuntu, Mint) używamy do tego wbudowanego polecenia `apt-get` lub `apt`.

# ==============================
# Instalacja na systemie macOS
# ==============================
# Pobranie najnowszego Pythona przez menedżer Homebrew:
brew install python

# ==============================
# Instalacja na systemie Linux (Debian/Ubuntu)
# ==============================
# Aktualizacja listy pakietów:
sudo apt update
# Instalacja właściwego interpretera:
sudo apt install python3 python3-pip
            

• Gdy kreator instalacji zakończy pracę, pierwszym krokiem programisty powinno być upewnienie się, że oprogramowanie działa prawidłowo.
• W tym celu musimy otworzyć konsolę systemową (Wiersz Poleceń/PowerShell w Windows lub aplikację Terminal na Macu/Linuxie).
• W okienku konsoli wpisujemy krótkie polecenie diagnostyczne sprawdzające wersję interpretera i wciskamy klawisz Enter.
• Na systemach Windows komenda ta zazwyczaj wygląda tak: `python --version`.
• Na systemach Mac oraz Linux, ze względu na obecność starego Pythona 2, często trzeba wpisać `python3 --version`.
• Wyświetlenie w odpowiedzi numeru wersji (np. Python 3.12.0) jest dowodem na to, że system 'widzi' nasz interpreter i jesteśmy gotowi do pracy.

# Uruchamiamy Wiersz Polecenia (CMD) lub Terminal i wpisujemy:
python --version

# Przykładowa prawidłowa odpowiedź systemu:
Python 3.12.0

# UWAGA: Jeśli zobaczysz komunikat błędu typu:
# "'python' is not recognized as an internal or external command"
# oznacza to, że przy instalacji na Windows zapomniano zaznaczyć "Add to PATH".
            

• Zanim napiszesz swoją pierwszą linijkę kodu, musisz zaprzyjaźnić się z terminalem (zwanym też wierszem poleceń).
• Jest to specjalne, zazwyczaj czarne okienko, w którym komunikujemy się z komputerem wyłącznie za pomocą tekstu, całkowicie rezygnując z myszki.
• Na systemach Windows nazywa się to Wiersz Polecenia (cmd) lub PowerShell, na Mac/Linux po prostu Terminal.
• Dla profesjonalnego programisty terminal jest naturalnym środowiskiem pracy, o wiele szybszym i potężniejszym niż klikanie po interfejsie graficznym.
• W terminalu możemy m.in. przeglądać foldery, tworzyć nowe pliki, a przede wszystkim – uruchamiać napisane przez nas programy.
• Z początku czarny ekran może wydawać się przerażający, ale znajomość zaledwie kilku podstawowych komend wystarczy do swobodnej pracy.

# ==============================
# Kilka przydatnych komend na start (Windows):
# ==============================

# Wyświetla pliki i foldery w bieżącym folderze:
dir

# Przejście do konkretnego folderu (np. na Pulpit):
cd Pulpit

# Cofnięcie się o jeden folder "wyżej":
cd ..

# Wyczyszczenie ekranu z poprzednich wyników:
cls
            

• REPL to jedno z najpotężniejszych narzędzi do nauki języka Python. Skrót pochodzi od Read-Eval-Print Loop (Czytaj, Oblicz, Wypisz, Powtórz).
• Działa to jak interaktywna piaskownica – wpisujesz jedną komendę, naciskasz Enter i natychmiast widzisz rezultat.
• Nie musisz tworzyć żadnych plików, konfigurować środowisk ani kompilować całego programu – to czysta natychmiastowa interakcja.
• REPL jest niezwykle przydatny, gdy chcesz szybko przetestować, jak działa jakaś konkretna funkcja w Pythonie, albo gdy zapomniałeś szczegółów składni.
• Aby go włączyć, wystarczy otworzyć terminal i wpisać polecenie `python` (lub `python3`).
• Gdy znudzi Ci się testowanie, z REPL można wyjść z powrotem do normalnego terminala.

# Uruchomienie trybu interaktywnego z poziomu terminala:
python

# Zobaczysz tekst informacyjny i znak zachęty >>>
# Aby wyjść i wrócić do zwykłego wiersza poleceń wpisz:
exit()
# Pamiętaj o nawiasach () ! Na Mac/Linux działa też skrót Ctrl+D.
            

• Znak zachęty w REPL to kultowe trzy strzałki: `>>>`. Ich obecność na ekranie komunikuje jedną, bardzo ważną rzecz.
• Oznaczają one, że znajdujesz się w trybie wirtualnej rozmowy z samym jądrem języka Python.
• W tym miejscu terminal przestał reagować na komendy systemowe (jak `cd` czy `dir`) i słucha wyłącznie poleceń w języku Python.
• Cokolwiek tu wpiszesz, Python spróbuje to niezwłocznie wykonać i jeśli tylko to możliwe, zwróci wyliczoną wartość.
• Jeśli wpiszesz coś bezsensownego, Python wyrzuci tzw. błąd, ale nie uszkodzi to Twojego komputera.
• Jest to bezpieczne środowisko treningowe do popełniania błędów i weryfikacji pomysłów.

# Przykładowa sesja w REPL. 
# Trzy strzałki pokazują linijki, w których wprowadzamy kod.
>>> "Witaj, to mój pierwszy kod w REPL!"
'Witaj, to mój pierwszy kod w REPL!'

# Python posłusznie zwrócił to, co do niego wpisaliśmy.
            

• Aby oswoić się ze składnią i REPL, warto zacząć od wykorzystania Pythona jako bardzo drogiego i potężnego kalkulatora.
• Język ten z miejsca obsługuje wszystkie podstawowe operacje matematyczne bez wpisywania jakiegokolwiek skomplikowanego kodu.
• Możesz używać znaków `+` do dodawania, `-` do odejmowania, `*` (gwiazdka) do mnożenia oraz `/` (ukośnik) do dzielenia.
• Co niezwykle istotne, Python doskonale zna i respektuje szkolne reguły kolejności wykonywania działań (mnożenie przed dodawaniem).
• Jeśli chcesz wymusić na nim inną kolejność, możesz do woli wykorzystywać standardowe okrągłe nawiasy `()`.
• Dzięki REPL oszczędzasz czas – nie musisz szukać aplikacji Kalkulator w systemie.

# Mnożenie ma pierwszeństwo nad dodawaniem:
>>> 2 + 2 * 2
6

# Wykorzystujemy nawiasy do zmiany pierwszeństwa:
>>> (10 - 3) * 5
35

# Dzielenie zawsze zwraca liczbę zmiennoprzecinkową (z kropką):
>>> 10 / 2
5.0
            

• Mimo całej potęgi REPL, nikt nie pisze w nim pełnoprawnych i dużych programów komputerowych.
• Gdy tylko zamkniesz terminal, cała sesja w REPL bezpowrotnie ginie. Skomplikowane aplikacje muszą być zapisane na stałe w plikach.
• Zwykły Notatnik z Windowsa pozwala na napisanie kodu, jednak praca w nim to prawdziwa udręka programisty.
• Dlatego powstały IDE, czyli Zintegrowane Środowiska Programistyczne – specjalistyczne edytory tekstu stworzone specjalnie do pisania kodu.
• Działają one jak rozbudowany 'Microsoft Word', lecz zamiast podkreślać błędy ortograficzne, analizują na bieżąco Twoje funkcje i nawiasy.
• Automatycznie formatują tekst, kolorują składnię i umożliwiają łatwe zarządzanie całymi projektami.

• Zdecydowanym liderem na rynku, używanym przez ogromną większość programistów na świecie, jest obecnie edytor Visual Studio Code (często nazywany skrótem VS Code).
• Został on stworzony przez firmę Microsoft, jest całkowicie darmowy, bardzo lekki w działaniu i zjawiskowo wręcz łatwy w rozbudowie.
• Zaraz po pobraniu, VS Code to bardzo sprytny, lecz 'goły' notatnik. Jego prawdziwą moc odkrywamy instalując do niego wtyczki (Extensions).
• Aby w pełni wygodnie pisać w Pythonie, wystarczy w menu rozszerzeń w VS Code wyszukać oficjalną wtyczkę o nazwie 'Python'.
• Wtyczka ta wyposaży edytor w wiedzę o składni Pythona, co zaowocuje inteligentnymi podpowiedziami oraz możliwością uruchamiania kodu jednym przyciskiem.
• Inne bardzo popularne (lecz nieco cięższe) edytory to np. PyCharm od firmy JetBrains. My skupimy się na VS Code.

# Krok po kroku:
# 1. Pobierz plik instalacyjny ze strony: code.visualstudio.com
# 2. Po uruchomieniu aplikacji przejdź do zakładki "Extensions" (Ctrl+Shift+X)
# 3. W polu wyszukiwania wpisz "Python"
# 4. Zainstaluj wtyczkę autorstwa "Microsoft" i zrestartuj edytor.
            

• Instalator Pythona dla Windowsa nie dostarcza tylko samego jądra wykonawczego (interpretera).
• Wraz z nim otrzymujemy, wbudowany od razu w paczkę instalacyjną, mały edytor środowiskowy o nazwie IDLE.
• Został on zaprojektowany jako minimalistyczne IDE i posiada na pokładzie wbudowany REPL i skromny edytor tekstu w osobnych okienkach.
• Choć graficznie przypomina aplikacje sprzed dwudziestu lat i nie nadaje się do komercyjnych zastosowań, na absolutny start nauki wielu preferuje właśnie IDLE.
• Jeśli w Twojej szkole czy na uczelni nie ma zainstalowanego VS Code, najprawdopodobniej będziesz pracował właśnie na IDLE.
• Zresztą sama nazwa IDLE to ukłon w stronę członka grupy Monty Pythona – Erica Idle.

# Program IDLE możesz wyszukać normalnie w menu Start systemu Windows,
# albo błyskawicznie wywołać bezpośrednio w terminalu (o ile masz dodany PATH):
idle

# Uruchomi się osobne, jasne okienko graficzne edytora.
            

• Aby nasza praca nie uciekła w zapomnienie po zamknięciu komputera, polecenia musimy zapisać na dysku w zwykłym pliku tekstowym.
• Jedyną ważną różnicą jest zmiana końcówki pliku: rezygnujemy z typowego `.txt` na rzecz dedykowanego rozszerzenia `.py`.
• Utworzenie pliku np. `moj_program.py` jednoznacznie informuje system operacyjny, że zawiera on tzw. kod źródłowy skryptu Pythonowego.
• Z kolei edytor VS Code po odczytaniu tego rozszerzenia automatycznie załaduje wcześniej zainstalowaną wtyczkę i poprawne kolorowanie składni.
• Unikaj dodawania spacji oraz polskich znaków (ś, ć) w nazwach plików – system operacyjny nie zawsze to dobrze znosi.
• Plik `.py` jest absolutnie fundamentalną, najmniejszą jednostką składową każdego tworzonego oprogramowania.

# 1. W edytorze VS Code utwórz nowy plik (File -> New File)
# 2. Zapisz go od razu jako: powitanie.py na swoim Pulpicie
# 3. Wpisz w nim jedną, prostą linijkę kodu:
print("Witaj, świecie! Jestem zapisany w pliku.")
            

• Napisanie kodu w edytorze nie wystarczy, trzeba mu jeszcze pozwolić wejść w życie.
• Proces uruchamiania sprowadza się do odczytania zapisanego przez Ciebie pliku przez program zwany interpreterem (zainstalowany wcześniej Python).
• Jeśli pracujesz w VS Code, możesz to zrobić niezwykle wygodnie naciskając mały przycisk z ikoną "Play" znajdujący się w prawym górnym rogu okna.
• Jeśli wolisz polegać na tradycyjnym terminalu, przejdź po prostu do folderu z plikiem (np. używając komendy `cd`).
• Następnie wywołaj środowisko i wskaż precyzyjną nazwę swojego zapisanego pliku.
• Interpreter cierpliwie przeczyta plik linijka po linijce, a jeśli nie napotka katastrofalnych błędów, wykona zawarte w nim komendy.

# Upewniamy się w terminalu, że znajdujemy się obok pliku powitanie.py
# Następnie wpisujemy i zatwierdzamy Enterem:
python powitanie.py

# Na ekranie pojawi się wyłącznie wygenerowany przez nas tekst:
Witaj, świecie! Jestem zapisany w pliku.
            

• Poznałeś już, jak utworzyć plik i jak kazać go uruchomić. Pora nauczyć się w nim pisać.
• Najbardziej absolutnie podstawową funkcją w Pythonie, bez której ciężko wyobrazić sobie nawet najprostszy kod, jest `print()`.
• Nazwa wywodzi się z czasów, gdy komputery nie miały ekranów i wyniki wyliczeń były fizycznie "drukowane" na papierze – stąd 'print'.
• Dziś słowo to oznacza po prostu wyświetlenie, pokazanie danej informacji użytkownikowi w konsoli czy terminalu.
• Budowa tej funkcji jest trywialna: wpisujemy słowo `print`, a następnie, zaraz obok, w okrągłych nawiasach podajemy, co chcemy pokazać światu.
• To podstawowy kanał informacyjny. Program, w którym zaszłyby miliardy skomplikowanych obliczeń, bez użycia na koniec `print()` nie dałby w ogóle znaku życia na ekranie.

# Prawidłowa składnia wywołująca wypisanie w konsoli:
print("Rozpoczęcie misji. Pasy zapięte.")

# Można wywoływać print() raz za razem:
print("Odliczanie...")
print("Start!")
            

• Oprócz wykonywania poleceń, Python musi umieć odróżniać, które słowa są komendami do wykonania, a które są po prostu surowym tekstem dla użytkownika.
• Taki zbiór liter, słów czy całych zdań nazywamy w programowaniu "łańcuchem znaków" (z ang. string).
• Aby przekazać Pythonowi, że dany wyraz to tylko tekst i nie ma z nim nic robić, oprócz zapamiętania go, musimy użyć odpowiedniego opakowania.
• Tym opakowaniem są znaki cudzysłowu `"` lub pojedyncze apostrofy `'`, którymi otaczamy tekst z obu stron.
• Dla Pythona nie ma znaczenia, którego z tych dwóch symboli użyjesz – ważne jest to, aby zacząć i skończyć tekst tym samym znakiem.
• Jeśli zapomnisz o "zamknięciu" cudzysłowu, kod nie zostanie wykonany, a terminal zwróci popularny błąd "SyntaxError".

# Zarówno pojedynczy cudzysłów (apostrof), jak i podwójny zadziałają identycznie:
print("To jest zwykły tekst otoczony cudzysłowem podwójnym.")
print('A to tekst otoczony apostrofami.')

# Przydaje się to, gdy chcemy użyć apostrofu wewnątrz samego tekstu:
print("It's a beautiful day!") # Apostrof ' w środku nie psuje tekstu
            

• Funkcja `print()` jest niezwykle wszechstronna – potrafi wypisywać na ekranie nie tylko litery, ale również surowe liczby i wyniki działań.
• Najważniejszą rzeczą, o której musisz pamiętać, to to, że surowych liczb matematycznych NIGDY nie otaczamy cudzysłowami.
• Jeśli wpiszesz do środka działanie arytmetyczne (np. `2 + 2`), Python najpierw zachowa się jak kalkulator, a dopiero potem wypisze wynik (czyli `4`).
• Jednakże, jeśli popełnisz błąd i zrobisz z równania matematycznego string (tekst) otaczając go cudzysłowami, kalkulator się nie włączy.
• Python grzecznie wypisze dokładnie to, o co prosiłeś jako tekst: na ekranie zobaczysz znaki `2 + 2`.
• Dlatego zawsze zwracaj uwagę, czy na pewno podajesz liczbę, a nie wyraz wyglądający jak liczba.

# Drukujemy liczbę 100 jako wartość matematyczną:
print(100)          # Wynik w terminalu: 100

# Zlecenie Pythonowi wyliczenia matematycznego:
print(2 + 2 * 10)   # Wynik w terminalu: 22

# A tutaj zablokowaliśmy obliczenia używając cudzysłowu (to teraz zwykły tekst):
print("2 + 2 * 10") # Wynik w terminalu: 2 + 2 * 10
            

• Zazwyczaj potrzebujemy wyświetlić w jednej linii kilka różnych rzeczy – np. tekst informacyjny połączony z wyliczoną liczbą.
• Nie musimy do tego pisać wielokrotnie osobnych wywołań funkcji `print()`.
• Ta przydatna komenda potrafi przyjąć dowolną, niemal nieograniczoną ilość elementów, czyli tzw. argumentów.
• Jedynym wymogiem jest oddzielenie każdego z przekazywanych elementów zwykłym przecinkiem.
• Gdy Python wyświetli te wielorakie argumenty na ekranie, bardzo grzecznie doklei między każdym z nich jedną spację.
• Dzięki tej prostej sztuczce łączone zdania od razu stają się czytelne i unikamy sklejonego zbitka wyrazów.

# Oddzielamy tekst, liczbę matematyczną i kolejny tekst przecinkiem:
print("Mam już", 25, "lat, ale wciąż gram w gry.")
# Wynik w terminalu: Mam już 25 lat, ale wciąż gram w gry.

# Programiści często mieszają też różne typy danych w ten sposób:
print("Wynik skomplikowanego równania to:", 100 / 4)
# Wynik w terminalu: Wynik skomplikowanego równania to: 25.0
            

• W poprzednim kroku dowiedziałeś się, że przecinek automatycznie dodaje pustą spację podczas wypisywania na ekranie.
• Choć najczęściej jest to wysoce pożądane, czasem chcemy złączyć wyrazy za pomocą innego znaku (np. myślnika lub spójnika).
• Służy do tego wbudowany w `print()` parametr opcjonalny o nazwie `sep` (skrót od angielskiego 'separator').
• Podając na samym końcu nawiasu zapis `sep="coś"`, podmieniasz domyślną spację na podany przez Ciebie znak czy tekst.
• Możesz podać myślnik, długi napis " ORAZ ", a nawet całkowitą pustkę `""` – co spowoduje twarde sklejenie argumentów bez żadnej przerwy.
• Zwróć uwagę, że parametr separatora w ogóle nie pokaże się na ekranie na samym końcu – jest on wstawiany *tylko pomiędzy* wymienione obiekty.

# Zmieniamy domyślną spację na myślnik:
print("jablko", "banan", "kiwi", sep="-")
# Wynik: jablko-banan-kiwi

# Użycie pustego tekstu (żadnej spacji) skutecznie skleja argumenty:
print("M", "A", "C", "I", "E", "K", sep="")
# Wynik: MACIEK
            

• Zauważyłeś na pewno, że każde kolejne napisanie komendy `print()` powoduje, że wyraz ląduje linijkę niżej w terminalu.
• To drugie domyślne, z góry zaprogramowane zachowanie – `print()` zawsze naciska niewidzialny 'Enter' na sam koniec swojej pracy.
• Tę niewidoczną nową linię także można łatwo nadpisać za pomocą kolejnego parametru, noszącego jasną nazwę `end` (koniec).
• Zastępując domyślnego 'Entera' np. spacją (`end=" "`), sprawisz, że kolejny `print()` w kodzie zacznie pisać wciąż w tej samej linijce!
• Jest to bardzo przydatne, np. w systemach pobierających paski postępu – napis "10%" drukuje się bez enterów, dzięki czemu aplikacja nie zasypuje konsoli nowymi liniami.
• Parametr ten, podobnie jak `sep`, należy zawsze dopisywać na samym końcu, po podaniu wszystkich rzeczy do drukowania.

# Zastępujemy Enter trzema kropkami i spacją:
print("Trwa ładowanie", end="... ")

# Poniższy print zostanie "doklejony" w starej linii!
print("Gotowe! System uruchomiony.")

# Wygląd całego rezultatu w terminalu:
# Trwa ładowanie... Gotowe! System uruchomiony.
            

• Podczas tworzenia długich tekstów w cudzysłowach, często chcemy sztucznie przenieść część zdania do nowej linii.
• Jeśli w połowie cudzysłowu naciśniesz klawisz Enter na klawiaturze, edytor zepsuje kod, nie rozumiejąc o co chodzi i wyrzuci SyntaxError.
• Dlatego w programowaniu wdrożono ideę 'znaków specjalnych', powoływanych do życia potężnym ukośnikiem wstecznym, czyli tzw. Backslashem `\`.
• Połączenie ukośnika wstecznego i litery 'n' (`\n` – od 'new line') wewnątrz tekstu podziała na konsolę jak fizyczne naciśnięcie entera!
• Analogicznie, zapisanie `\t` nie wypisze litery 't', lecz wstawi obszerne, eleganckie wcięcie, czyli popularną Tabulację.
• Dzięki temu możesz tworzyć zgrabnie ułożone menu czy cenniki używając tylko jednej funkcji `print()`.

# Użycie \n (Enter) do oddzielenia linii:
print("Pierwsza Linia\nDruga Linia z nowej kartki")
# Wynik: 
# Pierwsza Linia
# Druga Linia z nowej kartki

# Użycie \t (Tabulacja) dla estetycznych odstępów:
print("Imię\tNazwisko\tWiek")
print("Jan\tKowalski\t35")
            

• Znak `\n` sprawdza się doskonale przy krótkich wiadomościach, lecz potrafi strasznie zabałaganić długi tekst składający się z wielu zdań.
• Wyobraź sobie, że piszesz do kogoś w terminalu wirtualny list lub rozbudowaną instrukcję obsługi – wszechobecne ukośniki doprowadziłyby do zawrotów głowy.
• Python udostępnia doskonałą alternatywę w postaci bloku ograniczonego POTRÓJNYM znakiem cudzysłowu `"""` na początku i końcu.
• Pomiędzy takimi barierami znika zakaz naciskania fizycznego Entera w edytorze kodu.
• Każde przejście do nowej linii czy każda twarda spacja zostanie natychmiast zapamiętana przez wbudowanego w Pythona menedżera tekstu.
• Program wydrukuje taki tekst idealnie w ten sam format, w jaki ułożyłeś go ręcznie na ekranie – to potężne ułatwienie dla twórców menu z opcjami.

# Zwróć uwagę na otwarcia i zamknięcia bloków: """
print("""=============
MENU GŁÓWNE
=============

1. Rozpocznij nową grę
2. Załaduj stan zapisu
3. Opcje
4. Wyjście do pulpitu""")

# Kod zadziała wyśmienicie bez ani jednego znaczka \n !
            

• Wiemy już, jak matematycznie dodać dwie liczby znakiem plus, tak by `2 + 2` dało `4`.
• Jednak w Pythonie znak plus `+` ma podwójne życie! Jeśli użyjesz go między dwoma tekstami (stringami), zadziała w zupełnie inny sposób.
• Spowoduje on twarde zlejenie dwóch tekstów w jeden nierozerwalny fragment. W słowniku informatycznym nazywamy to trudnym słowem 'konkatenacja'.
• W przeciwieństwie do drukowania elementów po przecinku, nie wstawia z automatu żadnej ukrytej spacji!
• Jeśli chcesz uniknąć sklejonego potworka wyrazowego, musisz o spacji pamiętać samodzielnie, umieszczając ją np. wewnątrz cudzysłowu na końcu pierwszego słowa.
• Konkatenacja to fundament tworzenia spersonalizowanych komunikatów aplikacji opartych na interakcji użytkownika.

# Doklejamy brutalnie jeden tekst do drugiego - bez przerw:
print("Spider" + "man")
# Wynik: Spiderman

# Doklejamy, ale dbamy o rzucenie spacji w jednym z kawałków:
print("Pani" + " Ewo") # Oraz alternatywa: "Pani " + "Ewo"
# Wynik: Pani Ewo

# Można w ten sposób połączyć całe góry tekstów!
print("Panie" + " i " + "Panowie" + " - witamy!")
            

• Skoro w Pythonie teksty można dodawać, logicznym krokiem naprzód wydaje się sprawdzenie operacji matematycznego mnożenia, prawda?
• Użycie matematycznej gwiazdki `*` na ciągu znaków (string) nie uszkodzi komputera, tylko wykona bardzo fajną sztuczkę.
• Przemnożenie tekstu przez całkowitą liczbę (np. 5) wygeneruje tekst kilkukrotnie w powtarzalny i błyskawiczny sposób.
• Język ten wypluje dosłownie powielone wyrazy bezpośrednio, bez jakichkolwiek uciążliwych spacji sklejając je twardo w jedno ciało.
• Metoda ta bywa niezwykle często używana przez weteranów do graficznego oddzielania w terminalu różnych fragmentów, np. linii na 50 znaków.
• Dzięki temu zyskujemy potężne oszczędności pamięci i czasu w niepotrzebnym uderzaniu w klawisze.

# Trzykrotne zaśmianie - Python robi za Ciebie powielenie:
print("Ha" * 3)
# Wynik: HaHaHa

# Błyskawiczne i eleganckie oddzielenie fragmentów kreską:
print("=" * 40)
# Wynik: ========================================
            

• Pisanie kodu bywa rzeczą niezwykle skomplikowaną. By samemu pamiętać co i po co zostało zrobione, zostawiamy w nim 'żółte karteczki'.
• Te wirtualne karteczki to tzw. komentarze – przypisy zostawione ściśle dla innych ludzi do przeczytania.
• W Pythonie, aby utworzyć komentarz, wystarczy przed tekstem napisać symbol ostrej kratki – `#` (ang. hash).
• Gdy interpreter natknie się w trakcie 'czytania' kodu na znak hasztagu, udaje, że nagle ogłuchł i ignoruje wszystko do końca obecnej linii.
• Komentarze chronią ludzki pot przed zapomnieniem i ułatwiają wprowadzanie nowicjuszy do skomplikowanych projektów informatycznych.
• Jedna stara, złota maksyma brzmi: Kod mówi Ci *jak* to zostało wyliczone. Komentarz powinien mówić Ci *dlaczego* w ogóle to zrobiliśmy.

# Ten tekst jest absolutnie niewidzialny dla silnika Pythona.

print("Skrypt działa!") # Komentarze można pisać od połowy linii!

# Złota reguła dobrego programisty: nie pisz komentarzy, jeśli coś jest oczywiste.
# (np. ZŁY KOMENTARZ: "teraz używam print by napisać coś w konsoli")
            

• Znak ostrej kratki `#` pozwala skomentować tylko i wyłącznie pojedynczą linijkę tekstu.
• Gdy naciśniesz Enter, w nowej linii interpreter ponownie zacznie nasłuchiwać i wymagać pełnoprawnego, działającego kodu.
• Wielu programistów chcąc ukryć przed komputerem ogromny blok tekstowy po prostu wstawia uparcie znaczek `#` przed każdą nową linią.
• Z pomocą przychodzi jednak znany nam już wieloliniowy napis otoczony barierami z potrójnego cudzysłowu `"""`.
• Zasada działania opiera się na sztuczce: jeśli wygenerujesz bardzo długi string tekstowy w kodzie, ale nie obejmiesz go poleceniem `print()`, co się stanie?
• Python grzecznie, zgodnie z poleceniem przeczyta dany tekst i połamie w nim wiersze... po czym natychmiast wrzuci do kosza (zapomni) bez wpływu na program, czyniąc z niego ogromny komentarz!

# Tradycyjny i najczęstszy sposób komentowania w kilku liniach:
# Wymaga wstawiania hasztagu przed każdym nowym zdaniem.
# Jest to męczące, ale w pełni zgodne ze sztuką.

"""
Natomiast tutaj wykorzystaliśmy trik z potrójnym cudzysłowem!
Ponieważ nie ma tu polecenia wydruku (print), ten tekst nigdy 
nie ujrzy światła dziennego. Zostanie przeczytany i zignorowany.
Dzięki temu funkcjonuje de facto jako komentarz wieloliniowy.
"""
            

• Ucząc się na prostych przykładach nie dostrzega się ogromnej siły płynącej z mądrego opisywania kodu komentarzami.
• Zrozum jednak perspektywę pracownika wielkiej firmy tworzącej program oparty na stu tysiącach skomplikowanych linijek tekstu.
• Komentarz jest wtedy na wagę złota, stanowi swego rodzaju mapę po umyśle programisty, który stworzył dany moduł np. rok wcześniej.
• Istnieje tu jednak bardzo ciemna strona mocy: nadmierne, potężne komentowanie każdej jednej głupiej rzeczy prowadzi do nieczytelności.
• Należy bezwzględnie unikać powtarzania tego, co widać gołym okiem. Komentarz `# drukuje wynik` nad linijką `print(wynik)` to błąd w sztuce nazywany 'spamowaniem kodu'.
• Dobry kod powinien w dużej mierze czytać się sam, jak książka. Komentarz powinien wyjaśniać zawiłości i nieoczekiwane zmiany w logice biznesowej.

• Prędzej czy później – a najpewniej w przeciągu pierwszej godziny nauki – terminal eksploduje dużą ilością czerwonego, brzydkiego tekstu.
• Taki widok to powiadomienie o błędzie. Oznacza on absolutne zatrzymanie działania oprogramowania.
• Jednym z najbardziej fundamentalnych potknięć jest słynny `SyntaxError`, czyli w tłumaczeniu na polski: Błąd Składniowy.
• Pojawia się on zawsze, gdy napiszesz coś niezgodnego z twardym słownikiem języka (tzw. byki ortograficzne).
• Do typowych winowajców należą: niedomknięte cudzysłowy (np. `print("Aha)`), zgubione nawiasy czy pozostawienie całkowicie losowych literek w kodzie.
• Python przed wykonaniem kodu po cichu skanuje cały plik – jeśli znajdzie błąd składni, zablokuje program zanim ten chociażby spróbuje wystartować.

# Częsty błąd początkujących: zapomniano zamknąć twardy cudzysłów:
print("Brak zamknięcia

# Python zaprotestuje komunikatem z serii: 
# SyntaxError: unterminated string literal

# Oznacza to "Błąd składni: niezakończony literowo łańcuch znaków".
            

• Tuż obok błędów językowych często ujrzysz na swojej drodze potknięcie z rodziny `NameError` (Błąd Nazwy).
• Błąd ten pojawia się w momencie, gdy z punktu widzenia gramatyki Twoje kropki i przecinki są idealne, ale używasz słów nieistniejących w słowniku Pythona.
• Pomyśl o nim jak o wypowiedzeniu do psa komendy "Aport!", podczas gdy ten nauczony jest reagować tylko na "Przynieś!". Pies zgłupieje.
• Dość typową pomyłką jest zrobienie drobnej literówki w kluczowych funkcjach, np. napisanie `prnit()` zamiast `print()`.
• Interpreter Pythona zacznie desperacko przeszukiwać swoje czeluści w poszukiwaniu komendy "prnit", po czym kapitulując wyświetli `NameError`.
• Na całe szczęście, nowoczesny Python jest na tyle inteligentny, że przy niewielkich literówkach w funkcji `print` sam zasugeruje, gdzie się pomyliłeś!

# Klasyczna pomyłka klawiaturowa w pośpiechu (zjedzono literkę 'i'):
prnt("O rany, literówka!")

# Python skapituluje po tej komendzie rzucając komunikatem:
# NameError: name 'prnt' is not defined. Did you mean: 'print'?

# Interpreter poinformował nas o braku definicji "prnt",
# jednocześnie pytając z uśmiechem: "Czy chodziło Ci o 'print'?"
            

• Zobaczenie krwisto-czerwonych napisów u nowicjuszy często wywołuje przerażenie i chęć natychmiastowego wyłączenia aplikacji. Nic bardziej mylnego!
• Błędy w terminalu to nie są oznaki zniszczonego komputera, to bardzo pomocne i niezwykle precyzyjne wskazówki od samego serca języka.
• Naucz się je z uwagą czytać. Najważniejsze informacje zawsze znajdują się na samym dole tego czerwonego stosu.
• W ostatniej linijce zawsze podany jest typ dolegliwości, np. omawiany wcześniej `SyntaxError`.
• Natomiast linijkę wyżej uśmiechnie się do Ciebie informacja `line X` wskazująca jak na dłoni, w której linii pliku skrywa się morderca programu.
• Python na tyle lubi pomagać, że często dorzuca mały daszek `^` precyzyjnie celujący w literkę powodującą cały kłopot.

# Terminal wyświetla m.in. takie pomocne wskazówki (np. plik z błędem w 2. linii):

File "moj_skrypt.py", line 2
    print("Brak nawiasu"
         ^
SyntaxError: unexpected EOF while parsing

# Interpreter poinformował o nieoczekiwanym końcu pliku (EOF - End Of File).
            

• Wielu frustrujących awarii na początku nauki nie powoduje kod sam w sobie, lecz błędne przygotowanie otoczenia roboczego przez użytkownika.
• Pierwszą złotą zasadą jest używanie wyłącznie angielskiego alfabetu bez polskich ogonków (ł,ś,ć) w absolutnie każdej nazwie (plików, folderów, programów).
• Kolejnym powszechnym grzechem jest wrzucanie spacji do nazw plików – zamiast tego używaj znaków podkreślenia np. `moj_kod.py`.
• Największą irytację wśród młodych kursantów powoduje jednak uruchamianie kodu, w którym... nie widać wprowadzonych przed sekundą zmian!
• Wynika to z faktu uruchamiania w terminalu pliku bezpośrednio z dysku, w momencie gdy nowe zmiany "wiszą" jeszcze niezapisane w obłoku pamięci edytora.
• Aby oszczędzić sobie wielu godzin zastanawiania się "dlaczego to nie działa, skoro poprawiłem?", wyrób w sobie mocny nawyk naciskania Ctrl+S.

• Języki takie jak popularne C++ czy Java wykorzystują tzw. nawiasy klamrowe `{}` do grupowania w nich całych rodzin poleceń.
• Python charakteryzuje się tu bardzo unikalnym, rygorystycznym podejściem: w ogóle nie używa nawiasów klamrowych do tego celu!
• Zamiast nich, używa obowiązkowych, restrykcyjnych "wcięć" w kodzie wygenerowanych przy pomocy Spacji lub klawisza Tabulator (Tab).
• Jeśli dany fragment kodu znajduje się pod warunkiem i ma należeć do niego hierarchicznie, MUSI być przesunięty w prawo (zazwyczaj o standardowe 4 spacje).
• Ten mechanizm zmusza każdego programistę do pięknego formatowania tekstów i utrzymania kodu w ekstremalnie czytelnej formie.
• Jednakże postawienie spacji za mało lub za dużo, choćby o jedną, bez powodu zakończy się nagłym wstrzymaniem programu przez `IndentationError`.

# Przykładowy poprawny kod z zachowanym wcięciem dla warunku 'jeśli' (if):
if 10 > 5:
    print("Liczba 10 jest większa!")

# Przykład potężnego błędu blokującego uruchomienie (IndentationError):
if 10 > 5:
print("Ten brak ułożenia wyrzuci potężny błąd!")
            

• Na co dzień wyszukując hasła w Internecie pewnie nie używasz klawisza SHIFT. Pisząc "Paryż" czy "paryż" znajdziesz miasto we Francji.
• Kompilatory programistyczne, w tym środowisko Pythona, są jednak całkowicie wrażliwe na wielkość liter.
• Mówimy o nim, że jest systemem wrażliwym na wielkość znaków (z j. angielskiego `case-sensitive`).
• Z punktu widzenia interpretera wyraz "PRINT" ma całkowicie inne znaczenie niż polecenie do konsoli "print" – to dla niego dwa różne gatunki.
• Niemal wszystkie podstawowe słowa-klucze sterujące językiem są zdefiniowane ściśle z wykorzystaniem wyłącznie małych liter.
• Próba wciśnięcia funkcji napisanej np. z Dużej Litery, np. dlatego że masz wciśnięty klawisz Caps-Lock, zostanie skwitowana znanym błędem NameError.

# Wywołanie prawidłowej wersji, która dokona wypisania liter na ekranie:
print("Operacja zakończona sukcesem.")

# Wersje ze zmienioną wielkością wygenerują fatalny błąd braku nazwy (NameError):
# Print("Wcale nie wydrukuję, bo P jest za duże!")
# PRINT("Ja tym bardziej, tu nic się nie zgadza...")
            

• Największym mitem w branży jest myślenie, że bycie programistą to recytowanie komend bez wahania z pamięci niczym tabliczki mnożenia.
• Środowisko to ewoluuje każdego dnia, a komend i modułów jest tyle, że ich poznanie na pamięć wymagałoby wiedzy dziesięciu uniwersytetów.
• Prawdziwy talent to nie pamięć fotograficzna do znaków, lecz potężna zdolność odnajdywania, filtrowania i implementowania poszukiwanych informacji.
• Świętym Grallem programisty i miejscem pierwszego kontaktu jest oficjalna dokumentacja. Dla omawianego języka jest to serwis `docs.python.org`.
• Działająca niczym gigantyczna Wikipedia instrukcja obsługi, bardzo merytorycznie i bez zbytecznych opowieści opisuje co robi i jak się zachowuje dana funkcja.
• Gdybyś nie znalazł tam ratunku na potężny błąd aplikacji, pomocą w programowaniu służą od dekad fora takie jak "StackOverflow".

• Zanim na dobre ugrzęźniesz w internetowych gąszczach i forach zadając setki trywialnych pytań, warto dać szansę encyklopedii.
• Okazuje się, że rdzenny Python ma wewnątrz siebie zbudowaną skrótową wersję internetowej dokumentacji w wersji terminalowej!
• Służy do tego potężna (a jednocześnie rzadko znana młodym koderom) wbudowana komenda "pomocy" – urocza funkcja `help()`.
• Po wejściu do trybu REPL, po znakach `>>>` możesz wpisać komendę podając w jej nawiasie nazwę jakiejkolwiek funkcji – tej domyślnej lub cudzej.
• Konsola błyskawicznie powróci do Ciebie z obszernym wyjaśnieniem tego do czego dana funkcja służy, pokazując też listę skomplikowanych opcji jak `sep` i `end`.
• Dzięki temu zyskujesz czas unikając wyjścia z notatnika do okna domyślnej przeglądarki internetowej.

# Wywołujemy wezwanie o pomoc dla funkcji wypluwającej treść:
>>> help(print)

# Python wywiesza do wglądu oficjalną ściągawkę terminalową:
# Help on built-in function print in module builtins:
# print(...)
#     print(value, ..., sep=' ', end='\n', file=sys.stdout, flush=False)
#     Prints the values to a stream, or to sys.stdout by default.
            

• Język polski liczy ponad sto tysięcy słów. Słownik Pythona jest ekstremalnie mały, zawiera w sobie jedynie 35 zarezerwowanych słów kluczowych (keywords).
• Te magiczne słowa stanowią absolutny fundament architektury języka i dyktują komputerowi jak ma się zachować (np. słowa `if`, `for`, `and`, `True`).
• Mówimy, że są to słowa "zarezerwowane" – oznacza to, że programista pod żadnym pozorem nie ma prawa ich nadpisywać.
• Nie możesz stworzyć np. swojej własnej gry czy aplikacji i nazwać jej wewnątrz kodu słowem `import` czy `def`. Zostaniesz zatrzymany przez SyntaxError.
• Dobrą wiadomością jest to, że nie musisz uczyć się ich na pamięć. Każde profesjonalne IDE, w tym VS Code, natychmiast podkreśli zarezerwowane słowo innym kolorem.
• Jeśli w trakcie pisania nazwy Twoje słowo nagle zaświeci się na niebiesko lub fioletowo – wiedz, że musisz wymyślić inną nazwę.

# Wywołanie wewnętrznej, zaimplementowanej biblioteki 'keyword':
import keyword

# Możemy łatwo podejrzeć i upewnić się co do listy wszystkich słów:
print(keyword.kwlist)

# Wynik w terminalu:
# ['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']
            

• Możesz napisać działający program na dziesiątki różnych sposobów, jednak w świecie inżynierii liczy się czytelność.
• Społeczność Pythona wydała oficjalny, legendarny dokument o nazwie PEP-8. Jest to Biblia stylistyki i dobrych manier programisty.
• Jedną z najważniejszych reguł zdefiniowanych w PEP-8 jest konwencja nazewnicza zwana `snake_case` (styl węża).
• Polega ona na tym, by wszystkie nazywane przez nas rzeczy pisać wyłącznie małymi literami, a zamiast zakazanej spacji używać znaku podkreślenia `_`.
• Zapisanie nazwy jako `moja_super_gra` jest wysoce pożądane, podczas gdy Java-podobne `MojaSuperGra` (tzw. PascalCase) lub `mojaSuperGra` (camelCase) zostanie w społeczności Pythona bardzo źle odebrane.
• Chociaż złamanie PEP-8 zazwyczaj nie psuje komputera, używanie poprawnych konwencji jest testem na profesjonalizm w każdej rekrutacji.

• Ostatnią sprawą formalną przed rozpoczęciem dzikiego pisania kodu, jest przyswojenie ogólnie panującej architektury pliku `.py`.
• Dobrze sformatowany program zawsze posiada strukturę czytaną klasycznie: od lewej do prawej i z góry na dół.
• Sam wierzchołek pliku zarezerwowany jest absolutnie dla deklaracji importowych – to tam sprowadzamy do programu zewnętrzne biblioteki i moduły rozszerzające możliwości Pythona.
• Następnie, na kolejnym piętrze tworzymy i nazywamy stałe, uniwersalne wartości, które nie będą się zmieniać (tzw. Stałe Globalne).
• Dopiero na samym dole, najczęściej na przestrzeni setek linijek, wdrażamy właściwą logikę: budujemy pętle, wyświetlamy menu dla klienta, żądamy wpisywania haseł.
• Utrzymanie tej hierarchii gwarantuje, że interpreter Pythona (czytając kod zawsze z góry na dół) nie natrafi na żądanie wykonania modułu, którego ten jeszcze nie zdążył pobrać z pierwszej linijki.

# 1. SEKCJA IMPORTÓW (najwyżej w kodzie):
# Importujemy paczkę odpowiedzialną za skomplikowaną matematykę:
import math

# 2. LOGIKA I DZIAŁANIE APLIKACJI (poniżej importów):
print("Rozpoczęcie wyliczania stałej Pi z wbudowanego modułu...")

# Odpytanie ściągniętego wcześniej modułu math o dokładną liczbę Pi:
print(math.pi)
            

• Nadeszła pora, aby udowodnić sobie i maszynie nabycie nowej wiedzy z zakresu sterowania wierszem poleceń.
• Twoim pierwszym prawdziwym miniprojektem (ćwiczeniem) jest stworzenie tekstowej wizytówki biznesowej.
• Za pomocą licznych wywołań komendy wypisującej na ekran pożądany ciąg znaków, spróbuj narysować ramkę.
• Wewnątrz wygenerowanej ramki zamieść informacje przypominające wizytówkę: Twoje Imię, Nazwisko oraz wykonywany lub wyuczony zawód.
• Wykorzystaj spacje wewnątrz cudzysłowów, aby zadbać o równe marginesy prawego boku gwiazdek zamykających wizytówkę.
• Uruchom plik tak często jak to konieczne, by eksperymentalnie dopracować wszystkie szczegóły graficzne.

# Przykładowe rozwiązanie zadania wizytówki:
# Zastosowano tu wielokrotny print do formatowania prostokąta.

print("********************************")
print("* Imię i Nazwisko: Jan Kowalski*")
print("* Zawód: Python Developer      *")
print("* Miasto: Warszawa             *")
print("********************************")
            

• Wiedza z zakresu manipulowania przestrzeniami to brama do cudownego świata nostalgicznej sztuki ASCII (ASCII Art).
• W czasach, gdy pierwsze komputery potrafiły generować tylko i wyłącznie czarne ekrany tekstowe bez obrazków, programiści zaczęli z nudów rysować zmysłowe obrazy z liter.
• Nawet dziś, logując się do potężnych serwerów w serwerowni potrafią powitać nas wielkie, wymalowane tekstem smoki lub loga wielkich firm korporacyjnych.
• Zadanie dla Ciebie: poćwicz umiejscawianie znaków specjalnych kreśląc w terminalu postać, na przykład wirtualnego kota.
• Będziesz musiał pobawić się znakami nawiasów, kropek i lewych oraz prawych ukośników, dbając o symetryczne oddalenie spacji w każdym wywołaniu printa.
• Pamiętaj tylko, co robi wsteczny backslash `\` – czasem trzeba napisać go podwójnie (`\\`), żeby Python potraktował go jako zwykły obrazek zamiast początku komendy `\n`.

# Przykładowe rozwiązanie sztuki graficznej ASCII z motywem kocim:

print(" /\\_/\\ ")
print("( o.o )")
print(" > ^ < ")

# Wygenerowany w ten sposób zwierzak wyświetli się przy każdym uruchomieniu skryptu!
            

• Czas wdrożyć w życie obietnicę o odciążeniu mózgu ze żmudnych matematycznych kalkulacji.
• Komputery powstały właśnie po to, by wykonywać ciężką arytmetykę setki tysięcy razy szybciej od najtęższych inżynierów.
• Kolejne zadanie: sprawdź swoje umiejętności, łącząc w jednym zadaniu drukowanie tekstowe z czystym działaniem mnożenia w nawiasach.
• Twoim celem jest wyprowadzenie na ekran komunikatu mówiącego o tym, ile godzin ma cały rok, gdy jest rokiem przestępnym.
• W jednej funkcji poinformuj użytkownika co znajduje się na ekranie za pomocą zgrabnego łańcucha tekstowego, a w linijce niżej umieść nieotoczone niczym wartości.
• Pozwól wbudowanemu kalkulatorowi wyręczyć Cię z konieczności wpisywania odpowiedzi ręcznie.

# Rozwiązanie zadania korzystające z wbudowanej arytmetyki:

# Wpierw drukujemy informacyjny string (tekst):
print("Tyle dokładnie godzin liczy każdy rok przestępny:")

# Poniżej powierzamy Pythonowi rolę kalkulatora przemnażającego dni przez godziny:
print(366 * 24)

# Odpowiedź pokaże się natychmiastowo pod tekstem.
            

• Dla udowodnienia pełnego opanowania konsoli, połącz wiedzę na temat wszystkich parametrów ukrytych funkcji `print()`.
• Mamy sytuację losową: napisałeś kod posiadający dwa oddzielne od siebie polecenia `print`. Twoim celem jest zmuszenie ich do zignorowania prawa przejścia do nowej linii.
• Dodatkowo, pierwsze z nich drukuje zbiór trzech rozrzuconych elementów (np. litery A, B, C oddzielone w kodzie jedynie przecinkiem).
• Rozwiąż zagadkę, manipulując modyfikatorem `sep` (separator elementów) oraz `end` (zakończenie linii).
• Zablokuj wyłamywanie entera tak, aby ostateczny rezultat wyświetlił się jako zbita i dopasowana wiadomość pozioma.
• Rozwiązywanie takich mikrozadań wyrabia tzw. pamięć mięśniową – mechanizmy te staną się po paru dniach w pełni automatyczne.

# Oczekiwane rozwiązanie formatowania złożonego:

# Pierwsza funkcja skleja słowa myślnikiem i zabija Entera wstawiając swój tekst łączący:
print("A", "B", "C", sep="-", end=" a doklejoną końcówką jest litera ")

# Druga funkcja zostanie na siłę zaabsorbowana przez linię powyżej:
print("D")

# Terminal wyświetli z dumą tylko jedną linię:
# A-B-C a doklejoną końcówką jest litera D
            

• Czasem zdarza się sytuacja, w której lądujemy przy komputerze służbowym czy publicznym, gdzie instalacja oprogramowania zewnętrznego nie jest możliwa.
• Nie oznacza to jednak przerwy w nauce! Ogromna część edukacji programistycznej odbywa się w dzisiejszych czasach bezpośrednio w 'chmurze'.
• Środowiska wewnątrzprzeglądarkowe omijają uciążliwy proces pobierania instalatorów, oferując gotowe maszyny wirtualne i kompilatory zasilane mocą zagranicznych serwerów.
• Do najbardziej fenomenalnych, darmowych narzędzi w tej klasie zaliczyć można "Replit" – imitujący IDE portal społecznościowy z wbudowanym serwerem Pythona i konsolą.
• Wśród inżynierów Data Science niekoronowanym królem jest platforma Google Colaboratory (oraz siostrzany Jupyter Notebook), skupiona na notatnikach edukacyjnych z wbudowanymi modułami uruchomieniowymi.
• Wszystkie wymienione wyżej opcje pozwalają na wyklikanie terminala jednym przyciskiem wprost z ulubionej przeglądarki Chrome czy Firefox.

• Dotarliśmy szczęśliwie do brzegu pierwszego, potężnego etapu Twojej programistycznej wędrówki.
• Podczas tego szkolenia zgłębiłeś definicje języków wysokopoziomowych, pojęcie bycia interpreterem oraz bezkonkurencyjną popularność węża Pythona.
• Zainstalowaliśmy silnik wykonawczy na komputerze i wyciągnęliśmy na światło dzienne mityczny "Terminal" oraz inżynierski tryb testowy REPL.
• Zapoznaliśmy się ze sprzętem (edytory takie jak VS Code, IDLE) oraz utworzyliśmy autorskie skrypty źródłowe ze specjalnym rozszerzeniem `.py`.
• Spędziliśmy mnóstwo czasu rzucając wyzwania absolutnie najważniejszej funkcji komunikacyjnej – `print()`, męcząc ją parametrami `sep`, `end` i znakami specjalnymi.
• Rozwikłaliśmy tajemnice ukrywanych komentarzy `#` i wielkich, czerwonych potworów wywołujących krzyki z napisem SyntaxError.

• Wypisywanie predefiniowanego tekstu ze statycznego pliku działa, cieszy oko i poprawia morale na samym początku. Niestety, w żaden sposób nie czyni jeszcze komputera inteligentnym rozwiązaniem naszych problemów.
• W prawdziwych aplikacjach biznesowych i systemach IT, niemal nigdy nie wiemy, co dokładnie znajdzie się w pamięci programu – przecież imię wpisywane podczas rejestracji zależy wprost od obecnego klienta siedzącego przed monitorem.
• Z tego też powodu w drugiej potężnej części naszej podróży rzucimy się w wir dynamicznych zasobów maszyny. Będziemy bezkarnie zapisywać i kasować tajne dane z wirtualnych szuflad przydzielanej pamięci RAM komputera.
• Pudełka te, ze względu na dynamicznie zmieniającą się podczas działania aplikacji wartość ich środka, noszą kluczowe miano – tzw. Zmiennych (Variables).
• Odkryjemy, dlaczego pudełko z liczbami gryzie się z pudełkiem wypełnionym literami (Typy Danych) i w jakim systemie połączymy je w bezpieczną więź.
• Uruchomimy również pierwszą poważną interakcję z człowiekiem, prosząc go bezpośrednio w konsoli o podanie prywatnych wartości tekstowych używając nieustępliwej funkcji interkomowej `input()`. Do zobaczenia w drugiej części!