Τα βασικά της Python

Εισαγωγή

Σε αυτό το κεφάλαιο, παρουσιάζουμε τα θεμελιώδη δομικά στοιχεία της Python: τα objects (αντικείμενα) και τις συναρτήσεις. Στην Python, σχεδόν τα πάντα είναι objects, συμπεριλαμβανομένων των δεδομένων, των συνόλων δεδομένων (datasets) και ακόμη και των ίδιων των συναρτήσεων. Οι συναρτήσεις εκτελούν ενέργειες πάνω σε άλλα objects, γεγονός που τις καθιστά απαραίτητα εργαλεία για την εργασία με δεδομένα. Ξεκινάμε εξετάζοντας την έννοια του object, καθώς και τους διαφορετικούς τύπους δεδομένων (data types) και τις δομές δεδομένων (data structures) που χρησιμοποιεί η Python. Στη συνέχεια, εξηγούμε τις συναρτήσεις πιο αναλυτικά, εξετάζουμε μερικές από τις κύριες ενσωματωμένες (built-in) συναρτήσεις της Python και βλέπουμε πώς μπορούμε να δημιουργήσουμε τις δικές μας συναρτήσεις.

Objects και απλοί υπολογισμοί

Ας ξεκινήσουμε με ένα πολύ απλό αριθμητικό παράδειγμα. Στον παρακάτω κώδικα χρησιμοποιούμε πρόσθεση, αφαίρεση, πολλαπλασιασμό, διαίρεση, ύψωση σε δύναμη και modulo (υπόλοιπο διαίρεσης):

# Πρόσθεση
1 + 2 + 3 + 4 + 5
15
# Αφαίρεση
10 - 5
5
# Πολλαπλασιασμός
2 * 3
6
# Διαίρεση
5 / 4
1.25
# Ύψωση σε δύναμη
2 ** 4
16
# Υπόλοιπο
5 % 4
1

Όπως εξηγήσαμε στο Κεφάλαιο Εισαγωγή στην Python και στο Visual Studio Code, μπορούμε να πληκτρολογήσουμε τον κώδικά μας στον Code Editor και να πατήσουμε Run. Στο παραπάνω παράδειγμα, τα αποτελέσματα εμφανίζονται στο Terminal (ή ακριβώς κάτω από κάθε cell, αν χρησιμοποιούμε Jupyter Notebook), και έτσι μπορούμε να τα ελέγξουμε αμέσως.

Σχόλια κώδικα

