# Βρόχοι στην Python

> for με range, while, και ο αθροιστής που μαζεύει.

Πληροφορική, Γ΄ Γυμνασίου. https://www.akademio.gr/el/gym-c/informatics/python-loops

## Τι θα μάθεις

- Να γράφεις βρόχους for με range και να προβλέπεις ποιες τιμές παίρνει ο μετρητής.
- Να γράφεις βρόχους while και να εξηγείς πότε σταματούν.
- Να χρησιμοποιείς αθροιστή και μετρητή μέσα σε βρόχο.
- Να συμπληρώνεις πίνακα τιμών για έναν βρόχο, βήμα βήμα.

## Επανάληψη χωρίς αντιγραφή

Θέλεις να τυπώσεις «Γεια» πέντε φορές. Μπορείς να γράψεις πέντε φορές την ίδια `print`. Για εκατό φορές όμως, ή για «όσες φορές δώσει ο χρήστης», αυτό δεν γίνεται.

Στο Scratch υπήρχαν τα πλακίδια «επανάλαβε 10» και «επανάλαβε ώσπου». Στον ψευδοκώδικα, `ΓΙΑ` και `ΟΣΟ`. Στην Python οι δύο **δομές επανάληψης** (βρόχοι, loops) είναι το `for` και το `while`.

## Ο βρόχος for και η range

```python
for i in range(5):
    print("Γεια", i)
```

```text
Γεια 0
Γεια 1
Γεια 2
Γεια 3
Γεια 4
```

Η μεταβλητή `i` λέγεται **μεταβλητή ελέγχου**: σε κάθε επανάληψη παίρνει την επόμενη τιμή από τη `range`. Όπως στο `if`, η γραμμή τελειώνει με `:` και ό,τι επαναλαμβάνεται γράφεται με εσοχή.

Η `range` έχει τρεις μορφές:

| Γράφεις            | Τιμές            | Πόσες |
| ------------------ | ---------------- | ----- |
| `range(5)`         | `0, 1, 2, 3, 4`  | $5$   |
| `range(1, 6)`      | `1, 2, 3, 4, 5`  | $5$   |
| `range(2, 11, 2)`  | `2, 4, 6, 8, 10` | $5$   |
| `range(10, 0, -3)` | `10, 7, 4, 1`    | $4$   |

> **Κλειδί**
>
> **Η `range(a, b)` ξεκινά από το `a` και σταματά πριν από το `b`. Το `b` δεν περιλαμβάνεται ποτέ.**
>
> Γι' αυτό τους αριθμούς από $1$ έως $100$ τους δίνει η `range(1, 101)`, όχι η `range(1, 100)`. Και γι' αυτό η `range(5)`, που ξεκινά από το $0$, κάνει ακριβώς $5$ επαναλήψεις: $0$ ως $4$.

Το τρίτο όρισμα είναι το **βήμα**. Μπορεί να είναι και αρνητικό, για αντίστροφη μέτρηση.

## Ο αθροιστής

Ένα από τα πιο συνηθισμένα μοτίβα στον προγραμματισμό: μια μεταβλητή που ξεκινά από το μηδέν και **μαζεύει** τιμές σε κάθε επανάληψη.

```python
synolo = 0
for i in range(1, 6):
    synolo = synolo + i
print("Άθροισμα:", synolo)
```

```text
Άθροισμα: 15
```

*Διαδραστικό στη σελίδα: Πίνακας τιμών: ο αθροιστής βήμα βήμα*

Το `synolo = synolo + i` γράφεται και σύντομα ως `synolo += i`. Αν αλλάξεις το `range(1, 6)` σε `range(1, 101)`, παίρνεις το άθροισμα από $1$ έως $100$, που είναι $5050$.

> **Πρόσεχε**
>
> **Ο αθροιστής παίρνει αρχική τιμή έξω από τον βρόχο.** Αν γράψεις το `synolo = 0` μέσα στον βρόχο, μηδενίζεται σε κάθε επανάληψη και στο τέλος κρατά μόνο την τελευταία τιμή του `i`.
>
> Το ίδιο ισχύει για τη θέση της `print`: μέσα στον βρόχο τυπώνει σε κάθε επανάληψη, έξω τυπώνει μία φορά.

Ο **μετρητής** είναι ο ίδιος μηχανισμός, αλλά προσθέτει πάντα $1$ και συνήθως μόνο όταν ισχύει μια συνθήκη. Πόσα πολλαπλάσια του $3$ υπάρχουν από $1$ ως $30$;

```python
metritis = 0
for i in range(1, 31):
    if i % 3 == 0:
        metritis = metritis + 1
print(metritis)
```

Τυπώνει `10`. Πρόσεξε τις δύο εσοχές: το `if` είναι μέσα στο `for`, και η αύξηση είναι μέσα στο `if`.

## Ο βρόχος while

