# Συμβολοσειρές

> Δείκτες, φέτες, μήκος, διάσχιση με for, και γιατί μια συμβολοσειρά δεν αλλάζει.

Προγραμματισμός Υπολογιστών, Γ΄ ΕΠΑΛ. https://www.akademio.gr/el/epal-c/programming/strings

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

- Να βρίσκεις έναν χαρακτήρα μιας συμβολοσειράς από τον δείκτη του, θετικό ή αρνητικό, και να χρησιμοποιείς τις len, str, int και τους τελεστές + και *.
- Να εξηγείς γιατί μια συμβολοσειρά είναι μη μεταβαλλόμενη και να φτιάχνεις νέα συμβολοσειρά αντί να αλλάζεις την παλιά.
- Να χρησιμοποιείς τους τελεστές in και not in και να προβλέπεις το αποτέλεσμα μιας λεξικογραφικής σύγκρισης.
- Να διασχίζεις μια συμβολοσειρά με for, χαρακτήρα-χαρακτήρα ή με δείκτη, και να παίρνεις κομμάτια της με τον τελεστή διαμέρισης.

## Τι είναι μια συμβολοσειρά

Μια **συμβολοσειρά** (ή αλφαριθμητικό, string) είναι μια ακολουθία από χαρακτήρες: γράμματα, ψηφία, κενά, σύμβολα. Γράφεται μέσα σε μονά ή διπλά εισαγωγικά, και ο τύπος της στην Python λέγεται `str`, από τα αρχικά της λέξης string.

> **Στον υπολογιστή σου, με Python 3**
>
> Το βιβλίο και οι εξετάσεις γράφουν σε Python 2.7. Στην Python 3 το `print x` γράφεται `print(x)` και το `print a, b` γράφεται `print(a, b)`. Η `raw_input` λέγεται `input`, και αριθμό διαβάζεις με `int(input())`. Δείκτες, φέτες, `in` και συγκρίσεις δουλεύουν ίδια.

Κάθε χαρακτήρας έχει μια θέση, τον **δείκτη** του. Όπως στις λίστες, η αρίθμηση αρχίζει από το $0$. Για `word = "PYTHON"`:

| Χαρακτήρας   | `P`  | `Y`  | `T`  | `H`  | `O`  | `N`  |
| ------------ | ---- | ---- | ---- | ---- | ---- | ---- |
| Δείκτης      | $0$  | $1$  | $2$  | $3$  | $4$  | $5$  |
| Από το τέλος | $-6$ | $-5$ | $-4$ | $-3$ | $-2$ | $-1$ |

Το `word[0]` είναι το 1ο γράμμα, `'P'`, και το `word[3]` το 4ο, `'H'`. Ο τελευταίος χαρακτήρας είναι στη θέση `len(word) - 1`, εδώ $5$. Η Python δέχεται και **αρνητικούς δείκτες**, που μετρούν από το τέλος: το `word[-1]` είναι κι αυτό το `'N'`. Ένας δείκτης έξω από τα όρια, όπως το `word[6]`, σταματά το πρόγραμμα με `IndexError`.

## Μήκος, συνένωση, μετατροπές

| Γράφεις             | Αποτέλεσμα | Τι κάνει                                            |
| ------------------- | ---------- | --------------------------------------------------- |
| `len(word)`         | `6`        | το **μήκος**: πόσους χαρακτήρες έχει                |
| `word[5] + word[0]` | `'NP'`     | ο `+` **συνενώνει** δύο συμβολοσειρές σε μία        |
| `"ab" * 3`          | `'ababab'` | ο `*` επαναλαμβάνει μια συμβολοσειρά                |
| `str(28)`           | `'28'`     | μετατρέπει μια τιμή σε συμβολοσειρά                 |
| `int("496") + 4`    | `500`      | μετατρέπει μια συμβολοσειρά στον ακέραιο που γράφει |

Ο `+` δεν ανακατεύει τύπους. Το `"Τάξη " + 3` σταματά με `TypeError`· γράφεις `"Τάξη " + str(3)`. Και το ανάποδο: η `raw_input()` επιστρέφει πάντα συμβολοσειρά, ακόμα κι αν ο χρήστης γράψει ψηφία. Γι' αυτό το βιβλίο διαβάζει κείμενο με `raw_input` και αριθμούς με `input`.

