Python dla początkujących: pierwsze programy bez stresu

Dlaczego Python jest idealny na pierwszy język programowania

Python dla początkujących – spokojny start zamiast frustracji

Pierwszy kontakt z programowaniem często kojarzy się z chaosem: niezrozumiałe błędy, skomplikowana instalacja, ściana teorii. Python rozwiązuje większość z tych problemów. Język jest czytelny, ma prostą składnię i ogromną społeczność, która już dawno przetestowała wszystkie typowe pułapki. Dzięki temu Python dla początkujących oznacza faktycznie łagodny start, a nie ból głowy po pierwszej godzinie.

Kod w Pythonie wygląda niemal jak rozszerzony zapis w języku angielskim. Nie trzeba stawiać średników na końcu linii, pamiętać o nawiasach klamrowych czy martwić się o typy zmiennych na początku nauki. Programy, które w innych językach wymagają wielu linii kodu, w Pythonie da się napisać w kilku. To obniża barierę wejścia i pozwala skupić się na logice, a nie na walce ze składnią.

Python dobrze wspiera zarówno osoby totalnie początkujące, jak i te, które kiedyś coś programowały i chcą wrócić do tematu bez stresu. Sprawdza się w nauce samodzielnej, na kursach internetowych i na zajęciach w szkołach. Ucząc się Pythona, można szybko przeskoczyć od „nic nie umiem” do „mam działający program”, co działa bardzo motywująco.

Gdzie wykorzystasz Pythona poza nauką

Python nie jest tylko zabawką edukacyjną. To pełnoprawny język programowania, którego używają zarówno startupy, jak i wielkie firmy technologiczne. Dzięki temu od samego początku uczysz się narzędzia, które ma realne zastosowania na rynku pracy, a każdy napisany przez ciebie kod może być pierwszym krokiem do bardziej zaawansowanych projektów.

Najpopularniejsze obszary, w których króluje Python, to:

• analiza danych i nauka o danych (pandas, NumPy, Jupyter Notebook),
• sztuczna inteligencja i uczenie maszynowe (TensorFlow, PyTorch, scikit-learn),
• tworzenie stron i aplikacji webowych (Django, Flask, FastAPI),
• automatyzacja zadań (skrypty, narzędzia CLI, integracje),
• testowanie oprogramowania (pytest, unittest),
• obsługa plików, raportów, integracje z systemami firmowymi.

Nawet jeśli dziś chcesz tylko napisać kilka prostych programów bez stresu, dobrze jest wiedzieć, że inwestujesz czas w coś, co przyda się także w większych projektach. Ta świadomość ułatwia wytrwanie w nauce, gdy pojawią się pierwsze trudniejsze momenty.

Python a inne języki – krótkie porównanie

Python często jest porównywany z innymi popularnymi językami, których uczy się na start: C, C++, Java, JavaScript. Różnice między nimi dobrze pokazują, dlaczego Python dla początkujących jest rozsądnym wyborem.

Java i C/C++ są świetne, ale stawiają więcej wymagań na starcie. Python pozwala szybciej przejść do pisania pierwszych programów bez stresu, bez rezygnacji z mocy i elastyczności w późniejszym etapie nauki.

Przygotowanie środowiska – pierwszy krok bez paniki

Sprawdzenie, czy Python jest już zainstalowany

Zanim zainstalujesz cokolwiek nowego, sprawdź, czy Python nie jest już na twoim komputerze. Wielu użytkowników nawet nie wie, że go ma. Najszybsza metoda to użycie wiersza poleceń.

Windows

Otwórz:

• Wiersz polecenia (w menu Start wpisz: cmd) lub
• Windows PowerShell.

Następnie wpisz:

python --version

Jeśli zobaczysz coś w stylu Python 3.11.2 – Python jest zainstalowany. Jeśli pojawi się informacja o braku polecenia, spróbuj:

py --version

macOS / Linux

Otwórz Terminal i wpisz:

python3 --version

Na wielu systemach Python jest częścią systemu, ale czasem jest to starsza wersja. Dobrze, aby wersja była przynajmniej z linii 3.8 lub nowsza. Jeśli masz starą wersję 2.x, lepiej zainstalować aktualną „trójkę”.

Instalacja Pythona krok po kroku

Jeśli Python nie jest zainstalowany albo chcesz mieć aktualną wersję, przejdź na oficjalną stronę python.org i pobierz instalator dla swojego systemu. Proces jest prosty, ale jedna opcja jest kluczowa, szczególnie na Windowsie.

Instalacja na Windows

Po uruchomieniu instalatora:

1. Na dole okna zaznacz Add Python 3.x to PATH – to bardzo ważne, ułatwia uruchamianie Pythona z wiersza poleceń.
2. W większości przypadków możesz wybrać Install Now.
3. Po zakończeniu instalacji zamknij instalator.
4. Sprawdź instalację w wierszu poleceń: python --version lub py --version.

