łatwyProgramowaniePythonC++

Instrukcje Warunkowe (IF, ELSE) na Maturze z Informatyki

10 min czytania

Python, C++

Zaktualizowano: 3.11.2025

Instrukcje warunkowe to absolutny fundament programowania. To 'mózg' Twojego kodu, który pozwala mu podejmować decyzje. Działa to dokładnie tak jak w życiu: 'JEŚLI (if) pada deszcz, TO weź parasol, W PRZECIWNYM RAZIE (else) weź okulary słoneczne'. Komputer bez instrukcji `if` jest jak kalkulator – potrafi tylko liczyć po kolei. Dopiero `if` pozwala mu reagować na różne sytuacje, filtrować dane i implementować jakąkolwiek logikę. Każdy algorytm, który rozwiązuje jakikolwiek problem, jest zbudowany na instrukcjach warunkowych.

Dlaczego to ważne? Nie da się napisać *żadnego* programu maturalnego bez `if`. Ta instrukcja jest używana dosłownie wszędzie: do sprawdzania, czy liczba jest parzysta (`if n % 2 == 0`), czy hasło jest poprawne, czy wczytana z pliku liczba spełnia kryteria zadania (`if liczba > 100`), czy znaleźliśmy nowy największy element (`if nowa > max`). To podstawowe narzędzie do filtrowania, sprawdzania i sterowania przepływem programu.

Teoria

Instrukcja `if` sprawdza, czy dany *warunek logiczny* jest prawdziwy (`True`) czy fałszywy (`False`). Jeśli jest prawdziwy, wykonuje blok kodu pod nią. Opcjonalnie można dodać blok `else`, który wykona się, gdy warunek jest fałszywy. Aby sprawdzić wiele warunków po kolei, używamy `elif` (w Pythonie) lub `else if` (w C++).

Jak to działa?

`if [warunek]:` (Python) lub `if ([warunek])` (C++) - Sprawdza warunek. Jeśli `True`, wykonuje kod w bloku.
Warunek to dowolne wyrażenie, które zwraca `True` lub `False`, np. `x > 10`.
Do tworzenia warunków używasz operatorów porównania: `==` (czy równe?), `!=` (czy różne?), `>`, `<`, `>=`, `<=`.
Do łączenia warunków używasz operatorów logicznych: `and` (oba muszą być `True`), `or` (przynajmniej jeden musi być `True`), `not` (zaprzeczenie).
`elif [inny_warunek]:` (Python) lub `else if ([inny_warunek])` (C++) - Sprawdzane *tylko* wtedy, gdy poprzedni `if` lub `elif` był fałszywy. Można ich mieć wiele.
`else:` - Wykonuje się, jeśli *wszystkie* powyższe warunki (`if` i `elif`) były fałszywe. To 'ostatnia deska ratunku'.

Złożoność: Nie dotyczy. Sprawdzenie warunku (np. `x > 10`) jest operacją natychmiastową, o stałym czasie O(1).

Implementacja

Prosty `if-else` (sprawdzanie parzystości)

Python

liczba = 7

if liczba % 2 == 0:
    print(f"{liczba} jest parzysta")
else:
    print(f"{liczba} jest nieparzysta")

# Wynik: 7 jest nieparzysta

To klasyczny przykład. `liczba % 2` daje resztę z dzielenia przez 2. Jeśli reszta `== 0`, liczba jest parzysta. W przeciwnym razie (`else`) jest nieparzysta.

`if-elif-else` (wiele warunków)

Python

punkty = 75

if punkty >= 90:
    print("Ocena: 5")
elif punkty >= 75:
    print("Ocena: 4")
elif punkty >= 50:
    print("Ocena: 3")
else:
    print("Ocena: 2")

# Wynik: Ocena: 4

Python sprawdza warunki po kolei. `punkty >= 90` jest fałszywe. Przechodzi do `elif punkty >= 75`. Ten warunek jest prawdziwy, więc wypisuje 'Ocena: 4' i *przerywa* sprawdzanie reszty (nie sprawdza już `elif punkty >= 50`).

Prosty `if-else` (C++)

C++

#include <iostream>

using namespace std;