Όπως και σε άλλες γλώσσες προγραμματισμού, μπορούμε να γράφουμε σχόλια (comments) μέσα στον κώδικα χρησιμοποιώντας το σύμβολο της δίεσης (hashtag, #), όπως κάναμε παραπάνω, ώστε να θυμόμαστε τι κάναμε ή να το εξηγούμε σε άλλους αναλυτές. Όταν χρησιμοποιούμε hashtag σε μια γραμμή κώδικα, η Python δεν προσπαθεί να επεξεργαστεί ό,τι πληκτρολογούμε μετά από αυτό· απλώς το αγνοεί.

Ένα από τα σημαντικότερα πράγματα που θέλουμε να κάνουμε στον προγραμματισμό είναι να αποθηκεύουμε τα αποτελέσματα των συναρτήσεών μας, ώστε να τα χρησιμοποιούμε σε επόμενα σημεία των προγραμμάτων μας. Στην Python, χρησιμοποιούμε το σύμβολο της ισότητας (=) για να εκχωρήσουμε (assign) μια τιμή ή ένα αποτέλεσμα σε μια μεταβλητή. Στη συνέχεια, η μεταβλητή αποθηκεύει μια αναφορά (reference) σε αυτό που δημιουργήσαμε, το οποίο ονομάζεται object. Ένα object είναι μια δομή δεδομένων που περιέχει τιμές (ή δεδομένα), όπως αριθμούς, κείμενο ή πιο σύνθετες δομές. Μπορούμε να επεξεργαστούμε και να αναλύσουμε αυτά τα objects με διάφορες συναρτήσεις και πράξεις. Στην Python, σχεδόν τα πάντα είναι objects. Όταν δημιουργούμε μια μεταβλητή, μια δομή δεδομένων (όπως μια list) ή μια συνάρτηση, στην πραγματικότητα δημιουργούμε ένα object.

Ορισμός

Στην Python, ένα object είναι οποιαδήποτε τιμή δεδομένων (όπως ένας αριθμός, ένα string, μια list ή ένα dictionary) που αποθηκεύει πληροφορία, ενώ μια μεταβλητή είναι ένα όνομα ή αναγνωριστικό (identifier) που χρησιμοποιείται για να αναφερόμαστε σε ένα object στη μνήμη. Ουσιαστικά, το object είναι τα δεδομένα και η μεταβλητή είναι η ετικέτα αυτών των δεδομένων.

Η Python είναι μια αντικειμενοστρεφής γλώσσα (object-oriented language), που σημαίνει ότι όλες οι τιμές δεδομένων και οι συναρτήσεις αντιμετωπίζονται ως objects με συγκεκριμένη συμπεριφορά και ιδιότητες. Προς το παρόν, αρκεί να σκεφτόμαστε τα objects ως «πράγματα» αποθηκευμένα στην Python, με τα οποία μπορούμε να δουλέψουμε και τα οποία μπορούμε να επεξεργαστούμε. Αυτό μπορεί να φαίνεται λίγο αφηρημένο τώρα, αλλά θα γίνει πιο κατανοητό καθώς θα βλέπουμε περισσότερα παραδείγματα. Αρκεί να θυμόμαστε ότι ένα object είναι κάτι που έχουμε αποθηκεύσει και με το οποίο μπορούμε να δουλέψουμε στην Python.

Για να δούμε πώς μπορούμε να δημιουργήσουμε και να επεξεργαστούμε ένα object στην Python, ας υποθέσουμε ότι θέλουμε να αποθηκεύσουμε την τιμή 2 στη μεταβλητή x. Μπορούμε να το κάνουμε με τον παρακάτω κώδικα:

# Εκχώρηση αριθμητικής τιμής στη μεταβλητή x
x = 2

Γενικά, όταν δημιουργούμε ένα νέο object, μπορούμε να του δώσουμε όποιο όνομα θέλουμε. Ωστόσο, υπάρχουν δύο πράγματα που πρέπει να έχουμε υπόψη:

  • Εύκολο όνομα: Είναι καλύτερο να επιλέγουμε ένα όνομα που σχετίζεται με τα δεδομένα, ώστε όλοι να καταλαβαίνουν εύκολα σε τι αναφέρεται το object. Για παράδειγμα, ένα object που περιέχει δεδομένα πωλήσεων θα μπορούσε να ονομάζεται sales ή sales_data.

  • Περιορισμοί ονομάτων: Υπάρχουν αυτονόητοι περιορισμοί όταν δημιουργούμε ένα object. Για παράδειγμα, το όνομα μιας μεταβλητής δεν μπορεί να ξεκινά με αριθμό ούτε να είναι δεσμευμένη λέξη-κλειδί (reserved keyword), όπως if ή for. Θα πρέπει επίσης να αποφεύγουμε ονόματα υπαρχουσών συναρτήσεων ή ενσωματωμένων τύπων, όπως το list, επειδή το νέο object θα τα αντικαθιστούσε.

Παρατηρούμε ότι, όταν κάνουμε μια εκχώρηση, η Python δεν εμφανίζει τίποτα. Αυτή η συμπεριφορά (η μη εμφάνιση αποτελέσματος) δείχνει ότι το object ορίστηκε επιτυχώς· διαφορετικά, θα λαμβάναμε ένα σφάλμα. Για να δούμε τα αποτελέσματα, πρέπει να «καλέσουμε» το object. Μπορούμε να το κάνουμε με τη συνάρτηση print() ή απλώς καλώντας το ίδιο το object σε ένα διαδραστικό περιβάλλον (interactive environment):

# Εμφάνιση της μεταβλητής x
print(x)
2
# Εμφάνιση της μεταβλητής x σε διαδραστικό περιβάλλον
x
2

Κάθε φορά που εμφανίζουμε τη μεταβλητή x, βλέπουμε την τιμή 2. Τι γίνεται όμως αν θέλουμε να αλλάξουμε την τιμή αυτής της μεταβλητής σε 3; Για να το κάνουμε αυτό, απλώς εκχωρούμε τη νέα τιμή στην ίδια μεταβλητή:

# Εκχώρηση αριθμητικής τιμής στη μεταβλητή x
x = 3

# Εμφάνιση της μεταβλητής x
x
3

Η μεταβλητή x έχει τώρα την τιμή 3 αντί για 2. Αντικαταστήσαμε την προηγούμενη τιμή με μια νέα. Αν θέλαμε να κρατήσουμε και την τιμή 2 για να δουλέψουμε με αυτήν, θα έπρεπε να εκχωρήσουμε την τιμή 3 σε μια διαφορετική μεταβλητή. Φυσικά, αυτό σημαίνει ότι πρέπει να ξέρουμε πότε χρειάζεται να δημιουργήσουμε μια νέα μεταβλητή και πότε να ενημερώσουμε μια υπάρχουσα. Μπορούμε να χρησιμοποιήσουμε τη συνάρτηση dir() για να δούμε όλα τα objects που είναι αποθηκευμένα αυτή τη στιγμή στον χώρο εργασίας μας (workspace).

# Εκχώρηση αριθμητικής τιμής στη μεταβλητή x
x = 2

# Εκχώρηση αριθμητικής τιμής στη μεταβλητή y
y = 3

# Εμφάνιση της μεταβλητής x
x
2
# Εμφάνιση της μεταβλητής y
y
3
# Εμφάνιση των ονομάτων όλων των υπαρχουσών μεταβλητών
dir()
['In',
 'Out',
 '_',
 '_10',
 '_11',
 '_12',
 '_13',
 '_2',
 '_3',
 '_4',
 '_5',
 '_6',
 '_7',
 '__',
 '___',
 '__builtin__',
 '__builtins__',
 '__name__',
 '__spec__',
 '_dh',
 '_i',
 '_i1',
 '_i10',
 '_i11',
 '_i12',
 '_i13',
 '_i14',
 '_i2',
 '_i3',
 '_i4',
 '_i5',
 '_i6',
 '_i7',
 '_i8',
 '_i9',
 '_ih',
 '_ii',
 '_iii',
 '_oh',
 'exit',
 'get_ipython',
 'np',
 'ojs_define',
 'open',
 'pd',
 'plt',
 'quit',
 'sns',
 'x',
 'y']

Μερικές φορές θέλουμε να διαγράψουμε objects, για παράδειγμα για να ελευθερώσουμε μνήμη ή επειδή δεν χρειαζόμαστε ένα συγκεκριμένο object στην ανάλυσή μας. Μπορούμε να διαγράψουμε ένα υπάρχον object με την εντολή (statement) del. Ας διαγράψουμε το object x και ας ελέγξουμε το αποτέλεσμα με την dir():

# Διαγραφή object
del x

# Εμφάνιση των ονομάτων όλων των υπαρχόντων objects
dir()
['In',
 'Out',
 '_',
 '_10',
 '_11',
 '_12',
 '_13',
 '_14',
 '_2',
 '_3',
 '_4',
 '_5',
 '_6',
 '_7',
 '__',
 '___',
 '__builtin__',
 '__builtins__',
 '__name__',
 '__spec__',
 '_dh',
 '_i',
 '_i1',
 '_i10',
 '_i11',
 '_i12',
 '_i13',
 '_i14',
 '_i15',
 '_i2',
 '_i3',
 '_i4',
 '_i5',
 '_i6',
 '_i7',
 '_i8',
 '_i9',
 '_ih',
 '_ii',
 '_iii',
 '_oh',
 'exit',
 'get_ipython',
 'np',
 'ojs_define',
 'open',
 'pd',
 'plt',
 'quit',
 'sns',
 'y']

Πράγματι, το object x διαγράφηκε επιτυχώς (δεν εμφανίζεται στη λίστα).

Τύποι δεδομένων

Στην Python, οι τύποι δεδομένων χρησιμοποιούνται για να ορίσουν το είδος της τιμής που αποθηκεύεται σε μια μεταβλητή. Είναι σημαντικοί επειδή καθορίζουν ποιες πράξεις μπορούν να εκτελεστούν στα δεδομένα και πώς τα ερμηνεύει η Python. Η Python διαθέτει αρκετούς ενσωματωμένους τύπους δεδομένων, οι οποίοι εκχωρούνται αυτόματα όταν δημιουργούμε objects.

Αριθμητικοί (Numeric): Οι αριθμητικοί τύποι δεδομένων χρησιμοποιούνται για την αποθήκευση πραγματικών αριθμών, οι οποίοι μπορούν να εκφραστούν ως integers (ακέραιοι) ή floats (αριθμοί κινητής υποδιαστολής):

# Εκχώρηση αριθμητικής τιμής
x = 9999

# Εμφάνιση του x
x
9999
# Εκχώρηση αριθμητικής τιμής
y = 3.14

# Εμφάνιση του y
y
3.14

Χαρακτήρες (Character): Γνωστοί και ως strings (συμβολοσειρές), οι τύποι δεδομένων χαρακτήρων χρησιμοποιούνται για την αποθήκευση δεδομένων κειμένου. Το κείμενο αναπαρίσταται ως μια ακολουθία χαρακτήρων που περικλείεται είτε σε μονά εισαγωγικά ('') είτε σε διπλά εισαγωγικά (""):

# Εκχώρηση τιμής string
text = "Hello World"

# Εμφάνιση του text
text
'Hello World'

Λογικοί (Logical): Οι λογικοί τύποι δεδομένων αναπαριστούν τιμές Boolean (λογικές τιμές), οι οποίες μπορεί να είναι είτε True είτε False. Οι λογικές τιμές χρησιμοποιούνται συχνά σε εντολές συνθήκης (conditional statements) και σε λογικές πράξεις. Σε αντίθεση με τα strings, οι λογικές τιμές δεν χρειάζονται εισαγωγικά όταν εκχωρούνται ή εμφανίζονται:

# Εκχώρηση λογικών τιμών
true_value = True
false_value = False

# Εμφάνιση του true_value
true_value
True
# Εμφάνιση του false_value
false_value
False

Date (ημερομηνία) και Datetime (ημερομηνία και ώρα): Αυτοί οι τύποι δεδομένων χρησιμοποιούνται για την αποθήκευση… ημερομηνιών και ωρών (ναι, το μαντέψατε!), όπως το έτος και ο μήνας. Οι ημερομηνίες και οι ώρες διαχειρίζονται μέσω του module datetime. Αυτό μας επιτρέπει να δουλεύουμε με ημερομηνίες, όπως έτος, μήνας και ημέρα:

from datetime import date

# Εκχώρηση τιμής ημερομηνίας
publication_date = date(2026, 1, 1)

# Εμφάνιση του publication_date
publication_date
datetime.date(2026, 1, 1)

Αυτοί είναι οι θεμελιώδεις τύποι δεδομένων της Python, και μπορούμε να εκτελούμε διάφορες πράξεις και μετασχηματισμούς σε αυτούς, ώστε να αναλύουμε και να οπτικοποιούμε δεδομένα αποτελεσματικά. Όπως είναι προφανές, είναι πολύ σημαντικό να έχουμε πάντα υπόψη τον τύπο δεδομένων ενός object. Πάντως, η Python προσπαθεί να εκχωρήσει έναν τύπο δεδομένων σε κάθε object που δημιουργούμε, συμπεραίνοντάς τον από τις τιμές που του εκχωρούνται. Μπορούμε πάντα να ελέγξουμε τον τύπο δεδομένων, ή αλλιώς την κλάση (class), ενός object με τη συνάρτηση type(). Ας χρησιμοποιήσουμε αυτή τη συνάρτηση στα objects που δημιουργήσαμε:

# Τύπος του x
type(x)
int
# Τύπος του y
type(y)
float
# Τύπος του text
type(text)
str
# Τύπος του true_value
type(true_value)
bool
# Τύπος του false_value
type(false_value)
bool
# Τύπος του publication_date
type(publication_date)
datetime.date

Είναι εύκολο να κάνουμε υπολογισμούς χρησιμοποιώντας αριθμητικά objects αντί για τις τιμές που τους έχουμε εκχωρήσει. Με άλλα λόγια, εκχωρούμε μια αριθμητική τιμή σε μια μεταβλητή και στη συνέχεια μπορούμε να χρησιμοποιήσουμε αυτή τη μεταβλητή στους υπολογισμούς μας. Έτσι, δεν χρειάζεται να θυμόμαστε ποια τιμή εκχωρήσαμε στα objects μας· η Python «αποθηκεύει» αυτές τις τιμές για εμάς.

# Εκχώρηση τιμής στη μεταβλητή x
x = 5

# Εκχώρηση τιμής στη μεταβλητή y
y = 4

# Πρόσθεση
x + y
9
# Αφαίρεση
x - y
1
# Πολλαπλασιασμός
x * y
20
# Διαίρεση
x / y
1.25
# Ύψωση σε δύναμη
x ** y
625
# Υπόλοιπο
x % y
1

Νωρίτερα αναφέραμε ότι η γνώση των τύπων δεδομένων είναι σημαντική, επειδή μας επιτρέπει να διαχειριζόμαστε τα δεδομένα μας πιο αποτελεσματικά. Παρόλο που μπορούμε να χρησιμοποιήσουμε τη συνάρτηση type() για να ελέγξουμε τον ακριβή τύπο δεδομένων ενός object, μπορούμε επίσης να χρησιμοποιήσουμε συναρτήσεις όπως η isinstance() για να ελέγξουμε αν ένα object δεδομένων είναι συγκεκριμένου τύπου. Σε αυτή την περίπτωση, καθορίζουμε τον τύπο δεδομένων απευθείας μέσα στη συνάρτηση. Για παράδειγμα, μπορούμε να ελέγξουμε αν ένα object είναι integer (int), float (float), string (str) ή Boolean (bool). Ως αποτέλεσμα, η συνάρτηση επιστρέφει μια λογική τιμή (True ή False). Σημειώνεται ότι τα True και False θεωρούνται επίσης integers, επειδή στην Python ο τύπος Boolean είναι ένα ειδικό είδος integer (το True ισούται με 1 και το False με 0):

# Είναι integer;
isinstance(1, int)
True
isinstance(1.1, int)
False
isinstance("1", int)
False
isinstance(True, int)
True
# Είναι float;
isinstance(1, float)
False
isinstance(1.1, float)
True
isinstance("1", float)
False
isinstance(True, float)
False
# Είναι κείμενο;
isinstance(1, str)
False
isinstance(1.1, str)
False
isinstance("1", str)
True
isinstance(True, str)
False
# Είναι Boolean;
isinstance(1, bool)
False
isinstance(1.1, bool)
False
isinstance("1", bool)
False
isinstance(True, bool)
True

Ας υποθέσουμε ότι έχουμε ένα object που θέλουμε να μετατρέψουμε σε διαφορετικό τύπο δεδομένων (εφόσον η μετατροπή είναι εφικτή). Για τον σκοπό αυτό, χρησιμοποιούμε ενσωματωμένες συναρτήσεις μετατροπής, όπως οι int(), float(), str() και bool(). Γενικά, αυτή είναι μια πολύ χρήσιμη προσέγγιση, επειδή μας επιτρέπει να αλλάζουμε εύκολα τον τύπο δεδομένων ενός object, αντί να προσπαθούμε να το κάνουμε χειροκίνητα:

# Μετατροπές σε integer
int(2)
2
int("2")
2
int(True)
1
# Μετατροπές σε float
float(2)
2.0
float("2")
2.0
float(True)
1.0
# Μετατροπές σε string
str(2)
'2'
str("YES")
'YES'
str(True)
'True'
# Μετατροπές σε Boolean
bool(0)
False
bool(2)
True
bool("YES")
True
bool("")
False
bool(True)
True

Στο παραπάνω παράδειγμα υπάρχουν μερικές ενδιαφέρουσες παρατηρήσεις. Αρχικά, το True μετατρέπεται σε 1 (ή 1.0), κάτι που συμφωνεί με όσα αναφέραμε νωρίτερα: στην Python, ο τύπος Boolean είναι ένα ειδικό είδος integer. Επιπλέον, σχεδόν κάθε τύπος δεδομένων μπορεί να μετατραπεί σε string. Για παράδειγμα, η Python μπορεί να ερμηνεύσει την τιμή 2 ως το string '2', μια τιμή που διαφέρει από την αριθμητική τιμή 2. Ακόμη, στην Python η τιμή 0 ερμηνεύεται ως False, ενώ οποιαδήποτε άλλη αριθμητική τιμή ερμηνεύεται ως True. Τα κενά strings ερμηνεύονται επίσης ως False, ενώ τα μη κενά strings ερμηνεύονται ως True. Σημειώνεται ότι, αν μια μετατροπή δεν είναι εφικτή, η Python προκαλεί σφάλμα.

Η Python χρησιμοποιεί δυναμική τυποποίηση (dynamic typing), που σημαίνει ότι οι τύποι εκχωρούνται αυτόματα με βάση τις τιμές και ότι μια μεταβλητή μπορεί αργότερα να αναφέρεται σε τιμή διαφορετικού τύπου. Η Python είναι επίσης αυστηρά τυποποιημένη (strongly typed), που σημαίνει ότι σπάνια μετατρέπει από μόνη της μια τιμή από έναν τύπο σε άλλον (για παράδειγμα, το "2" + 2 προκαλεί σφάλμα), οπότε οι μετατροπές συνήθως πρέπει να γίνονται ρητά.

Δομές δεδομένων

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

Στην Python, οι κύριες θεμελιώδεις δομές δεδομένων είναι: οι lists (λίστες), τα tuples (πλειάδες), τα sets (σύνολα) και τα dictionaries (λεξικά). Στην επιστήμη δεδομένων, μια ακόμη θεμελιώδης δομή δεδομένων είναι τα arrays/data frames (πίνακες/πλαίσια δεδομένων), μέσω εξωτερικών βιβλιοθηκών όπως το NumPy και το Pandas, τα οποία εξετάζουμε στα επόμενα κεφάλαια.

Lists: Η list είναι μία από τις πιο σημαντικές και ευέλικτες δομές δεδομένων στην Python. Χρησιμοποιείται για την αποθήκευση μιας διατεταγμένης συλλογής στοιχείων (items), και αυτά τα στοιχεία δεν χρειάζεται να είναι του ίδιου τύπου. Οι lists δημιουργούνται με αγκύλες []:

# Εκχώρηση τιμών σε μια list
our_list = [100, -100, "TEXT", 102, -98]

# Εμφάνιση του our_list
our_list
[100, -100, 'TEXT', 102, -98]

Μπορούμε ακόμη να έχουμε lists μέσα σε μια list. Αυτό συχνά ονομάζεται nested list (εμφωλευμένη λίστα), που σημαίνει ότι κάθε στοιχείο της κύριας list μπορεί να είναι και το ίδιο μια άλλη list:

# Δημιουργία μιας διπλής list
our_double_list = [
  [100, -100, 102, -98],
  ["TEXT 1", "TEXT 2", "TEXT 3"]
  ]

Για να επιλέξουμε στοιχεία από μια list, χρησιμοποιούμε αγκύλες [] μαζί με τη θέση (index) του στοιχείου. Η Python ξεκινά την αρίθμηση από το 0 αντί για το 1, που σημαίνει ότι το πρώτο στοιχείο βρίσκεται στη θέση 0, το δεύτερο στη θέση 1 κ.ο.κ.

# Επιλογή του πρώτου στοιχείου της list
our_list[0]
100
# Επιλογή του τρίτου στοιχείου της list
our_list[2]
'TEXT'

Όταν δουλεύουμε με nested lists, μπορούμε να χρησιμοποιήσουμε πολλαπλές αγκύλες για να μετακινηθούμε στα διάφορα επίπεδα της δομής. Στο παρακάτω παράδειγμα, το our_double_list[0] επιλέγει την πρώτη εσωτερική list, ενώ το δεύτερο [1] επιλέγει το δεύτερο στοιχείο αυτής της list:

# Επιλογή στοιχείου από μια nested list
our_double_list[0][1]
-100

Η Python μας επιτρέπει επίσης να επιλέγουμε πολλά στοιχεία ταυτόχρονα, μέσω μιας τεχνικής που ονομάζεται slicing (τεμαχισμός). Το slicing έχει τη μορφή [start:end], όπου η αρχική θέση περιλαμβάνεται, ενώ η τελική θέση εξαιρείται:

# Επιλογή των τριών πρώτων στοιχείων
our_list[0:3]
[100, -100, 'TEXT']

Σε αυτό το παράδειγμα, η Python επιλέγει τα στοιχεία στις θέσεις 0, 1 και 2, αλλά όχι στη θέση 3.

Σε μια list, μπορούμε επίσης να αντικαταστήσουμε τιμές εκχωρώντας μια νέα τιμή σε μια συγκεκριμένη θέση:

# Αλλαγή της τελευταίας τιμής
our_list[4] = 4

# Εμφάνιση της ενημερωμένης list
our_list
[100, -100, 'TEXT', 102, 4]

Οι lists μπορούν επίσης να επεκταθούν με την προσθήκη νέων στοιχείων. Ένας απλός τρόπος για να το κάνουμε αυτό είναι με τον τελεστή (operator) +. Σε αυτή την περίπτωση, το νέο στοιχείο πρέπει επίσης να δοθεί με τη μορφή list, ακόμη κι αν θέλουμε να προσθέσουμε μόνο μία τιμή:

# Επέκταση της list
our_list = our_list + [120]

# Εμφάνιση της ενημερωμένης list
our_list
[100, -100, 'TEXT', 102, 4, 120]

Μια σημαντική έννοια στην Python είναι ότι οι lists είναι τροποποιήσιμες (mutable), που σημαίνει ότι μπορούν να τροποποιηθούν μετά τη δημιουργία τους. Γι’ αυτόν τον λόγο, η εκχώρηση μιας list σε μια άλλη μεταβλητή δεν δημιουργεί ένα εντελώς ανεξάρτητο αντίγραφο. Αντίθετα, και οι δύο μεταβλητές αναφέρονται στην ίδια list στη μνήμη. Για να δημιουργήσουμε ένα πραγματικό αντίγραφο μιας list, μπορούμε να χρησιμοποιήσουμε τη συνάρτηση list():

# Δημιουργία αντιγράφου μιας list
our_list_copy = list(our_list)

# Αλλαγή των πέντε πρώτων στοιχείων της αντιγραμμένης list
our_list_copy[0:5] = [0, 0, 0, 0, 0]

# Εμφάνιση όλων των στοιχείων της αντιγραμμένης list
our_list_copy
[0, 0, 0, 0, 0, 120]
# Εμφάνιση όλων των στοιχείων της αρχικής list
our_list
[100, -100, 'TEXT', 102, 4, 120]

Παρατηρούμε ότι σε αυτό το παράδειγμα αλλάζουμε τις πέντε πρώτες τιμές του our_list_copy, αλλά οι τιμές του our_list παραμένουν ίδιες. Αυτό δείχνει ότι το our_list_copy είναι ένα ανεξάρτητο αντίγραφο της αρχικής list και όχι μια ακόμη αναφορά στην ίδια list στη μνήμη. Αυτό είναι χρήσιμο, επειδή μας επιτρέπει να τροποποιούμε την αντιγραμμένη list χωρίς να επηρεάζουμε την αρχική.

Tuples: Ένα tuple μοιάζει με μια list, αλλά είναι αμετάβλητο (immutable), που σημαίνει ότι οι τιμές του δεν μπορούν να αλλάξουν μετά τη δημιουργία του. Τα tuples δημιουργούνται με παρενθέσεις ():

# Δημιουργία tuple
our_tuple = (100, -100, 105, 102, -98)

# Εμφάνιση του our_tuple
our_tuple
(100, -100, 105, 102, -98)

Για να επιλέξουμε στοιχεία ενός tuple, μπορούμε και πάλι να χρησιμοποιήσουμε αγκύλες [] μαζί με τη θέση του στοιχείου, ακριβώς όπως κάνουμε με τις lists:

# Επιλογή του πρώτου στοιχείου
our_tuple[0]
100
# Επιλογή των τριών πρώτων στοιχείων
our_tuple[0:3]
(100, -100, 105)

Όπως αναφέραμε, δεν μπορούμε να προσθέσουμε απευθείας νέα στοιχεία σε ένα υπάρχον tuple· αυτό θα εξακολουθούσε να αποτελεί τροποποίηση. Ωστόσο, μπορούμε να δημιουργήσουμε ένα νέο tuple συνδυάζοντας tuples με τον τελεστή +:

# Δημιουργία νέου tuple με επιπλέον τιμές
our_tuple = our_tuple + (120,)
# Εμφάνιση του ενημερωμένου tuple
our_tuple
(100, -100, 105, 102, -98, 120)

Παρόλο που φαίνεται σαν να «επεκτείνουμε» το tuple, αυτό που στην πραγματικότητα συμβαίνει είναι ότι η Python δημιουργεί ένα εντελώς νέο tuple, το οποίο περιέχει όλα τα στοιχεία του αρχικού tuple συν τις νέες τιμές. Το ίδιο το αρχικό tuple παραμένει αμετάβλητο, και στη μεταβλητή απλώς εκχωρείται ξανά αυτό το νέο object. Επίσης, παρατηρούμε ότι, όταν δημιουργούμε ένα tuple με ένα μόνο στοιχείο, πρέπει και πάλι να βάλουμε ένα κόμμα μετά την τιμή. Χωρίς το κόμμα, η Python δεν ερμηνεύει την έκφραση ως tuple.

Sets: Ένα set είναι μια μη διατεταγμένη συλλογή μοναδικών τιμών. Στην Python, χρησιμοποιούμε άγκιστρα {} για να δημιουργήσουμε ένα set. Επειδή τα sets μπορούν να περιέχουν μόνο μοναδικά στοιχεία, οι διπλότυπες τιμές αφαιρούνται αυτόματα:

# Δημιουργία set
our_set = {100, -100, 105, 102, -98, 100}

# Εμφάνιση του our_set
our_set
{-100, -98, 100, 102, 105}

Βλέπουμε ότι οι επαναλαμβανόμενες τιμές εμφανίζονται μόνο μία φορά. Τα sets είναι χρήσιμα όταν μας ενδιαφέρουν μόνο τα μοναδικά στοιχεία.

Όπως και οι lists, τα sets είναι τροποποιήσιμα, που σημαίνει ότι μπορούμε να προσθέσουμε ή να αφαιρέσουμε στοιχεία μετά τη δημιουργία τους. Ωστόσο, επειδή τα sets δεν είναι διατεταγμένα, δεν μπορούμε να βασιστούμε σε θέσεις (indexing) για να προσπελάσουμε συγκεκριμένα στοιχεία. Για να προσθέσουμε νέα στοιχεία σε ένα set, χρησιμοποιούμε τη μέθοδο (method) add() ως εξής:

# Προσθήκη νέου στοιχείου
our_set.add(120)

# Εμφάνιση του ενημερωμένου set
our_set
{-100, -98, 100, 102, 105, 120}

Για να προσθέσουμε πολλά στοιχεία ταυτόχρονα, χρησιμοποιούμε τη μέθοδο update():

# Προσθήκη πολλών στοιχείων
our_set.update([130, 140])

# Εμφάνιση του ενημερωμένου set
our_set
{-100, -98, 100, 102, 105, 120, 130, 140}

Παρομοίως, μπορούμε να αφαιρέσουμε στοιχεία με την remove() (η οποία προκαλεί σφάλμα αν το στοιχείο δεν υπάρχει) ή με την discard() (η οποία δεν προκαλεί σφάλμα):

# Αφαίρεση στοιχείου
our_set.remove(100)

# Ασφαλής αφαίρεση στοιχείου
our_set.discard(-999)

# Εμφάνιση του ενημερωμένου set
our_set
{-100, -98, 102, 105, 120, 130, 140}

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

Dictionaries: Ένα dictionary είναι μια δομή δεδομένων που αποθηκεύει δεδομένα σε ζεύγη κλειδιού–τιμής (key–value pairs). Κάθε κλειδί συνδέεται με μια τιμή, όπως μια λέξη συνδέεται με τον ορισμό της σε ένα πραγματικό λεξικό. Στην Python, τα dictionaries δημιουργούνται με άγκιστρα {}, όπου κάθε κλειδί ακολουθείται από άνω και κάτω τελεία : και την αντίστοιχη τιμή του:

# Δημιουργία dictionary
our_dict = {
  "x": 100,
  "y": -100,
  "z": 105
  }

# Εμφάνιση του object our_dict
our_dict
{'x': 100, 'y': -100, 'z': 105}

Σε αντίθεση με τις lists ή τα tuples, δεν χρησιμοποιούμε αριθμητικές θέσεις για να προσπελάσουμε στοιχεία ενός dictionary. Αντίθετα, χρησιμοποιούμε το αντίστοιχο κλειδί για να ανακτήσουμε την τιμή:

# Προσπέλαση τιμών του our_dict
our_dict["x"]
100
our_dict["y"]
-100

Μπορούμε επίσης να προσπελάσουμε τα κλειδιά (keys), τις τιμές (values) ή τα στοιχεία (items, δηλαδή τα ζεύγη κλειδιού–τιμής) ενός dictionary, με τις μεθόδους keys(), values() και items() αντίστοιχα:

# Προσπέλαση των κλειδιών του our_dict
our_dict.keys()
dict_keys(['x', 'y', 'z'])
# Προσπέλαση των τιμών του our_dict
our_dict.values()
dict_values([100, -100, 105])
# Προσπέλαση των στοιχείων του our_dict
our_dict.items()
dict_items([('x', 100), ('y', -100), ('z', 105)])

Τα dictionaries είναι τροποποιήσιμα, δηλαδή μπορούμε να τα αλλάξουμε μετά τη δημιουργία τους. Για παράδειγμα, μπορούμε να αλλάξουμε μια υπάρχουσα τιμή εκχωρώντας μια νέα τιμή σε ένα κλειδί:

# Ενημέρωση τιμής
our_dict["x"] = 999

# Εμφάνιση του ενημερωμένου dictionary
our_dict
{'x': 999, 'y': -100, 'z': 105}

Μπορούμε επίσης να προσθέσουμε νέα ζεύγη κλειδιού–τιμής με τον εξής τρόπο:

# Προσθήκη νέου ζεύγους κλειδιού-τιμής
our_dict["w"] = 200

# Εμφάνιση του ενημερωμένου dictionary
our_dict
{'x': 999, 'y': -100, 'z': 105, 'w': 200}

Παρομοίως, μπορούμε να αφαιρέσουμε στοιχεία με την εντολή del:

# Αφαίρεση ζεύγους κλειδιού-τιμής
del our_dict["y"]

# Εμφάνιση του ενημερωμένου dictionary
our_dict
{'x': 999, 'z': 105, 'w': 200}

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

Όπως χρησιμοποιήσαμε την isinstance() για να ελέγξουμε τύπους δεδομένων, μπορούμε να τη χρησιμοποιήσουμε με τον ίδιο τρόπο για να ελέγξουμε δομές δεδομένων:

# Έλεγχος της δομής δεδομένων του our_list
isinstance(our_list, list)
True
isinstance(our_list, tuple)
False
isinstance(our_list, set)
False
isinstance(our_list, dict)
False
# Έλεγχος της δομής δεδομένων του our_tuple
isinstance(our_tuple, list)
False
isinstance(our_tuple, tuple)
True
isinstance(our_tuple, set)
False
isinstance(our_tuple, dict)
False
# Έλεγχος της δομής δεδομένων του our_set
isinstance(our_set, list)
False
isinstance(our_set, tuple)
False
isinstance(our_set, set)
True
isinstance(our_set, dict)
False
# Έλεγχος της δομής δεδομένων του our_dict
isinstance(our_dict, list)
False
isinstance(our_dict, tuple)
False
isinstance(our_dict, set)
False
isinstance(our_dict, dict)
True

Τέλος, μπορούμε να αξιοποιήσουμε τις μοναδικές ιδιότητες κάθε δομής δεδομένων για συγκεκριμένες εργασίες. Για παράδειγμα, για να κρατήσουμε μόνο τα μοναδικά στοιχεία μιας list, μπορούμε να τη μετατρέψουμε σε set:

# Δημιουργία νέας list
new_list = [100, -100, 100, 102]

# Μετατροπή της list σε set για να κρατήσουμε μόνο τις μοναδικές τιμές
set_with_list_values = set(new_list)

# Εμφάνιση του set_with_list_values
set_with_list_values
{-100, 100, 102}

Παρατηρούμε ότι η τιμή 100 εμφανίζεται μόνο μία φορά στο set που προκύπτει, παρόλο που υπήρχε δύο φορές στην αρχική list.

Συναρτήσεις

Στην Python, μια συνάρτηση είναι ένα οργανωμένο, επαναχρησιμοποιήσιμο κομμάτι κώδικα που εκτελεί μια συγκεκριμένη εργασία. Οι συναρτήσεις αναγνωρίζονται συνήθως από τις παρενθέσεις (), μέσα στις οποίες δίνουμε τις εισόδους που χρειάζεται η συνάρτηση. Αυτές οι είσοδοι ονομάζονται ορίσματα (arguments). Τα ορίσματα είναι οι τιμές που περνάμε σε μια συνάρτηση όταν την καλούμε, ώστε η συνάρτηση να μπορεί να εκτελέσει τις λειτουργίες της.

Έχουμε ήδη χρησιμοποιήσει κάποιες συναρτήσεις, όπως οι print(), isinstance() και type(), χωρίς να δηλώσουμε ρητά τα ονόματα των ορισμάτων. Πολλές συναρτήσεις έχουν παραμέτρους (parameters) με προεπιλεγμένες τιμές (default values), κάτι που σημαίνει ότι δεν χρειάζεται πάντα να δηλώνουμε ρητά όλα τα ορίσματα. Κάποιες συναρτήσεις μπορούν μάλιστα να κληθούν χωρίς κανένα όρισμα, όπως η dir(), οπότε απλώς χρησιμοποιούμε κενές παρενθέσεις. Σημειώνεται ότι οι παράμετροι είναι τα ονόματα που αναγράφονται στον ορισμό μιας συνάρτησης, ενώ τα ορίσματα είναι οι πραγματικές τιμές που περνάμε όταν καλούμε τη συνάρτηση.

Για παράδειγμα, μπορούμε να χρησιμοποιήσουμε τη συνάρτηση isinstance() περνώντας απευθείας το object και τον τύπο που θέλουμε να ελέγξουμε:

# Έλεγχος αν ένα object είναι list
isinstance([1, 2, 3], list)
True

Σε πιο σύνθετες συναρτήσεις, είναι συχνά καλή πρακτική να χρησιμοποιούμε ονομαστικά ορίσματα (named arguments), επειδή έτσι βελτιώνεται η αναγνωσιμότητα και μειώνεται η σύγχυση όταν οι συναρτήσεις έχουν πολλές παραμέτρους.

Παρόλο που η Python και οι ενσωματωμένες βιβλιοθήκες της παρέχουν πολλές συναρτήσεις, μπορούμε επίσης να δημιουργήσουμε τις δικές μας. Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να δημιουργήσουμε μια συνάρτηση που υπολογίζει το άθροισμα όλων των αριθμών μιας ακολουθίας:

# Δημιουργία συνάρτησης
def our_function(first_number, last_number):
    numbers_range = range(first_number, last_number + 1)
    return sum(numbers_range)

# Υπολογισμός του αθροίσματος των ακεραίων από το 1 έως το 10 με την our_function
our_function(first_number = 1, last_number = 10)
55

Ας εξηγήσουμε τι ακριβώς κάναμε. Ως πρώτο βήμα, ορίσαμε μια συνάρτηση με την εντολή def και της δώσαμε δύο παραμέτρους: first_number και last_number. Αυτά τα ονόματα είναι της επιλογής μας (έχουμε δει πώς άλλες συναρτήσεις χρησιμοποιούν ορίσματα). Μέσα στη συνάρτηση, δημιουργήσαμε μια ακολουθία αριθμών με την range() και εκχωρήσαμε αυτά τα αποτελέσματα στο numbers_range (και πάλι, ένα όνομα της επιλογής μας). Στην Python, η range() παράγει αριθμούς ξεκινώντας από την πρώτη τιμή έως (αλλά χωρίς να περιλαμβάνεται) την τελευταία τιμή, γι’ αυτό χρησιμοποιούμε last_number + 1. Έπειτα, χρησιμοποιήσαμε τη συνάρτηση sum(), η οποία αθροίζει όλες τις τιμές μιας ακολουθίας. Τέλος, χρησιμοποιήσαμε το return για να επιστρέψουμε το αποτέλεσμα.

Καθολική και τοπική εμβέλεια

Λέμε ότι τα objects που δημιουργούνται μέσα σε μια συνάρτηση ανήκουν στην τοπική εμβέλεια (local scope), που σημαίνει ότι υπάρχουν μόνο μέσα σε αυτή τη συνάρτηση. Τα objects που δημιουργούνται έξω από συναρτήσεις ανήκουν στην καθολική εμβέλεια (global scope), που σημαίνει ότι είναι προσβάσιμα σε ολόκληρο το πρόγραμμα. Η κατανόηση αυτής της διάκρισης είναι σημαντική, επειδή οι μεταβλητές που δημιουργούνται μέσα σε συναρτήσεις δεν είναι άμεσα προσβάσιμες έξω από αυτές.

Ένας πιο γρήγορος αλλά λιγότερο δομημένος τρόπος για να δημιουργήσουμε δικές μας συναρτήσεις στην Python είναι οι συναρτήσεις lambda (lambda functions), δηλαδή μικρές, ανώνυμες συναρτήσεις που μπορούν να γραφτούν σε μία μόνο γραμμή. Είναι χρήσιμες όταν χρειαζόμαστε μια απλή συνάρτηση για μια σύντομη εργασία και δεν θέλουμε να την ορίσουμε επίσημα με το def. Σε αντίθεση με τις συνηθισμένες συναρτήσεις, οι συναρτήσεις lambda δεν χρησιμοποιούν την εντολή return και δεν χρειάζονται όνομα (αν και εδώ της δίνουμε ένα, ώστε να μπορούμε να την επαναχρησιμοποιήσουμε). Αντίθετα, γράφονται σε συμπαγή μορφή με τη λέξη-κλειδί lambda. Για παράδειγμα, η παρακάτω συνάρτηση lambda προσθέτει 10 σε έναν αριθμό:

# Συνάρτηση lambda που προσθέτει 10 σε έναν αριθμό
add_ten = lambda x: x + 10

# Χρήση της συνάρτησης
add_ten(5)
15

Σε αυτή την περίπτωση, το x είναι η είσοδος (όρισμα) και το x + 10 είναι η πράξη της οποίας το αποτέλεσμα επιστρέφεται αυτόματα.

Ας δούμε τώρα μερικές σημαντικές ενσωματωμένες συναρτήσεις της Python. Για να κατανοήσουμε πώς λειτουργούν αυτές οι συναρτήσεις σε συλλογές τιμών, δημιουργούμε πρώτα μια κατάλληλη list:

# Δημιουργία του object list_for_functions
list_for_functions = [100, 1, 2, 3, 4, 5, 6, 6, 6]

Η συνάρτηση sorted() χρησιμοποιείται για να επιστρέψει μια ταξινομημένη εκδοχή μιας συλλογής τιμών. Σε αντίθεση με τις μεθόδους που τροποποιούν απευθείας ένα object, η sorted() δεν αλλάζει το αρχικό object. Αντίθετα, δημιουργεί μια νέα ταξινομημένη list και την επιστρέφει. Αυτή η συνάρτηση μπορεί να εφαρμοστεί όχι μόνο σε lists, αλλά και σε άλλα objects, όπως τα tuples. Για παράδειγμα, αν θέλουμε να ταξινομήσουμε τα στοιχεία της list μας σε αύξουσα σειρά, μπορούμε να κάνουμε το εξής:

# Ταξινόμηση της list
sorted(list_for_functions)
[1, 2, 3, 4, 5, 6, 6, 6, 100]

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

Οι συναρτήσεις max() και min() μπορούν να χρησιμοποιηθούν για να βρούμε τη μέγιστη και την ελάχιστη τιμή μιας list αντίστοιχα:

# Εύρεση της μέγιστης τιμής
max(list_for_functions)
100
# Εύρεση της ελάχιστης τιμής
min(list_for_functions)
1

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

# Εύρεση της θέσης της μέγιστης τιμής
list_for_functions.index(max(list_for_functions))
0
# Εύρεση της θέσης της ελάχιστης τιμής
list_for_functions.index(min(list_for_functions))
1

Παρατηρούμε ότι αναφερθήκαμε στην index() ως μέθοδο και όχι ως συνάρτηση. Παρόλο που οι συναρτήσεις και οι μέθοδοι σχετίζονται στενά και μερικές φορές χρησιμοποιούνται με παρόμοιους τρόπους, δεν είναι το ίδιο πράγμα. Μια συνάρτηση είναι ένα αυτόνομο κομμάτι κώδικα που εκτελεί μια λειτουργία όταν της περνάμε δεδομένα ως είσοδο. Για παράδειγμα, οι max() και min() είναι συναρτήσεις, επειδή δέχονται μια list ως όρισμα και επιστρέφουν ένα αποτέλεσμα. Από την άλλη πλευρά, μια μέθοδος είναι μια συνάρτηση που είναι συνδεδεμένη με ένα συγκεκριμένο object και καλείται με τελεία (.). Αυτό σημαίνει ότι η λειτουργία εφαρμόζεται απευθείας στο ίδιο το object. Για παράδειγμα, η index() είναι μέθοδος των lists της Python, επειδή καλείται πάνω σε μια list και λειτουργεί στα περιεχόμενά της. Νωρίτερα σε αυτό το κεφάλαιο, είδαμε επίσης άλλες μεθόδους, όπως τις keys() και values() των dictionaries της Python. Συνοπτικά, οι συναρτήσεις δέχονται εισόδους ως ορίσματα, ενώ οι μέθοδοι ανήκουν σε objects και καλούνται μέσω αυτών των objects με τη σύνταξη της τελείας (.).

Τέλος, αλλά εξίσου σημαντικό, αξίζει να αναφέρουμε δύο ακόμη συναρτήσεις: την range() και την len(). Έχουμε ήδη δει τη συνάρτηση range()· δημιουργεί μια ακολουθία αριθμών με βάση μια αρχική τιμή, μια τελική τιμή και ένα βήμα (step). Για παράδειγμα, μπορούμε να χρησιμοποιήσουμε αυτή τη συνάρτηση για να δημιουργήσουμε όλους τους ζυγούς αριθμούς από το 0 έως (αλλά χωρίς να περιλαμβάνεται) το 40 (0, 2, 4 κ.λπ.). Σημειώνεται ότι πρέπει να μετατρέψουμε την έξοδο σε list, επειδή η ίδια η range() παράγει ένα object τύπου range, το οποίο δεν εμφανίζεται ως πλήρης list τιμών:

# Δημιουργία list με τους ζυγούς αριθμούς από το 0 έως (αλλά χωρίς να περιλαμβάνεται) το 40
even_numbers = list(range(0, 40, 2))

# Εμφάνιση του even_numbers
even_numbers
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38]

