# Συναρτήσεις και παράμετροι

> def και return, παράμετροι και ορίσματα, και τι γίνεται όταν καλείς μια συνάρτηση.

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

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

- Να εξηγείς τι είναι υποπρόγραμμα και τον τμηματικό προγραμματισμό, και να αναφέρεις τα τρία χαρακτηριστικά ενός υποπρογράμματος.
- Να ορίζεις συνάρτηση με def και να την καλείς, ακολουθώντας τη ροή εκτέλεσης από την κλήση στο σώμα και πίσω.
- Να ξεχωρίζεις παραμέτρους από ορίσματα και να αντιστοιχίζεις τα ορίσματα στις παραμέτρους κατά θέση.
- Να χρησιμοποιείς τη return, να ξεχωρίζεις συναρτήσεις που επιστρέφουν τιμή από κενές, και να προβλέπεις τι γίνεται με μια λίστα που περνά ως όρισμα.

## Υποπρογράμματα

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

Η λύση είναι ο **τμηματικός προγραμματισμός**: γράφεις το πρόγραμμα ως σύνολο από μικρότερα κομμάτια. Ένα **υποπρόγραμμα** είναι κομμάτι προγράμματος γραμμένο χωριστά από το υπόλοιπο, που κάνει ένα αυτόνομο έργο. Το γράφεις μία φορά και το **καλείς** όσες φορές θέλεις, με άλλες τιμές κάθε φορά.

Κάθε υποπρόγραμμα έχει τρία βασικά χαρακτηριστικά:

1. Έχει **ένα μόνο σημείο εισόδου**, από το οποίο δέχεται τα δεδομένα του.
2. Το (υπο)πρόγραμμα που καλεί **σταματά** όσο εκτελείται το καλούμενο. Μία χρονική στιγμή εκτελείται μόνο ένα υποπρόγραμμα.
3. Ο έλεγχος **επιστρέφει** σε αυτό που κάλεσε, μόλις το καλούμενο τελειώσει.

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

## Συναρτήσεις στην Python

> **Στον υπολογιστή σου, με Python 3**
>
> Η `print` θέλει παρενθέσεις: `print(x)`, `print(a, 'είναι το μέγιστο')`. Η `input` δίνει πάντα κείμενο, οπότε για αριθμό γράφεις `int(input(…))`. Οι `def`, `return` και οι κλήσεις γράφονται ίδια.

Ο κώδικας γράφεται όπως στο βιβλίο και στις εξετάσεις, σε Python 2.7: `print x`, `print a, b`, `input` για αριθμό.

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

```python
def onoma_synartisis(parametros_1, parametros_2):
    entoles
    return apotelesma
```

Μια συνάρτηση μπορεί να καλεί άλλες. Η `epanalave_4fores` καλεί δύο φορές την `epanalave_hello`, που καλεί δύο φορές την `hello`. Στους runners της σελίδας η `print(...)` έχει ένα μόνο όρισμα: έτσι δουλεύει ίδια και στις δύο εκδόσεις.

*Διαδραστικό στη σελίδα: Συναρτήσεις που καλούν συναρτήσεις*

Δύο κανόνες φαίνονται εδώ. Μια συνάρτηση πρέπει να έχει **οριστεί πριν** κληθεί. Και οι εντολές μέσα της **δεν εκτελούνται** ώσπου να κληθεί.

Η κλήση είναι μια **παράκαμψη** στη ροή εκτέλεσης: αντί για την επόμενη εντολή, η εκτέλεση περνά στο σώμα της συνάρτησης, το εκτελεί όλο, και γυρίζει εκεί που σταμάτησε. Όταν διαβάζεις ένα πρόγραμμα, μπορείς και να μην μπεις στο σώμα: δέχεσαι ότι η συνάρτηση δουλεύει σωστά και συνεχίζεις, όπως κάνεις με τις ενσωματωμένες `len` ή `abs`.

## Παράμετροι και ορίσματα

