W poniższym przykładzie wypisany zostanie tylko jeden z komunikatów. Jeśli zmienna będzie równa 0, kod wykona się tylko w części instrukcji warunkowej następującej po if. Dla każdego innego przypadku, jeśli zmienna nie będzie równa 0, wykona się kod zawarty po słowie kluczowym else.

W tym przypadku wypisany komunikat to: Zmienna równa się zero.

zmienna = 0

if zmienna == 0:
    print("Zmienna równa się zero")
else:
    print("Zmienna jest różna od zera")
    
# Efekt działania programu:
# Zmienna równa się zero

Po zmianie wartości zmiennej na 1, wyświetli się komunikat Zmienna jest różna od zera.

zmienna = 1

if zmienna == 0:
    print("Zmienna równa się zero")
else:
    print("Zmienna jest różna od zera")
    
# Efekt działania programu:
# Zmienna jest różna od zera

W przykładzie wypisany zostanie tylko jeden z komunikatów, mimo że dla zmiennej równej 50 prawdziwym jest, że liczba ta jest większa i od 0 i od 10 (oba warunki postawione przy słowie elif). Gdy wartość zmiennej nie będzie większa bądź równa 100 (pierwszy warunek), wykona się jedynie instrukcja podana dla pierwszego spełnionego warunku, a reszta nie będzie już sprawdzana.

zmienna = 50
if zmienna >= 100:
    print("Liczba jest większa bądź równa 100")
elif zmienna >= 10:
    print("Liczba jest większa bądź równa 10, ale mniejsza niż 100")
elif zmienna >= 0:
    print("Liczba jest większa bądź równa 0, ale mniejsza niż 10")
else: 
    print("Liczba jest mniejsza od zera")
        
# Efekt działania programu:
# Liczba jest większa bądź równa 10, ale mniejsza niż 100

Po zmianie wartości zmiennej na liczbę ujemną, np. -50, wykona się instrukcja po słowie else (w przeciwnym razie), ponieważ żaden z wcześniej postawionych warunków nie został spełniony.

zmienna = -50
if zmienna >= 100:
    print("Liczba jest większa bądź równa 100")
elif zmienna >= 10:
    print("Liczba jest większa bądź równa 10, ale mniejsza niż 100")
elif zmienna >= 0:
    print("Liczba jest większa bądź równa 0, ale mniejsza niż 10")
else: 
    print("Liczba jest mniejsza od zera")
        
# Efekt działania programu:
# Liczba jest mniejsza od zera

W poniższym przykładzie zostaną wypisane dwa komunikaty.

Najpierw sprawdzany jest warunek, czy liczba jest parzysta (czyli czy reszta z dzielenia przez 2 wynosi 0). Jeśli ten warunek jest spełniony, sprawdzamy, czy parzysta liczba jest większa bądź równa 0. Jeśli tak to wypisywany jest komunikat Liczba jest większa bądź równa 0, a w każdym innym przypadku (czyli dla liczb ujemnych) wypisujemy komunikat Liczba jest mniejsza od 0.

zmienna = -10

if zmienna % 2 == 0:
    print("Liczba jest parzysta")
    
    if zmienna >= 0:
        print("Liczba jest większa bądź równa 0")
        
    else:
        print("Liczba jest mniejsza od 0")
        
else:
    print("Liczba jest nieparzysta")
    
# Efekt działania programu:
# Liczba jest parzysta
# Liczba jest mniejsza od 0

Po zmianie wartości zmiennej na -7, liczba nie jest już parzysta, zatem nie spełnia pierwszego warunku (reszta z dzielenia przez 2 nie wynosi 0). W konsekwencji program przechodzi do wykonania instrukcji zapisanych po słowie kluczowym else. Jeśli liczba nie jest parzysta, nie są sprawdzane dodatkowe warunki.

zmienna = -7

if zmienna % 2 == 0:
    print("Liczba jest parzysta")
    
    if zmienna >= 0:
        print("Liczba jest większa bądź równa 0")
        
    else:
        print("Liczba jest mniejsza od 0")
        
else:
    print("Liczba jest nieparzysta")
    
# Efekt działania programu:
# Liczba jest nieparzysta

Chcemy sprawdzić, czy dana liczba całkowita przechowywana w zmiennej należy do jednego z podanych przedziałów. Program powinien wyświetlić tylko jeden komunikat.

Możemy to zrobić za pomocą zagnieżdżonych instrukcji warunkowych. Dla wartości zmiennej równej 20 program przejdzie przez kolejne zagnieżdżenia instrukcji warunkowych if...else i wyświetli wyłącznie przedostatni komunikat informujący, że wartość zmiennej należy do drugiej dziesiątki.

zmienna = 20

if zmienna <= 0:
    print("Liczba jest ujemna lub równa 0")