Η συνάρτηση len() προέρχεται από τη λέξη length (μήκος) και επιστρέφει το πλήθος των στοιχείων μιας list (ή οποιασδήποτε άλλης συλλογής). Για παράδειγμα, το πλήθος των ζυγών αριθμών από το 0 έως (αλλά χωρίς να περιλαμβάνεται) το 40 μπορεί να υπολογιστεί ως εξής:

# Εμφάνιση του πλήθους των στοιχείων του even_numbers
len(even_numbers)
20

Ροή ελέγχου

Στην Python, η ροή ελέγχου (control flow) αναφέρεται στους μηχανισμούς που καθορίζουν τη σειρά με την οποία εκτελείται ο κώδικας. Αντί να εκτελείται γραμμή προς γραμμή με αυστηρά γραμμικό τρόπο, η ροή ελέγχου μας επιτρέπει να παίρνουμε αποφάσεις, να επαναλαμβάνουμε ενέργειες και να δημιουργούμε πιο δυναμικά προγράμματα. Τα δύο πιο θεμελιώδη εργαλεία ροής ελέγχου είναι οι εντολές συνθήκης (αποφάσεις) και οι βρόχοι (loops, επανάληψη).

Μια σύγκριση (comparison) στην Python ελέγχει μια συνθήκη και επιστρέφει μια λογική τιμή: True αν η συνθήκη ικανοποιείται και False διαφορετικά. Οι συγκρίσεις χρησιμοποιούν τελεστές όπως > (μεγαλύτερο από), < (μικρότερο από), == (ίσο με) και != (διάφορο από), και αποτελούν τα δομικά στοιχεία των εντολών συνθήκης, τις οποίες εξετάζουμε στη συνέχεια. Για παράδειγμα, ας υποθέσουμε ότι έχουμε ένα object z και θέλουμε να ελέγξουμε αν η τιμή του είναι μεγαλύτερη από 2.5:

# Δημιουργία του object z
z = 3

# Έλεγχος αν το z είναι μεγαλύτερο από 2.5
print(z > 2.5)
True

Ένας πιο δομημένος τρόπος για να παίρνουμε αποφάσεις με βάση συνθήκες είναι να χρησιμοποιούμε εντολές συνθήκης, οι οποίες έχουν την εξής μορφή:

# Μορφή if-else
if condition:
    expression
elif condition:
    expression
else:
    expression

Εδώ χρησιμοποιούμε τις εντολές if, elif και else για να ελέγχουμε τη ροή του προγράμματος, ανάλογα με το αν ικανοποιούνται ή όχι οι συνθήκες. Ο κώδικας αξιολογείται από πάνω προς τα κάτω, και εκτελείται το μπλοκ της πρώτης συνθήκης που είναι True. Αν καμία από τις συνθήκες δεν ικανοποιείται, εκτελείται το μπλοκ του else.

Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να ελέγξουμε την τιμή του z και να την κατατάξουμε ανάλογα με το μέγεθός της. Αν είναι μεγαλύτερη από 4, εμφανίζουμε ένα μήνυμα· αν είναι ακριβώς 4, εμφανίζουμε ένα άλλο μήνυμα· διαφορετικά, εμφανίζουμε ένα τρίτο μήνυμα:

# Εντολές συνθήκης
if z > 4:
    print("z is higher than 4.")
elif z == 4:
    print("z is equal to 4.")
else:
    print("z is lower than 4.")
z is lower than 4.

Όπως αναμενόταν, αφού z = 3, η συνθήκη z > 4 δεν ικανοποιείται, και το πρόγραμμα μεταβαίνει στο μπλοκ του else, το οποίο εκτελείται.

Με τους βρόχους μπορούμε να δημιουργήσουμε ένα κομμάτι κώδικα που επαναλαμβάνεται. Για παράδειγμα, αν και δεν είναι ιδιαίτερα χρήσιμο στην πράξη, μπορούμε να δημιουργήσουμε έναν βρόχο for (for-loop) που εμφανίζει κάθε στοιχείο της list μας ξεχωριστά. Παρόλο που θα μπορούσαμε να χρησιμοποιήσουμε τη συνάρτηση print() για να εμφανίσουμε όλα τα στοιχεία ταυτόχρονα, ας εμφανίσουμε, για χάρη του παραδείγματος, κάθε στοιχείο ξεχωριστά:

# Εμφάνιση όλων των στοιχείων μαζί
print(list_for_functions)
[100, 1, 2, 3, 4, 5, 6, 6, 6]
# Εμφάνιση κάθε στοιχείου ξεχωριστά με βρόχο for
for i in range(0, 9):
    print(list_for_functions[i])