Στο πρόγραμμα που ακολουθεί, το `print(...)` με ένα όρισμα δουλεύει ίδια και στις δύο εκδόσεις.

*Διαδραστικό στη σελίδα: Δείκτες, μήκος, συνένωση*

## Μια συμβολοσειρά δεν αλλάζει

Οι συμβολοσειρές έχουν **σταθερό μέγεθος** και **μη μεταβαλλόμενα περιεχόμενα**: δεν προσθέτεις, δεν αφαιρείς και δεν αλλάζεις χαρακτήρες σε μια συμβολοσειρά που υπάρχει ήδη. Γι' αυτό λέμε ότι ανήκουν στις **μη μεταβαλλόμενες** (immutable) δομές της Python.

```python
word = "PYTHON"
word[0] = "J"      # TypeError: η συμβολοσειρά δεν αλλάζει
```

Αυτό που κάνεις είναι να φτιάξεις μια **νέα** συμβολοσειρά και να τη δώσεις στη μεταβλητή. Το `word = "J" + word[1:]` κάνει τη `word` να δείχνει στο `'JYTHON'`. Η `'PYTHON'` δεν άλλαξε· απλώς η μεταβλητή δείχνει πια σε άλλη τιμή.

> **Κλειδί**
>
> **Μια συμβολοσειρά δεν αλλάζει ποτέ. Αλλάζει μόνο η μεταβλητή, που δείχνει σε μια νέα.**
>
> Γι' αυτό η επεξεργασία κειμένου γίνεται πάντα με τον ίδιο τρόπο: ξεκινάς από την κενή συμβολοσειρά `""` και, χαρακτήρα-χαρακτήρα, προσθέτεις με `+` ό,τι θέλεις να κρατήσεις. Οι **λίστες**, αντίθετα, είναι μεταβαλλόμενες (mutable): εκεί το `L[0] = 5` επιτρέπεται.

## Ο τελεστής in και οι συγκρίσεις

Ο **υπαρξιακός τελεστής** `in` ελέγχει αν μια συμβολοσειρά περιέχεται σε μια άλλη, και ο `not in` το αντίθετο. Το κομμάτι πρέπει να είναι **συνεχόμενο** και με τα ίδια πεζά ή κεφαλαία:

| Έκφραση               | Τιμή                                    |
| --------------------- | --------------------------------------- |
| `"Py" in "Python"`    | `True`                                  |
| `"a" in "Python"`     | `False`                                 |
| `"a" not in "Python"` | `True`                                  |
| `"Pn" in "Python"`    | `False`: τα `P` και `n` δεν είναι δίπλα |
| `"py" in "Python"`    | `False`: το `p` δεν είναι `P`           |

Οι συγκριτικοί τελεστές `<`, `<=`, `>`, `>=`, `==`, `!=` δουλεύουν και στις συμβολοσειρές, με τη **λεξικογραφική διάταξη**: συγκρίνονται οι χαρακτήρες ένας-ένας από την αρχή, και αποφασίζει ο πρώτος που διαφέρει. Το `'antonis' > 'antonia'` είναι `True`, γιατί στη θέση $6$ το `s` έρχεται μετά το `a`. Το `'babylon5' > 'babylon4'` είναι κι αυτό `True`. Τα κεφαλαία λατινικά έρχονται πριν από τα πεζά, οπότε και το `'Z' < 'a'` είναι `True`.

> **Πρόσεχε**
>
> **Τα ψηφία μέσα σε εισαγωγικά δεν είναι αριθμοί.** Το `'1000' < '2'` είναι `True`: συγκρίνεται πρώτα το `'1'` με το `'2'`, και το `'1'` είναι μικρότερο. Το μήκος δεν παίζει ρόλο. Αν θέλεις σύγκριση αριθμών, μετατρέπεις πρώτα με `int()`: το `int('1000') < int('2')` είναι `False`.

## Διάσχιση με for

Μια συμβολοσειρά είναι **ακολουθία**, οπότε η `for` την περνά χαρακτήρα-χαρακτήρα. Στο `for char in sentence:` η `char` παίρνει με τη σειρά κάθε χαρακτήρα της `sentence`, κενά και σύμβολα μαζί.