Brak zaznaczenia opcji PATH jest częstą przyczyną frustracji początkujących, bo system „nie widzi” polecenia python. Jeśli zapomnisz o tym kroku, zawsze możesz uruchomić instalator ponownie i naprawić instalację.

Instalacja na macOS

Na macOS najwygodniejsza metoda to użycie menedżera pakietów Homebrew (jeśli go nie masz, warto go zainstalować, ale nie jest to obowiązkowe na sam początek). Jeśli już masz Homebrew:

brew install python

Bez Homebrew możesz pobrać oficjalny instalator z python.org i przejść standardową instalację, klikając „Dalej”/„Kontynuuj” zgodnie z instrukcjami. Po zakończeniu używaj komendy:

python3 --version

Instalacja na Linux

Na większości dystrybucji Linux Python 3 jest już zainstalowany. Jeśli potrzebujesz najnowszej wersji, użyj menedżera pakietów:

• Ubuntu / Debian:

  sudo apt update
  sudo apt install python3
  

• Fedora:

  sudo dnf install python3
  

• Arch Linux:

  sudo pacman -S python
  

Proste środowisko do pisania kodu bez zbędnych dodatków

Początkujący często od razu instalują rozbudowane IDE (np. PyCharm) i gubią się w dziesiątkach opcji. Na start wystarczy coś znacznie prostszego – edytor tekstu i interpreter Pythona. Dzięki temu uczysz się języka, a nie samego narzędzia.

Edytor tekstu dla początkujących

Dobre lekkie edytory to:

• VS Code (Windows, macOS, Linux) – darmowy, popularny, z rozszerzeniami do Pythona,
• Sublime Text – szybki, przejrzysty, wygodny,
• Notepad++ (Windows) – prosty, ale wystarczający na małe skrypty.

Na początek wystarczy skonfigurować podświetlanie składni Pythona i możliwość zapisywania plików z rozszerzeniem .py. Do uruchamiania programów i tak będziesz używać terminala lub wiersza poleceń, co daje lepsze zrozumienie tego, co dzieje się „pod maską”.

Interpreter interaktywny – piaskownica bez stresu

Python ma tryb interaktywny (REPL), który pozwala wpisywać pojedyncze polecenia i od razu widzieć wynik. To świetne narzędzie do nauki, testowania pomysłów i zrozumienia podstaw.

Uruchom w terminalu lub wierszu poleceń:

python

(na macOS/Linux często trzeba użyć python3).

Zobaczysz coś w stylu:

Python 3.11.2 (main, ...)
>>>

Te trzy znaki >>> oznaczają, że interpreter czeka na twoje polecenie. Można tu wykonywać obliczenia, testować funkcje, uczyć się składni. To miejsce, w którym pierwsze programy bez stresu naprawdę nabierają sensu.

Pierwsze uruchomienia Pythona – REPL vs plik .py

Tryb interaktywny – natychmiastowa informacja zwrotna

Tryb interaktywny pozwala „porozmawiać” z Pythonem. Wpisujesz polecenie – dostajesz natychmiastową odpowiedź. To idealne środowisko, aby obyć się z językiem i przetestować drobne fragmenty kodu, zanim umieścisz je w większym programie.

Przykład krótkiej sesji:

>>> 2 + 3
5
>>> print("Witaj, Pythonie!")
Witaj, Pythonie!
>>> 10 / 3
3.3333333333333335

Interpreter można wyłączyć, wpisując:

exit()

lub używając skrótu Ctrl + Z (Windows) / Ctrl + D (macOS/Linux), a następnie Enter.

Pliki .py – pierwszy „prawdziwy” program

Gdy kod zaczyna się rozrastać, tryb interaktywny przestaje być wygodny. Wtedy czas na stworzenie pliku z rozszerzeniem .py. To tutaj zaczną powstawać programy, które można uruchamiać wielokrotnie i udostępniać innym.

Pierwszy program w pliku

Otwórz swój edytor tekstu i wpisz:

print("Witaj w świecie Pythona!")

Zapisz plik jako pierwszy_program.py w znanym sobie folderze, np. na Pulpicie lub w katalogu Dokumenty/Python.

Aby uruchomić program:

1. Otwórz wiersz poleceń lub terminal.
2. Przejdź do folderu z plikiem (np. na Windows:

   cd C:UzytkownicyTwojeImiePulpit
   

   na macOS/Linux:

   cd /Users/TwojeImie/Desktop
   

   ).

3. Uruchom:

   python pierwszy_program.py
   

   (albo python3 pierwszy_program.py).

Na ekranie powinno pojawić się:

Witaj w świecie Pythona!

Różnice między REPL a plikiem – kiedy co wybrać

Oba sposoby uruchamiania kodu są potrzebne, ale służą do nieco innych celów. Szybkie porównanie:

