Wielokrotny wybór w języku Python

Podczas tworzenia programu zdarzają się sytuacje, w których potrzebujemy zrealizować jeden z wielu scenariuszy działań.

Przeanalizujmy przykład, gdzie mamy wypisać informację, w którym z następujących przedziałów: $(10,15],(15,21],(21,50]$ zawiera się dana liczba.

Do zrealizowania takiego scenariusza możemy zastosować konstrukcję if/elif/else, ponieważ wybieramy jeden z wielu przedziałów.

Ogólną postać instrukcji znajdziesz w e‑materiale Instrukcja warunkowa w języku PythonPb35akOxSInstrukcja warunkowa w języku Python.

wartosc = 23

if 10 < wartosc and wartosc <= 15:
	print("Przedział 1")
elif wartosc > 15 and wartosc <= 21:
	print("Przedział 2")
elif wartosc > 21 and wartosc <= 50:
	print("Przedział 3")
else:
	print("Liczba nie zawiera się w żadnym z przedziałów")

wartosc = 23

if wartosc > 10 and wartosc <= 15:
    print("Przedział 1")
if wartosc > 15 and wartosc <= 21:
    print("Przedział 2")
if wartosc > 21 and wartosc <= 50:
    print("Przedział 3")
if wartosc <= 10 or wartosc > 50:
    print("Liczba nie zawiera się w żadnym z przedziałów")

def funkcja_1():
	print("Funkcja 1.")

def funkcja_2():
	print("Funkcja 2.")

def funkcja_3():
	print("Funkcja 3.")

def funkcja_x():
	print("Funkcja x.")


wybor = input("Podaj numer: ")
wynik = int(wybor)

if wynik == 1:
	funkcja_1()
elif wynik == 2:
	funkcja_2()
elif wynik == 3:
	funkcja_3()
else:
	funkcja_x()

# Efekt wykonania:

# Podaj numer: 2
# Funkcja 2.

def funkcja_1():
	print("Funkcja 1.")

def funkcja_2():
	print("Funkcja 2.")

def funkcja_3():
	print("Funkcja 3.")

def funkcja_x():
	print("Funkcja x.")


wybor = input("Podaj numer: ")
wynik = int(wybor)

# tworzymy słownik zawierający jako wartości nazwy funkcji
slownik = {1: funkcja_1, 2: funkcja_2, 3: funkcja_3}

# jeśli wybór jest kluczem słownika, wykonujemy funkcję
if wynik in slownik:
	slownik[wynik]()
# w innym przypadku wykonujemy konkretną funkcję
else:
	funkcja_x()

Trójargumentowe wyrażenie wyboru

Używane jest w sytuacjach, gdy wystarczy zwrócić prostą informację zależną od jednego warunku. W takim przypadku rozbudowywanie kodu jest niecelowe.

Oto wyrażenie trójargumentowe zapisane w języku Python:

wartość_gdy_prawda if warunek_logiczny else wartość_gdy_fałsz

Instrukcja taka odpowiada poleceniom:

if warunek_logiczny:
	wartość_gdy_prawda
else:
	wartość_gdy_fałsz

Porównajmy kody dwóch funkcji. Mają one sprawdzić, czy tekst przekazany im jako argument jest palindromem. Sprawdzenie, czy słowo jest palindromem, wykonane jest przy użyciu wyrażenia indeksującego.

Pierwsza funkcja wykorzystuje zwykłą konstrukcję if/else:

def czy_palindrom(tekst):
	if tekst == tekst[::-1]:
		return True
	else:
		return False

Druga funkcja wykorzystuje wyrażenie trójargumentowe:

def czy_palindrom(tekst):
	return True if tekst == tekst[::-1] else False

Obie powyższe funkcje mogą być zapisane również następująco:

def czy_palindrom(tekst):
	return tekst == tekst[::-1]

Innym przykładem zastosowania wyrażenia trójargumentowego jest podanie jednego z dwóch komunikatów, zależnych od spełnienia pewnego warunku. Posłużymy się funkcją print():

wartosc = 15
print('Dużo' if wartosc > 20 else 'Mało', 'pieniędzy.')
# Mało pieniędzy.

wartosc = 23
print('Dużo' if wartosc > 20 else 'Mało', 'pieniędzy.')
# Dużo pieniędzy.

Instrukcja match/case

W wersji 3.10 języka Python została wprowadzona instrukcja match/case. Instrukcja ta jako argument przyjmuje wyrażenie i porównuje jego wartość ze zdefiniowanymi schematami. Jeśli wyrażenie jest zgodne ze zdefiniowanym schematem, wykonywane są związane z nim instrukcje.