Το `for` ταιριάζει όταν ξέρεις από πριν **πόσες** επαναλήψεις θέλεις. Όταν δεν το ξέρεις, όταν ξέρεις μόνο **πότε** πρέπει να σταματήσεις, χρησιμοποιείς `while`.

```python
x = 1
while x < 100:
    x = x * 3
print(x)
```

Το `while` ελέγχει τη συνθήκη **πριν** από κάθε επανάληψη. Όσο είναι αληθής, εκτελεί το σώμα. Εδώ το `x` γίνεται $3, 9, 27, 81, 243$. Όταν φτάσει στο $243$, η συνθήκη `243 < 100` είναι ψευδής και ο βρόχος σταματά. Τυπώνεται `243`.

Αν η συνθήκη είναι ψευδής από την αρχή, το σώμα δεν εκτελείται **ούτε μία φορά**.

> **Πρόσεχε**
>
> **Ο ατέρμων βρόχος.** Αν τίποτα μέσα στο σώμα δεν αλλάζει τη μεταβλητή της συνθήκης, η συνθήκη μένει αληθής για πάντα και το πρόγραμμα δεν τελειώνει ποτέ. Αν σβήσεις τη γραμμή `x = x * 3` από το παράδειγμα, το `x` μένει $1$ και το `1 < 100` αληθεύει για πάντα.
>
> Αν σου συμβεί, το πρόγραμμα σταματά με **Ctrl+C**.

### Τιμή-φρουρός

Ένα `while` διαβάζει συχνά τιμές από τον χρήστη μέχρι να δώσει μια ειδική τιμή που σημαίνει «τέλος», τη **φρουρό** (sentinel).

*Διαδραστικό στη σελίδα: Μέσος όρος με φρουρό*

Με εισόδους `17`, `12`, `19` και `0`, τυπώνει `Μέσος όρος: 16.0`. Το μηδέν δεν μετράει στον μέσο όρο: ο βρόχος το διαβάζει, ελέγχει τη συνθήκη και σταματά πριν το προσθέσει. Αν όμως ο χρήστης δώσει $0$ από την πρώτη φορά, το `plithos` μένει $0$ και η διαίρεση σταματά το πρόγραμμα με σφάλμα `ZeroDivisionError`· ένα `if plithos > 0:` πριν από την τελευταία `print` το προλαβαίνει.

*Διαδραστικό στη σελίδα: Βάλε τις γραμμές στη σειρά: τα πολλαπλάσια του 3*

## Παραδείγματα

### Παράδειγμα 1: Έχεις 50 ευρώ και βάζεις στην άκρη 20 ευρώ κάθε εβδομάδα. Σε πόσες εβδομάδες θα έχεις τουλάχιστον 200 ευρώ;

1. **Δεν ξέρουμε από πριν πόσες επαναλήψεις θέλουμε.** Αυτό ακριβώς ψάχνουμε. Ξέρουμε μόνο πότε σταματάμε, άρα `while`.
2. **Η συνθήκη** είναι αυτή που κρατά τον βρόχο ζωντανό: όσο το ποσό είναι **κάτω** από $200$. Μέσα, μια αύξηση του ποσού και ένας μετρητής εβδομάδων.
   ```python
   poso = 50
   evdomades = 0
   while poso < 200:
       poso = poso + 20
       evdomades = evdomades + 1
   print("Εβδομάδες:", evdomades, "Ποσό:", poso)
   ```
3. **Το ποσό περνά** από $70, 90, 110, 130, 150, 170, 190$ και στην όγδοη εβδομάδα γίνεται $210$. Εκεί το `210 < 200` είναι ψευδές.
   ```text
   Εβδομάδες: 8 Ποσό: 210
   ```
4. **Γιατί όχι 200 ακριβώς;** Από το $50$ με βήματα του $20$ δεν φτάνεις ποτέ ακριβώς στο $200$. Αν είχες γράψει `while poso != 200:`, ο βρόχος δεν θα σταματούσε ποτέ. Οι συνθήκες με `<` ή `>` είναι πιο ασφαλείς από τις συνθήκες με `!=`.

### Παράδειγμα 2: Πόσα ψηφία έχει ο αριθμός 2026; Γράψε βρόχο που τα μετρά χωρίς να μετατρέψει τον αριθμό σε κείμενο.

1. **Η ιδέα:** το `n // 10` «κόβει» το τελευταίο ψηφίο: `2026 // 10` είναι `202`. Όσες φορές μπορώ να κόψω ψηφίο πριν μείνει $0$, τόσα ψηφία έχει.
2. ```python
   n = 2026
   psifia = 0
   while n > 0:
       n = n // 10
       psifia = psifia + 1
   print("Ψηφία:", psifia)
   ```