Dobry nawyk na start: testuj drobne fragmenty kodu w REPL, a gdy zaczynasz tworzyć coś dłuższego niż kilka linii, od razu przenoś to do pliku. Dzięki temu unikniesz sytuacji, w której przypadkowo zamkniesz interpreter i stracisz wszystko, co właśnie napisałeś.

Absolutne podstawy składni – bez których ani rusz

Instrukcja print – twój pierwszy kanał komunikacji

Funkcja print() to najprostszy sposób, by program „coś powiedział”. Bez niej trudno ocenić, co dzieje się w środku kodu. Na początku nauki będziesz korzystać z niej bardzo często – i dobrze. To podstawa, by pisać programy w Pythonie bez stresu.

Proste przykłady:

print("Witaj!")
print("To jest", "pierwszy", "program")
print(2 + 3)

Kilka ważnych obserwacji:

Tekst, liczby i inne typy danych

W przykładach z print() przewija się zarówno tekst, jak i liczby. Python traktuje je inaczej, choć na ekranie widzisz po prostu znaki.

Kilka podstawowych typów danych:

• tekst – typ str (od „string”), np. "Ala", 'Python',
• liczby całkowite – typ int, np. 3, -10, 2024,
• liczby zmiennoprzecinkowe – typ float, np. 3.14, 0.5,
• wartości logiczne – typ bool, czyli True lub False.

Python sam rozpoznaje typ na podstawie zapisu:

print(type("Hello"))   # <class 'str'>
print(type(10))        # <class 'int'>
print(type(3.5))       # <class 'float'>
print(type(True))      # <class 'bool'>

Tekst zawsze musi być w cudzysłowach (pojedynczych ' ' lub podwójnych " "). Liczby i True/False – bez.

Łączenie tekstu i liczb – częsta pułapka

Prędzej czy później pojawi się potrzeba wypisania tekstu wraz z wynikiem obliczeń. Intuicja podpowiada coś takiego:

print("Wynik:", 2 + 3)      # to zadziała
print("Wynik: " + 2 + 3)    # to już nie

Pierwsza linijka jest poprawna, bo print() umie przyjąć kilka argumentów oddzielonych przecinkami. Druga próbuje skleić tekst z liczbą za pomocą + i kończy się błędem typu TypeError.

Jeśli chcesz łączyć za pomocą +, przekształć liczbę na tekst:

print("Wynik: " + str(2 + 3))

W praktyce początkujący dobrze radzą sobie z prostym wzorcem:

wynik = 2 + 3
print("Wynik:", wynik)

Przecinek w print() automatycznie wstawia spację i sam zamienia liczby na tekst.

Zmienne – przechowywanie wartości na później

Do tej pory wszystkie wartości były wpisywane „na twardo”. Prawdziwe programy przechowują dane w zmiennych. Zmienna to po prostu nazwana „szufladka” na wartość.

wiek = 25
imie = "Ania"
srednia = 4.5

print(imie, "ma", wiek, "lat i średnią", srednia)

Kilka zdrowych zasad nazewnictwa zmiennych:

• mogą składać się z liter, cyfr i podkreślenia, ale nie mogą zaczynać się od cyfry,
• nie używaj polskich liter (ą, ę, itd.) – unikniesz problemów,
• nazwy nie mogą być słowami zarezerwowanymi Pythona (np. if, for, class),
• wybieraj nazwy opisowe: liczba_studentow zamiast ls.

Python rozróżnia wielkość liter, więc wiek i Wiek to dwie różne zmienne.

Proste działania na liczbach – kalkulator w terminalu

Interpreter Pythona świetnie nadaje się na podręczny kalkulator. Najpotrzebniejsze operacje:

• + – dodawanie,
• - – odejmowanie,
• * – mnożenie,
• / – dzielenie (wynik zawsze typu float),
• // – dzielenie całkowite (obcina część ułamkową),
• % – reszta z dzielenia,
• ** – potęgowanie.

