# Python: λίστες και συμβολοσειρές

> Διάσχιση, τεμαχισμός, και οι ενσωματωμένες συναρτήσεις.

Πληροφορική, Α΄ Λυκείου. https://www.akademio.gr/el/lyk-a/informatics/python-lists-strings

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

- Να προσπελαύνεις στοιχεία λίστας και χαρακτήρες συμβολοσειράς με θετικούς και αρνητικούς δείκτες.
- Να κάνεις τεμαχισμό (slicing) με αρχή, τέλος και βήμα.
- Να διασχίζεις λίστες και συμβολοσειρές με for, και να χρησιμοποιείς len, in, sum, min, max.
- Να χρησιμοποιείς τις μεθόδους append, insert, pop, remove, sort, και τις split και join.
- Να εξηγείς γιατί μια λίστα αλλάζει ενώ μια συμβολοσειρά όχι.

## Πολλές τιμές με ένα όνομα

Για τους βαθμούς ενός μαθητή σε δέκα μαθήματα δεν φτιάχνεις δέκα μεταβλητές. Φτιάχνεις μία **λίστα** (list): μια σειρά τιμών, ανάμεσα σε αγκύλες, χωρισμένες με κόμμα.

```python
grades = [14, 18, 9, 18, 16]
names = ["Άννα", "Βασίλης", "Γιώργος"]
empty = []
print(len(grades), len(names), len(empty))
```

```text
5 3 0
```

Μια **συμβολοσειρά** (string, `str`) είναι κι αυτή σειρά: σειρά χαρακτήρων. Γι' αυτό λίστες και συμβολοσειρές μοιράζονται σχεδόν όλους τους τρόπους πρόσβασης, και τις βλέπουμε μαζί.

## Δείκτες: θετικοί και αρνητικοί

Κάθε στοιχείο έχει μια θέση, τον **δείκτη** (index). Η αρίθμηση ξεκινά από το $0$. Μετρώντας από το τέλος, οι δείκτες είναι **αρνητικοί**: το `-1` είναι το τελευταίο.

| Χαρακτήρας        | `P`  | `y`  | `t`  | `h`  | `o`  | `n`  |
| ----------------- | ---- | ---- | ---- | ---- | ---- | ---- |
| Θετικός δείκτης   | `0`  | `1`  | `2`  | `3`  | `4`  | `5`  |
| Αρνητικός δείκτης | `-6` | `-5` | `-4` | `-3` | `-2` | `-1` |

```python
word = "Python"
print(word[0], word[5], word[-1], word[-2])
```

```text
P n n o
```

Σε μια σειρά μήκους `n`, οι έγκυροι δείκτες πάνε από `0` ως `n - 1`, ή από `-n` ως `-1`. Το `word[6]` δεν υπάρχει και δίνει σφάλμα `IndexError`.

## Τεμαχισμός

Ο **τεμαχισμός** (slicing) παίρνει ένα κομμάτι της σειράς: `s[αρχή:τέλος:βήμα]`. Όπως στη `range()`, **η αρχή περιλαμβάνεται, το τέλος όχι**.

```python
word = "Python"
print(word[0:2], word[2:], word[:3], word[-3:])
print(word[::2], word[::-1])
```

```text
Py thon Pyt hon
Pto nohtyP
```

| Τεμαχισμός   | Σημαίνει                    | Αποτέλεσμα |
| ------------ | --------------------------- | ---------- |
| `word[0:2]`  | από το `0` ως πριν το `2`   | `Py`       |
| `word[2:]`   | από το `2` ως το τέλος      | `thon`     |
| `word[:3]`   | από την αρχή ως πριν το `3` | `Pyt`      |
| `word[-3:]`  | τα τρία τελευταία           | `hon`      |
| `word[::2]`  | όλα, με βήμα $2$            | `Pto`      |
| `word[::-1]` | όλα, ανάποδα                | `nohtyP`   |

