Twoje Centrum Szkoleniowe

PYTHON Pętle zagnieżdżone

Pętle zagnieżdżone w Pythonie to konstrukcja, w której jedna pętla jest umieszczona wewnątrz innej pętli. Możemy myśleć o tym jak o pętlach umieszczonych jedna w drugiej, gdzie każda iteracja zewnętrznej pętli może wywoływać wiele iteracji wewnętrznej pętli. Pętle zagnieżdżone mogą być używane zarówno z pętlami for, jak i while, a także w kombinacji obu tych typów.

Główne cechy pętli zagnieżdżonych:

1. Hierarchia Pętli: W zagnieżdżonych pętlach mamy co najmniej dwie pętle: zewnętrzną i wewnętrzną. Pętla wewnętrzna jest wykonywana w całości przy każdej iteracji pętli zewnętrznej.

2. Przetwarzanie wielowymiarowe: Zagnieżdżone pętle są często używane do przetwarzania danych wielowymiarowych, takich jak listy dwuwymiarowe (np. macierze) lub więcej wymiarów.

3. Kontrola Przepływu: Pętla wewnętrzna może mieć własne warunki i sterowanie, niezależne od zewnętrznej pętli, co umożliwia skomplikowane operacje.

4. Efektywność: Choć zagnieżdżone pętle mogą być potężnym narzędziem, mogą także prowadzić do złożoności obliczeniowej, szczególnie w przypadku głębokiego zagnieżdżenia i/lub dużych zbiorów danych.

Przykłady zastosowań:

• Przetwarzanie danych tabelarycznych: Przeszukiwanie, przetwarzanie lub wyświetlanie danych w tabelach lub macierzach.
• Algorytmy numeryczne: W matematyce i fizyce, np. obliczenia na macierzach, transformacje liniowe.
• Gry i symulacje: W programowaniu gier, do iteracji po elementach siatek gier, np. w grach planszowych.
• Algorytmy grafowe: Przeszukiwanie grafów i drzew, gdzie każdy wierzchołek może prowadzić do kolejnych pętli iteracyjnych.

Ważne uwagi:

• Należy zwracać uwagę na efektywność takiego kodu, ponieważ zagnieżdżone pętle mogą szybko zwiększać złożoność obliczeniową programu.
• Czytelność i utrzymanie kodu może być trudniejsze, gdy używamy wielu poziomów zagnieżdżonych pętli.
• W niektórych przypadkach lepszym rozwiązaniem może być użycie innych struktur danych lub algorytmów.

Przykład 1

Załóżmy, że chcemy wydrukować wszystkie możliwe pary liczb od 1 do 3. Poniżej znajdują się przykłady z wykorzystaniem pętli for oraz while.

for

for i in range(1, 4):
    for j in range(1, 4):
        print(f"Para: {i}, {j}")

1. Zewnętrzna pętla for i in range(1, 4):

   • Ta pętla iteruje przez sekwencję liczb od 1 do 3 (włącznie), ponieważ range(1, 4) generuje liczby 1, 2, 3.
   • W każdej iteracji, zmienna i przyjmuje kolejną wartość z tej sekwencji.

2. Wewnętrzna pętla for j in range(1, 4):

   • Dla każdej wartości i z zewnętrznej pętli, ta pętla również iteruje przez sekwencję liczb od 1 do 3.
   • Zmienna j przyjmuje kolejną wartość z tej sekwencji w każdej iteracji wewnętrznej pętli.

3. Instrukcja print(f"Para: {i}, {j}"):

   • Ta instrukcja jest wykonywana dla każdej kombinacji wartości i i j.
   • Wypisuje ona parę liczb (i, j), gdzie i jest wartością z zewnętrznej pętli, a j wartością z wewnętrznej pętli.

while

i = 1
while i < 4:
    j = 1
    while j < 4:
        print(f"Para: {i}, {j}")
        j += 1
    i += 1

1. Inicjalizacja zmiennej i:

   • Skrypt rozpoczyna się od ustawienia i na 1. Zmienna i będzie służyć jako pierwszy element każdej pary.

2. Pierwsza pętla while:

   • Pętla ta (while i < 4) będzie kontynuowana dopóki i jest mniejsze niż 4. Oznacza to, że pętla wykonuje się dla wartości i równych 1, 2 i 3.

3. Inicjalizacja zmiennej j wewnątrz pierwszej pętli:

   • Wewnątrz pętli while dla i, zmienna j jest inicjowana jako 1. Zmienna j będzie służyć jako drugi element każdej pary.

4. Druga pętla while wewnątrz pierwszej:

   • Ta wewnętrzna pętla (while j < 4) również kontynuuje działanie dopóki j jest mniejsze niż 4, co oznacza iterowanie przez wartości 1, 2 i 3.

5. Instrukcja print wewnątrz drugiej pętli:

   • Wewnątrz drugiej pętli while, instrukcja print(f"Para: {i}, {j}") wypisuje aktualną parę wartości i i j.
   • Po wypisaniu pary, j jest zwiększane o 1 (j += 1), aby przejść do następnej wartości.

6. Inkrementacja i po zakończeniu wewnętrznej pętli while:

   • Po zakończeniu działania wewnętrznej pętli while, zewnętrzna pętla while zwiększa wartość i o 1 (i += 1) i powtarza wewnętrzną pętlę dla nowej wartości i.

