# Αρχεία κειμένου

> open, read, readline, write, close, και οι τρόποι r, w, a.

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

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

- Να εξηγείς γιατί ένα πρόγραμμα αποθηκεύει δεδομένα σε αρχείο κειμένου.
- Να ανοίγεις αρχείο με την open και τον σωστό τρόπο προσπέλασης (r, w, a, r+) και να το κλείνεις με την close.
- Να γράφεις σε αρχείο με τη write, με την αλλαγή γραμμής και τη μετατροπή αριθμών με τη str.
- Να διαβάζεις αρχείο με τις read και readline και γραμμή γραμμή με for.
- Να βρίσκεις τι εμφανίζει ένα πρόγραμμα που γράφει και διαβάζει αρχεία.

## Γιατί αρχεία

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

Για να μη χάνονται, τα γράφεις σε **αρχείο**, σε μέσο μόνιμης αποθήκευσης όπως ο σκληρός δίσκος. Ως αρχεία δεδομένων χρησιμοποιούνται συνήθως **αρχεία κειμένου**: αρχεία που περιέχουν μια ακολουθία χαρακτήρων. Η ανάγνωση και η εγγραφή τους λέγεται **είσοδος/έξοδος αρχείου**.

Ένα πρόγραμμα δουλεύει έτσι με δύο είδη αρχείων: το αρχείο που περιέχει το ίδιο το πρόγραμμα, για παράδειγμα το demo.py, και τα αρχεία με τα **δεδομένα** που διαβάζει όταν εκτελείται και που ίσως ενημερώνει. Ένα αρχείο κειμένου μπορείς να το φτιάξεις και με έναν συντάκτη, όπως το Notepad, και να το διαβάσεις μετά από το πρόγραμμα.

## Άνοιγμα και κλείσιμο

Ένα αρχείο, για να χρησιμοποιηθεί, ανοίγει με την ενσωματωμένη συνάρτηση `open` και στο τέλος κλείνει με την `close`. Η `open` δεν θέλει `import`:

```python
fin = open("words.txt", "r")
```

Το πρώτο όρισμα είναι το **όνομα του αρχείου**. Το δεύτερο είναι ο **τρόπος προσπέλασης**. Η `open` επιστρέφει ένα αντικείμενο αρχείου, που εδώ το κρατά η μεταβλητή `fin`. Όλες οι λειτουργίες πάνω στο words.txt γίνονται από εδώ και πέρα μέσω της `fin`.

| Τρόπος | Λειτουργία                                           | Αν το αρχείο δεν υπάρχει |
| ------ | ---------------------------------------------------- | ------------------------ |
| `"r"`  | ανάγνωση                                             | σφάλμα                   |
| `"w"`  | εγγραφή· τα προηγούμενα περιεχόμενα **διαγράφονται** | δημιουργείται            |
| `"a"`  | προσθήκη στο τέλος· τα προηγούμενα **διατηρούνται**  | δημιουργείται            |
| `"r+"` | ανάγνωση και εγγραφή                                 | σφάλμα                   |

Αν λείπει το δεύτερο όρισμα, ο τρόπος είναι `"r"`: η `open("words.txt")` ανοίγει για ανάγνωση.

Όταν τελειώσεις, καλείς **πάντα** την `close`. Έτσι το λειτουργικό σύστημα αποθηκεύει ό,τι έχει μείνει ακόμα στη μνήμη και απελευθερώνει το αρχείο. Η ιδιότητα `closed` λέει αν το αρχείο έκλεισε:

```python
fin = open("workfile.txt", "w")
print fin.closed    # False
fin.close()
print fin.closed    # True
```

> **Πρόσεχε**
>
> **Ο τρόπος `"w"` σβήνει το αρχείο.** Αν το words.txt έχει ήδη γραμμές και το ανοίξεις με `"w"`, μένει άδειο πριν γράψεις τίποτα. Για να προσθέσεις δεδομένα σε αρχείο που υπάρχει, το ανοίγεις με `"a"`.
>
> Και ο τρόπος ορίζει τι επιτρέπεται: σε αρχείο ανοιγμένο με `"w"` η `read` δίνει σφάλμα, και σε κλειστό αρχείο κάθε ανάγνωση ή εγγραφή δίνει σφάλμα.

## Εγγραφή με τη write