Instrukcja match/case zapisana za pomocą języka Python wygląda następująco:

match numer_ucznia:
	case 1:
		# wypisz informacje o uczniu numer 1.
	case 2:
		# wypisz informacje o uczniu numer 2.
	case 3:
		# wypisz informacje o uczniu numer 3.  
	case 4:
		# wypisz informacje o uczniu numer 4.

numerUucznia = 3

match numer_ucznia:
	case 1:
		# wypisz informacje o uczniu numer 1.
	case 2:
		# wypisz informacje o uczniu numer 2.
	case 3:
		# wypisz informacje o uczniu numer 3.  
	case 4:
		# wypisz informacje o uczniu numer 4.

Instrukcja match/case pobiera obiekt (numer_ucznia), testuje go względem jednego lub więcej wzorców dopasowania (case 1, case 2 etc.) i wykonuje akcję, jeśli znajdzie dopasowanie.

Po każdym słowie kluczowym case następuje wzorzec dopasowania.

Python wykonuje dopasowania, przechodząc przez listę przypadków od góry do dołu. Przy pierwszym dopasowaniu Python wykonuje instrukcje w odpowiadającym im bloku przypadków, a następnie przeskakuje na koniec bloku dopasowania i kontynuuje dalszą część programu. Oznacza to, że po znalezieniu pierwszego pasującego przypadku, kończy się działanie instrukcji match/case.