100
1
2
3
4
5
6
6
6

Οι βρόχοι for χρησιμοποιούν έναν δείκτη (index), ο οποίος παίρνει μία τιμή μιας ακολουθίας κάθε φορά και κρατά αυτή την τιμή για έναν γύρο (επανάληψη). Ο δείκτης συνήθως συμβολίζεται με i, αλλά μπορούμε να επιλέξουμε οποιοδήποτε άλλο γράμμα ή όνομα. Όταν ολοκληρωθεί η εκτέλεση του κώδικα μέσα στον βρόχο, ο δείκτης παίρνει την επόμενη τιμή της ακολουθίας (η οποία δημιουργήθηκε με τη συνάρτηση range()) και ο κώδικας εκτελείται ξανά. Όλη αυτή η διαδικασία συνεχίζεται μέχρι το i να πάρει όλες τις τιμές της ακολουθίας. Στο παράδειγμά μας, ο δείκτης i παίρνει πρώτα την τιμή 0 και εκτελείται ο κώδικας μέσα στον βρόχο. Ο κώδικας απλώς εμφανίζει το στοιχείο που βρίσκεται στη θέση i της list μας (το οποίο, στην πρώτη εκτέλεση, είναι το 100). Στη συνέχεια, το i παίρνει την τιμή 1 και ο κώδικας εκτελείται ξανά, μέχρι το i να πάρει και τις 9 τιμές και ο κώδικας να εκτελεστεί 9 φορές. Σημειώνεται ότι, σε αυτό το παράδειγμα, πληκτρολογούμε τον αριθμό 9 χειροκίνητα, που σημαίνει ότι ο βρόχος for θα εκτελούνταν 9 φορές ακόμη κι αν το πλήθος των στοιχείων ήταν διαφορετικό.