Η μέθοδος `write` γράφει στο αρχείο τη συμβολοσειρά που της δίνεις. Για να υπάρχουν **γραμμές** και όχι συνεχόμενοι χαρακτήρες, σημειώνεις το τέλος κάθε γραμμής με τον χαρακτήρα αλλαγής γραμμής `"\n"`.

```python
fin = open("words.txt", "w")
fin.write("This is line 1\n")
fin.write("This is line 2\n")
fin.write("This is line 3\n")
fin.close()
```

Το words.txt έχει τώρα τρεις γραμμές. Για να προσθέσεις μια τέταρτη χωρίς να χαθούν οι τρεις, ανοίγεις με `"a"`:

```python
fin = open("words.txt", "a")
fin.write("This is line 4\n")
fin.close()
```

Το όρισμα της `write` πρέπει να είναι **συμβολοσειρά**. Ένας αριθμός μετατρέπεται πρώτα με τη `str`: η `fin.write(52)` δίνει `TypeError`, ενώ η `fin.write(str(52) + "\n")` γράφει τη γραμμή `52`.

## Ανάγνωση με τις read και readline

Στα παραδείγματα που ακολουθούν, το words.txt έχει τις τέσσερις γραμμές.

Η `read(count)` διαβάζει `count` χαρακτήρες. Χωρίς όρισμα, η `read()` διαβάζει ως το τέλος του αρχείου:

```python
fin = open("words.txt", "r")
print fin.read(1)      # T
print fin.read(13)     # his is line 1
print fin.read()
fin.close()
```

Η δεύτερη `read` δεν ξεκινά από την αρχή. Συνεχίζει από το `h`, εκεί που σταμάτησε η πρώτη. Η τρίτη δίνει **το υπόλοιπο** του αρχείου: την αλλαγή γραμμής που έμεινε μετά το `line 1` και τις γραμμές 2 ως 4. Γι' αυτό το `print` της εμφανίζει πρώτα μια κενή γραμμή.

> **Κλειδί**
>
> **Το αντικείμενο αρχείου θυμάται πού βρίσκεται.** Κάθε ανάγνωση ξεκινά από εκεί που τελείωσε η προηγούμενη και μετακινεί τη θέση πιο κάτω. Για να ξαναδιαβάσεις από την αρχή, κλείνεις και ξανανοίγεις το αρχείο.
>
> Στο τέλος του αρχείου δεν υπάρχει τίποτα άλλο: η `read()` και η `readline()` επιστρέφουν κενή συμβολοσειρά, `""`.

Η `readline()` διαβάζει **μία γραμμή**: διαδοχικούς χαρακτήρες ως και τον χαρακτήρα αλλαγής γραμμής. Η επόμενη κλήση δίνει την επόμενη γραμμή:

```python
fin = open("words.txt")
print fin.readline()    # This is line 1, και μια κενή γραμμή
print fin.readline()    # This is line 2, και μια κενή γραμμή
fin.close()
```

Για να περάσεις όλες τις γραμμές με τη σειρά, γράφεις `for` πάνω στο ίδιο το αρχείο:

```python
for line in fin:
    print line
```

Η συνάρτηση `linecount` μετρά έτσι τις γραμμές ενός αρχείου:

```python
def linecount(filename):
    count = 0
    for line in open(filename):
        count = count + 1
    return count
```

> **Πρόσεχε**
>
> **Κάθε γραμμή που διαβάζεις τελειώνει με `"\n"`.** Η `readline()` δίνει `"This is line 1\n"`, όχι `"This is line 1"`. Αν την εμφανίσεις με `print`, το `print` προσθέτει δική του αλλαγή γραμμής, και βγαίνει μια κενή γραμμή ανάμεσα σε κάθε δύο. Έτσι κάνει και το `for line in fin: print line`.
>
> - Για να εμφανιστούν οι γραμμές όπως είναι στο αρχείο: `print line,`. Το κόμμα στο τέλος κόβει την αλλαγή γραμμής του `print`.
> - Για να συγκρίνεις μια γραμμή με κείμενο, κόβεις πρώτα το `"\n"`: `line.strip() == "15"`. Η `"15\n" == "15"` είναι `False`.
> - Η `int(line)` δέχεται το `"15\n"` και δίνει `15`, γιατί αγνοεί τα κενά και την αλλαγή γραμμής στις άκρες.

## Θέση μέσα στο αρχείο