> **Κλειδί**
>
> **Ο δείκτης δίνει ένα στοιχείο· ο τεμαχισμός δίνει πάντα νέα σειρά.**
>
> Το `word[0]` είναι ο χαρακτήρας `P`. Το `word[0:1]` είναι η συμβολοσειρά `"P"`, και το `grades[0:1]` είναι η λίστα `[14]`, όχι ο αριθμός $14$. Και ένας τεμαχισμός εκτός ορίων δεν βγάζει σφάλμα: απλώς δίνει ό,τι υπάρχει, ή μια κενή σειρά.

Το ίδιο ισχύει για λίστες: `grades[-2:]` είναι οι δύο τελευταίοι βαθμοί, `grades[1:4]` ο δεύτερος ως ο τέταρτος.

## Διάσχιση

Το `for` περνά από κάθε στοιχείο με τη σειρά. Υπάρχουν δύο τρόποι:

```python
word = "κάστρο"
for ch in word:
    print(ch, end=" ")
print()
for i in range(len(word)):
    print(i, word[i])
```

```text
κ ά σ τ ρ ο 
0 κ
1 ά
2 σ
3 τ
4 ρ
5 ο
```

Ο πρώτος τρόπος δίνει κατευθείαν τα στοιχεία. Ο δεύτερος δίνει τους δείκτες, και χρειάζεται όταν σε ενδιαφέρει **η θέση**: π.χ. να συγκρίνεις κάθε στοιχείο με το επόμενο. Το `end=" "` λέει στην `print()` να μην αλλάξει γραμμή μετά την εμφάνιση.

## Χρήσιμες ενσωματωμένες συναρτήσεις

| Συνάρτηση ή τελεστής | Τι κάνει               | Παράδειγμα                            |
| -------------------- | ---------------------- | ------------------------------------- |
| `len(s)`             | πλήθος στοιχείων       | `len("Python")` δίνει `6`             |
| `x in s`             | υπάρχει το `x` μέσα;   | `"th" in "Python"` δίνει `True`       |
| `sum(L)`             | άθροισμα αριθμών       | `sum([1, 2, 5, 9])` δίνει `17`        |
| `min(L)`, `max(L)`   | ελάχιστο, μέγιστο      | `max([1, 2, 5, 9])` δίνει `9`         |
| `sorted(L)`          | νέα ταξινομημένη λίστα | `sorted([5, 2, 9])` δίνει `[2, 5, 9]` |

Το `in` στις συμβολοσειρές ψάχνει **κομμάτι** κειμένου, και ξεχωρίζει κεφαλαία από πεζά: το `"Th" in "Python"` είναι `False`.

## Οι λίστες αλλάζουν

Μια λίστα μπορεί να αλλάξει αφού φτιαχτεί. Οι **μέθοδοι** καλούνται με τελεία μετά το όνομα της λίστας:

```python
fruits = ["μήλο", "αχλάδι", "σύκο"]
fruits.append("κεράσι")
fruits.insert(1, "μπανάνα")
print(fruits)
last = fruits.pop()
fruits.remove("σύκο")
print(last, fruits)
fruits[0] = "πορτοκάλι"
print(fruits)
```

```text
['μήλο', 'μπανάνα', 'αχλάδι', 'σύκο', 'κεράσι']
κεράσι ['μήλο', 'μπανάνα', 'αχλάδι']
['πορτοκάλι', 'μπανάνα', 'αχλάδι']
```

| Μέθοδος                | Τι κάνει                                                                  |
| ---------------------- | ------------------------------------------------------------------------- |
| `append(x)`            | προσθέτει το `x` στο τέλος                                                |
| `insert(i, x)`         | βάζει το `x` στη θέση `i`, σπρώχνοντας τα υπόλοιπα δεξιά                  |
| `pop()`                | αφαιρεί και **επιστρέφει** το τελευταίο (ή το `pop(i)` αυτό στη θέση `i`) |
| `remove(x)`            | αφαιρεί την πρώτη εμφάνιση της **τιμής** `x`                              |
| `sort()`               | ταξινομεί τη λίστα **επί τόπου**                                          |
| `index(x)`, `count(x)` | θέση της πρώτης εμφάνισης, πλήθος εμφανίσεων                              |