Εκτός από τους βρόχους for, μπορούμε επίσης να χρησιμοποιήσουμε βρόχους while (while-loops), οι οποίοι επαναλαμβάνουν ένα μπλοκ κώδικα όσο μια δεδομένη συνθήκη παραμένει True. Σε αντίθεση με τους βρόχους for, οι οποίοι εκτελούνται για έναν προκαθορισμένο αριθμό επαναλήψεων, οι βρόχοι while συνεχίζουν μέχρι να ικανοποιηθεί μια συνθήκη τερματισμού:

# Εκχώρηση της τιμής -3
z = -3

# Δημιουργία βρόχου while
while z != 0:
    print("z is still not equal to 0")
    if z > 0:
        z = z - 1
    else:
        z = z + 1
    print(z)
z is still not equal to 0
-2
z is still not equal to 0
-1
z is still not equal to 0
0

Στο παραπάνω παράδειγμα, ξεκινάμε με την τιμή -3 στο object z και στη συνέχεια μπαίνουμε σε έναν βρόχο while. Εδώ, όσο το z δεν είναι ίσο (!=) με 0, ο βρόχος συνεχίζει να εκτελείται. Μέσα στον βρόχο, η Python ελέγχει αν το z είναι μεγαλύτερο από 0. Αν ισχύει αυτό, μειώνει την τιμή του z κατά 1, ώστε να το φέρει πιο κοντά στο 0. Αν το z δεν είναι μεγαλύτερο από 0, τότε πρέπει να είναι μικρότερο από 0, και επομένως η τιμή του αυξάνεται κατά 1, ώστε και πάλι να πλησιάσει το 0. Αυτή η διαδικασία συνεχίζεται μέχρι το z να φτάσει τελικά στο 0, οπότε η συνθήκη z != 0 γίνεται False και ο βρόχος σταματά.

