Stosowanie instrukcji iteracyjnej do realizacji algorytmów iteracyjnych w języku Python

Chcemy wyświetlić na ekranie wszystkie elementy listy. Aby zacząć iterowanie po jej elementach, definiujemy zmienną lista.

Zmienna sterująca użyta w pętli for może być nazwana dowolnie. W poniższym wypadku nazywamy ją liczba, ponieważ lista zawiera wyłącznie liczby.

lista = [1, 5, 2, 7, 5]
for liczba in lista:
    print(liczba)
        
    # Efekt działania programu:
    #1
    #5
    #2
    #7
    #5

Podczas pierwszej iteracji zmienna sterująca liczba wynosi 1 (pierwszy element na liście), podczas drugiej jest równa 5, podczas trzeciej 2, podczas czwartej 7, a podczas piątej (ostatniej) 5 (ostatni element na liście).

Zmienna sterująca często nazwana jest i.

lista = ["Ala", "ma", 13, "lat"]
    for i in lista:
        print(i)
        
    # Efekt działania programu:
    #Ala
    #ma
    #13
    #lat

Podczas pierwszej iteracji zmienna sterująca i jest równa Ala, podczas drugiej ma, podczas trzeciej 13, a podczas czwartej, czyli ostatniej, "lat".

Chcemy wyświetlić po kolei wszystkie litery podanego łańcucha znaków. Zmienna zdanie przechowuje łańcuch znaków. Zmienna sterująca w pętli for nazywa się znak. Pętla iteruje po każdym elemencie zmiennej zdanie.

zdanie = "Pętle iteracyjne"
    for znak in zdanie:
        print(znak)
    
# Efekt działania programu:
#P
#ę
#t
#l
#e
# 
#i
#t
#e
#r
#a
#c
#y
#j
#n
#e

Zmienna sterująca znak przyjmuje w każdej iteracji wartość kolejnych znaków łańcucha znaków.

Chcemy wyświetlić liczby całkowite z przedziału <0, 10>. Wykorzystujemy do tego funkcję range.

for i in range(0,11,1):
    print(i)
# Efekt działania programu:
#0
#1
#2
#3
#4
#5
#6
#7
#8
#9
#10

Możemy uprościć zaprezentowany kod. Parametr start w funkcji range domyślnie przyjmuje wartość 0, a krok wartość 1. Jeśli funkcja range otrzyma tylko jeden argument, zostanie uznany za parametr stop.

for element in range(stop):
        # Instrukcje wewnętrzne pętli wykonywane dla każdego elementu zbioru

Zmieniony kod:

for i in range(11):
    print(i)
# Efekt działania programu:
#0
#1
#2
#3
#4
#5
#6
#7
#8
#9
#10

Ponownie zapisujemy program, który wyświetli liczby od 0 do 10. Tym razem wykorzystujemy pętlę while.

Definiujemy zmienną i, której wartość sprawdzamy w warunku logicznym. Zastępujemy nią zmienną sterującą pętli for.

Nadajemy jej wartość 0, ponieważ to początek przedziału, który ma zostać wyświetlony. W każdej iteracji pętli zmienną inkrementujemy o 1. Pętla wykonuje się dopóki wartość zmiennej i jest mniejsza niż 11.

i = 0
while i < 11:
    print(i)
    i = i + 1
# Efekt działania programu:
#0
#1
#2
#3
#4
#5
#6
#7
#8
#9
#10

Zmiennej i wartość początkową przypisujemy przed pętlą, aby określić na podstawie wartości zwracanej przez warunek logiczny zawarty w pętli while, czy pętla ma się wykonać.

Jeśli warunek kontynuacji pętli while zawsze zwraca wartość True, mamy do czynienia z pętlą nieskończoną.

while True:
    print("To jest pętla nieskończona")

Naszym celem jest zmodyfikowanie programu zaprezentowanego w przykładzie 6, by program przerwał działanie pętli, gdy wartość zmiennej i wyniesie 5. W tym celu we wnętrzu pętli while umieszczamy instrukcję warunkową oraz instrukcję break.

i = 1
while i < 11:
    print(i)
    if i == 5:
        break
    i = i + 1
# Efekt działania programu:
#1
#2
#3
#4
#5

Instrukcja warunkowa zawierająca instrukcję break w zaprezentowanym przykładzie znajduje się przed instrukcją zwiększającą wartość zmiennej i. Kolejność instrukcji ma znaczenie. Załóżmy, że zmieniamy kolejność instrukcji print(i) i instrukcji inkrementacji wartości zmiennej i:

i = 1
while i < 11:
    i = i + 1
    if i == 5:
        break
    print(i)

Efekt działania tego programu byłby inny. W pierwszej iteracji program najpierw zwiększy wartość zmiennej i do i = 2, następnie sprawdzi czy wartość i jest równa 5. Warunek nie jest spełniony, więc program przejdzie do wykonania kolejnej instrukcji, czyli wypisze wartość zmiennej i (czyli 2).

W drugiej iteracji zwiększy wartość zmiennej i do 3 i sprawdzi, czy wartość ta jest równa 5. Nie jest, zatem warunek nie jest spełniony – wartość zmiennej i zostaje  wypisana.

W trzeciej iteracji zwiększy wartość zmiennej i do 4. Program ponownie sprawdza, czy wartość jest równa 5. Nie jest, zatem warunek nie jest spełniony; wypisana zostaje wartość zmiennej i.

W czwartej iteracji zwiększy wartość zmiennej i do 5. Program następnie sprawdza, czy wartość jest równa 5. Jest, zatem wykonuje się instrukcja break i pętla zostaje przerwana przed wywołaniem instrukcji print.

W wypadku, gdy zwiększalibyśmy wartość zmiennej i przed instrukcją warunkową, przerwanie pętli nastąpiłoby za wcześnie, nie zostałaby wyświetlona liczba 5.

Zapoznaj się z kodem, w którym wykorzystujemy instrukcję while oraz klauzulę else:

i = 1
while i < 11:
    print(i)
    i = i + 1
else:
    print("Pętla zakończona")
# Efekt działania programu:
#1
#2
#3
#4
#5
#6
#7
#8
#9
#10
#Pętla zakończona

Warto zauważyć, że klauzula else działa wyłącznie wtedy, gdy warunek kontynuacji pętli nie jest spełniony (zwraca wartość False). Użycie instrukcji break jest przedwczesnym wymuszeniem zakończenia pętli, a więc komunikat "Pętla zakończona" nie jest wyświetlony.

i = 1
while i < 11:
    print(i)
    if i == 5:
        break
    i = i + 1
else:
    print("Pętla zakończona")
# Efekt działania programu:
#1
#2
#3
#4
#5

Rozwiązanie wykorzystujące pętlę for

Wynik funkcji jest przechowywany w zmiennej indeks. Na początku tej zmiennej nadajemy wartość -1 (zakładamy, że szukana liczba nie występuje w przeglądanej liście). Następnie tworzymy zmienną i, której przypisujemy wartość 0. Zmienna i przechowuje indeks aktualnie sprawdzanego elementu listy.

Pętla for ze zmienną sterującą element iteruje po kolejnych elementach listy lista. W pętli umieszczona jest instrukcja warunkowa. Instrukcja warunkowa if w pętli sprawdza dwa warunki, które połączone są operatorem and (koniunkcji). Aby instrukcja wewnętrzna została wykonana, muszą być spełnione oba warunki.

Pierwszy warunek to sprawdzenie, czy przeglądany aktualnie element listy jest poszukiwaną wartością przechowywaną w zmiennej szukana.

Drugi warunek to sprawdzenie, czy wartość zmiennej indeks jest równa -1, czyli czy dany element nie został jeszcze znaleziony.

Jeśli oba warunki są prawdziwe, zmiennej indeks przypisywana jest wartość zmiennej i.

Po sprawdzeniu warunku logicznego następuje inkrementacja o 1 zmiennej i.

Funkcja zwraca wartość indeksu szukanego elementu.

def szukaj_element_for(lista, szukana):
    indeks = -1
    i = 0
    
    for element in lista:
        if element == szukana and indeks == -1:
            indeks = i
        i += 1

    return f"Liczba {szukana} - indeks {indeks}"

print("Wersja z pętlą for")
print(szukaj_element_for([2, 3, 3, 3, 2, 4, 6, 7, 7, 8, 2, 4], 4))
print(szukaj_element_for([2, 3, 3, 3, 2, 4, 6, 7, 7, 8, 2, 4], 9))

# przykładowe wyniki
# Wersja z pętlą for
# Liczba 4 - indeks 5
# Liczba 9 - indeks -1

x = 5
x += 3
# x wynosi 8
y = 5
y = y + 3
# y wynosi 8

