# Εμβέλεια μεταβλητών και αρθρώματα

> Τοπικές και καθολικές μεταβλητές, η global, το import και η πρότυπη βιβλιοθήκη.

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

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

- Να ξεχωρίζεις τις τοπικές από τις καθολικές μεταβλητές ενός προγράμματος Python.
- Να βρίσκεις τι εμφανίζει ένα πρόγραμμα όταν μια τοπική μεταβλητή έχει το ίδιο όνομα με μια καθολική.
- Να χρησιμοποιείς την εντολή global και να ξέρεις πότε η return είναι καλύτερη λύση.
- Να εισάγεις αρθρώματα με import και from … import και να καλείς τις συναρτήσεις τους με συμβολισμό τελείας.
- Να περιγράφεις την πρότυπη βιβλιοθήκη, τα αρθρώματα math και random και τα πακέτα.

## Πού «φαίνεται» μια μεταβλητή

Μια μεταβλητή δεν είναι προσπελάσιμη από όλα τα σημεία ενός προγράμματος. **Εμβέλεια** (scope) μιας μεταβλητής λέγεται το τμήμα του προγράμματος από το οποίο έχεις πρόσβαση σε αυτήν.

Οι γλώσσες προγραμματισμού έχουν δύο τύπους εμβέλειας:

| Εμβέλεια         | Οι μεταβλητές λέγονται | Πού ισχύουν                                                 |
| ---------------- | ---------------------- | ----------------------------------------------------------- |
| **απεριόριστη**  | **καθολικές** (global) | σε οποιοδήποτε τμήμα του προγράμματος, όπου κι αν δηλώθηκαν |
| **περιορισμένη** | **τοπικές** (local)    | μόνο στο υποπρόγραμμα όπου δηλώθηκαν                        |

Οι καθολικές μεταβλητές έχουν ένα μειονέκτημα: περιορίζουν την **ανεξαρτησία** των υποπρογραμμάτων. Μια συνάρτηση που αλλάζει μια καθολική μεταβλητή επηρεάζει όλο το πρόγραμμα, και το αποτέλεσμά της εξαρτάται από ό,τι έγινε πριν από την κλήση της.

## Καθολικές και τοπικές μεταβλητές στην Python

Στην Python ο κανόνας είναι απλός:

- Μια μεταβλητή που ορίζεται **μέσα** στο σώμα μιας συνάρτησης είναι **τοπική**. Προσπελαύνεται μόνο μέσα σε αυτή τη συνάρτηση.
- Μια μεταβλητή που ορίζεται **έξω** από κάθε συνάρτηση, στο κύριο πρόγραμμα, είναι **καθολική**. Μπορούν να τη διαβάσουν όλες οι συναρτήσεις.

Στο παρακάτω πρόγραμμα υπάρχουν δύο μεταβλητές με το ίδιο όνομα `total`. Η μία είναι καθολική και η άλλη τοπική στη συνάρτηση `prosthese`.

```python
total = 0

def prosthese(arg1, arg2):
    total = arg1 + arg2
    print "Μέσα στη συνάρτηση η τοπική total:", total
    return total

prosthese(10, 20)
print "Έξω από τη συνάρτηση η καθολική total:", total
```

```text
Μέσα στη συνάρτηση η τοπική total: 30
Έξω από τη συνάρτηση η καθολική total: 0
```

Η εκχώρηση `total = arg1 + arg2` **δεν** άλλαξε την καθολική `total`. Δημιούργησε μια νέα, τοπική μεταβλητή με το ίδιο όνομα. Η τιμή $30$ επιστράφηκε με τη `return`, αλλά το κύριο πρόγραμμα δεν την αποθήκευσε πουθενά, οπότε χάθηκε.

### Τι ισχύει για τις τοπικές μεταβλητές

- Δεν έχουν καμία σχέση με μεταβλητές που έχουν το ίδιο όνομα έξω από τη συνάρτηση.
- **Χάνονται** όταν τελειώσει η εκτέλεση της συνάρτησης. Κάθε νέα κλήση δημιουργεί **νέες** τοπικές μεταβλητές.
- Και οι **παράμετροι** είναι τοπικές μεταβλητές της συνάρτησης.

Το τελευταίο φαίνεται όταν η παράμετρος έχει το ίδιο όνομα με μια καθολική:

```python
x = 50

def func(x):
    print "Το x είναι", x
    x = 2
    print "Το τοπικό x άλλαξε σε", x

func(x)
print "Το x είναι ακόμα", x
```

```text
Το x είναι 50
Το τοπικό x άλλαξε σε 2
Το x είναι ακόμα 50
```