int main() {
    int liczba = 7;
    
    if (liczba % 2 == 0) {
        cout << liczba << " jest parzysta" << endl;
    } else {
        cout << liczba << " jest nieparzysta" << endl;
    }
    return 0;
}
// Wynik: 7 jest nieparzysta

Logika jest identyczna jak w Pythonie. Różnice składniowe: warunki są w nawiasach `()`, a bloki kodu w nawiasach klamrowych `{}`.

`if-else if-else` (C++)

C++

#include <iostream>

using namespace std;

int main() {
    int punkty = 75;
    
    if (punkty >= 90) {
        cout << "Ocena: 5" << endl;
    } else if (punkty >= 75) {
        cout << "Ocena: 4" << endl;
    } else if (punkty >= 50) {
        cout << "Ocena: 3" << endl;
    } else {
        cout << "Ocena: 2" << endl;
    }
    return 0;
}
// Wynik: Ocena: 4

W C++ odpowiednikiem `elif` jest `else if`. Działa tak samo - sprawdza warunek tylko, jeśli poprzedni był fałszywy.

Przykładowe Zadania Maturalne

Matura 2026Zadanie Zadanie Typu Maturalnego 1

W pliku 'liczby.txt' znajduje się 200 liczb całkowitych, każda w osobnym wierszu. Napisz program, który policzy, ile z tych liczb jest dodatnich, ile ujemnych, a ile jest równych zero.

Wskazówka: To zadanie na `if-elif-else`. Dla każdej wczytanej liczby 'n' musisz sprawdzić trzy przypadki: `if n > 0`, `elif n < 0` oraz `else` (który obsłuży jedyny pozostały przypadek, czyli `n == 0`).

Pokaż szkic rozwiązania

1. Zainicjuj trzy liczniki: `dodatnie = 0`, `ujemne = 0`, `zera = 0`.
2. Otwórz plik 'liczby.txt' do odczytu.
3. Dla każdej linii w pliku:
   a. Wczytaj liczbę: `n = int(linia.strip())`.
   b. Sprawdź pierwszy warunek: `if n > 0:`
   c. `  dodatnie += 1`
   d. Sprawdź drugi warunek: `elif n < 0:`
   e. `  ujemne += 1`
   f. Obsłuż resztę: `else:`
   g. `  zera += 1`
4. Po pętli wypisz wartości wszystkich trzech liczników.

Matura 2023Zadanie 3.1 (Matura Czerwiec 2023)

W pliku anagram.txt znajdują się liczby binarne. Liczbę binarną nazywamy zrównoważoną, gdy zawiera tyle samo zer i jedynek, natomiast prawie zrównoważoną, gdy liczba jedynek różni się od liczby zer o 1. Podaj, ile jest liczb zrównoważonych oraz ile jest prawie zrównoważonych.

Wskazówka: Dla każdej liczby (wczytanej jako string!) musisz policzyć liczbę zer i jedynek (np. metodą `.count()`). Następnie użyj `if` oraz `elif`, aby sprawdzić te dwa warunki. Pamiętaj, że `abs(ile_jedynek - ile_zer) == 1` sprawdza warunek 'prawie zrównoważenia'.

Pokaż szkic rozwiązania

1. Zainicjuj liczniki: `zrownowazone = 0`, `prawie_zrownowazone = 0`.
2. Otwórz plik 'anagram.txt'.
3. Dla każdej linii w pliku:
   a. Wczytaj napis: `napis = linia.strip()`.
   b. Policz zera i jedynki: `ile_0 = napis.count('0')`, `ile_1 = napis.count('1')`.
   c. Sprawdź pierwszy warunek: `if ile_0 == ile_1:`
   d. `  zrownowazone += 1`
   e. Sprawdź drugi warunek: `if abs(ile_0 - ile_1) == 1:`
   f. `  prawie_zrownowazone += 1`
4. Wypisz `zrownowazone` i `prawie_zrownowazone`.

Częste Błędy

❌ Mylenie operatora przypisania (=) z porównaniem (==)

To klasyczny błąd. `if x = 5:` próbuje *przypisać* 5 do x (co w Pythonie da błąd, ale w C++ może zostać zinterpretowane jako `True`!). `if x == 5:` *porównuje*, czy x jest równe 5.