else:  
    if zmienna <= 10:
        print("Liczba należy do przedziału <1; 10>.")
    else:
        if zmienna <= 20:
            print("Liczba należy do przedziału <11; 20>.")
        else:
            print("Liczba jest większa niż 20.")

Mimo że powyższy kod jest w pełni poprawny i działa tak, jak tego oczekujemy, nie jest to zalecany sposób stosowania zagnieżdżonych instrukcji warunkowych. Ten sam program można napisać za pomocą konstrukcji if...elif...else, a jej zastosowanie jest bardziej zwięzłe i łatwiejsze do odczytania, szczególnie gdy mamy wiele warunków do sprawdzenia.

Poniższy kod wykonuje dokładnie tą samą procedurę, ale ze zwiększoną przejrzystością działania.

zmienna = 20

if zmienna <= 0:
    print("Liczba jest ujemna lub równa 0")
elif zmienna <= 10:
    print("Liczba należy do przedziału <1; 10>.")
elif zmienna <= 20:
    print("Liczba należy do przedziału <11; 20>.")
else:
    print("Liczba jest większa niż 20.")

Przykład instrukcji warunkowej w życiu codziennym: jeśli pogoda jest deszczowa, weź parasol. W języku programowania wprowadzamy i sprawdzamy warunek, używając operatora relacjioperator relacjioperatora relacji. Zapoznajmy się z przykładowym warunkiem w środowisku blokowym Scratch.

RWEja9a6Vpimq

Schemat blokowy w Scratch

W języku Python zapisujemy to w następujący sposób:

pogoda = "deszcz"
if pogoda == "deszcz":
    print("weź parasol")

Możesz urchomić ten kod w środowisku IDLEIDLEIDLE.

RD7Avty9qWE4X

Wykonanie kodu w IDLE

Chcemy sprawdzić, jak duża jest podana liczba. Sprawdzimy, czy liczba spełnia warunki:

• liczba >= 100;

• liczba ∈ <10; 100);

• liczba ∈ <0, 10).

Przyjmujemy, że sprawdzana liczba to 5.

Jest ona jedynie większa albo równa 0.

O liczbie 200 możemy powiedzieć, że jest większa albo równa 100, większa albo równa 10 i  większa albo równa 0. Natomiast tak naprawdę wystarczyłoby stwierdzenie, że jest  większa albo równa 100, ponieważ oznacza to również, że jest większa od 10 oraz 0.

W zależności od użytej instrukcji warunkowej w języku Python możemy prześledzić dwa różne wyniki działania programu, związane z kolejnością zapisanych warunków oraz konstrukcją instrukcji warunkowej.

Przeanalizujmy zaprezentowany kod.

W poniższym przypadku stosujemy konstrukcję if...elif:

liczba = 50
if liczba >= 100:
    print("Liczba jest większa bądź równa 100")
elif liczba >= 10:
    print("Liczba jest większa bądź równa 10, ale mniejsza niż 100")
elif liczba >= 0:
    print("Liczba jest większa bądź równa 0, ale mniejsza niż 10")
        
# Efekt działania programu:
# Liczba jest większa bądź równa 10, ale mniejsza niż 100

Program wypisze wyłącznie jeden komunikat ze względu na zastosowaną konstrukcję instrukcji warunkowej if... elif.  W kodzie sprawdzane są kolejno zapisane warunki, aż do momentu napotkania pierwszego, którego wartość wynosi True. Wówczas wykonywany jest blok instrukcji zapisany po dwukropku i instrukcja kończy swoje działanie bez sprawdzania pozostałych warunków. Zmienna liczba o przypisanej wartości 50 nie jest większa albo równa 100, więc program przechodzi do sprawdzania kolejnego warunku. Zadana wartość zmiennej jest większa albo równa 10, więc instrukcja warunkowa zakończy sprawdzanie warunków po pierwszym przypadku spełnienia warunku.

W kolejnym przykładzie instrukcję if...elif zastępujemy trzema instrukcjami warunkowymi if:

liczba = 50
if liczba >= 100:
    print("Liczba jest większa bądź równa 100")
if liczba >= 10:
    print("Liczba jest większa bądź równa 10, ale mniejsza niż 100")
if liczba >= 0:
    print("Liczba jest większa bądź równa 0, ale mniejsza niż 10")
        
# Efekt działania programu:
# Liczba jest większa bądź równa 10, ale mniejsza niż 100
# Liczba jest większa bądź równa 0, ale mniejsza niż 10