> **Πρόσεχε**
>
> **Το `sort()` αλλάζει τη λίστα και δεν επιστρέφει τίποτα.**
>
> Το `nums = nums.sort()` είναι λάθος: η λίστα ταξινομείται, αλλά στη `nums` γράφεται το `None` που επιστρέφει η μέθοδος, και η λίστα χάνεται. Γράφεις σκέτο `nums.sort()`, ή `nums = sorted(nums)` αν θέλεις νέα λίστα.

## Οι συμβολοσειρές δεν αλλάζουν

Μια συμβολοσειρά είναι **αμετάβλητη** (immutable): το `word[0] = "J"` δίνει σφάλμα. Οι μέθοδοί της δεν την αλλάζουν, **επιστρέφουν νέα**:

```python
s = "Hello world"
t = s.replace("world", "class")
print(s)
print(t, t.upper(), t.lower())
```

```text
Hello world
Hello class HELLO CLASS hello class
```

Δύο μέθοδοι γεφυρώνουν λίστες και συμβολοσειρές. Η `split()` κόβει κείμενο σε λίστα, και η `join()` ενώνει λίστα συμβολοσειρών σε κείμενο:

```python
line = "12,15,9"
parts = line.split(",")
print(parts)
print("-".join(["2026", "09", "26"]))
print("Άννα Βασίλης Γιώργος".split())
```

```text
['12', '15', '9']
2026-09-26
['Άννα', 'Βασίλης', 'Γιώργος']
```

Πρόσεξε ότι η `split()` δίνει λίστα **συμβολοσειρών**, `'12'` και όχι $12$. Για να τις αθροίσεις, πρέπει να τις μετατρέψεις με `int()`. Χωρίς όρισμα, η `split()` κόβει στα κενά.

> **Θυμήσου**
>
> - Δείκτες από `0` ως `len - 1`, ή από `-len` ως `-1`.
> - `s[a:b]`: από το `a` ως **πριν** το `b`. Το `s[::-1]` είναι η σειρά ανάποδα.
> - Οι λίστες αλλάζουν (`append`, `pop`, `sort`, `L[i] = x`). Οι συμβολοσειρές όχι: οι μέθοδοί τους επιστρέφουν νέα συμβολοσειρά.
> - `split` κόβει κείμενο σε λίστα, `join` ενώνει λίστα σε κείμενο.

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

### Παράδειγμα 1: Δίνεται s = «informatics». Τι δίνουν τα s\[2:6], s\[-4:], s\[::3] και s\[-1:-4:-1];

1. **Οι δείκτες:** `i`=0, `n`=1, `f`=2, `o`=3, `r`=4, `m`=5, `a`=6, `t`=7, `i`=8, `c`=9, `s`=10. Μήκος $11$.
2. **`s[2:6]`**: θέσεις $2$ ως $5$, δηλαδή `form`. **`s[-4:]`**: τα τέσσερα τελευταία, `tics`.
3. **`s[::3]`**: θέσεις $0$, $3$, $6$, $9$, δηλαδή `ioac`. **`s[-1:-4:-1]`**: από το τελευταίο προς τα πίσω, θέσεις $-1$, $-2$, $-3$, δηλαδή `sci`.
   ```python
   s = "informatics"
   print(s[2:6], s[-4:], s[::3], s[-1:-4:-1])
   ```
   ```text
   form tics ioac sci
   ```

### Παράδειγμα 2: Μια γραμμή κειμένου περιέχει βαθμούς χωρισμένους με κενά, π.χ. «14 18 9 16». Βρες τον μέσο όρο και πόσοι βαθμοί είναι τουλάχιστον 15.

1. **Κόψε τη γραμμή σε λίστα** με `split()`. Κάθε στοιχείο είναι συμβολοσειρά, οπότε μετατρέπεις με `int()` καθώς τη διασχίζεις.
2. **Άθροισμα και μέτρηση μαζί**, στον ίδιο βρόχο:

   *Διαδραστικό στη σελίδα: Μέσος όρος από μια γραμμή*
3. **Έλεγχος:** $14 + 18 + 9 + 16 = 57$, και $57 / 4 = 14{,}25$. Από $15$ και πάνω είναι οι $18$ και $16$, άρα $2$.

   Χωρίς το `int()` η πρόσθεση θα έδινε σφάλμα, γιατί θα προσπαθούσε να προσθέσει κείμενο σε αριθμό.