Poprawka: Do porównań *zawsze* używaj podwójnego znaku równości: `==`.

❌ Błędy wcięć (IndentationError) w Pythonie

W Pythonie wcięcia (spacje/tabulatory) definiują, co jest 'wewnątrz' bloku `if`, a co 'na zewnątrz'. Niewłaściwe wcięcie `else` lub kodu po `if` kompletnie zmienia logikę programu.

Poprawka: Bądź konsekwentny. Używaj zawsze 4 spacji. Kod wewnątrz `if` musi być wcięty. `else` i `elif` muszą być na tym samym poziomie wcięcia co `if`.

❌ Pisanie `if ... if ...` zamiast `if ... elif ...`

Jeśli napiszesz `if punkty > 75: ...` a potem `if punkty > 50: ...`, to dla 80 punktów oba warunki będą prawdziwe i oba bloki się wykonają. `elif` gwarantuje, że wykona się *tylko jeden* blok.

Poprawka: Jeśli warunki się wykluczają (jak w skali ocen), zawsze używaj łańcucha `if-elif-else`.

❌ Błędna składnia łączenia warunków

Uczeń pisze `if x == 1 or 2:`, myśląc, że to znaczy 'jeśli x to 1 lub 2'. To błąd. Python interpretuje to jako `if (x == 1) or (2):`, a `2` jest zawsze `True`.

Poprawka: Zawsze powtarzaj pełny warunek: `if x == 1 or x == 2:`. W C++: `if (x == 1 || x == 2)`.

❌ Python: zapominanie o dwukropku (:)

Częsty błąd składniowy to pominięcie dwukropka na końcu linii `if`, `elif` lub `else`.

Poprawka: Pamiętaj, że `if warunek:`, `elif warunek:`, `else:` zawsze kończą się dwukropkiem.

Kluczowe Wnioski

`if` służy do podejmowania decyzji; wykonuje kod, gdy warunek jest `True`.
`else` wykonuje kod, gdy warunek `if` jest `False`.
`elif` (Python) lub `else if` (C++) służy do sprawdzania wielu wykluczających się warunków po kolei.
Do porównania używaj `==` (równe), a nie `=` (przypisanie).
Do łączenia warunków służą operatory logiczne `and` oraz `or`.
W Pythonie wcięcia (indentacja) są częścią składni i definiują bloki kodu.
W C++ bloki kodu są definiowane przez nawiasy klamrowe `{...}`.

Najczęściej Zadawane Pytania

❓ Jaka jest różnica między `if ... if ...` a `if ... elif ...`?

Dwa osobne `if` są sprawdzane *niezależnie*. `if-elif` to łańcuch. Jeśli `if` jest prawdziwy, `elif` nie jest już sprawdzany. Przykład: dla `x = 10`, kod `if x > 5: print(1); if x > 8: print(2)` wypisze '1' i '2'. Kod `if x > 5: print(1); elif x > 8: print(2)` wypisze tylko '1'.

❓ Co to jest 'zagnieżdżony if'?

To po prostu instrukcja `if` umieszczona wewnątrz innej instrukcji `if`. Pozwala to na bardziej skomplikowaną logikę, np. `if pada_deszcz: if mam_parasol: ... else: ...`.

❓ Czy C++ ma coś takiego jak `elif`?

Tak, to po prostu `else if` (pisane osobno). Działa identycznie jak `elif` w Pythonie.

❓ Jak w Pythonie sprawdzić, czy liczba jest w zakresie?

Python ma bardzo wygodną składnię: `if 10 <= x < 20:`. To jest to samo, co `if x >= 10 and x < 20:`. W C++ musisz użyć pełnego zapisu: `if (x >= 10 && x < 20)`.

❓ Co to jest `switch` w C++?

`switch` to alternatywa dla długiego łańcucha `if-else if-else`, ale działa tylko dla sprawdzania równości jednej zmiennej (zazwyczaj `int` lub `char`). W Pythonie (od wersji 3.10) wprowadzono podobną konstrukcję `match-case`, ale rzadko pojawia się ona na maturze.

Chcesz opanować wszystkie tematy maturalne?

Dołącz do kursu i zyskaj dostęp do interaktywnych lekcji, edytora kodu i setek zadań.