Δοκίμασέ το βήμα βήμα. Το `print(...)` με ένα όρισμα δουλεύει ίδια και στις δύο εκδόσεις της Python.

*Διαδραστικό στη σελίδα: Η παράμετρος x*

Αντίστροφα, μια συνάρτηση μπορεί να **διαβάσει** μια καθολική μεταβλητή, αρκεί να μην της εκχωρεί τιμή:

```python
name = "black"

def f():
    print "Μέσα στη συνάρτηση", name

print "Έξω από τη συνάρτηση", name
f()
```

```text
Έξω από τη συνάρτηση black
Μέσα στη συνάρτηση black
```

> **Κλειδί**
>
> **Η εκχώρηση αποφασίζει.** Αν μέσα σε μια συνάρτηση εκχωρείς τιμή σε μια μεταβλητή, η Python τη θεωρεί **τοπική**, εκτός αν δηλώσεις ρητά το αντίθετο. Αν μόνο τη **διαβάζεις** και δεν υπάρχει τοπικά, η Python την αναζητά στην καθολική εμβέλεια.
>
> Η τοπική μεταβλητή με το ίδιο όνομα **υπερκαλύπτει** την καθολική μόνο μέσα στη συνάρτηση, και χάνεται μαζί με την κλήση.

## Η εντολή global

Αν θέλεις μια συνάρτηση να **αλλάξει** την τιμή μιας καθολικής μεταβλητής, το δηλώνεις με την εντολή `global`, πριν από την πρώτη χρήση της μεταβλητής στη συνάρτηση:

```python
myGlobal = 5

def func1():
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()
```

```text
5
```

Η `func1` δημιούργησε μια τοπική `myGlobal`, που χάθηκε μόλις τελείωσε. Η `func2` δεν βλέπει ποτέ τι έγινε μέσα σε άλλη συνάρτηση: βλέπει μόνο την καθολική, που έμεινε $5$. Με τη δήλωση `global` στη `func1`, η εκχώρηση πηγαίνει στην καθολική:

```python
myGlobal = 5

def func1():
    global myGlobal
    myGlobal = 42

def func2():
    print myGlobal

func1()
func2()
```

```text
42
```

> **Πρόσεχε**
>
> **Διάβασμα και μετά εκχώρηση, χωρίς `global`, είναι σφάλμα.** Η Python αποφασίζει ότι μια μεταβλητή είναι τοπική για **όλη** τη συνάρτηση, μόλις δει μια εκχώρηση σε αυτήν οπουδήποτε μέσα στο σώμα. Η `print x` εδώ δεν διαβάζει την καθολική $10$:
>
> ```python
> x = 10
>
> def f():
>     print x
>     x = 5
>
> f()
> ```
>
> ```text
> UnboundLocalError: local variable 'x' referenced before assignment
> ```
>
> Το ίδιο συμβαίνει με το `metritis = metritis + 1` μέσα σε συνάρτηση: θέλει `global metritis`, ή, καλύτερα, η τιμή να μπαίνει ως όρισμα και να επιστρέφεται με `return`.

## Αρθρώματα (modules)

Με τις συναρτήσεις ξαναχρησιμοποιείς κώδικα μέσα στο **ίδιο** πρόγραμμα. Για να ξαναχρησιμοποιήσεις συναρτήσεις σε **άλλα** προγράμματα, τις βάζεις σε ένα **άρθρωμα** (module).

Ένα άρθρωμα είναι ένα αρχείο με κώδικα Python, με επέκταση `.py`, που ορίζει συναρτήσεις, μεταβλητές (και κλάσεις). Η ομαδοποίηση σχετικού κώδικα σε ένα άρθρωμα κάνει τον κώδικα ευκολότερο στην κατανόηση και στη χρήση. Για να χρησιμοποιήσεις ένα άρθρωμα, το **εισάγεις** με τη δήλωση `import`.

| Δήλωση                      | Τι εισάγει                        | Πώς καλείς                                                 |
| --------------------------- | --------------------------------- | ---------------------------------------------------------- |
| `import math`               | όλο το άρθρωμα                    | `math.sqrt(81)`, με το όνομα του αρθρώματος και τελεία     |
| `from math import sqrt, pi` | μόνο τα ονόματα που γράφεις       | `sqrt(81)`, χωρίς τελεία                                   |
| `from math import *`        | όλα τα περιεχόμενα του αρθρώματος | `cos(pi)`, χωρίς τελεία· δεν ενδείκνυται η συχνή χρήση του |