Η `fin.tell()` επιστρέφει την τρέχουσα θέση, σε χαρακτήρες από την αρχή του αρχείου. Εκεί θα γίνει η επόμενη ανάγνωση ή εγγραφή. Μετά το `read(1)` και το `read(13)` του παραδείγματος, η `tell()` δίνει `14`.

Η `fin.seek(offset, from_what)` αλλάζει την τρέχουσα θέση: προσθέτει `offset` χαρακτήρες σε ένα σημείο αναφοράς. Με `from_what` ίσο με $0$ μετρά από την αρχή του αρχείου (το ίδιο όταν λείπει), με $1$ από την τρέχουσα θέση, με $2$ από το τέλος:

```python
fin = open("workfile", "r+")
fin.write("0123456789abcdef")
fin.seek(5)        # στον 6ο χαρακτήρα
print fin.read(1)  # 5
fin.seek(-3, 2)    # 3 χαρακτήρες πριν από το τέλος
print fin.read(1)  # d
fin.close()
```

Ο τρόπος `"r+"` θέλει το workfile να υπάρχει ήδη.

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

Το επόμενο πρόγραμμα γράφει σε αρχείο τα τετράγωνα των αριθμών από $1$ ως $5$ και μετά το διαβάζει:

```python
f = open("output.txt", "w")
for i in range(1, 6):
    f.write(str(i * i) + "\n")
f.close()
f = open("output.txt", "r")
print f.readline()
print f.read()
f.close()
```

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

1. **Το αρχείο:** ο βρόχος γράφει πέντε γραμμές, `1`, `4`, `9`, `16`, `25`, καθεμία με το δικό της `"\n"`. Η `str` χρειάζεται, γιατί το `i * i` είναι ακέραιος.
2. **Η `readline()`** δίνει `"1\n"`. Το `print` εμφανίζει το `1`, και η δική του αλλαγή γραμμής αφήνει μια κενή γραμμή.
3. **Η `read()`** συνεχίζει από τη δεύτερη γραμμή και δίνει `"4\n9\n16\n25\n"`. Μετά το `25` υπάρχει πάλι το `"\n"` του αρχείου και η αλλαγή γραμμής του `print`:
   ```text
   1

   4
   9
   16
   25

   ```

### Παράδειγμα 2: Να γράψετε πρόγραμμα σε Python το οποίο θα διαβάζει το αρχείο input\_file.txt και θα το ξαναγράφει στο νέο αρχείο output\_file.txt, προσθέτοντας πριν από κάθε γραμμή τον αύξοντα αριθμό της.

1. **Δύο αρχεία, δύο τρόποι:** το input\_file.txt ανοίγει με `"r"`, το output\_file.txt με `"w"`, γιατί είναι νέο. Ένας μετρητής `linecounter` ξεκινά από $1$.
2. ```python
   inputFile = open("input_file.txt", "r")
   outputFile = open("output_file.txt", "w")
   linecounter = 1
   for line in inputFile:
       outputFile.write(str(linecounter) + ". " + line)
       linecounter = linecounter + 1
   inputFile.close()
   outputFile.close()
   ```
3. **Γιατί δεν προστίθεται `"\n"`:** κάθε `line` έχει ήδη το δικό της στο τέλος. Αν το input\_file.txt έχει τις γραμμές `Python`, `files`, `are easy`, το output\_file.txt γίνεται `1. Python`, `2. files`, `3. are easy`, σε τρεις γραμμές.

### Παράδειγμα 3: Να γράψετε πρόγραμμα σε Python το οποίο θα γράφει τους άρτιους αριθμούς από το 2 ως το 1000 σε αρχείο, έναν σε κάθε γραμμή. Στη συνέχεια θα διαβάζει τους αριθμούς από το αρχείο και θα γράφει το άθροισμά τους στο τέλος του, χωρίς να σβήσει τα περιεχόμενα.

1. **Τρία ανοίγματα, τρεις τρόποι:** `"w"` για να γραφτούν οι αριθμοί, `"r"` για να διαβαστούν, `"a"` για να μπει το άθροισμα στο τέλος χωρίς να χαθεί τίποτα.
2. ```python
   f = open("artioi.txt", "w")
   for i in range(2, 1001, 2):
       f.write(str(i) + "\n")
   f.close()
   f = open("artioi.txt", "r")
   athroisma = 0
   for line in f:
       athroisma = athroisma + int(line)
   f.close()
   f = open("artioi.txt", "a")
   f.write(str(athroisma) + "\n")
   f.close()
   ```