Zwróć uwagę na to, że pętla wykonuje się nadal po znalezieniu pierwszego wystąpienia elementu. Nie jest to efektywne i nie należy do dobrych praktyk programowania. Aby temu zapobiec, możemy dodać instrukcję break w instrukcji warunkowej if po przypisaniu zmiennej indeks wartości zmiennej i. Usuwamy również drugi warunek z instrukcji warunkowej.

def szukaj_element_for(lista, szukana):
    indeks = -1  
    i = 0  

    for element in lista:
        if element == szukana:
            indeks = i  
            break 
        i += 1 

    return f"Liczba {szukana} - indeks {indeks}"

print("Wersja z pętlą for")
print(szukaj_element_for([2, 3, 3, 3, 2, 4, 6, 7, 7, 8, 2, 4], 4))
print(szukaj_element_for([2, 3, 3, 3, 2, 4, 6, 7, 7, 8, 2, 4], 9))

Rozwiązanie wykorzystujące pętlę while

Zapoznamy się z przykładem rozwiązania tego samego problemu za pomocą pętli while. Pętla iteruje po kolejnych indeksach listy przechowywanej w parametrze lista. W odróżnieniu od pętli for, pętla while nie zatrzyma się sama, gdy skończą się elementy przeglądanej listy, więc do zmiennej dlugosc przypiszemy liczbę elementów listy lista zwróconą przez funkcję len().

Zmienna i będzie przechowywała indeks aktualnie porównywanego elementu listy. Pierwszy element ma indeks równy 0, dlatego też zmiennej i nadajemy wartość 0. Do elementów listy odwołujemy się przez wskazanie pozycji elementu w liście, na przykład by odwołać się do elementu listy lista o indeksie 3, użyjemy instrukcji lista[3].

W ten sposób uzyskamy dostęp do elementu listy na wskazanej pozycji i (lista[i]). Dlatego przed rozpoczęciem iteracji sprawdzamy długość listy przechowywanej w parametrze lista. Ponownie zmienna i przechowuje indeks sprawdzanego elementu.

def szukaj_element_while(lista, szukana):
    indeks = -1
    i = 0
    dlugosc = len(lista)

    while i < dlugosc:
        if lista[i] == szukana and indeks == -1:
            indeks = i
            break
        i += 1
        
    return f"Liczba {szukana} - indeks {indeks}"

print("Wersja z pętlą while")
print(szukaj_element_while([2, 3, 3, 3, 2, 4, 6, 7, 7, 8, 2, 4], 4))
print(szukaj_element_while([2, 3, 3, 3, 2, 4, 6, 7, 7, 8, 2, 4], 9))

# Wersja z pętlą while
# Liczba 4 - indeks 5
# Liczba 9 - indeks -1

Pętla while może zakończyć się w dwóch wypadkach. Pierwszy wypadek to sytuacja, w której po sprawdzeniu całej listy nie znajdujemy szukanego elementu, czyli wartość zmiennej i jest równa liczbie elementów w liście (czyli zmiennej dlugosc). Drugi to sytuacja, w której znajdziemy pierwsze wystąpienie poszukiwanego elementu – pętla zostanie przerwana przez wykonanie instrukcji break.

Pierwszy warunek to sprawdzenie, czy przeglądany aktualnie element listy jest poszukiwaną wartością przechowywaną w zmiennej szukana.

Drugi warunek to sprawdzenie, czy wartość zmiennej indeks jest równa -1, czyli czy dany element nie został jeszcze znaleziony.

Jeśli oba warunki są prawdziwe, zmiennej indeks przypisywana jest wartość zmiennej i, a pętla zostaje przerwana instrukcją break.

Jeśli przynajmniej jeden z warunków nie jest prawdziwy, następuje inkrementacja wartości zmiennej i.

Zadanie to możemy rozwiązać, nie wykorzystując pętli.

def szukaj_element_index(lista, szukana):
    if szukana in lista:
        indeks = lista.index(szukana)
    else:
        indeks = -1
    
    return f"Liczba {szukana} - indeks {indeks}"

print("Wersja z metodą index()")
print(szukaj_element_index([2, 3, 3, 3, 2, 4, 6, 7, 7, 8, 2, 4], 4))
print(szukaj_element_index([2, 3, 3, 3, 2, 4, 6, 7, 7, 8, 2, 4], 9))

# Wersja z metodą index()
# Liczba 4 - indeks 5
# Liczba 9 - indeks -1