Η γραφή `math.sqrt` λέγεται **συμβολισμός με τελεία** (dot notation): πρώτα το όνομα του αρθρώματος, μετά το όνομα της συνάρτησης. Αν έγραψες `import math` και μετά σκέτο `pi`, παίρνεις μήνυμα λάθους, γιατί το `pi` ανήκει στο άρθρωμα.

### Τρεις κατηγορίες συναρτήσεων

Σε ένα πρόγραμμα συνυπάρχουν:

1. οι **ενσωματωμένες** (built-in), όπως η `abs`, η `len`, η `range`. Είναι πάντα διαθέσιμες, γιατί αποτελούν μέρος του πυρήνα της γλώσσας.
2. οι συναρτήσεις **εξωτερικών αρθρωμάτων**, όπως η `sqrt` του `math`. Πρέπει πρώτα να εισαχθούν.
3. οι συναρτήσεις που ορίζει ο **προγραμματιστής** με τη `def`.

```python
from math import sqrt

def cube(x):
    return x * x * x

print abs(-1)
print cube(9)
print sqrt(81)
```

```text
1
729
9.0
```

Η `abs` είναι ενσωματωμένη, η `sqrt` έρχεται από το `math` και η `cube` είναι δική σου. Η `sqrt` επιστρέφει πάντα πραγματικό αριθμό, γι' αυτό εμφανίζει `9.0`.

### Δικό σου άρθρωμα

Αποθηκεύεις τις συναρτήσεις σου σε ένα αρχείο, για παράδειγμα `geometria.py`:

```python
# αρχείο geometria.py
def emvado_orthogoniou(a, b):
    return a * b

def perimetros_orthogoniou(a, b):
    return 2 * (a + b)
```

Ένα άλλο πρόγραμμα, στον ίδιο φάκελο, το εισάγει με το όνομα του αρχείου χωρίς το `.py`:

```python
import geometria

print geometria.emvado_orthogoniou(4, 3)
print geometria.perimetros_orthogoniou(4, 3)
```

```text
12
14
```

## Η πρότυπη βιβλιοθήκη και τα πακέτα

**Βιβλιοθήκη** είναι μια συλλογή εργαλείων, γραμμένων συχνά από άλλους προγραμματιστές, για συγκεκριμένες λειτουργίες. Η **πρότυπη βιβλιοθήκη** (standard library) της Python έρχεται με κάθε εγκατάσταση και περιέχει πολλά χρήσιμα αρθρώματα: για γραφικά (Tkinter), για αριθμητική επεξεργασία, για βάσεις δεδομένων (Sqlite3), για το διαδίκτυο. Πολλά προβλήματα λύνονται γρήγορα, αν ξέρεις τι υπάρχει ήδη έτοιμο.

Το άρθρωμα **`math`** έχει τις πιο συνηθισμένες μαθηματικές συναρτήσεις και σταθερές:

```python
import math

print math.pi
print math.sqrt(2)
print math.cos(math.pi)
```

```text
3.14159265359
1.41421356237
-1.0
```

Το άρθρωμα **`random`** δίνει ψευδοτυχαίους αριθμούς. Η έξοδος αλλάζει σε κάθε εκτέλεση:

| Κλήση                                        | Τι επιστρέφει                                            |
| -------------------------------------------- | -------------------------------------------------------- |
| `random.random()`                            | πραγματικό αριθμό από $0$ ως $1$, χωρίς το $1$           |
| `random.randrange(6)`                        | ακέραιο από τη `range(6)`, δηλαδή $0$ ως $5$             |
| `random.choice(['apple', 'pear', 'banana'])` | ένα τυχαίο στοιχείο της λίστας                           |
| `random.sample(range(100), 10)`              | λίστα με $10$ διαφορετικούς αριθμούς από τη `range(100)` |

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

Οι μεταβλητές πηγαίνουν μέσα στις συναρτήσεις, και οι συναρτήσεις μέσα στα αρθρώματα. Τα αρθρώματα οργανώνονται κι αυτά ιεραρχικά σε **πακέτα** (packages). Ένα πακέτο είναι ένας κατάλογος (φάκελος) με αρθρώματα, που περιέχει και ένα αρχείο `__init__.py`.

> **Στον υπολογιστή σου, με Python 3**
>
> Το βιβλίο και οι εξετάσεις γράφουν Python 2.7. Στην Python 3 η `print` θέλει παρενθέσεις, `print(math.pi)`, και οι πραγματικοί εμφανίζονται με όλα τους τα ψηφία (`3.141592653589793`). Η `input()` δίνει πάντα κείμενο, οπότε για αριθμό γράφεις `float(input(…))`. Το μήνυμα του `UnboundLocalError` είναι διατυπωμένο αλλιώς, αλλά το σφάλμα είναι το ίδιο.

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