Οι **παράμετροι** είναι μεταβλητές μέσα στις παρενθέσεις του **ορισμού**, χωρισμένες με κόμμα. Οι τιμές που δίνεις στην **κλήση** λέγονται **ορίσματα**. Στην κλήση, κάθε όρισμα εκχωρείται στην παράμετρο της **ίδιας θέσης**. Στην ΑΕΠΠ οι ίδιες έννοιες λέγονται **τυπικές** και **πραγματικές** παράμετροι.

Τα ορίσματα μπορεί να είναι σταθερές, μεταβλητές ή εκφράσεις:

```python
def printMax(a, b):
    if a > b:
        print a, 'είναι το μέγιστο'
    elif a == b:
        print a, 'είναι ίσο με το', b
    else:
        print b, 'είναι το μέγιστο'

printMax(3, 4)      # σταθερές τιμές ως ορίσματα
x = 5
y = 7
printMax(x, y)      # μεταβλητές ως ορίσματα
```

Εμφανίζεται `4 είναι το μέγιστο` και μετά `7 είναι το μέγιστο`.

Η `a` πήρε την τιμή της `x` και η `b` της `y` επειδή είναι στην **ίδια θέση**, όχι επειδή μοιάζουν τα ονόματα. Στην κλήση `printMax(y, x)` η `a` θα έπαιρνε $7$.

Το πλήθος μετρά κι αυτό. Η `printMax` έχει δύο παραμέτρους, άρα θέλει **δύο** ορίσματα: η `printMax(3)` σταματά με `TypeError`.

Η Python δεν ελέγχει τον τύπο. Μια συνάρτηση δουλεύει με όποια τιμή μπορούν να επεξεργαστούν οι εντολές της:

```python
def print_twice(x):
    print x
    print x

print_twice("Spam")
print_twice(25)
```

Εμφανίζονται `Spam` δύο φορές και μετά `25` δύο φορές.

## Η return και η επιστρεφόμενη τιμή

Η `return` τελειώνει τη συνάρτηση και στέλνει μια τιμή πίσω στο σημείο της κλήσης. Η τιμή αυτή λέγεται **επιστρεφόμενη τιμή**. Εκεί η κλήση «γίνεται» αυτή η τιμή και μπαίνει σε `print`, σε εκχώρηση ή σε πράξη.

```python
def find_sum(par1, par2):
    result = par1 + par2
    return result

print find_sum(3, 4)
print find_sum("well", "come")
```

Η πρώτη κλήση επιστρέφει `7`. Η δεύτερη επιστρέφει `wellcome`: ο τελεστής `+` στις συμβολοσειρές κάνει **συνένωση**, και η ίδια συνάρτηση δουλεύει και γι' αυτές.

> **Κλειδί**
>
> **Η `print` δείχνει μια τιμή στον χρήστη· η `return` τη δίνει πίσω στο πρόγραμμα.**
>
> Η `find_sum(3, 4) * 2` κάνει $14$, γιατί η κλήση επιστρέφει $7$. Η `printMax(3, 4) * 2` σταματά με σφάλμα: η `printMax` τυπώνει, αλλά δεν επιστρέφει τίποτα. Μια συνάρτηση χωρίς `return` επιστρέφει την ειδική τιμή `None`.

## Κατηγορίες συναρτήσεων

Το βιβλίο τις χωρίζει με δύο τρόπους.

**Αν αλλάζουν το αντικείμενο στο οποίο εφαρμόζονται.** Η `upper` των συμβολοσειρών δεν το αλλάζει: φτιάχνει νέα συμβολοσειρά. Η `append` των λιστών το αλλάζει.

| Εντολές                                            | Εμφανίζεται                    |
| -------------------------------------------------- | ------------------------------ |
| `a = "Python"`, `print a.upper()`, `print a`       | `PYTHON`, μετά `Python`        |
| `b = ["a", "b"]`, `print b.append("c")`, `print b` | `None`, μετά `['a', 'b', 'c']` |

**Αν επιστρέφουν τιμή.** Η `find_sum` επιστρέφει. Η `printMax` είναι **κενή** (void) συνάρτηση: κάνει κάτι, εδώ τυπώνει, αλλά δεν επιστρέφει τιμή.