Wykorzystujemy metodę index(), która zwraca indeks pierwszego wystąpienia elementu. Najpierw, wykorzystując instrukcję if, sprawdzamy, czy szukana liczba występuje w liście. Jeśli tak, wykorzystujemy metodę index(), by uzyskać indeks jej pierwszego wystąpienia.

Jeśli nie, przypisujemy zmiennej indeks wartość -1, ponieważ liczba nie występuje w liście.

Wczytanie danych:

informacja = input("Podaj informację do przekazania: ")
# sprawdzamy, co wprowadziliśmy
print(informacja)

Oto przykładowe wartości zwracane przez funkcję ord(). Zawsze zwraca ona liczbę naturalną.

#ord(znak) -> kod ASCII

ord("A") -> 65
ord("a") -> 97
ord("ę") -> 281
ord("Ę") -> 280
ord("d") -> 100
ord("m") -> 109

Jeśli obliczymy taką sumę kontrolną dla słowa Adam, wyniesie ona 371. Możemy przy tym zauważyć, że:

• Jeśli zmienimy znak na inny, zmieni się suma kontrolna.

• Jeśli dodamy lub usuniemy znak, zmieni się suma kontrolna.

• Algorytm działa w czasie liniowym, tzn. im dłuższa informacja, tym dłużej trwa jego wykonanie.

#ord(znak) -> kod ASCII

ord("A") -> 65
ord("d") -> 100
ord("a") -> 97
ord("m") -> 109

65 + 100 + 97 + 109 -> 371

Aktualny algorytm traktuje wyrazy bark i krab tak samo, ponieważ sumuje wartości ASCII bez uwzględnienia pozycji znaku w tekście.

Podaj informację: krab
Obliczona suma kontrolna wynosi 416
# zmieniona wiadomość
Podaj informację: bark
Obliczona suma kontrolna wynosi 416

Aby to zmienić, możemy modyfikować wartość znaku na podstawie jego pozycji w tekście. Na przykład możemy pomnożyć wartość ASCII znaku przez jego pozycję w tekście, wtedy nawet drobna zmiana treści pociąga za sobą zmianę wartości sumy kontrolnej. Przeanalizujemy przykład:

#ord(znak) -> kod ASCII * pozycja znaku w tekście

ord("A") -> 65 * 1
ord("d") -> 100 * 2
ord("a") -> 97 * 3
ord("m") -> 109 * 4

65 * 1 + 100 * 2 + 97 * 3 + 109 * 4 = 65 + 200 + 291 + 436 -> 992

Przygotujemy skrypt, który pozwoli zrealizować nasz algorytm. Zapiszmy go jako suma_kontrolna_01.py.

def wartosc_znaku(znak, pozycja):
    return ord(znak) * pozycja

informacja = input("Podaj informację: ")
suma_kontrolna = 0
pozycja = 1

for znak in informacja:
    suma_kontrolna += wartosc_znaku(znak, pozycja)
    pozycja += 1

print("Obliczona suma kontrolna wynosi", suma_kontrolna)

Funkcja wartosc_znaku zwraca wartość uzyskaną przez pomnożenie kodu ASCII podanego znaku przez jego pozycję w podanym przez użytkownika tekście.

Przeanalizuj poprzedni przykład, aby lepiej zrozumieć działanie kodu wewnątrz funkcji.

W wierszach 4–6 nadajemy zmiennym wartości początkowe. Pobieramy łańcuch znaków do zmiennej informacja za pomocą funkcji input(). To jego sumę kontrolną liczymy.

Przyjrzymy się dokładniej pętli for w wierszu 8. Zmienną sterującą jest znak; iterujemy po ciągu znakowym przechowywanym w zmiennej informacja. Wcześniej zdefiniowana zmienna suma_kontrolna zwiększa swoją wartość o liczbę zwróconą przez funkcję wartosc_znaku z każdą następną iteracją. Funkcję wywołujemy dla każdego kolejnego znaku.

for znak in informacja:
    suma_kontrolna += wartosc_znaku(znak, pozycja)
    pozycja += 1

Zmienna sterująca znak w pierwszej iteracji przechowuje pierwszy znak ciągu znakowego informacja. Znak ten znajduje się na pozycji 1, czyli wartości początkowej nadanej zmiennej pozycja. Podczas pierwszego przejścia pętli zmienna suma_kontrolna zmieni swoją wartość z 0 na kod ASCII pierwszego znaku pomnożony przez 1 (początkowa wartość zmiennej pozycja).