3. **Έλεγχος:** το αρχείο έχει $500$ αριθμούς και στη $501$η γραμμή το άθροισμα, `250500`. Η `int(line)` διαβάζει κάθε γραμμή μαζί με το `"\n"` της χωρίς σφάλμα.

### Παράδειγμα 4: Να γράψετε πρόγραμμα σε Python το οποίο θα εμφανίζει τις γραμμές του αρχείου demo.txt και μετά θα τις γράφει σε άλλο αρχείο, το reversed.txt, με την αντίστροφη σειρά.

1. **Η σειρά αντιστρέφεται μόνο αν έχεις όλες τις γραμμές:** τις διαβάζεις και τις κρατάς σε μια λίστα `grammes`, και μετά τη διατρέχεις από το τέλος προς την αρχή.
2. ```python
   fin = open("demo.txt", "r")
   grammes = []
   for line in fin:
       print line,
       grammes.append(line)
   fin.close()
   fout = open("reversed.txt", "w")
   for i in range(len(grammes) - 1, -1, -1):
       fout.write(grammes[i])
   fout.close()
   ```
3. **Η `range(len(grammes) - 1, -1, -1)`** δίνει τις θέσεις από την τελευταία ως και το $0$. Με τέλος το $0$ αντί για το $-1$, η πρώτη γραμμή του αρχείου δεν θα γραφόταν ποτέ.

> **Στον υπολογιστή σου, με Python 3**
>
> Οι `open`, `read`, `readline`, `write` και `close` γράφονται ίδια. Αλλάζει το `print`: `print(fin.read(1))` αντί για `print fin.read(1)`, και `print(line, end="")` αντί για `print line,`. Το σφάλμα για αρχείο που λείπει λέγεται `FileNotFoundError`. Σε αρχείο κειμένου η `seek` δέχεται μετατόπιση μόνο από την αρχή: η `seek(-3, 2)` δίνει σφάλμα.

> **Θυμήσου**
>
> - `open(όνομα, τρόπος)`: `"r"` ανάγνωση (προεπιλογή), `"w"` εγγραφή που σβήνει, `"a"` προσθήκη στο τέλος, `"r+"` και τα δύο.
> - Πάντα `close()` στο τέλος· η `closed` λέει αν έκλεισε.
> - Η `write` θέλει συμβολοσειρά: `str` για τους αριθμούς, `"\n"` για αλλαγή γραμμής.
> - `read(n)` διαβάζει `n` χαρακτήρες, `read()` ως το τέλος, `readline()` μία γραμμή, `for line in f` όλες με τη σειρά.
> - Κάθε ανάγνωση συνεχίζει από εκεί που σταμάτησε η προηγούμενη. Κάθε γραμμή τελειώνει με `"\n"`.

Η ενότητα 6.3 του βιβλίου (ιδιότητες name και mode, διαδρομές και το άρθρωμα os) δεν εξετάζεται.

## Ερωτήσεις

1. Σωστό ή Λάθος: Η `open("data.txt", "w")` διατηρεί τα περιεχόμενα του data.txt, αν το αρχείο υπάρχει ήδη.
   - Λάθος: τα περιεχόμενα διαγράφονται
   - Σωστό: γράφει μετά το τέλος τους
   - Σωστό: μόνο ο τρόπος "r" τα σβήνει
   - Λάθος: η open δίνει σφάλμα
2. Θέλεις να προσθέσεις γραμμές στο τέλος του log.txt χωρίς να χαθούν όσες έχει. Με ποιον τρόπο προσπέλασης το ανοίγεις;
   - "a"
   - "w"
   - "r"
   - χωρίς δεύτερο όρισμα
3. Η εντολή `fin = open("words.txt")` δεν έχει δεύτερο όρισμα. Για ποιο σκοπό ανοίγει το αρχείο;
   - για ανάγνωση
   - για εγγραφή
   - για ανάγνωση και εγγραφή
   - δεν ανοίγει, γιατί λείπει όρισμα
4. Ένα πρόγραμμα ανοίγει το a.txt με "w", καλεί `f.write("abc")` και `f.write("def")` και το κλείνει. Τι εμφανίζει μετά το `print open("a.txt").read()`;
   - abcdef, σε μία γραμμή
   - abc και def, σε δύο γραμμές
   - μόνο def
   - abc def, με ένα κενό