> **Πρόσεχε**
>
> **Η `append` επιστρέφει `None`.** Αλλάζει τη λίστα επί τόπου, οπότε το `b = b.append("c")` δεν προσθέτει απλώς ένα στοιχείο: κάνει τη `b` ίση με `None` και η λίστα χάνεται. Γράφεις σκέτο `b.append("c")`.
>
> Το ίδιο λάθος γίνεται και με δικές σου συναρτήσεις: αν ξεχάσεις τη `return`, η `s = athroisma(5)` δίνει `s = None`, ακόμα κι αν μέσα στη συνάρτηση το αποτέλεσμα υπολογίστηκε σωστά.

## Λίστα ως παράμετρος

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

| Μέσα στη `changeme(mylist)`   | Μέσα                         | Έξω, μετά την κλήση          |
| ----------------------------- | ---------------------------- | ---------------------------- |
| `mylist.append([1, 2, 3, 4])` | `[10, 20, 30, [1, 2, 3, 4]]` | `[10, 20, 30, [1, 2, 3, 4]]` |
| `mylist = [1, 2, 3, 4]`       | `[1, 2, 3, 4]`               | `[10, 20, 30]`               |

Με την `append` η αλλαγή γίνεται στην ίδια τη λίστα, και μένει και μετά την κλήση. Με την εκχώρηση `mylist = [1, 2, 3, 4]`, η παράμετρος δείχνει πια σε **νέα** λίστα, που υπάρχει μόνο μέσα στη συνάρτηση. Η λίστα της κλήσης μένει όπως ήταν.

*Διαδραστικό στη σελίδα: Η changeme με append*

Μια **απλή** τιμή, όπως ένας αριθμός, δεν αλλάζει ποτέ έξω από τη συνάρτηση: η `t2 = t2 + 10` μέσα σε μια συνάρτηση φτιάχνει νέα τιμή για την παράμετρο, όπως η εκχώρηση στη λίστα. Αυτό το βλέπεις στο λυμένο παράδειγμα 1. Ποιες μεταβλητές είναι **τοπικές** και ποιες **καθολικές**, και πώς τις αλλάζεις με τη `global`, το βλέπεις στην ενότητα «Εμβέλεια μεταβλητών και αρθρώματα».

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

### Παράδειγμα 1: Τι θα εμφανίσει το παρακάτω πρόγραμμα; def print\_1(t2): με σώμα print t2, t2 = t2 + 10, print t2. Στο κύριο πρόγραμμα: t1 = 5, print\_1(t1), print t1.

1. **Από πού αρχίζει η εκτέλεση.** Ο ορισμός δεν εκτελείται. Η πρώτη εντολή είναι η `t1 = 5`, και μετά η κλήση `print_1(t1)`.
2. **Η κλήση.** Η παράμετρος `t2` παίρνει την τιμή του ορίσματος, $5$. Η πρώτη `print t2` εμφανίζει `5`. Η `t2 = t2 + 10` κάνει την `t2` ίση με $15$, και η δεύτερη `print` εμφανίζει `15`.
3. **Μετά την κλήση.** Η `t1` δεν άλλαξε: η `t2` πήρε μόνο την **τιμή** της και μετά άλλαξε η ίδια. Η `print t1` εμφανίζει `5`.
4. *Διαδραστικό στη σελίδα: Η t2 αλλάζει, η t1 όχι*

### Παράδειγμα 2: Να γράψετε συνάρτηση megisto3(a, b, c) σε Python, που επιστρέφει τον μεγαλύτερο από τρεις αριθμούς χωρίς τη max(). Στη συνέχεια, κύριο πρόγραμμα που διαβάζει τρεις ακέραιους, καλεί τη συνάρτηση και εμφανίζει το αποτέλεσμα.