Zapoznajmy się z różnicami w działaniu obu programów. W przypadku kilku instrukcji if następujących po sobie wszystkie instrukcje są wykonywane, a każdy warunek jest sprawdzany indywidualnie. W kolejnych instrukcjach sprawdzane są warunki niezależnie od pozostałych bloków instrukcji, co oznacza, że wypisane zostaną dwa komunikaty, ponieważ zmienna liczba równa się 50, czyli jest większa i od 10, i od 0, a więc spełnia warunki zapisane w drugiej i trzeciej instrukcji if.

Zwróć uwagę, że ze względu na odmienne działanie konstrukcji złożonej z trzech niezależnych od siebie instrukcji warunkowych if w powyższym przykładzie błędne stały się wyświetlane komunikaty – liczba 50 jest większa od 0, ale nie jest mniejsza niż 10. Kod nie działa zgodnie z założeniami.

Aby program działał poprawnie bez zmiany treści komunikatów, należy użyć instrukcji warunkowych if, zatem należy poprawić warunki. W tym celu użyjemy słowa kluczowego and pozwalającego łączyć wyrażenia logiczne.

liczba = 50
if liczba >= 100:
    print("Liczba jest większa bądź równa 100")
if liczba >= 10 and liczba < 100:
    print("Liczba jest większa bądź równa 10, ale mniejsza niż 100")
if liczba >= 0 and liczba < 10:
    print("Liczba jest większa bądź równa 0, ale mniejsza niż 10")
        
# Efekt działania programu:
# Liczba jest większa bądź równa 10, ale mniejsza niż 100

Operator and zwraca wartość True tylko wtedy, gdy wszystkie połączone wyrażenia są prawdziwe. Jeśli którekolwiek z wyrażeń jest fałszywe, cała instrukcja warunkowa zwraca False. Wartość zmiennej liczba równa 50 nadal nie jest większa od 100, dlatego pierwszy komunikat nie zostanie wyświetlony.

Druga instrukcja warunkowa zwróci wartość True, ponieważ 50 jest większe albo równe 10 oraz (and) jest mniejsze od 100. Jak widzimy, oba warunki są spełnione, zatem drugi komunikat zostanie wyświetlony.

W ostatniej instrukcji warunkowej prawdziwy jest wyłącznie pierwszy warunek, ponieważ 50 jest większe bądź równe 0, ale nie jest mniejsze od 10. Zgodnie ze sposobem działania operatora and, jeśli którekolwiek z wyrażeń jest fałszywe, cała instrukcja warunkowa jest fałszywa, a więc jej kod wewnętrzny nie zostanie wykonany.

Bankomaty wykorzystują różne technologie do przetwarzania transakcji, technologię kryptograficzną do zapewnienia bezpieczeństwa transakcji i technologię sieci komputerowych do komunikacji z centralą banku. Wewnątrz bankomatu znajduje się komputer, którego program musi podjąć wiele decyzji na podstawie dostarczonych informacji, np.:

• w jakim języku wyświetlać komunikaty,

• czy włożona karta jest prawidłowa,

• czy karta nie jest zastrzeżona,

• czy podaliśmy prawidłowy PIN do karty,

• czy kwota, którą chcemy wypłacić, jest mniejsza niż saldo konta,

• czy kwota, którą chcemy wypłacić, jest mniejsza niż limity wypłat jednorazowych lub dziennych,

• czy kwota, którą chcemy wypłacić, jest możliwa do wypłaty (czy w bankomacie są banknoty),

• jakimi banknotami wydać kwotę.

Pomińmy trzy pierwsze punkty z listy. By wypłacić środki, zaczynamy od podania numeru PIN. Jeśli będzie poprawny, kolejne warunki będą sprawdzane. Jeśli nie będzie poprawny, działanie programu zostanie przerwane.

Spróbujmy przygotować odpowiednie instrukcje w środowisku Scratch, zakładając, że poprawny PIN to 1234:

RXzAQeYCpPAS3

Schemat blokowy w Scratch.

Zapiszmy odpowiednie instrukcje również w języku Python. Wczytamy PIN z klawiatury funkcją input() i porównamy z poprawnym, używając odpowiedniego operatora relacjioperator relacjioperatora relacji:

podany_pin = input("Proszę podać PIN: ")

if podany_pin == "1234":
    print("PIN prawidłowy.")
else:
    print("Podano BŁĘDNY PIN")

Rozważmy przykład karty bankomatowej, która pozwala na wypłacanie różnych sum pieniędzy w zależności od użytego numeru PIN, np.:

• dla numeru PIN 1234 maksymalna kwota to 100 zł,

• dla numeru PIN 2345 maksymalna kwota to 300 zł,

• dla numeru PIN 3374 maksymalna kwota to 500 zł,

• dla numeru PIN 1034 maksymalna kwota to 700 zł.

Dla każdego innego numeru PIN należy wypisać informację o błędnym numerze PIN.