5. Ποια εντολή γράφει σωστά τον ακέραιο `x = 52` σε αρχείο ανοιγμένο για εγγραφή, ως μία γραμμή;
   - f.write(str(x) + "\n")
   - f.write(x + "\n")
   - f.write(x)
   - f.write(int(x) + "\n")
6. Το words.txt ξεκινά με τη γραμμή This is line 1. Τι επιστρέφει η πρώτη `fin.readline()` μετά το άνοιγμα;
   - "This is line 1\n"
   - "This is line 1"
   - "T"
   - ολόκληρο το αρχείο
7. Το πρόγραμμα `for line in fin: print line` εμφανίζει μια κενή γραμμή ανάμεσα σε κάθε δύο γραμμές του αρχείου. Γιατί;
   - η line έχει ήδη "\n" και το print βάζει ένα ακόμα
   - το αρχείο έχει κενές γραμμές ανάμεσα στις γραμμές του
   - η for διαβάζει κάθε γραμμή δύο φορές
   - το αρχείο άνοιξε με "w" αντί για "r"
8. Σωστό ή Λάθος: Αν ανοίξεις με "r" ένα αρχείο που δεν υπάρχει, η Python το δημιουργεί κενό.
   - Λάθος: η open δίνει σφάλμα
   - Σωστό: όπως κάνουν και ο "w" και ο "a"
   - Σωστό: και η read επιστρέφει ""
   - Λάθος: η open επιστρέφει None
9. Γιατί ένα πρόγραμμα καλεί την close όταν τελειώσει με ένα αρχείο;
   - για να αποθηκευτούν όσα έμειναν στη μνήμη
   - για να διαγραφεί το αρχείο από τον δίσκο
   - για να ξεκινήσει η ανάγνωση από την αρχή
   - για να αλλάξει ο τρόπος σε "r"
10. Το n.txt έχει τρεις γραμμές: 10, 20, 30. Τι εμφανίζει το `s = 0`, `for line in open("n.txt"): s = s + int(line)`, `print s`;
   - 60
   - 102030
   - σφάλμα, λόγω του "\n"
   - 30

## Ασκήσεις

1. Ποια ιδιότητα του αντικειμένου αρχείου δείχνει αν το αρχείο έχει κλείσει, και ποια τιμή έχει μετά την `close()`;
2. Το b.txt έχει δύο γραμμές: 12345 και 678. Ένα πρόγραμμα το ανοίγει για ανάγνωση, καλεί `f.read(3)` και μετά `f.readline()`. Τι επιστρέφει η `readline`;
3. Ένα πρόγραμμα ανοίγει το a.txt με "w" και γράφει `"X\n"`, μετά το ανοίγει με "a" και γράφει `"Y\n"`, και τέλος το ανοίγει με "w" και γράφει `"Z\n"`. Κάθε φορά το κλείνει. Τι περιέχει στο τέλος το a.txt;
4. Ένα πρόγραμμα ανοίγει το e4.txt με "w", καλεί `f.write("a\nb")` και μετά `f.write("c\n")`, και το κλείνει.
   α) Ποια τιμή επιστρέφει η `linecount("e4.txt")` της ενότητας;
   β) Τι περιέχει η δεύτερη γραμμή του αρχείου;
5. Το vathmoi.txt έχει τέσσερις γραμμές, καθεμία με το `"\n"` της: 15, 18, 12, 20. Ένα πρόγραμμα το διαβάζει με `for line in fin` και αθροίζει με `int(line)`. Μετά το ανοίγει με "a" και γράφει τη γραμμή `"Mesos oros: " + str(athroisma / plithos) + "\n"`.
   α) Ποια γραμμή προστίθεται στο αρχείο με την πρώτη εκτέλεση;
   β) Τι γίνεται αν το πρόγραμμα εκτελεστεί δεύτερη φορά;
   γ) Πόσες γραμμές έχει το αρχείο μετά τη δεύτερη εκτέλεση;
6. Το c.txt γράφτηκε με `f.write("ab\ncd\n")`. Ένα πρόγραμμα το ανοίγει για ανάγνωση και εκτελεί `x = f.readline()`, `y = f.read(1)`, `z = f.read()`, `print len(x), y, len(z)`.
   α) Τι εμφανίζει το print;
   β) Τι επιστρέφει μια `f.readline()` αμέσως μετά;

---

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