print(2 + 3 * 4)       # 14
print((2 + 3) * 4)     # 20
print(10 / 3)          # 3.3333333333333335
print(10 // 3)         # 3
print(10 % 3)          # 1
print(2 ** 5)          # 32

Zasady pierwszeństwa działań są takie jak w matematyce, a nawiasy zawsze wygrywają. Gdy robisz coś bardziej złożonego, lepiej dodać nawiasy niż się domyślać, jak zinterpretuje to interpreter.

Wejście od użytkownika – program, który reaguje

Program, który tylko wypisuje stały tekst, szybko się nudzi. Czas sprawić, by reagował na użytkownika. Do odczytu danych służy funkcja input().

imie = input("Jak masz na imię? ")
print("Cześć,", imie)

Funkcja input() zawsze zwraca tekst (str), nawet jeśli użytkownik wpisze liczbę. Jeśli potrzebujesz liczby, musisz ją przekonwertować:

wiek_tekst = input("Ile masz lat? ")
wiek = int(wiek_tekst)     # zamiana tekstu na liczbę całkowitą

print("Za rok będziesz mieć", wiek + 1, "lat.")

Częsty skrót:

wiek = int(input("Ile masz lat? "))

Jeśli użytkownik wpisze coś, czego nie da się zamienić na liczbę (np. abc), program zgłosi błąd. Na tym etapie nie trzeba się tym przejmować – obsługa błędów przyjdzie później.

Instrukcje warunkowe – decyzje w kodzie

Program bez decydowania, co zrobić w zależności od sytuacji, jest mało użyteczny. Do podejmowania decyzji służy if wraz z opcjonalnymi elif i else.

Prosty przykład:

wiek = int(input("Ile masz lat? "))

if wiek >= 18:
    print("Jesteś pełnoletni.")
else:
    print("Jesteś niepełnoletni.")

Kilka rzeczy dzieje się tu jednocześnie:

• po if (i else) stoi dwukropek :,
• instrukcje, które mają się wykonać „w środku” warunku, są wcięte (zwykle 4 spacje),
• warunek to wyrażenie, które daje wynik True lub False.

Inne porównania:

• == – równe,
• != – różne,
• >, <, >=, <= – jak w matematyce.

liczba = int(input("Podaj liczbę: "))

if liczba > 0:
    print("Liczba dodatnia")
elif liczba == 0:
    print("Zero")
else:
    print("Liczba ujemna")

Ważne: wcięcia to nie kosmetyka. Python używa ich do określenia, które linie należą do danego bloku. Jeśli linijka ma inne wcięcie niż reszta, interpreter zgłosi błąd.

Operatory logiczne – łączenie warunków

Często jedna decyzja zależy od więcej niż jednego warunku. Służą do tego operatory logiczne and, or i not.

wiek = int(input("Ile masz lat? "))
kraj = input("W jakim kraju mieszkasz? ")

if wiek >= 18 and kraj == "Polska":
    print("Masz pełne prawa wyborcze w Polsce (w uproszczeniu).")

Inne przykłady:

temperatura = 5

if temperatura > 0 and temperatura < 10:
    print("Chłodno, ale powyżej zera.")

if temperatura <= 0 or temperatura >= 30:
    print("Ekstremalne warunki.")

czy_padalo = True

if not czy_padalo:
    print("Dzisiaj nie padało.")

W bardziej złożonych warunkach używaj nawiasów, żeby jasno określić kolejność:

if (wiek >= 18 and kraj == "Polska") or kraj == "Inny":
    ...

Pętle – powtarzanie tego, co działa

Ręczne powtarzanie tej samej instrukcji kilkanaście razy to dobry sygnał, że przyda się pętla. W Pythonie podstawowe są dwie: while i for.

Pętla while – dopóki warunek jest spełniony

while powtarza blok kodu, dopóki warunek jest prawdziwy:

licznik = 1

while licznik <= 5:
    print("To jest iteracja nr", licznik)
    licznik = licznik + 1

print("Koniec pętli")

Najpierw ustawiana jest wartość początkowa (licznik = 1), potem pętla sprawdza warunek, wykonuje ciało i na końcu zmienia licznik. Jeśli o tym ostatnim punkcie zapomnisz, pętla może stać się nieskończona.

Przykładowy prosty program do zgadywania liczby:

tajna_liczba = 7
propozycja = int(input("Zgadnij liczbę od 1 do 10: "))

while propozycja != tajna_liczba:
    print("Nie, spróbuj jeszcze raz.")
    propozycja = int(input("Zgadnij liczbę od 1 do 10: "))

print("Brawo, zgadłeś!")

Pętla for – przechodzenie po zakresie lub kolekcji

for dobrze sprawdza się, gdy z góry wiadomo, ile razy coś ma się powtórzyć, albo gdy iterujesz po elementach kolekcji (np. po literach w tekście).

for i in range(5):
    print("i =", i)

range(5) tworzy ciąg liczb 0, 1, 2, 3, 4. Inne możliwości:

for i in range(1, 6):      # od 1 do 5 (6 jest wyłączone)
    print(i)

for i in range(0, 10, 2):   # od 0 do 8, co 2
    print(i)

Pętla po tekście:

slowo = "Python"

for litera in slowo:
    print(litera)

Instrukcje break i continue – kontrola pętli

Czasami trzeba przerwać pętlę wcześniej lub ominąć jedną iterację. Do tego służą break i continue.

# Przerwanie pętli po znalezieniu liczby parzystej
for i in range(1, 10):
    if i % 2 == 0:
        print("Pierwsza parzysta:", i)
        break

# Pomijanie liczb parzystych
for i in range(1, 10):
    if i % 2 == 0:
        continue    # przejście do następnej iteracji
    print("Nieparzysta:", i)

Świadome używanie tych instrukcji pomaga tworzyć czytelny przepływ w pętli, zamiast budować bardzo rozbudowane warunki.

Listy – wiele wartości w jednej zmiennej

Gdy pojawia się więcej danych, pojedyncze zmienne przestają wystarczać. Do przechowywania wielu elementów służą listy.

liczby = [10, 20, 30]
imiona = ["Ania", "Bartek", "Celina"]

print(liczby)
print(imiona)

Dostęp do elementów odbywa się przez indeks (numer pozycji), przy czym liczenie zaczyna się od zera:

print(imiona[0])   # "Ania"
print(imiona[1])   # "Bartek"
print(imiona[2])   # "Celina"

Podstawowe operacje na listach:

imiona.append("Darek")      # dodanie na koniec
print(imiona)

imiona[1] = "Bartosz"       # zmiana elementu
print(imiona)

print(len(imiona))          # długość listy

Połączenie listy z pętlą for bardzo szybko daje użyteczne programy:

zakupy = ["chleb", "masło", "ser"]

print("Lista zakupów:")
for produkt in zakupy:
    print("-", produkt)

Proste funkcje – własne klocki z kodu

Przy większych programach powtarzające się fragmenty kodu aż proszą się o wyciągnięcie do osobnych „klocków”. Tymi klockami są funkcje.

def przywitaj(imie):
    print("Cześć,", imie, "!")

przywitaj("Ania")
przywitaj("Bartek")

Struktura jest prosta:

• słowo kluczowe def, nazwa funkcji i nawiasy z parametrami,
• dwukropek :,
• wcięty blok kodu – ciało funkcji.

Funkcja może też zwracać wartość za pomocą return:

Funkcje zwracające wyniki – małe „maszynki” w kodzie

def dodaj(a, b):
    suma = a + b
    return suma

wynik = dodaj(3, 5)
print("Wynik dodawania:", wynik)

Po wykonaniu return funkcja kończy działanie i zwraca podaną wartość. Można też użyć krótszej wersji:

def pomnoz(a, b):
    return a * b

print(pomnoz(4, 6))

Zwrócona wartość może być od razu użyta w innym obliczeniu:

def pole_prostokata(a, b):
    return a * b

pole = pole_prostokata(3, 7)
print("Pole:", pole)
print("Podwojone pole:", pole_prostokata(3, 7) * 2)

Jeśli funkcja nie ma return, domyślnie zwraca specjalną wartość None. Takie funkcje wykonują głównie „akcje” (np. print), a nie obliczenia.

Parametry domyślne i wartości opcjonalne

Czasami funkcja ma sens z dodatkowymi parametrami, ale chciałoby się móc ich nie podawać za każdym razem. Do tego służą wartości domyślne.

def przywitaj(imie, powitanie="Cześć"):
    print(powitanie + ",", imie + "!")

przywitaj("Ania")                    # użyje domyślnego powitania
przywitaj("Bartek", "Dzień dobry")  # nadpisanie domyślnej wartości

Parametry z wartościami domyślnymi muszą być na końcu listy parametrów:

def przedstaw(imie, wiek, miasto="Warszawa"):
    print("Imię:", imie)
    print("Wiek:", wiek)
    print("Miasto:", miasto)

przedstaw("Kasia", 25)
przedstaw("Marek", 30, "Kraków")

Prosty podział programu na funkcje

Niewielki, ale praktyczny przykład: prosty kalkulator działający w konsoli. Zamiast pisać wszystko w jednym ciągu, można podzielić program na małe części.

def wczytaj_liczbe(tekst):
    wartosc = float(input(tekst))
    return wartosc

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

def odejmowanie(a, b):
    return a - b

def mnozenie(a, b):
    return a * b

def dzielenie(a, b):
    return a / b

print("Prosty kalkulator")
print("1 - dodawanie")
print("2 - odejmowanie")
print("3 - mnożenie")
print("4 - dzielenie")

wybor = input("Wybierz operację (1-4): ")

x = wczytaj_liczbe("Podaj pierwszą liczbę: ")
y = wczytaj_liczbe("Podaj drugą liczbę: ")

if wybor == "1":
    wynik = dodawanie(x, y)
elif wybor == "2":
    wynik = odejmowanie(x, y)
elif wybor == "3":
    wynik = mnozenie(x, y)
elif wybor == "4":
    wynik = dzielenie(x, y)
else:
    print("Nieznana operacja")
    wynik = None

if wynik is not None:
    print("Wynik:", wynik)

Widać, że logika obliczeń jest oddzielona od części odpowiedzialnej za komunikację z użytkownikiem. Dzięki temu łatwiej później poprawiać lub rozbudowywać taki kod.

Napisy (str) – praca z tekstem

Python bardzo dobrze radzi sobie z tekstem. Napisy można łączyć, ciąć na kawałki i modyfikować za pomocą metod.

tekst = "Python dla początkujących"

print(len(tekst))          # długość napisu
print(tekst.lower())       # wszystko małymi literami
print(tekst.upper())       # wszystko wielkimi literami
print(tekst.title())       # Każde Słowo z Wielkiej Litery

Wycinanie fragmentów (slicing):

napis = "programowanie"

print(napis[0])      # 'p'
print(napis[1:4])    # 'rog' (od indeksu 1 do 3)
print(napis[:5])     # 'progr' (od początku do 4)
print(napis[5:])     # 'amowanie' (od 5 do końca)
print(napis[-1])     # ostatni znak: 'e'
print(napis[-4:])    # 'anie'

Kilka przydatnych metod przy pracy z wejściem od użytkownika:

imie = input("Jak masz na imię? ").strip()   # usuwa spacje z początku i końca
print("Witaj,", imie.capitalize())           # pierwsza litera duża, reszta małe

email = "user@example.com"
print(email.startswith("user"))              # True
print(email.endswith(".pl"))                 # False

Formatowanie tekstu – czytelne komunikaty

Łączenie wielu elementów przecinkami w print() działa, ale szybko robi się niewygodne. Python ma wygodniejsze sposoby formatowania napisów.

f-stringi (zalecany sposób)

f-string to napis poprzedzony literą f. W klamrach {} można wstawić zmienne lub wyrażenia.

imie = "Ania"
wiek = 20

komunikat = f"Cześć, {imie}! Masz {wiek} lat."
print(komunikat)

print(f"Za rok będziesz mieć {wiek + 1} lat.")

Można też używać prostego formatowania liczb:

pi = 3.1415926535
print(f"Pi w przybliżeniu: {pi:.2f}")   # 2 miejsca po przecinku

Metoda format() – starsza, ale nadal używana

imie = "Bartek"
punkty = 95

tekst = "Uczeń {} zdobył {} punktów.".format(imie, punkty)
print(tekst)

Słowniki – pary klucz–wartość

Lista przechowuje elementy pozycjami (0, 1, 2, …). Słownik (dict) przechowuje dane w parach klucz–wartość. Zamiast numeru indeksu używa się klucza, najczęściej napisu.

osoba = {
    "imie": "Kasia",
    "wiek": 28,
    "miasto": "Gdańsk"
}

print(osoba["imie"])
print(osoba["wiek"])

Dodawanie i zmiana:

osoba["zawod"] = "programistka"   # dodanie nowego klucza
osoba["wiek"] = 29               # zmiana wartości

print(osoba)

Iteracja po słowniku:

for klucz in osoba:
    print(klucz, "=>", osoba[klucz])

for klucz, wartosc in osoba.items():
    print(klucz, "=>", wartosc)

Słowniki dobrze sprawdzają się tam, gdzie dane mają „nazwane pola”: konfiguracja programu, dane kontaktowe, proste rekordy.

Prosty przykład: mini-baza kontaktów

Połączenie słowników, list i pętli daje już coś całkiem użytecznego, nawet jeśli nadal jest to konsola.

kontakty = []

def dodaj_kontakt():
    imie = input("Imię: ")
    telefon = input("Telefon: ")
    email = input("Email: ")

    kontakt = {
        "imie": imie,
        "telefon": telefon,
        "email": email
    }
    kontakty.append(kontakt)
    print("Dodano kontakt.n")

def wyswietl_kontakty():
    if not kontakty:
        print("Brak kontaktów.n")
        return

    print("Twoje kontakty:")
    for k in kontakty:
        print(f"- {k['imie']}: tel. {k['telefon']}, email: {k['email']}")
    print()

while True:
    print("Menu:")
    print("1 - dodaj kontakt")
    print("2 - pokaż kontakty")
    print("3 - zakończ")
    wybor = input("Wybierz opcję: ")

    if wybor == "1":
        dodaj_kontakt()
    elif wybor == "2":
        wyswietl_kontakty()
    elif wybor == "3":
        print("Koniec programu.")
        break
    else:
        print("Nieznana opcja.n")

Taki program nie jest efektowny wizualnie, ale rozwiązuje konkretny problem. Łatwo go rozbudować o zapisywanie do pliku albo wyszukiwanie kontaktu po imieniu.

Importowanie modułów – korzystanie z gotowych narzędzi

W standardowej bibliotece Pythona jest wiele modułów, które oszczędzają pisania żmudnego kodu. Żeby z nich skorzystać, używa się import.

import math

print(math.sqrt(16))       # pierwiastek
print(math.pi)             # liczba pi
print(math.sin(math.pi))   # sinus pi

Można też importować wybrane funkcje:

from random import randint, choice

print(randint(1, 10))           # losowa liczba z zakresu 1..10

kolory = ["czerwony", "zielony", "niebieski"]
print(choice(kolory))           # losowy element listy

Przykład: ulepszona gra w zgadywanie liczby z modułem random.

import random

tajna_liczba = random.randint(1, 20)
proby = 0

print("Zgadnij liczbę od 1 do 20.")

while True:
    proby += 1
    propozycja = int(input("Twoja liczba: "))

    if propozycja < tajna_liczba:
        print("Za mało.")
    elif propozycja > tajna_liczba:
        print("Za dużo.")
    else:
        print(f"Brawo! Zgadłeś w {proby} próbach.")
        break

Podstawy pracy z plikami – zapisywanie danych

Do wielu małych narzędzi przydaje się zapisywanie danych między uruchomieniami programu. Pierwszy krok to proste pliki tekstowe.

# zapis do pliku
with open("dane.txt", "w", encoding="utf-8") as plik:
    plik.write("Linia pierwszan")
    plik.write("Linia drugan")

# odczyt z pliku
with open("dane.txt", "r", encoding="utf-8") as plik:
    zawartosc = plik.read()

print("Zawartość pliku:")
print(zawartosc)

Instrukcja with dba o poprawne otwarcie i zamknięcie pliku, nawet jeśli po drodze pojawi się błąd. Tryb "w" nadpisuje plik, "a" dopisuje na koniec, a "r" służy do odczytu.

Odczyt wiersz po wierszu:

with open("dane.txt", "r", encoding="utf-8") as plik:
    for linia in plik:
        print("Linia:", linia.strip())

Prosty „dziennik” – łączenie funkcji, pętli i plików

Przykład małego narzędzia, które pozwala zapisywać notatki w jednym pliku tekstowym:

NAZWA_PLIKU = "notatki.txt"

def dodaj_notatke():
    tekst = input("Wpisz notatkę: ")
    with open(NAZWA_PLIKU, "a", encoding="utf-8") as plik:
        plik.write(tekst + "n")
    print("Zapisano.n")

def pokaz_notatki():
    print("n=== Twoje notatki ===")
    try:
        with open(NAZWA_PLIKU, "r", encoding="utf-8") as plik:
            numer = 1
            for linia in plik:
                print(f"{numer}. {linia.strip()}")
                numer += 1
    except FileNotFoundError:
        print("Brak notatek (plik jeszcze nie istnieje).")
    print()

while True:
    print("1 - dodaj notatkę")
    print("2 - pokaż notatki")
    print("3 - wyjście")
    wybor = input("Wybierz opcję: ")

    if wybor == "1":
        dodaj_notatke()
    elif wybor == "2":
        pokaz_notatki()
    elif wybor == "3":
        break
    else:
        print("Nieznana opcja.n")

Pojawia się tu pierwszy przykład obsługi błędu – sytuacji, w której plik jeszcze nie istnieje. try/except to temat na osobną, obszerniejszą sekcję, ale już teraz widać, jak może wyglądać prostsze zabezpieczenie programu.

Co dalej ćwiczyć – pomysły na własne mini-projekty

Najbardziej rozwijają krótkie, konkretne programy, które robią coś przydatnego albo po prostu sprawiają frajdę. Kilka propozycji do samodzielnego rozbudowania:

• kalkulator czasu – podajesz dystans i czas biegu, program wylicza tempo; można dopisać średnią z kilku treningów,
• lista zadań (to-do) w konsoli – dodawanie, usuwanie i oznaczanie zadań jako wykonane, przechowywanie w pliku,
• generator haseł – losuje bezpieczne hasła z liter, cyfr i znaków specjalnych z możliwością wyboru długości,
• proste quizy – pytania i odpowiedzi w słowniku lub pliku, losowe pytania, podsumowanie punktów.

Każdy z takich pomysłów można pisać małymi krokami: najpierw sama logika w kilku linijkach, potem pętla menu, następnie zapisywanie do pliku, a na końcu „szlifowanie” komunikatów i obsługa nietypowych sytuacji.

Najczęściej zadawane pytania (FAQ)

Czy Python to dobry pierwszy język programowania dla początkujących?

Tak, Python jest uznawany za jeden z najlepszych języków na start. Ma prostą, czytelną składnię, która przypomina zapis w języku angielskim, dzięki czemu możesz skupić się na logice programu, a nie na skomplikowanych zasadach technicznych.

Dodatkowo Python ma ogromną społeczność i dużo darmowych materiałów do nauki. Oznacza to, że większość typowych problemów początkujących została już dobrze opisana i łatwo znaleźć gotowe rozwiązania oraz odpowiedzi na pytania.

Do czego mogę wykorzystać Pythona oprócz nauki programowania?

Python jest pełnoprawnym językiem używanym w wielu dziedzinach, więc to, czego się nauczysz, przydaje się także zawodowo. Stosuje się go m.in. w analizie danych, uczeniu maszynowym, tworzeniu stron internetowych i automatyzacji powtarzalnych zadań.

• analiza danych i data science (pandas, NumPy, Jupyter Notebook),
• sztuczna inteligencja i uczenie maszynowe (TensorFlow, PyTorch, scikit-learn),
• tworzenie aplikacji webowych (Django, Flask, FastAPI),
• automatyzacja zadań i skrypty (np. obsługa plików, raportów, integracje firmowe).

Jak sprawdzić, czy Python jest już zainstalowany na moim komputerze?

Na Windows otwórz Wiersz polecenia (cmd) lub PowerShell i wpisz: python --version. Jeśli zobaczysz numer wersji (np. Python 3.11.2), to znaczy, że Python jest zainstalowany. Jeśli pojawi się błąd, spróbuj jeszcze: py --version.

Na macOS i Linux otwórz Terminal i wpisz: python3 --version. Jeśli pojawi się numer wersji z linii 3.x, możesz spokojnie zaczynać naukę. W przypadku wersji 2.x warto zainstalować nowszą „trójkę”.

Jak zainstalować Pythona krok po kroku na Windows?

Wejdź na stronę python.org i pobierz instalator dla Windows. Po uruchomieniu instalatora koniecznie zaznacz opcję Add Python 3.x to PATH, a następnie wybierz Install Now.

Po zakończeniu instalacji otwórz Wiersz polecenia i wpisz python --version lub py --version, aby sprawdzić, czy system poprawnie widzi Pythona. Jeśli zapomnisz zaznaczyć PATH, możesz ponownie uruchomić instalator i naprawić instalację.

Jakie środowisko do Pythona wybrać na początek: IDE czy prosty edytor?

Na start wystarczy prosty edytor tekstu z podświetlaniem składni, np. VS Code, Sublime Text czy Notepad++ na Windows. Rozbudowane IDE (np. PyCharm) może początkowo przytłaczać dużą liczbą opcji i ustawień.

Początkującym zaleca się pisanie kodu w edytorze i uruchamianie programów z terminala lub wiersza poleceń. Dzięki temu lepiej rozumiesz, co naprawdę dzieje się „pod maską”, co procentuje przy dalszej nauce.

Jak uruchomić pierwszy program w Pythonie – w REPL i z pliku .py?

Tryb interaktywny (REPL) uruchomisz, wpisując w terminalu: python (lub python3 na macOS/Linux). Po pojawieniu się znaku zachęty >>> możesz wpisywać pojedyncze polecenia i od razu widzieć wynik. To świetne miejsce na pierwsze eksperymenty bez stresu.

Aby uruchomić program z pliku, utwórz plik o rozszerzeniu .py (np. hello.py), wpisz w nim kod, zapisz, a następnie w terminalu przejdź do katalogu z plikiem i wpisz: python hello.py (lub python3 hello.py). W ten sposób zaczniesz pracę tak, jak robią to „prawdziwi” programiści.

Czym Python różni się od Javy i C/C++ na etapie nauki?

Python ma znacznie prostszą składnię – nie potrzebujesz klas ani funkcji main, aby uruchomić pierwszy program. Wiele rzeczy, które w Javie czy C/C++ wymagają kilku–kilkunastu linii, w Pythonie zapiszesz w 2–3 linijkach, co ułatwia start.

Java i C/C++ dają dużo kontroli nad szczegółami działania programu, ale wymagają od razu zrozumienia większej ilości pojęć technicznych (typy, wskaźniki, kompilacja, klasy). Python pozwala szybciej zobaczyć efekty swojej pracy, co jest bardzo motywujące na początku nauki.

Najważniejsze punkty

• Python jest idealny dla początkujących, bo ma prostą, czytelną składnię, przypominającą język naturalny, co zmniejsza stres i chaos typowy przy pierwszym kontakcie z programowaniem.
• Brak konieczności używania średników, nawiasów klamrowych i ręcznego określania typów zmiennych pozwala skupić się na logice programu zamiast na zawiłościach składni.
• Python umożliwia bardzo szybkie przejście od „nic nie umiem” do „mam działający program”, co silnie motywuje do dalszej nauki, zarówno samodzielnej, jak i na kursach czy w szkole.
• Język ma szerokie, realne zastosowania zawodowe: od analizy danych i sztucznej inteligencji, przez tworzenie aplikacji webowych, po automatyzację i testowanie oprogramowania.
• W porównaniu z Javą i C/C++ Python wymaga mniej kodu na pierwszy program, prostszej instalacji i mniej złożonej składni, zachowując jednocześnie dużą moc i elastyczność.
• Sprawdzenie i instalacja Pythona są stosunkowo proste na wszystkich systemach (Windows, macOS, Linux), a kluczowe jest poprawne skonfigurowanie ścieżki (PATH), szczególnie w systemie Windows.