### Παράδειγμα 3: Γράψε πρόγραμμα που ελέγχει αν μια λέξη είναι παλίνδρομη, δηλαδή διαβάζεται ίδια και ανάποδα.

1. **Η ανάποδη λέξη** είναι ο τεμαχισμός `word[::-1]`.
2. **Αρκεί μία σύγκριση** της λέξης με την ανάποδή της:
   ```python
   for word in ["radar", "python", "level"]:
       print(word, word == word[::-1])
   ```
   ```text
   radar True
   python False
   level True
   ```
3. **Αν οι λέξεις είχαν κεφαλαία**, όπως `"Radar"`, η σύγκριση θα αποτύγχανε, γιατί `R` και `r` είναι διαφορετικοί χαρακτήρες. Λύση: σύγκριση του `word.lower()` με το `word.lower()[::-1]`.

## Ερωτήσεις

1. Για L = [10, 20, 30, 40, 50], τι είναι το L[-2];
   - 40
   - 20
   - 30
   - Σφάλμα, γιατί οι δείκτες δεν είναι αρνητικοί
2. Για L = [10, 20, 30, 40, 50], τι είναι το L[1:3];
   - [20, 30]
   - [20, 30, 40]
   - [10, 20, 30]
   - 20
3. Τι δίνει το "Athens"[::-1];
   - "snehtA"
   - "s"
   - "Athen"
   - Σφάλμα, γιατί οι συμβολοσειρές δεν αλλάζουν
4. Για L = [10, 20, 30, 40, 50], τι δίνει το L[5:9];
   - []
   - Σφάλμα IndexError
   - [50]
   - None
5. Μετά την εντολή nums = nums.sort(), τι περιέχει η nums;
   - None
   - Τη λίστα ταξινομημένη
   - Την αρχική λίστα, χωρίς αλλαγή
   - Σφάλμα, γιατί η sort() θέλει όρισμα
6. Τι συμβαίνει με την εντολή s[0] = "J" όταν s = "Python";
   - Σφάλμα, γιατί οι συμβολοσειρές δεν αλλάζουν
   - Η s γίνεται "Jython", γιατί αλλάζει ο πρώτος χαρακτήρας
   - Η s γίνεται "JPython", γιατί το "J" μπαίνει μπροστά
   - Τίποτα, η εντολή αγνοείται χωρίς μήνυμα σφάλματος
7. Τι επιστρέφει η "12,15,9".split(",");
   - ['12', '15', '9']
   - [12, 15, 9]
   - 36
   - "12 15 9"
8. Ποια είναι η τιμή του "the" in "Athens";
   - True
   - False, γιατί το "the" δεν είναι ολόκληρη λέξη
   - False, γιατί το "Athens" ξεκινά με κεφαλαίο
   - 1, η θέση όπου βρέθηκε
9. Για x = [5, 3, 5, 1], τι περιέχει η x μετά το x.remove(5);
   - [3, 5, 1]
   - [3, 1]
   - [5, 3, 5, 1], γιατί δεν υπάρχει θέση 5
   - [5, 3, 1]
10. Για L = [1, 2, 3], πόσο είναι το len(L) μετά το L.append([4, 5]);
   - 4
   - 5
   - 3
   - Σφάλμα, γιατί δεν μπαίνει λίστα σε λίστα

## Ασκήσεις

1. Για w = "banana", τι δίνει το w[1:4];
2. Γράψε έναν τεμαχισμό που δίνει τους τρεις τελευταίους χαρακτήρες μιας συμβολοσειράς s, όποιο κι αν είναι το μήκος της.
3. Δίνεται η λίστα L = [7, 2, 9, 4].
   α) Τι περιέχει μετά το L.append(1);
   β) Και μετά το L.sort();
   γ) Τι επιστρέφει τότε το L.pop();
4. Δίνεται η φράση s = "to be or not to be".
   α) Πόσες λέξεις δίνει η s.split();
   β) Τι δίνει η s.count("be");
   γ) Τι δίνει η "-".join(s.split()[:2]);

---

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