Η συνάρτηση του βιβλίου `count_vowels` μετρά τα φωνήεντα μιας λέξης:

*Διαδραστικό στη σελίδα: Πόσα φωνήεντα έχει μια λέξη*

Ο `in` εμφανίζεται εδώ με **δύο ρόλους**. Στο `for letter in word` ορίζει τι διασχίζεις· στο `if letter in vowels` ελέγχει αν το γράμμα υπάρχει στη `vowels`.

Η άλλη συνάρτηση του βιβλίου, η `trimSpaces`, φτιάχνει μια νέα συμβολοσειρά χωρίς τα κενά. Ξεκινά από την κενή και προσθέτει κάθε χαρακτήρα που **δεν** είναι κενό:

```python
def trimSpaces(sentence):
    result = ""
    for char in sentence:
        if char != " ":
            result += char
    return result

print trimSpaces("Houston we have a problem")   # Houstonwehaveaproblem
```

Όταν σε ενδιαφέρει η **θέση** ενός χαρακτήρα, και όχι μόνο ο χαρακτήρας, διασχίζεις με δείκτη: `for i in range(len(word)):`, και μέσα στον βρόχο γράφεις `word[i]`. Έτσι μπορείς να συγκρίνεις τον `word[i]` με τον γείτονά του ή με τον χαρακτήρα στην απέναντι άκρη.

## Ο τελεστής διαμέρισης

Ο **τελεστής διαμέρισης** (slice) `:` δίνει ένα κομμάτι της συμβολοσειράς. Η έκφραση `word[a:b]` δίνει τους χαρακτήρες από τον `word[a]` **μέχρι και** τον `word[b-1]`. Ο `word[b]` μένει έξω, όπως το «μέχρι» στη `range`. Αν λείπει το `a`, το κομμάτι ξεκινά από την αρχή· αν λείπει το `b`, φτάνει ως το τέλος.

Για `word = "zanneio gymnasio"`, όπου το κενό είναι στη θέση $7$:

| Γράφεις                                 | Αποτέλεσμα           |
| --------------------------------------- | -------------------- |
| `word[3:11]`                            | `'neio gym'`         |
| `word[:7]`, ίδιο με `word[0:7]`         | `'zanneio'`          |
| `word[8:]`, ίδιο με `word[8:len(word)]` | `'gymnasio'`         |
| `word[-3:]`                             | `'sio'`              |
| `word[:]`                               | `'zanneio gymnasio'` |

Το πλήθος των χαρακτήρων στο `word[a:b]` είναι $b - a$. Και μια φέτα δεν βγάζει ποτέ `IndexError`: το `word[10:100]` δίνει απλώς ό,τι υπάρχει από τη θέση $10$ ως το τέλος.

Μια εφαρμογή από το βιβλίο είναι ο **κώδικας του Καίσαρα**, όπου κάθε γράμμα αντικαθίσταται από αυτό που βρίσκεται $3$ θέσεις πιο μπροστά. Το νέο αλφάβητο φτιάχνεται με δύο φέτες:

```python
alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
cipherAlphabet = alphabet[3:] + alphabet[:3]
print cipherAlphabet    # DEFGHIJKLMNOPQRSTUVWXYZABC
```

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

### Παράδειγμα 1: Να γράψετε πρόγραμμα σε Python το οποίο διαβάζει μια λέξη και εμφανίζει πόσα κεφαλαία γράμματα του αγγλικού αλφαβήτου περιέχει.

1. **Η ιδέα:** μια συμβολοσειρά `capitals` με όλα τα κεφαλαία, από το `A` ως το `Z`. Διασχίζεις τη λέξη με `for` και, για κάθε γράμμα, ελέγχεις με `in` αν υπάρχει στη `capitals`.
2. **Μετρητής:** η `count` ξεκινά από $0$ **πριν** από τον βρόχο και αυξάνεται κατά $1$ μόνο μέσα στο `if`. Η λέξη είναι κείμενο, οπότε διαβάζεται με `raw_input`.
3. ```python
   capitals = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
   word = raw_input("Δώσε μια λέξη: ")
   count = 0
   for letter in word:
       if letter in capitals:
           count = count + 1
   print count
   ```