Efektem działania obu skryptów będzie wyświetlenie wszystkich par liczb z zakresu od 1 do 3. Wygląda to następująco:

Para: 1, 1
Para: 1, 2
Para: 1, 3
Para: 2, 1
Para: 2, 2
Para: 2, 3
Para: 3, 1
Para: 3, 2
Para: 3, 3

Przykład 2

Załóżmy, że mamy tabelę (listę list) zawierającą dane o uczniach i ich oceny z różnych przedmiotów. Chcemy przejrzeć wszystkie oceny wszystkich uczniów i wyświetlić te, które są poniżej pewnego progu.

dane_uczniow = [
    ["Anna", 3, 4, 5],
    ["Bartek", 2, 4, 3],
    ["Cezary", 5, 5, 5],
    ["Dorota", 4, 3, 2]
]

for

for uczen in dane_uczniow:
    for ocena in uczen[1:]:  # Pomijamy pierwszy element, ponieważ jest to imię
        if ocena < 3:
            print(f"Uczeń {uczen[0]} ma ocenę poniżej 3: {ocena}")

1. Pętla zewnętrzna for uczen in dane_uczniow:

   • Ta pętla iteruje przez każdy element listy dane_uczniow.
   • Każdy element listy dane_uczniow jest również listą, reprezentującą pojedynczego ucznia wraz z jego ocenami. Na przykład, element [“Anna”, 3, 4, 5] reprezentuje ucznia o imieniu Anna, który otrzymał oceny 3, 4 i 5.
   • W każdej iteracji, zmienna uczen przechowuje aktualną listę (uczniów i ich ocen) podczas przechodzenia przez listę dane_uczniow.

2. Pętla wewnętrzna for ocena in uczen[1:]:

   • Ta pętla iteruje przez każdy element listy reprezentującej pojedynczego ucznia, zaczynając od drugiego elementu (indeks 1). Użycie uczen[1:] oznacza wzięcie "podlisty" od drugiego elementu do końca listy. Pomijamy pierwszy element, ponieważ jest to imię ucznia, a nie ocena.
   • W każdej iteracji, zmienna ocena przechowuje aktualną ocenę ucznia z listy ocen.

3. Warunek if ocena < 3:

   • Wewnątrz pętli wewnętrznej, mamy warunek sprawdzający, czy aktualna ocena jest mniejsza niż 3.
   • Jeśli warunek jest spełniony (czyli ocena jest niższa niż 3), wykonuje się blok kodu wewnątrz instrukcji if.

4. Instrukcja print(f"Uczeń {uczen[0]} ma ocenę poniżej 3: {ocena}"):

   • Ta instrukcja jest wykonana, jeśli warunek if jest prawdziwy.
   • Wyświetla ona informację, którego ucznia dotyczy ocena poniżej 3, wraz z tą oceną.
   • {uczen[0]} wstawia pierwszy element listy uczen (czyli imię ucznia) do łańcucha znaków.
   • {ocena} wstawia aktualną ocenę poniżej 3 do łańcucha znaków.

while

i = 0
while i < len(dane_uczniow):
    uczen = dane_uczniow[i]
    j = 1  # Zaczynamy od 1, aby pominąć imię
    while j < len(uczen):
        ocena = uczen[j]
        if ocena < 3:
            print(f"Uczeń {uczen[0]} ma ocenę poniżej 3: {ocena}")
        j += 1
    i += 1

1. Inicjalizacja zmiennej i:

   • Zaczynamy od ustawienia zmiennej i na 0. Ta zmienna służy jako indeks do iterowania przez listę dane_uczniow.

2. Pierwsza pętla while:

   • Pętla ta (while i < len(dane_uczniow)) będzie kontynuować wykonanie, dopóki i jest mniejsze niż liczba elementów w liście dane_uczniow.
   • W każdej iteracji, zmienna uczen przyjmuje wartość dane_uczniow[i], czyli kolejnego ucznia z listy.

3. Inicjalizacja zmiennej j:

   • Wewnątrz pierwszej pętli while, ustawiamy j na 1, aby zacząć przeglądanie ocen od pierwszego elementu po imieniu (pamiętamy, że indeks 0 w każdej liście uczen to imię).

4. Druga pętla while:

   • Ta pętla (while j < len(uczen)) przegląda wszystkie oceny dla danego ucznia.
   • len(uczen) daje nam długość listy ucznia, włączając imię i oceny.

5. Przypisywanie i sprawdzanie ocen:

   • W każdej iteracji tej pętli, ocena = uczen[j] przypisuje aktualną ocenę do zmiennej ocena.
   • Następnie warunek if ocena < 3 sprawdza, czy ta ocena jest mniejsza niż 3.

6. Drukowanie wyniku:

   • Jeśli warunek jest spełniony, wykonywana jest instrukcja print, która wyświetla imię ucznia i jego niską ocenę.

7. Inkrementacja indeksów j i i:

   • Na końcu każdej iteracji wewnętrznej pętli while, j jest zwiększane o 1 (j += 1), aby przejść do następnej oceny.
   • Po zakończeniu wewnętrznej pętli while dla danego ucznia, zmienna i jest zwiększana o 1 (i += 1) w zewnętrznej pętli while, aby przejść do następnego ucznia w liście.