1. **Τι μπαίνει και τι βγαίνει.** Τρία δεδομένα, άρα τρεις παράμετροι. Ένα αποτέλεσμα, που το επιστρέφει η `return`. Η ανάγνωση και η εμφάνιση είναι δουλειά του κύριου προγράμματος.
2. **Ο αλγόριθμος.** Η `megistos` ξεκινά από την `a`. Αν η `b` είναι μεγαλύτερη, γίνεται αυτή η `megistos`· μετά το ίδιο για τη `c`. Δύο χωριστά `if`, όχι `elif`: η `c` πρέπει να συγκριθεί όποια κι αν βγήκε από την πρώτη σύγκριση.
3. ```python
   def megisto3(a, b, c):
       megistos = a
       if b > megistos:
           megistos = b
       if c > megistos:
           megistos = c
       return megistos

   x = input('Δώσε τον πρώτο: ')
   y = input('Δώσε τον δεύτερο: ')
   z = input('Δώσε τον τρίτο: ')
   m = megisto3(x, y, z)
   print 'Ο μεγαλύτερος είναι', m
   ```
4. **Έλεγχος** με $12$, $31$, $7$: η `megistos` γίνεται $12$, μετά $31$, και μένει $31$ γιατί $7 < 31$. Η κλήση `megisto3(x, y, z)` επιστρέφει $31$, που εκχωρείται στη `m`, και εμφανίζεται `Ο μεγαλύτερος είναι 31`.

### Παράδειγμα 3: Ένα πρόγραμμα υπολογίζει τρία αθροίσματα με τρεις σχεδόν ίδιους βρόχους: το άθροισμα των 0 ως 99 δύο φορές, και το άθροισμα των 0 ως sum1 − 1, όπου sum1 το πρώτο. Να το ξαναγράψετε με μία συνάρτηση.

1. **Τι επαναλαμβάνεται.** Κάθε βρόχος είναι ο ίδιος: αθροιστής από $0$, `for` σε `range(…)`, πρόσθεση. Αλλάζει μόνο το «μέχρι» της `range`. Αυτό γίνεται **παράμετρος**.
2. **Η συνάρτηση.**
   ```python
   def f1(N):
       s = 0
       for i in range(N):
           s = s + i
       return s
   ```
   Η `f1(N)` επιστρέφει το $0 + 1 + … + (N - 1)$. Η `f1(100)` επιστρέφει $4950$.
3. **Το νέο πρόγραμμα.** Επειδή η κλήση είναι τιμή, μπαίνει ως όρισμα σε άλλη κλήση:
   ```python
   sum1 = f1(100)
   sum2 = f1(100)
   sum3 = f1(sum1)
   print sum1 + sum2 + sum3
   ```
   Ο βρόχος γράφτηκε **μία** φορά. Μια διόρθωση γίνεται πια σε ένα σημείο και ισχύει για όλα τα αθροίσματα.

> **Θυμήσου**
>
> - Η Python έχει ένα είδος υποπρογράμματος, τη συνάρτηση: `def όνομα(παράμετροι):`.
> - Ορίζεται πριν κληθεί· το σώμα της εκτελείται μόνο όταν κληθεί.
> - Παράμετροι στον ορισμό, ορίσματα στην κλήση, αντιστοίχιση **κατά θέση**.
> - Η `return` επιστρέφει τιμή· χωρίς αυτήν η κλήση δίνει `None`.
> - Λίστα ως όρισμα: η `append` μέσα στη συνάρτηση φαίνεται και έξω, η εκχώρηση νέας λίστας όχι.

## Ερωτήσεις

1. Σωστό ή Λάθος: «Οι εντολές μιας συνάρτησης εκτελούνται τη στιγμή που η Python διαβάζει τον ορισμό της με def.»
   - Λάθος: εκτελούνται μόνο όταν κληθεί
   - Σωστό: ο ορισμός τις εκτελεί μία πρώτη φορά
   - Σωστό: εκτελούνται στον ορισμό και σε κάθε κλήση
   - Λάθος: εκτελούνται στο τέλος του προγράμματος