3. **Πίνακας τιμών:**
   | Επανάληψη | Συνθήκη           | `n` μετά | `psifia` |
   | --------- | ----------------- | -------- | -------- |
   | 1η        | `2026 > 0` αληθής | `202`    | `1`      |
   | 2η        | `202 > 0` αληθής  | `20`     | `2`      |
   | 3η        | `20 > 0` αληθής   | `2`      | `3`      |
   | 4η        | `2 > 0` αληθής    | `0`      | `4`      |
   | —         | `0 > 0` ψευδής    | τέλος    |          |
4. Τυπώνεται `Ψηφία: 4`. Η συνθήκη ελέγχθηκε **πέντε** φορές αλλά το σώμα εκτελέστηκε **τέσσερις**: ο τελευταίος έλεγχος είναι αυτός που βγάζει το πρόγραμμα από τον βρόχο.

> **Θυμήσου**
>
> - `for i in range(a, b):` για γνωστό πλήθος επαναλήψεων. Το `b` δεν περιλαμβάνεται.
> - `while συνθήκη:` για «όσο ισχύει κάτι». Κάτι μέσα στον βρόχο πρέπει να αλλάζει τη συνθήκη.
> - Αθροιστής και μετρητής: αρχική τιμή **πριν** από τον βρόχο, ενημέρωση **μέσα**, εκτύπωση **μετά**.
> - Ο πίνακας τιμών είναι ο πιο σίγουρος τρόπος να καταλάβεις τι κάνει ένας βρόχος.

## Ερωτήσεις

1. Πόσες φορές εκτελείται το σώμα του βρόχου for i in range(5):;
   - 5
   - 4
   - 6
   - εξαρτάται από το τι κάνει το σώμα
2. Ποια είναι η τελευταία τιμή που παίρνει το i στο for i in range(1, 10):;
   - 9
   - 10
   - 1
   - 11
3. Ποιες τιμές δίνει η range(0, 20, 5);
   - 0, 5, 10, 15
   - 0, 5, 10, 15, 20
   - 5, 10, 15, 20
   - 0, 20, 5
4. Ο αθροιστής s ξεκινά από 0, και μέσα σε for i in range(1, 4) εκτελείται s = s + i. Ποια είναι η τελική τιμή του s;
   - 6
   - 10
   - 3
   - 4
5. Κάποιος γράφει το synolo = 0 μέσα στον βρόχο for i in range(1, 6), ακριβώς πριν από το synolo = synolo + i. Τι τιμή έχει το synolo στο τέλος;
   - 5
   - 15
   - 0
   - μήνυμα σφάλματος
6. Με x = 10, πόσες φορές εκτελείται το σώμα του while x < 5:;
   - καμία
   - μία
   - πέντε
   - άπειρες
7. Ποιος από τους παρακάτω βρόχους, με x = 1 στην αρχή, δεν σταματά ποτέ;
   - while x > 0: x = x + 1
   - while x < 10: x = x + 1
   - while x < 100: x = x * 2
   - while x > 5: x = x + 1
8. Ένα πρόγραμμα ρωτά τον χρήστη για κωδικό ξανά και ξανά, μέχρι να δώσει τον σωστό. Ποια δομή ταιριάζει;
   - while, γιατί δεν ξέρουμε από πριν πόσες προσπάθειες θα χρειαστούν
   - for, γιατί κάθε επανάληψη του βρόχου είναι μία προσπάθεια του χρήστη
   - if, γιατί ελέγχουμε αν ο κωδικός είναι σωστός
   - for με range(100), για να είμαστε σίγουροι
9. Σε έναν βρόχο που διαβάζει βαθμούς μέχρι να δοθεί 0, τι ρόλο παίζει το 0;
   - σημαίνει «τέλος» και δεν μετρά στο άθροισμα
   - είναι ένας βαθμός σαν τους άλλους
   - είναι η αρχική τιμή του αθροιστή
   - προκαλεί σφάλμα που σταματά το πρόγραμμα
10. Με x = 1 στην αρχή, εκτελείται while x < 50: x = x * 2. Ποια είναι η τελική τιμή του x;
   - 64
   - 32
   - 50
   - 100

## Ασκήσεις

1. Γράψε τη γραμμή for που δίνει στη μεταβλητή i τις τιμές 1, 2, …, 10.
2. Πόσες φορές εκτελείται το σώμα του βρόχου for i in range(2, 12, 3):;
3. Δίνεται ο κώδικας: n = 100, c = 0, και όσο ισχύει n > 1 εκτελούνται οι εντολές n = n // 2 και c = c + 1.
   α) Ποια είναι η τελική τιμή του c;
   β) Ποια είναι η τελική τιμή του n;
4. Θέλεις να αθροίσεις με βρόχο for τους άρτιους αριθμούς από 2 έως 100.
   α) Ποια range δίνει ακριβώς αυτούς τους αριθμούς;
   β) Ποιο άθροισμα θα τυπώσει το πρόγραμμα;

---

Οι απαντήσεις, τα διαδραστικά και τα παιχνίδια είναι στη σελίδα της ενότητας: https://www.akademio.gr/el/gym-c/informatics/python-loops