Na końcu pętli inkrementujemy o 1 zmienną pozycja. Gwarantuje nam to, że razem z przesuwającą się po kolejnych znakach ciągu znakowego zmienną sterującą znak, również wartość pozycji będzie się zmieniać.

W drugiej iteracji wartosc_znaku zostanie wywołana dla drugiego znaku ciągu znakowego i pozycji równej 2. O zwróconą wartość zostanie ponownie zwiększona suma_kontrolona (która po pierwszym przejściu pętli nie wynosi już 0), po czym przejdziemy na trzecią pozycję i trzeci znak ciągu znakowego informacja.

Wykonywanie pętli zakończy się, gdy obliczymy wartość znaku dla ostatniej litery ciągu znakowego informacja.

Na koniec wywołujemy funkcję print().

Sprawdźmy działanie zapisanego kodu. Możemy zauważyć, że zmiana treści informacji zmienia wartość sumy kontrolnej (nawet jeśli tylko zamienimy miejscami litery).

Bez mnożenia kodu ASCII znaku przez jego pozycję w ciągu znakowym dla wyrazów krab i bark otrzymalibyśmy taką samą sumę kontrolną – 416. Wciąż jednak możliwe jest otrzymanie takich samych sum kontrolnych dla różnych słów, np. wiosna oraz bliski:

Podaj informację: krab
Obliczona suma kontrolna wynosi 1018
# zmieniona wiadomość
Podaj informację: bark
Obliczona suma kontrolna wynosi 1062

Podaj informację: wiosna 
Obliczona suma kontrolna wynosi 2254
# zmieniona wiadomość
Podaj informację: bliski 
Obliczona suma kontrolna wynosi 2254

Przygotujemy skrypt, który pozwoli nam rozwiązać problem. Zapiszmy go jako suma_kontrolna_02.py.

def wartosc_znaku(znak, pozycja):
    wartosc = ord(znak) * pozycja
    if znak in ("eęyuioóaąEĘYUIOÓAĄ"):
        wartosc += 1
    return wartosc


informacja = input("Podaj informację: ")
suma_kontrolna = 0
pozycja = 1

for znak in informacja:
    suma_kontrolna += wartosc_znaku(znak,  pozycja)
    pozycja += 1

print("Obliczona suma kontrolna wynosi", suma_kontrolna)

Przeanalizujemy sposób działania funkcji wartosc_znaku() po wprowadzonych modyfikacjach. Wykonujemy kilka kolejnych kroków:

1. Obliczamy wartość liczbową znaku, mnożąc jego kod ASCII przez pozycję.

2. Sprawdzamy, czy znak znajduje się w zbiorze samogłosek (pamiętajmy, że sprawdzamy zarówno duże, jak i małe litery). Operator in w języku Python sprawdza, czy element z lewej strony znajduje się wśród elementów zbioru wartości z prawej strony.

3. Jesli znak znajduje się w zbiorze (jest samogłoską), zwiększamy (używając operatora +=) zmienną wartosc o 1.

4. Na końcu zwracamy wartość zmiennej wartosc.

Sprawdźmy efekt działania skryptu. Możemy zauważyć, że wartość sumy kontrolnej jest inna niż w poprzednim przykładzie. Różni się o 1, bo mamy tylko 1 samogłoskę.

Podaj informację: krab
Obliczona suma kontrolna wynosi 1019
# zmieniona wiadomość
Podaj informację: bark
Obliczona suma kontrolna wynosi 1063

zestaw instrukcji, który służy do rozwiązania problemu lub wykonania zadania; to procedura krok po kroku, która pobiera dane wejściowe, przetwarza je i generuje wynik

wydzielony fragment kodu programu, który posiada pewną funkcjonalność i logiczną całość; pozwala na zwiększenie przejrzystości kodu i jego wielokrotne użycie

gra w układankę słów; autorem jest Alfred Butts; wymyślił ją w 1931 roku, obecnie jest jedną z najpopularniejszych gier słownych na świecie; prawa autorskie do nazwy Scrabble mają firmy Mattel oraz Hasbro

wartość obliczona według specjalnego algorytmu, służy zapewnieniu integralności danych

(ang. string); znakowy typ danych w języku Python

(ang. list); struktura danych przechowująca uporządkowany zbiór wartości w języku Python; elementami listy mogą być różne typy danych; lista może zawierać duplikaty; elementy w liście są indeksowane od 0, co oznacza, że każdy element ma przypisany numer pozycji