Είναι πολύ σημαντικό να είμαστε προσεκτικοί με τους βρόχους while, γιατί, αν η συνθήκη δεν ενημερώνεται ποτέ με τρόπο που να την κάνει False, ο βρόχος θα εκτελείται επ’ αόριστον. Αυτό είναι γνωστό ως ατέρμων βρόχος (infinite loop) και μπορεί να κάνει το πρόγραμμα να «παγώσει» ή να συνεχίζει να εκτελείται χωρίς να σταματά.

Βοήθεια

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

Η Python παρέχει ενσωματωμένη τεκμηρίωση (documentation) για σχεδόν κάθε συνάρτηση, στην οποία μπορούμε να έχουμε πρόσβαση με διάφορους τρόπους. Ένας από τους πιο συνηθισμένους τρόπους είναι η συνάρτηση help(), στην οποία περνάμε το όνομα της συνάρτησης για την οποία θέλουμε να μάθουμε περισσότερα. Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να δούμε την τεκμηρίωση της συνάρτησης log() από το module math, μιας συνάρτησης που υπολογίζει τον φυσικό λογάριθμο ενός αριθμού:

import math

# Λήψη βοήθειας για τη math.log
help(math.log)
Help on built-in function log in module math:

log(...)
    log(x, [base=math.e])
    Return the logarithm of x to the given base.

    If the base is not specified, returns the natural logarithm (base e) of x.

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