### Παράδειγμα 1: Τι θα εμφανίσει το παρακάτω πρόγραμμα; Να εξηγήσετε ποιες μεταβλητές είναι τοπικές και ποιες καθολικές.

1. ```python
   x = 3
   y = 10

   def f(x):
       y = x + 1
       x = x * 2
       print x, y
       return x + y

   z = f(y)
   print x, y, z
   ```
2. **Καθολικές** είναι οι `x`, `y`, `z` του κύριου προγράμματος. **Τοπικές** στην `f` είναι η παράμετρος `x` και η `y`, γιατί της εκχωρείται τιμή μέσα στη συνάρτηση.
3. Η κλήση `f(y)` δίνει στην τοπική `x` την τιμή $10$. Τότε η τοπική `y` γίνεται $11$ και η τοπική `x` γίνεται $20$. Εμφανίζεται `20 11` και επιστρέφεται $20 + 11 = 31$.
4. Οι καθολικές `x` και `y` δεν άλλαξαν. Η `z` πήρε την τιμή που επέστρεψε η `f`. Εμφανίζονται:
   ```text
   20 11
   3 10 31
   ```

### Παράδειγμα 2: Ένα πρόγραμμα κρατά το υπόλοιπο ενός λογαριασμού στην καθολική μεταβλητή ypoloipo. Γράψε τη συνάρτηση katathesi(poso) που το αυξάνει, μία φορά με global και μία χωρίς.

1. **Με `global`.** Η συνάρτηση εκχωρεί τιμή στην `ypoloipo`, άρα χωρίς δήλωση θα ήταν τοπική (και θα έβγαζε `UnboundLocalError`, γιατί τη διαβάζει πρώτα).
   ```python
   ypoloipo = 100

   def katathesi(poso):
       global ypoloipo
       ypoloipo = ypoloipo + poso

   katathesi(50)
   katathesi(20)
   print ypoloipo
   ```
2. **Χωρίς `global`.** Το υπόλοιπο μπαίνει ως όρισμα και το νέο υπόλοιπο επιστρέφεται. Την εκχώρηση την κάνει το κύριο πρόγραμμα. Εδώ το `print(...)` έχει ένα όρισμα, οπότε το πρόγραμμα τρέχει ίδια και στις δύο εκδόσεις:

   *Διαδραστικό στη σελίδα: Κατάθεση με return*
3. Και τα δύο εμφανίζουν $170$. Η δεύτερη συνάρτηση όμως είναι **ανεξάρτητη**: δεν εξαρτάται από καμία καθολική μεταβλητή και μπορεί να χρησιμοποιηθεί για οποιονδήποτε λογαριασμό.

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

1. **Ποια εισαγωγή:** χρειάζεσαι μόνο τη σταθερά `pi`, οπότε αρκεί το `from math import pi`. Με `import math` θα έγραφες `math.pi`.
2. **Ποιες συναρτήσεις:** η ακτίνα είναι αριθμός, άρα τη διαβάζεις με `input`. Η `round` είναι ενσωματωμένη και δεν θέλει εισαγωγή.
   ```python
   from math import pi

   r = input("Ακτίνα: ")
   e = pi * r * r
   print "Εμβαδόν:", round(e, 2)
   ```
3. **Έλεγχος:** με ακτίνα $2$, το εμβαδόν είναι $\pi \cdot 4 \approx 12{,}566$, και εμφανίζεται `Εμβαδόν: 12.57`.

> **Θυμήσου**
>
> - Εμβέλεια: το τμήμα του προγράμματος από το οποίο προσπελαύνεται μια μεταβλητή.
> - Τοπική: ορίζεται μέσα σε συνάρτηση (και κάθε παράμετρος). Χάνεται όταν τελειώσει η κλήση.
> - Καθολική: ορίζεται έξω από κάθε συνάρτηση. Οι συναρτήσεις τη διαβάζουν, αλλά την αλλάζουν μόνο με `global`.
> - Άρθρωμα: αρχείο `.py` με συναρτήσεις και μεταβλητές, που εισάγεται με `import`.
> - `import math` → `math.sqrt(x)`· `from math import sqrt` → `sqrt(x)`.
> - Πακέτο: κατάλογος με αρθρώματα και ένα αρχείο `__init__.py`.

## Ερωτήσεις

1. Σωστό ή Λάθος: Οι παράμετροι μιας συνάρτησης είναι τοπικές μεταβλητές της.
   - Σωστό: υπάρχουν μόνο όσο τρέχει η συνάρτηση
   - Σωστό, αλλά μόνο αν δεν έχουν όνομα καθολικής
   - Λάθος: είναι καθολικές, γιατί τις δίνει το κύριο πρόγραμμα
   - Λάθος: δεν είναι καν μεταβλητές