2. Τι είδους υποπρογράμματα έχει η Python;
   - μόνο συναρτήσεις
   - συναρτήσεις και διαδικασίες
   - μόνο ενσωματωμένες συναρτήσεις
   - συναρτήσεις και βρόχους
3. Ποιος ορισμός συνάρτησης είναι γραμμένος σωστά;
   - def ektyposi(x1, x2):
   - def ektyposi(x1; x2):
   - def ektyposi x1, x2:
   - def ektyposi(x1 + x2):
4. Τι θα εμφανίσει το def f(a, b): return a - b, και μετά print f(3, 10);
   - -7
   - 7
   - 13
   - None
5. Στην κλήση find_sum(3, 4), πώς λέγονται το 3 και το 4;
   - ορίσματα
   - παράμετροι
   - επιστρεφόμενες τιμές
   - καθολικές μεταβλητές
6. Τι θα εμφανίσει το def dipla(x): print 2 * x, και μετά y = dipla(4) και print y;
   - 8 και μετά None
   - 8 και μετά 8
   - None και μετά 8
   - μόνο 8
7. Σωστό ή Λάθος: «Όταν ένα πρόγραμμα καλεί ένα υποπρόγραμμα, συνεχίζει να εκτελείται μαζί με αυτό.»
   - Λάθος: περιμένει ώσπου να τελειώσει το καλούμενο
   - Σωστό: τα δύο εκτελούνται ταυτόχρονα
   - Σωστό: το καλούμενο τρέχει όταν τελειώσει το πρόγραμμα
   - Λάθος: το πρόγραμμα τελειώνει μόλις κάνει την κλήση
8. Τι θα εμφανίσει το def add(L): L.append(0), και μετά a = [1, 2], add(a), print a;
   - [1, 2, 0]
   - [1, 2]
   - [0]
   - None
9. Τι θα εμφανίσει το def g(L): L = [9], και μετά a = [1, 2], g(a), print a;
   - [1, 2]
   - [9]
   - [1, 2, 9]
   - [9, 1, 2]
10. Η printMax(a, b) έχει δύο παραμέτρους. Τι γίνεται με την κλήση printMax(3);
   - σφάλμα TypeError
   - η b παίρνει 0
   - η b παίρνει 3
   - εμφανίζει 3

## Ασκήσεις

1. Η find_sum(par1, par2) επιστρέφει par1 + par2. Τι εμφανίζει η print find_sum("ab", "cd");
2. Η python3() τυπώνει τρεις φορές τη λέξη python και η python9() εννέα φορές. Μια νέα python21() πρέπει να την τυπώνει 21 φορές, μόνο με κλήσεις αυτών των δύο και με όσο λιγότερες εντολές γίνεται. Ποιες κλήσεις γράφεις στο σώμα της;
3. Δίνεται η συνάρτηση def f(n): με σώμα s = 0, for i in range(1, n + 1): s = s + i, και return s.
   α) Τι εμφανίζει η print f(4) + f(2);
   β) Τι εμφανίζει η print f(f(3));
4. Η def d(L): έχει σώμα for i in range(len(L)): L[i] = 2 * L[i]. Το κύριο πρόγραμμα γράφει a = [1, 2, 3], d(a), print a.
   α) Τι εμφανίζεται;
   β) Τι εμφανίζεται αν το σώμα της d γίνει απλώς L = [0, 0, 0];
5. Η def h(x, y): επιστρέφει x * 10 + y. Η print h(h(1, 2), 3) εμφανίζει 123. Βρες ακέραιους a, b, c από το 0 ως το 9, ώστε η print h(h(a, b), c) να εμφανίσει 507.
6. Θέλεις συνάρτηση avgPositive(L), που επιστρέφει τον μέσο όρο των θετικών στοιχείων μιας λίστας, ή None αν δεν υπάρχει κανένα θετικό. Γράφεται σε Python 2.7, όπως στο βιβλίο, με αθροιστή που ξεκινά από s = 0.0.
   α) Τι επιστρέφει για τη λίστα [4, -2, 0, 8, -6];
   β) Τι επιστρέφει για τη λίστα [-1, 0];

---

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