Załóżmy, że chcemy napisać program, który wyświetli komunikat Wakacje!, jeśli użytkownik poda numer wakacyjnego miesiąca (zakładamy, że wakacyjne miesiące to lipiec i sierpień) lub To nie wakacje :-(, jeśli poda numer jakiegokolwiek innego miesiąca.

miesiac = 2

match miesiac:
	case 1:
		print("To nie wakacje :-(")
	case 2:
		print("To nie wakacje :-(")
	case 3:
		print("To nie wakacje :-(")
	case 4:
		print("To nie wakacje :-(")
	case 5:
		print("To nie wakacje :-(")
	case 6:
		print("To nie wakacje :-(")        
	case 7:
		print("Wakacje!")
	case 8:
		print("Wakacje!")
	case 9:
		print("To nie wakacje :-(")
	case 10:
		print("To nie wakacje :-(")
	case 11:
		print("To nie wakacje :-(")
	case 12:
		print("To nie wakacje :-(")

Łączenie warunków

Używając operatora |, oznaczającego alternatywę, możemy łączyć warunki.

miesiac = 2

match miesiac:
	case 1 | 2 | 3 | 4 | 5 | 6 | 9 | 10 | 11 | 12:
		print("To nie wakacje :-(")
	case 7 | 8:
		print("Wakacje!")

Domyślny przypadek

W instrukcji match/case możemy podać przypadek _, który oznacza „w każdym innym przypadku”, czyli jeżeli wartość zmiennej podanej do sprawdzenia nie będzie równa żadnemu z ustawionych przypadków, program wykona fragment kodu zawarty w poleceniu.

Przeanalizuj przykład:

miesiac = 27

match miesiac:
	case 1 | 2 | 3 | 4 | 5 | 6 | 9 | 10 | 11 | 12:
		print("To nie wakacje :-(")
	case 7 | 8:
		print("Wakacje!")
	case _:
		print("Wybrano liczbę spoza przedziału [1, 12]")

Zaawansowane wykorzystanie

Instrukcja match/case pozwala na zdefiniowanie zmiennych lokalnych, które będą dopasowywane do argumentu. Do tych zmiennych lokalnych możemy się odwołać w zasięgu pojedynczej klauzuli case. Co więcej, możemy doprecyzować, kiedy ma się do tych zmiennych wpasować, stosując polecenie if.

Przeanalizujmy następujący program:

def wypisz_informacje(punkt, dziedzina_x=(-9, -1), dziedzina_y=(-4, -1)):
	x1, x2 = dziedzina_x
	y1, y2 = dziedzina_y

	match punkt:
		case (x, y) if x1 < x < x2 and y1 < y < y2:
			print("Punkt: ", punkt, " należy do rozważanej dziedziny")
		case (0, 0):
			print("Punkt: ", punkt, " nie należy do dziedziny, ale jest położony w środku układu współrzędnych")
		case (x, 0):
			print("Punkt: ", punkt, " nie należy do dziedziny, ale jest położony na osi odciętych")
		case (0, y):
			print("Punkt: ", punkt, " nie należy do dziedziny, ale jest położony na osi rzędnych")
		case (_, _):
			print("Punkt: ", punkt, "nie należy do dziedziny")

Funkcja wypisz_informacje przyjmuje trzy parametry: punkt, dziedzina_x, dziedzina_y. Dwa ostatnie mają podane wartości domyślne. Jeśli przy wywoływaniu funkcji do argumentów nie zostaną przekazane nowe wartości, funkcja zostanie wywołana z wartościami domyślnymi.

Widać to przy wywołaniach funkcji – funkcja wypisz_informacje wywoływana jest z jednym argumentem (dwa pozostałe mają przypisane wartości domyślne).

Wartości przekazane do funkcji są krotkami.

W programie definiujemy pewną dziedzinę, która ograniczona jest podanymi wartościami. Zwizualizujmy ją.

Moglibyśmy zdefiniować dwa główne przypadki:

• Punkt należy do rozważanej dziedziny.

• Punkt nie należy do rozważanej dziedziny.

Jeśli punkt miałby należeć do dziedziny, wartość współrzędnej $x$ musiałaby mieścić się w następującym przedziale $[-9, -1]$, a wartość współrzędnej $y$ musiałaby zawierać się w następującym przedziale $[-4, -1]$:

case (x, y) if x1 < x < x2 and y1 < y < y2:

Gdyby punkt nie znajdował się w tym przedziale, nie należałby do dziedziny:

case (x, y) if not (x1 < x < x2 and y1 < y < y2):

Jednak to niejedyny przypadek, jaki możemy zdefiniować. Pozostałe:

• Punkt leży na osi rzędnych.

• Punkt leży na osi odciętych.

• Punkt leży w środku układu współrzędnych.

Jeśli punkt miałby leżeć na osi rzędnych, jego pierwsza współrzędna musiałaby wynosić 0.

case (0, y):

Jeśli punkt miałby leżeć na osi odciętych, jego druga współrzędna musiałaby wynosić 0.

case (x, 0):

Jeśli punkt miałby leżeć w środku układu współrzędnych, obie jego współrzędne musiałyby wynosić 0.

case (0, 0):

Wiemy, że w przypadku instrukcji match/case program kończy działanie instrukcji, kiedy zostanie spełniony pierwszy warunek. Musimy zatem odpowiednio zaplanować ułożenie warunków.

Zacznijmy od sprawdzenia, czy punkt należy do dziedziny. Zatem to ten warunek zostanie zapisany jako pierwszy.

Następnie sprawdźmy, czy punkt leży w środku układu współrzędnych, na rzędnej lub odciętej. Zapiszmy kolejne warunki.

Warto pamiętać, że trzy wspomniane wcześniej przypadki odnoszą się do sytuacji, w której punkt nie należy do dziedziny, ale za to leży na osi współrzędnych. To rozróżnienie również powinno znaleźć się w komunikatach wyświetlanych przez program.

Sprawdziliśmy kilka konkretnych przypadków. Weźmy jednak pod uwagę również taką sytuację, w której punkt nie należy do dziedziny, nie leży w środku układu współrzędnych ani na żadnej osi.

def wypisz_informacje(punkt, dziedzina_x=(-9, -1), dziedzina_y=(-4, -1)):
	x1, x2 = dziedzina_x
	y1, y2 = dziedzina_y

	match punkt:
		case (x, y) if x1 < x < x2 and y1 < y < y2:
			print("Punkt: ", punkt, " należy do rozważanej dziedziny")
		case (0, 0):
			print("Punkt: ", punkt, " nie należy do dziedziny, ale jest położony w środku układu współrzędnych")
		case (x, 0):
			print("Punkt: ", punkt, " nie należy do dziedziny, ale jest położony na osi odciętych")
		case (0, y):
			print("Punkt: ", punkt, " nie należy do dziedziny, ale jest położony na osi rzędnych")
		case (_, _):
			print("Punkt: ", punkt, "nie należy do dziedziny")

Przetestujmy działanie programu dla następujących punktów:

-5, -3
-12, 2
0, 0
3, 0
0, 2

Nanieśmy je na wizualizację:

Wywołajmy funkcję z nimi jako argumentami:

wypisz_informacje((-5, -3))
wypisz_informacje((-12, 2))
wypisz_informacje((0, 0))
wypisz_informacje((3, 0))
wypisz_informacje((0, 2))

Wynik programu:

Punkt:  (-5, -3)  należy do rozważanej dziedziny
Punkt:  (-12, 2) nie należy do dziedziny
Punkt:  (0, 0)  nie należy do dziedziny, ale jest położony w środku układu współrzędnych
Punkt:  (3, 0)  nie należy do dziedziny, ale jest położony na osi odciętych
Punkt:  (0, 2)  nie należy do dziedziny, ale jest położony na osi rzędnych

Słownik