2. Σωστό ή Λάθος: Μια συνάρτηση δεν μπορεί να διαβάσει την τιμή μιας καθολικής μεταβλητής, αν δεν τη δηλώσει με global.
   - Λάθος: την ανάγνωση την κάνει χωρίς global
   - Σωστό: χωρίς global δεν τη βλέπει καθόλου
   - Σωστό: μια συνάρτηση βλέπει μόνο τις παραμέτρους της
   - Λάθος: η global δεν υπάρχει στην Python
3. Τι εμφανίζει το πρόγραμμα: `a = 1`, μετά `def f():` με σώμα `a = 7`, μετά `f()` και τέλος `print a`;
   - 1
   - 7
   - 8
   - μήνυμα λάθους
4. Τι εμφανίζει το πρόγραμμα: `b = 1`, μετά `def g():` με σώμα `global b` και `b = b + 5`, μετά `g()`, `g()` και τέλος `print b`;
   - 11
   - 6
   - 1
   - 10
5. Δίνεται `n = 4` και η συνάρτηση `def h():` με μοναδική εντολή `n = n + 1`. Τι γίνεται με την κλήση `h()`;
   - σταματά με σφάλμα
   - η καθολική n γίνεται 5
   - μια τοπική n γίνεται 5
   - δεν γίνεται τίποτα
6. Ποια δήλωση σου επιτρέπει να γράψεις σκέτο `sqrt(16)`, χωρίς το όνομα του αρθρώματος μπροστά;
   - from math import sqrt
   - import math
   - import sqrt
   - from sqrt import math
7. Ένα πρόγραμμα ξεκινά με `import math` και μετά εκτελεί `print pi`. Τι γίνεται;
   - μήνυμα λάθους
   - εμφανίζεται 3.14159265359
   - εμφανίζεται 3.14
   - εμφανίζεται pi
8. Τι είναι ένα πακέτο (package) στην Python;
   - κατάλογος με αρθρώματα και αρχείο __init__.py
   - ένα αρχείο .py με συναρτήσεις και μεταβλητές
   - μια συνάρτηση ορισμένη μέσα σε άλλη συνάρτηση
   - οι ενσωματωμένες συναρτήσεις της γλώσσας
9. Σε ποια κατηγορία ανήκει η συνάρτηση `abs`;
   - ενσωματωμένη (built-in)
   - του αρθρώματος math
   - του αρθρώματος random
   - ορισμένη από τον χρήστη
10. Ποιες τιμές μπορεί να επιστρέψει η `random.randrange(6)`;
   - ακέραιους από 0 ως 5
   - ακέραιους από 1 ως 6
   - ακέραιους από 0 ως 6
   - πραγματικούς από 0 ως 6

## Ασκήσεις

1. Πώς λέγεται μια μεταβλητή που ορίζεται έξω από κάθε συνάρτηση, και πώς μια μεταβλητή που ορίζεται μέσα στο σώμα μιας συνάρτησης;
2. Τι εμφανίζει το πρόγραμμα: `k = 2`, μετά `def f(k):` με σώμα `k = k * 3` και `return k`, και τέλος `print f(k), k`;
3. Το πρόγραμμα ξεκινά με `import random`. Γράψε την κλήση της `randrange` που δίνει μια ζαριά, δηλαδή έναν ακέραιο από το $1$ ως και το $6$.
4. Δίνεται το πρόγραμμα: `s = 0`, μετά η `def add(x):` με σώμα `global s`, `s = s + x`, `t = s * 2`, `return t`. Ακολουθούν οι εντολές `t = 1`, `t = add(4) + t`, `add(t)` και `print s, t`.
   α) Ποια τιμή έχει η καθολική `t` μετά την εντολή `t = add(4) + t`;
   β) Τι εμφανίζει η `print s, t`;
5. Δίνεται το πρόγραμμα: `a = 10`, μετά η `def p(a):` με σώμα `a = a + 1` και `return a`, μετά η `def q():` με σώμα `global a` και `a = p(a) * 2`. Στο τέλος καλούνται `q()`, `q()` και εκτελείται `print a`. Τι εμφανίζεται;
6. Δίνεται `L = [1, 2]` και δύο συναρτήσεις χωρίς παραμέτρους: η `f`, με μοναδική εντολή `L.append(3)`, και η `g`, με μοναδική εντολή `L = []`. Καμία δεν έχει δήλωση global. Εκτελούνται `f()`, `g()`, `f()` και `print L`. Τι εμφανίζεται;

---

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