4. Για να το δοκιμάσεις εδώ, ο ίδιος βρόχος μπαίνει σε συνάρτηση που παίρνει τη λέξη ως παράμετρο. Το `print(...)` με ένα όρισμα δουλεύει ίδια και στις δύο εκδόσεις.

   *Διαδραστικό στη σελίδα: Κεφαλαία αγγλικά γράμματα*
5. **Έλεγχος:** τα `P`, `T`, `O`, `N` είναι στη `capitals`, άρα $4$. Τα πεζά `y`, `h` και το ψηφίο `3` δεν είναι, γιατί ο `in` ξεχωρίζει πεζά από κεφαλαία.

Για το δεύτερο παράδειγμα δίνεται το τμήμα:

```python
s = "PROGRAMMING"
print s[3] + s[-2]
print s[3:7]
print s[:3] + s[-3:]
print len(s[4:])
t = ""
for i in range(0, len(s), 3):
    t = t + s[i]
print t
```

### Παράδειγμα 2: Τι θα εμφανίσει το παραπάνω τμήμα προγράμματος;

1. **Πρώτα οι δείκτες.** Η `s` έχει $11$ χαρακτήρες, στις θέσεις $0$ ως $10$: `P` $0$, `R` $1$, `O` $2$, `G` $3$, `R` $4$, `A` $5$, `M` $6$, `M` $7$, `I` $8$, `N` $9$, `G` $10$.
2. **Ένας-ένας χαρακτήρας και φέτες.** `s[3]` είναι `G` και `s[-2]` είναι ο προτελευταίος, `N`· ενωμένοι, `GN`. Το `s[3:7]` παίρνει τις θέσεις $3$ ως $6$: `GRAM`. Το `s[:3]` είναι `PRO` και το `s[-3:]` είναι `ING`, μαζί `PROING`. Το `s[4:]` έχει $11 - 4 = 7$ χαρακτήρες.
3. **Ο βρόχος.** Η `range(0, 11, 3)` δίνει $0, 3, 6, 9$, άρα η `t` μαζεύει `P`, `G`, `M`, `N`.
4. *Διαδραστικό στη σελίδα: Δείκτες και φέτες*

### Παράδειγμα 3: Να γράψετε συνάρτηση isPalindrome(word) η οποία επιστρέφει True αν η λέξη word είναι παλινδρομική (καρκινική), δηλαδή διαβάζεται ίδια και από το τέλος προς την αρχή, αλλιώς False.

1. **Τι συγκρίνεις:** τον 1ο χαρακτήρα με τον τελευταίο, τον 2ο με τον προτελευταίο, κ.ο.κ. Αν η λέξη έχει μήκος `N`, ο χαρακτήρας στη θέση `i` έχει απέναντί του αυτόν στη θέση `N - 1 - i`.
2. **Πόσα ζευγάρια:** φτάνει να ελέγξεις τη μισή λέξη, `N / 2` θέσεις· με ακέραιους, ο `/` της 2.7 κόβει τα δεκαδικά. Στον runner γράφεται `N // 2`, που δίνει το ίδιο και στις δύο εκδόσεις. Στη `radar` αυτό σημαίνει τις θέσεις $0$ και $1$· ο μεσαίος χαρακτήρας δεν έχει ζευγάρι.
3. **Πότε σταματάς:** με την πρώτη διαφορά η απάντηση είναι ήδη `False` και δεν χρειάζεται να συνεχίσεις. Αν ο βρόχος τελειώσει χωρίς διαφορά, επιστρέφεις `True`.
4. *Διαδραστικό στη σελίδα: Παλινδρομική λέξη*

> **Θυμήσου**
>
> - Δείκτες από $0$ ως `len(s) - 1`· ο `s[-1]` είναι ο τελευταίος χαρακτήρας.
> - Ο `+` συνενώνει, ο `*` επαναλαμβάνει, η `len` δίνει το μήκος, οι `str` και `int` μετατρέπουν.
> - Η συμβολοσειρά είναι **μη μεταβαλλόμενη**: το `s[0] = "x"` δίνει σφάλμα· φτιάχνεις νέα με `+`.
> - Ο `in` βρίσκει συνεχόμενο κομμάτι· οι συγκρίσεις είναι λεξικογραφικές, και το `'1000' < '2'` είναι `True`.
> - Το `s[a:b]` δίνει από τη θέση `a` ως και τη `b - 1`, δηλαδή $b - a$ χαρακτήρες.