W ten sposób sterujemy wykonywaniem programu. Jeśli warunekwarunek logicznywarunek będzie spełniony, wykonamy pewien blok instrukcji. Warunekwarunek logicznyWarunek sprawdzamy do pierwszego spełnionego warunku if lub elif, a jeśli nie będzie spełniony w żadnym z przypadków – wtedy wykonamy blok instrukcji else.

Przykładowy program w  Scratch, który zrealizuje takie założenia:

RIcwIK6XBKq9V

Program w Scratch.

Przykładowy kod w języku Python, który realizuje takie założenia:

podany_pin = input("Proszę podać PIN: ")

if podany_pin == "1234":
    print("Możesz wypłacić maksymalnie 100 zł.")
elif podany_pin == "2345":
    print("Możesz wypłacić maksymalnie 300 zł.")
elif podany_pin == "3374":
    print("Możesz wypłacić maksymalnie 500 zł.")
elif podany_pin == "1034":
    print("Możesz wypłacić maksymalnie 700 zł.")
else:
    print("Błędny PIN.")

Poprawna jest również inna kolejność warunków elif.

Wróćmy do bankomatu, tym razem ignorując ograniczenia nałożone na PIN. Przedstawmy za pomocą listy kroków algorytm wypłaty pieniędzy z bankomatu:

1. Pobieramy od użytkownika PIN.

2. Jeśli podany PIN jest błędny – wypisujemy odpowiedni komunikat i kończymy działanie.

3. Jeśli PIN jest poprawny, pobieramy od użytkownika kwotę do wypłaty.

4. Jeśli kwota pobrana od użytkownika w kroku 3 jest mniejsza albo równa dostępnej na koncie użytkownika, przechodzimy do kroku 5. W innym przypadku wypisujemy odpowiedni komunikat i kończymy działanie.

5. Jeśli kwota pobrana od użytkownika w kroku 3 jest mniejsza albo równa dostępnej w bankomacie, przechodzimy do kroku 6. W innym przypadku wypisujemy odpowiedni komunikat i kończymy działanie.

6. Jeśli kwota pobrana od użytkownika w kroku 3 jest możliwa do wypłaty dostępnymi banknotami w bankomacie, przechodzimy do kroku 7. W innym przypadku wypisujemy odpowiedni komunikat i kończymy działanie.

7. Wypłacamy kwotę pobraną od użytkownika w kroku 3 i kończymy działanie.

Listę kroków możemy zapisać za pomocą skryptu w środowisku Scratch. Pamiętajmy, że zmienne zawierające stan naszego konta i ilość pieniędzy w bankomacie to tylko przykłady. Zauważmy, że kolejne bloki sterujące znajdują się wewnątrz innych – zagnieżdżamy je.

R184IyH7Wxfdn

Bloki w środowisku Scratch

Sprawdźmy teraz, w jaki sposób możemy przygotować kod w języku Python, aby zrealizować taki algorytm:

stan_konta = 900
stan_bankomatu = 2500
odpowiednie_banknoty = True

podany_pin = input("Podaj PIN: ")

if podany_pin == "1234":
    print("PIN prawidłowy.")
    # PIN prawidłowy, wykonujemy dalsze instrukcje
    kwota = int(input("Podaj kwotę do wypłaty: "))
    if stan_konta >= kwota:
        # Stan konta pozwala wypłacić pieniądze
        print("Masz odpowiednią sumę na koncie.")
        if stan_bankomatu >= kwota:
            # W bankomacie są pieniądze
            print("Bankomat ma odpowiednie środki.")
            if odpowiednie_banknoty == True:
                # W bankomacie są odpowiednie banknoty
                print("Wypłacamy banknoty z bankomatu.")
            else:
                print("Brak odpowiednich banknotów.")
        else:
            print("Bankomat nie ma wystarczającej kwoty pieniędzy.")
    else:
        print("Nie masz wystarczających środków.")
else:
    print("Podano BŁĘDNY PIN.")
    

W kolejnych krokach sprawdzamy różne warunki.

Uruchom program w środowisku IDLEIDLEIDLE. Pamiętaj, by użyć trybu skryptowego, zapisując program w pliku, np. if_pin_01.py.

R4ldeN9HPxkJK

Wykonanie skryptu w IDLE

wydzielona grupa instrukcji przyporządkowana do nadrzędnego elementu

ang. Integrated Development and Learning Environment; środowisko do zapisywania i uruchamiania programów napisanych w języku Python

operator, który porównuje dwa wyrażenia lub wartości i zwraca wartość logiczną prawda (True) albo fałsz (False)

wyrażenie, które przyjmuje wartość logiczną prawda (True) lub fałsz (False); w języku Python odpowiadają im wartości liczbowe 1 oraz 0

sprawdzenie, czy liczba jest parzysta, czyli czy reszta z dzielenia przez 2 wynosi 0