## Ερωτήσεις

1. Με word = "PYTHON", ποιος χαρακτήρας είναι ο word[2];
   - 'T'
   - 'Y'
   - 'H'
   - 'P'
2. Τι επιστρέφει η len("Kali mera");
   - 9
   - 8
   - 2
   - 10
3. Σωστό ή λάθος; Με word = "PYTHON", η εντολή word[0] = "J" κάνει τη word ίση με "JYTHON".
   - Λάθος: σταματά με TypeError
   - Σωστό: αλλάζει μόνο το πρώτο γράμμα
   - Λάθος: βάζει το J μπροστά, JPYTHON
   - Σωστό, αν η word έχει κεφαλαία
4. Ποια τιμή έχει η έκφραση '1000' < '2';
   - True
   - False
   - σφάλμα TypeError
   - εξαρτάται από το μήκος
5. Με word = "zanneio gymnasio", τι δίνει το word[3:11];
   - 'neio gym'
   - 'neio gy'
   - 'eio gym'
   - 'neio'
6. Ποια από τις παρακάτω εκφράσεις έχει τιμή True;
   - "Py" in "Python"
   - "py" in "Python"
   - "Pt" in "Python"
   - "Python" in "Py"
7. Τι εμφανίζει η εντολή print "3" + "4";
   - 34
   - 7
   - σφάλμα TypeError
   - 3 4
8. Τι εμφανίζει το τμήμα: c = 0, και μετά for x in "banana": if x == "a": c = c + 1, και στο τέλος print c;
   - 3
   - 6
   - 2
   - 1
9. Σωστό ή λάθος; Η έκφραση 'antonis' > 'antonia' έχει τιμή True.
   - Σωστό: στη θέση 6 το 's' είναι μετά το 'a'
   - Λάθος: έχουν ίδιο μήκος, και είναι ίσες
   - Λάθος: οι συμβολοσειρές δεν συγκρίνονται με >
   - Λάθος: το 'a' είναι μετά το 's'
10. Ποια έκφραση δίνει τους τρεις τελευταίους χαρακτήρες μιας συμβολοσειράς s;
   - s[-3:]
   - s[-3]
   - s[:3]
   - s[3:]

## Ασκήσεις

1. Ποιος είναι ο δείκτης του τελευταίου χαρακτήρα της συμβολοσειράς "KALIMERA", μετρώντας από την αρχή;
2. Με s = "zanneio gymnasio", γράψε τη φέτα της s που δίνει τη συμβολοσειρά 'gym'.
3. Τι εμφανίζει το τμήμα: t = "", και μετά for c in "banana": if c != "a": t = t + c, και στο τέλος print t;
4. Γράψε μία λογική έκφραση που είναι True μόνο όταν η συμβολοσειρά e περιέχει το «@», δεν περιέχει κενό και τελειώνει σε «.gr».
5. Γράφεις συνάρτηση count(s, sub) που επιστρέφει πόσες φορές εμφανίζεται η sub μέσα στη s. Για κάθε θέση i της s ελέγχεις αν η φέτα της s που ξεκινά στο i και έχει μήκος len(sub) είναι ίση με τη sub.
   α) Ποιο είναι το «μέχρι» της range(…), ώστε να ελεγχθεί και η τελευταία δυνατή θέση και καμία περιττή;
   β) Τι επιστρέφει η count("bananarama", "ana");
   γ) Τι επιστρέφει η count("aaaa", "aa");
6. Με alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZ" και cipher = alphabet[3:] + alphabet[:3], κάθε γράμμα ενός μηνύματος που βρίσκεται στη θέση i του alphabet κρυπτογραφείται ως cipher[i].
   α) Ποια λέξη κρυπτογραφείται ως "FDW";
   β) Γράψε, με δύο φέτες του alphabet, το αλφάβητο που αποκρυπτογραφεί: στη θέση του D να είναι το A.

---

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