• Λίστες (Lists)
• Πλειάδες και ακολουθίες (Tuples & Sequences)
• Σετ (Sets)
• Λεξικά (Dictionaries)

Και κάποια εξεζητημένα ζητήματα όπως:

• Τεχνικές επανάληψης (Looping Techniques)
• Συνθήκες επιλογής (Conditions) – προχωρημένα θέματα –

Προαπαιτούμενα

Μαθαίνοντας Python

Πριν ξεκινήσουμε…

… θα ήθελα να επισημάνω ένα – δύο πρακτικά ζητήματα.

Στη συνέχεια παρουσιάζεται ο τρόπος για να επιτευχθούν οι στόχοι που περιγράψαμε στην εισαγωγή. Θα παρατηρήσετε ότι το άρθρο ακολουθεί τη δομή:

Παράδειγμα κώδικα

Για να τα χρησιμοποιήσετε, αντιγράφετε το εκάστοτε παράδειγμα σε ένα νέο αρχείο python και το εκτελείτε (βλ. Μαθαίνοντας Python – Μέρος 1ο ). Τα παραδείγματα είναι φτιαγμένα με τέτοιον τρόπο ώστε να τυπώνουν τα αποτελέσματα στην οθόνη ώστε να μπορείτε να πιστοποιήσετε εύκολα τη λειτουργικότητά τους. Για διευκόλυνσή σας έχουμε χωρίσει τα παραδείγματα με σχόλια που δίνουν μια μικρή περιγραφή του τι επιχειρούμε κάθε φορά.

Βεβαιωθείτε ότι δεν ξεχάσατε το μάτι της κουζίνας ανοικτό, ετοιμάστε μία κούπα καφέ ή τσάι, βάλτε απαλή μουσική και ξεκινάμε…

( ΒΛΕΠΟΝΤΑΣ ΤΙΣ ΛΙΣΤΕΣ ΜΕ «ΑΛΛΟ ΜΑΤΙ» )

Στο σημερινό άρθρο θα μας απασχολήσουν πιο προχωρημένα θέματα που έχουν να κάνουν με λίστες.

Χρησιμοποιώντας τις λίστες σαν ουρές

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

Μια ουρά δηλαδή, είναι ένα σύνολο αντικειμένων στοιχισμένα το ένα πίσω από το άλλο. Κάθε νέο αντικείμενο που προστίθεται στην ουρά καταλαμβάνει την τελευταία θέση (μπαίνει πίσω από κάθε άλλο προϋπάρχον στοιχείο). Επίσης, όταν πάρουμε ένα αντικείμενο από την ουρά, θα  είναι το στοιχείο που βρίσκεται στην πρώτη θέση. Η παραπάνω σκέψη μας οδηγεί στο συμπέρασμα ότι μια ουρά λειτουργεί με τη λογική «το πρώτο στοιχείο που εισάγουμε, είναι το πρώτο που εξάγουμε». Στη βιβλιογραφία αυτή η διαπίστωση και, κατ’ επέκταση η φύση λειτουργίας της ουράς, ως δομή δεδομένων, αναφέρεται ως “FIRST IN, FIRST OUT” ή, εν συντομία, “FIFO”.

Πως το υλοποιούμε σε Python όμως;

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

>>> from collections import deque

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

TIP: Ο όρος “collections” συναντάται σε πολλές γλώσσες προγραμματισμού. Συνήθως αποτελεί μια συλλογή από δομές δεδομένων υλοποιημένες για την εκάστοτε γλώσσα.

Τώρα που γνωρίζουμε τα παραπάνω μπορούμε εύκολα να αντιληφθούμε ότι η εντολή που μόλις πληκτρολογήσαμε «φορτώνει» από την βιβλιοθήκη «collections» τη δομή «deque» – η οποία αποτελεί προφανώς υλοποίηση της ουράς –.

Ο λόγος που αυτή τη φορά δεν χρησιμοποιούμε εντολές της Python για να «κατασκευάσουμε» τη δική μας ουρά αλλά χρησιμοποιούμε κάτι έτοιμο είναι ο εξής. Το να κάνουμε προσθήκες και ανακτήσεις στο τέλος μιας λίστας (δείτε Μαθαίνοντας Python – Μέρος 7^ο (β)) είναι γενικά μια διαδικασία που δεν κοστίζει πολύ από άποψη πόρων. Δυστυχώς όμως, η δομή της ουράς εμπλέκει το  τέλος της λίστας. Οι διαδικασίες της προσθήκης και ανάκτησης στο τέλος της λίστας είναι πράξεις που κοστίζουν στη γλώσσα Python.

Ας δούμε τώρα τι δυνατότητες διαχείρισης μας προσφέρονται.

>>> myQueue = deque(["The tale of Sir Robin", "The tale of Sir Lancelot", "The tale of Sir Bedevir"])

Με την εντολή deque(LIST) δημιουργούμε μια ουρά. Παρατηρήστε ότι το όρισμα που δέχεται η deque είναι μια λίστα (η οποία μπορεί να περιέχει όλα όσα έχουμε δει ότι μπορεί να περιέχει μια λίστα σε προηγούμενα άρθρα μας).

Η συγκεκριμένη εντολή δημιουργεί μία ουρά με αντικείμενα, τα αντικείμενα της λίστας που έχουμε δώσει σαν όρισμα (στην συγκεκριμένη περίπτωση LIST).

Οι διαδικασίες εισαγωγής και ανάκτησης γίνονται με τον ίδιο τρόπο που συναντήσαμε όταν μελετούσαμε τη δομή στοίβας (stuck). Αναλυτικότερα:

>>> myQueue.append("The tail of Sir Arthur")

Με την εντολή αυτή ένα νέο στοιχείο εισέρχεται στην ουρά (δηλαδή καταλαμβάνει την τελευταία θέση).

Όσων αφορά την υλοποίηση της ανάκτησης, θα χρησιμοποιήσουμε μια παραλλαγή της γνωστής μας, από την υλοποίηση της στοίβας, pop().

>>> myQueue.popleft()

Εκτελώντας την παραπάνω εντολή, η κονσόλα μας επιστρέφει:

“The tale of Sir Robin”

… που είναι το πρώτο στοιχείο που εισήχθηκε στη λίστα. Επαληθεύουμε με:

>>> myQueue

και παίρνουμε:

["The tale of Sir Lancelot", "The tale of Sir Bedevir"]

Εκτελώντας ξανά

>>> myQueue.popleft()

(σωστά μαντεύετε)

“The tale of Sir Lancelot”

και έτσι η ουρά μας έχει πλέον τη μορφή:

>>> myQueue
["The tale of Sir Bedevir"]

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

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

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

Μέχρι τότε, να μην ξεχνάτε…

να είστε καλά και να φροντίζεται τον εαυτό σας.

• Λίστες (Lists)
• Πλειάδες και ακολουθίες (Tuples & Sequences)
• Σετ (Sets)
• Λεξικά (Dictionaries)

Και κάποια εξεζητημένα ζητήματα όπως:

• Τεχνικές επανάληψης (Looping Techniques)
• Συνθήκες επιλογής (Conditions) – προχωρημένα θέματα –

Βεβαιωθείτε ότι δεν ξεχάσατε το μάτι της κουζίνας ανοικτό, ετοιμάστε μία κούπα καφέ ή τσάι, βάλτε απαλή μουσική και ξεκινάμε…

( ΒΛΕΠΟΝΤΑΣ ΤΙΣ ΛΙΣΤΕΣ ΜΕ ΑΛΛΟ ΜΑΤΙ )

Στο σημερινό άρθρο θα μας απασχολήσουν πιο προχωρημένα θέματα που έχουν να κάνουν με λίστες.

Χρησιμοποιώντας τις λίστες σαν στοίβες

Η έννοια της στοίβας είναι βασική όσων αφορά το αντικείμενο των δομών δεδομένων και αποτελεί συνήθως το εισαγωγικό μάθημα στο εν λόγω αντικείμενο σε μια σχολή Πληροφορικής. Η στοίβα, ως δομή δεδομένων, δε διαφέρει ιδιαίτερα από την κοινή στοίβα που συναντούμε στην καθημερινή μας ζωή (μια στοίβα βιβλία, μια στοίβα CD ή DVD, η στοίβα με τα άπλυτα, κλπ.).

Ας συμφωνήσουμε ότι μια στοίβα είναι ένα σύνολο αντικειμένων το ένα πάνω στο άλλο. Κάθε νέο αντικείμενο που προστίθεται στην στοίβα καταλαμβάνει την ανώτερη θέση. Επίσης όταν πάρουμε ένα αντικείμενο από τη στοίβα, μοιραία θα είναι το στοιχείο που βρίσκεται στην ανώτερη θέση. Η παραπάνω σκέψη μας οδηγεί στο συμπέρασμα ότι μια στοίβα λειτουργεί με τη λογική «το τελευταίο στοιχείο που εισάγουμε, είναι το πρώτο που εξάγουμε». Στη βιβλιογραφία αυτή η διαπίστωση και, κατ’ επέκταση η φύση λειτουργίας της στοίβας ως δομή δεδομένων, αναφέρεται ως “LAST IN, FIRST OUT” ή, εν συντομία, “LIFO”.

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

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

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

>>> myStack = [‘Monty Python and the holy grail’, ‘The life of Brian’, ‘The meaning of life’]

Σε αυτό το σημείο θα ήθελα να επικαλεστώ την φαντασία σας. Σκεφτείτε το παραπάνω σετ στοιχείων ως στοίβα… οπτικά θα έμοιαζε κάπως έτσι:

‘The meaning of life’
‘The life of Brian’
‘Monty Python and the holy grail’

Σωστά;

Ας υλοποιήσουμε τώρα την εισαγωγή ενός καινούριου στοιχείου στη στοίβα. Σύμφωνα με τη θεωρία κάθε νέο στοιχείο που εισέρχεται στη στοίβα καταλαμβάνει την ανώτερη θέση. Θέλουμε δηλαδή το νέο στοιχείο που θα προστεθεί στην παραπάνω στοίβα που δημιουργήσαμε, να τοποθετηθεί πάνω από το ‘The meaning of life’. Θυμάστε την append(); Αν όχι, ανατρέξτε σε προηγούμενα άρθρα του οδηγού και θυμηθείτε την γιατί είναι η λύση στο πρόβλημά μας

>>> myStack.append(‘And now for something completely different’)

η στοίβα μας έχει τώρα την ακόλουθη μορφή:

‘And now for something completely different’
‘The meaning of life’
‘The life of Brian’
‘Monty Python and the holy grail’

Φυσικά η Python δεν μπορεί να απεικονίσει την στοίβα με τον παραπάνω τρόπο. Για την Python μια στοίβα θα είναι πάντοτε μια λίστα. Επομένως αν δώσουμε στην κονσόλα…

>>> myStack

…θα δούμε

[‘Monty Python and the holy grail’, ‘The life of Brian’, ‘The meaning of life’, ‘And now for something completely different’]

(σε μία γραμμή – γιατί πρέπει να χρησιμοποιώ πάντα τόσο μεγάλα παραδείγματα; – )

Ομοίως:

>>> myStack.append(‘Brazil’)

και η στοίβα μας έχει πάρει τη μορφή:

‘Brazil’
‘And now for something completely different’
‘The meaning of life’
‘The life of Brian’
‘Monty Python and the holy grail’

ή

[‘Monty Python and the holy grail’, ‘The life of Brian’, ‘The meaning of life’, ‘And now for something completely different’, ‘Brazil’]

Τώρα ήρθε η ώρα να υλοποιήσουμε το δεύτερο κομμάτι λειτουργικότητας που αποτελεί την ανάκτηση των στοιχείων της λίστας. Όπως είπαμε, «πρώτο στοιχείο» σε μια στοίβα θεωρείται το στοιχείο που βρίσκεται στην κορυφή σωστά μαντεύετε, στην συγκεκριμένη περίπτωση είναι το ‘Brazil’). Πως το υλοποιούμε όμως σε Python;

Θα χρησιμοποιήσουμε μία ακόμη γνωστή μας εντολή:

>>> myStack.pop()

…η κονσόλα μας επιστρέφει:

‘Brazil’

Ο κύβος ερρίφθη

Ας σιγουρευτούμε ότι όλα πήγαν κατ’ ευχήν βλέποντας την τρέχουσα κατάσταση στην οποία έχει περιέλθει η λίστα μας:

>>> myStack

[‘Monty Python and the holy grail’, ‘The life of Brian’, ‘The meaning of life’, ‘And now for something completely different’]

Ομοίως…

>>> myStack.pop()

…και η κονσόλα μας επιστρέφει:

‘And now for something completely different’

>>> myStack

[‘Monty Python and the holy grail’, ‘The life of Brian’, ‘The meaning of life’]

Πολλοί από εσάς θα παρατήρησαν ότι στο σημερινό άρθρο δεν δουλέψαμε πάνω σε κάποιο Python script, όπως συνήθως. Αντίθετα χρησιμοποιήσαμε εντολές απ’ ευθείας στην κονσόλα. Αυτό συμβαίνει διότι σήμερα δεν μάθαμε κάτι καινούριο. Χρησιμοποιήσαμε προϋπάρχουσα γνώση για να μπορέσουμε να υλοποιήσουμε μία από τις πιο θεμελιώδεις δομές δεδομένων στην θεωρία της Πληροφορικής. Τη στοίβα.

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

Μέχρι τότε, να μην ξεχνάτε…

να είστε καλά και να φροντίζεται τον εαυτό σας.

• Λίστες (Lists)
• Πλειάδες και ακολουθίες (Tuples & Sequences)
• Σετ (Sets)
• Λεξικά (Dictionaries)

Και κάποια εξεζητημένα ζητήματα όπως:

• Τεχνικές επανάληψης (Looping Techniques)
• Συνθήκες επιλογής (Conditions) – προχωρημένα θέματα –

Προαπαιτούμενα

Μαθαίνοντας Python

Πριν ξεκινήσουμε…
… θα ήθελα να επισημάνω ένα – δύο πρακτικά ζητήματα.

Στη συνέχεια παρουσιάζεται ο τρόπος για να επιτευχθούν οι στόχοι που περιγράψαμε στην εισαγωγή. Θα παρατηρήσετε ότι το άρθρο ακολουθεί τη δομή:

Μικρή περιγραφή του τι θέλουμε να επιτύχουμε (+ επιπλέον σχόλια)

Παράδειγμα κώδικα

Στο τέλος του αρχείου θα βρείτε συνημμένο ένα python script που περιέχει συγκεντρωμένα όλα τα παραδείγματα.

Για να τα χρησιμοποιήσετε, αντιγράφετε το εκάστοτε παράδειγμα σε ένα νέο αρχείο python και το εκτελείτε (βλ. Μαθαίνοντας Python – Μέρος 1ο ). Τα παραδείγματα είναι φτιαγμένα με τέτοιον τρόπο ώστε να τυπώνουν τα αποτελέσματα στην οθόνη ώστε να μπορείτε να πιστοποιήσετε εύκολα τη λειτουργικότητά τους. Για διευκόλυνσή σας έχουμε χωρίσει τα παραδείγματα με σχόλια που δίνουν μια μικρή περιγραφή του τι επιχειρούμε κάθε φορά.

Βεβαιωθείτε ότι δεν ξεχάσατε το μάτι της κουζίνας ανοικτό, ετοιμάστε μία κούπα καφέ ή τσάι, βάλτε απαλή μουσική και ξεκινάμε…

( ΦΡΕΣΚΑΡΟΝΤΑΣ ΤΑ ΒΑΣΙΚΑ… )

Στο σημερινό άρθρο θα μας απασχολήσουν και πάλι θέματα που έχουν να κάνουν με λίστες. Ας θυμηθούμε τα βασικά:

Ορισμός Λίστας

myList = ['monty', 'python', 999, 222]

Επιλογή Στοιχείου Λίστας

myList[0]
myList[-1]

Εισαγωγή Στοιχείου σε Λίστα

myList[3] = 'foo'

Διαγραφή Στοιχείου από Λίστα

myList[2] = []

Καθαρισμός Λίστας

myList[:] = []

Μέγεθος Λίστας

Len(myList)

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

Προσθήκη στοιχείου στο τέλος της λίστας

myList.append("Team")

εδώ προστίθεται το στοιχείο Team στην τελευταία θέση

Επέκταση μιας λίστας με τα στοιχεία μιας άλλης

anotherList = ['foo', 'foo2']
myList.extend( anotherList )

Η λίστα myList επεκτείνεται με τα στοιχεία της λίστας anotherList τα οποία και τοποθετούνται στο τέλος της myList

Εισαγωγή στοιχείου σε συγκεκριμένη θέση της λίστας

myList.insert(0, 'inserted')

Εδώ το στοιχέιο ‘inserted’ θα εισαχθεί στη θέση 0 (δηλαδή την πρώτη)

Αφαίρεση στοιχείου με συγκεκριμένη τιμή

myList.remove('inserted')

Εδώ θα αφαιρεθεί το στοιχείο με τιμή ‘inserted’

Ανάγνωση του τελευταίου στοιχείου της λίστας

print(myList.pop())

Εδώ θα επιστραφεί το τελευταίο στοιχείο της λίστας και θα διαγραφεί ταυτόχρονα από αυτή

Ανάγνωση του στοιχείου στη θέση X

print(myList.pop(0))

Εδώ θα επιστρέφει το στοιχείο στη θέση 0 και θα διαγραφεί από αυτήν

Εύρεση της θέσης στοιχείου με τιμή ‘τιμή’

print(myList.index('Monty'))

Εδώ θα επιστραφεί η θέση του στοιχείου με τιμή ‘Monty’

Ταξινόμηση λίστας
numList = [1, 15, 25, 2, 8, 19, 1012, 3]

numList.sort()

Εδώ ταξινομούνται τα στοιχεία της λίστας σε αύξουσα σειρά

Αντιστροφή λίστας σε επίπεδο στοιχείων

numList.reverse()

Εδώ η λίστα θα αντιστραφεί (αν η λίστα δεν είναι ταξινομημένη εξ’ αρχής, η λίστα που θα προκύψει θα είναι απλά η ανάστροφη της αρχικής).

Για την καλύτερη κατανόηση των παραπάνω ειδικών λειτουργιών με λίστες σας συμβουλεύουμε να ανατρέξετε στο παράδειγμα κώδικα που θα βρείτε στο τέλος του άρθρου.

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

Μέχρι την επόμενη φορά ωστόσο, να μην ξεχνάτε…
να είστε καλά και να φροντίζεται τον εαυτό σας

Μπορείτε να κατεβάσετε τα αρχεία του βοηθήματος εδώ

Όταν μιλούμε για ποιοτικό κώδικα εννοούμε, στην γενική περίπτωση, κώδικα ο οποίος κάνει σωστά και αποτελεσματικά αυτό για το οποίο προορίζεται, ενώ παράλληλα είναι ευανάγνωστος, καλογραμμένος και σωστά τεκμηριωμένος.

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

Προαπαιτούμενα;

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

Ωστόσο, επειδή ορισμένες συμβουλές αφορούν σε συγκεκριμένα χαρακτηριστικά της γλώσσας Python, είναι καλό να γνωρίζει κανείς τα βασικά. Συνοψίζοντας, η πληροφορία που θα παρουσιαστεί στον εν λόγω οδηγό είναι γενικής φύσης και αφορά όλους όσους σκέπτονται να ασχοληθούν ή ήδη ασχολούνται με τον προγραμματισμό, ωστόσο προτείνεται να έχετε δει (έστω και εν τάχει) όλα τα άρθρα της σειράς «Μαθαίνοντας την Python» για να επιτύχετε το μέγιστο δυνατό κέρδος.

ΟΚ με έπεισες… Ποιος υπογράφει τα τρικ;

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

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

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

Ζήτημα 1^ο – Πότε πρέπει να ακολουθώ τους κανόνες συγγραφής και πότε όχι;

Εν γένει είναι καλό να ακολουθούνται πάντοτε οι κανόνες συγγραφείς. Ωστόσο αν αυτό τύγχανε καθολικής αποδοχής τότε δεν θα είχε ποτέ δημιουργηθεί η φράση «οι κανόνες υπάρχουν για να παραβιάζονται». Όσο ριζοσπαστικό και αν ακούγεται αυτό σαν φράση εμπεριέχει μια μεγάλη αλήθεια. Οι κανόνες, τουλάχιστον σε ότι αφορά τον προγραμματισμό, έχουν δημιουργηθεί ώστε να λύνουν δύο μεγάλα προβλήματα:

• Να παρέχουν μια κοινή γραμμή σε όλους τους προγραμματιστές μιας ομάδας (είτε πρόκειται για παρέα, είτε για εταιρικό σχήμα, είτε για ομάδα φοιτητών)
• Να προλαμβάνουν κοινά προγραμματιστικά λάθη (ναι, η μη συμμόρφωση με τους κανόνες μπορεί να καταλήξει σε προγραμματιστικά λάθη)

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

Είπαμε τους λόγου για τους οποίους είναι καλό αν  ακολουθούμε τους κανόνες. Ας δούμε τώρα πότε επιτρέπεται, αν όχι επιβάλλεται, να τους σπάμε (είμαι σίγουρος ότι οι περισσότεροι πρόκειται να το διαβάσετε αυτό).

1. Όταν το να εφαρμόσουμε τον κανόνα κάνει το αποτέλεσμα λιγότερο ευανάγνωστο, ακόμη και για κάποιον που έχει συνηθίσει να γράφει κώδικα ακολουθώντας τους κανόνες.
2. Για να είναι ο κώδικάς μας συμβατός με άλλον, περιβάλλοντα κώδικα που επίσης δεν ακολουθεί κανόνες συγγραφείς – αν και αυτή η περίπτωση αποτελεί μια καλή ευκαιρία να διορθώσουμε «παλιές αμαρτίες».

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

Ζήτημα 2^ο – Αν πρόκειται να γράψεις κώδικα, κάντο με στυλ!

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

Στοίχιση

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

Πόσοι όμως πρέπει να είναι αυτοί οι χαρακτήρες; Εδώ υπάρχουν δύο σχολές σκέψεις:

• Τέσσερις (4). Αυτό σημαίνει ότι κάθε φορά που πάμε να γράψουμε ένα μπλοκ κώδικα που περιέχεται μέσα σε ένα άλλο, κάθε εντολή του νέου μπλοκ θα γράφεται τέσσερις χαρακτήρες πιο μέσα από ότι το εξωτερικό.
• Ένα TAB κενοί χαρακτήρες (δηλαδή 8). Αυτό σημαίνει ότι αντί να αφήνουμε 4 κενά, όπως είπαμε παραπάνω για κάθε νέα εσοχή, αφήνουμε ένα TAB (το οποίο παράγεται με τον πλήκτρο TAB). Όπως ήδη τονίσαμε, αυτό ισοδυναμεί με 8 κενούς χαρακτήρες.

Υποθέτω ότι οι περισσότεροι θα βρήκατε τον δεύτερο τρόπο ευκολότερο και πιο συμφέρον από τον πρώτο. Σε αυτήν την περίπτωση κάνατε λάθος. Αν και αμφότεροι οι τρόποι είναι σωστοί, σύμφωνα με τον οδηγό καλής συγγραφής κώδικα που αναφέραμε στην εισαγωγή του άρθρου ο καλύτερος τρόπος αντιμετώπισης είναι ο πρώτος. Ο ίδιος οδηγός προτείνει την πολιτική των TABs ως συμφέρουσα μόνον όταν δουλεύουμε πάνω σε κώδικα που έχει φτιαχτεί εξ’ αρχής (και προφανώς από κάποιον άλλο) με τη χρήση TABs. Σε κάθε περίπτωση που ξεκινούμε να φτιάχνουμε δικό μας κώδικα, προτείνεται η χρήση των 4 κενών χαρακτήρων.

ΠΡΟΣΟΧΗ: Οι παραπάνω δυο πολιτικές είναι αμφότερες σωστές. Η μίξη τους ωστόσο, δηλαδή η χρήση άλλοτε τεσσάρων κενών χαρακτήρων και άλλοτε TABs απαγορεύεται αυστηρα.

Μέγιστο μήκος γραμμής

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

Σύμφωνα με τον οδηγό που ακολουθούμε, αυτό το όριο για την Python είναι οι 79 χαρακτήρες.

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

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

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

class Rectangle(Blob):
       def __init__(self, width, height,
              color='black', emphasis=None, highlight=0):
       if width == 0 and height == 0 and \
              color == 'red' and emphasis == 'strong' or \
              highlight > 100:
               raise ValueError("sorry, you lose")
       if width == 0 and height == 0 and (color == 'red' or
                                                     emphasis is None):
              raise ValueError("I don't think so -- values are %s, %s" %
                                   (width, height))
       Blob.__init__(self, width, height,
                            color, emphasis, highlight)

Στο παραπάνω δείγμα κώδικα η μεγαλύτερη γραμμή φθάνει τους 74 χαρακτήρες. Παρατηρήστε επίσης ότι οι πολύ μακριές γραμμές χωρίζονται με τον χαρακτήρα ‘\’.

Κενές γραμμές

• Οι κλάσεις πρέπει να χωρίζονται μεταξύ τους με δύο κενές γραμμές
• Η πρώτη μέθοδος μιας κλάσης πρέπει να χωρίζεται από τα χαρακτηριστικά της κλάσης με δύο κενές γραμμές
• Έξτρα κενές γραμμές μπορούν να χρησιμοποιηθούν σε μεγάλες (σε μέγεθος συναρτήσεις) ώστε να χωρίζουν τη λογική της συνάρτησης σε τμήματα.

Κωδικοποίηση χαρακτήρων (encoding)

Ο κώδικας του πυρήνα της διανομής της Python πρέπει υποχρεωτικά να είναι κωδικοποιημένος σε ASCII Latin-1 κωδικοποίηση χαρακτήρων (ISO-8859-1). Για εκδόσεις της Python από 3.0 και επάνω, η κωδικοποίηση χαρακτήρων UTF-8 προτιμάται τις Latin-1. Για περισσότερες πληροφορίες σχετικά με την οδηγία για την κωδικοποίηση χαρακτήρων μπορείτε να ανατρέξετε στο PEP 3120 που βρίσκεται στο επίσημο site της Python.

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

Μέχρι την επόμενη φορά…

να είστε καλά και να φροντίζεται τον εαυτό σας.

• Να δημιουργήσουμε ανώνυμες συναρτήσεις τύπου lambda
• Να τεκμηριώνουμε σωστά τις συναρτήσεις μας

Προαπαιτούμενα

Μαθαίνοντας Python:  Μέρος Ι, Μέρος  ΙΙ, Μέρος ΙΙΙ, Μέρος IV, Μέρος V, Μερος VI (α), Μερος VI (β)

Πριν ξεκινήσουμε…

… θα ήθελα να επισημάνω ένα – δύο πρακτικά ζητήματα.

Στη συνέχεια παρουσιάζεται ο τρόπος για να επιτευχθούν οι στόχοι που περιγράψαμε στην εισαγωγή. Θα παρατηρήσετε ότι το άρθρο ακολουθεί τη δομή

Μικρή περιγραφή του τι θέλουμε να επιτύχουμε (+ επιπλέον σχόλια)

Παράδειγμα κώδικα

Στο τέλος του αρχείου θα βρείτε συνημμένο ένα python script που περιέχει συγκεντρωμένα όλα τα παραδείγματα.

Για να τα χρησιμοποιήσετε, αντιγράφετε το εκάστοτε παράδειγμα σε ένα νέο αρχείο python και το εκτελείτε (βλ. Μαθαίνοντας Python – Μέρος 1ο ). Τα παραδείγματα είναι φτιαγμένα με τέτοιον τρόπο ώστε να τυπώνουν τα αποτελέσματα στην οθόνη ώστε να μπορείτε να πιστοποιήσετε εύκολα τη λειτουργικότητά τους. Για διευκόλυνσή σας έχουμε χωρίσει τα παραδείγματα με σχόλια που δίνουν μια μικρή περιγραφή του τι επιχειρούμε κάθε φορά.

Βεβαιωθείτε ότι δεν ξεχάσατε το μάτι της κουζίνας ανοικτό, ετοιμάστε μία κούπα καφέ ή τσάι, βάλτε απαλή μουσική και ξεκινάμε…

( ΦΡΕΣΚΑΡΟΝΤΑΣ ΤΑ ΒΑΣΙΚΑ… )

Σύνταξη μιας συνάρτησης

def triangle_area(a, b):
area = a * b / 2
print("Το εμβαδό του τριγώνου είναι:", area)

Καλώντας μια συνάρτηση

triangle_area(66, 2010)

και χωρίς παραμέτρους αν χρειαστεί…

def no_params_function():
print("Αυτή η συνάρτηση δε δέχεται παραμέτρους...")

Έχοντας στο μυαλό μας τα παραπάνω πάμε να δούμε τις περαιτέρω λειτουργίες που μπορεί να προσφέρει μια συνάρτηση γραμμένη σε γλώσσα Python.

Lambda forms

Ο όρος “Lambda form” προέρχεται από παλαιότερες συναρτησιακές γλώσσες (όπως η Lisp) και φαίνεται πως οι δημιουργοί της Python θεώρησαν καλό να την συμπεριλάβουν σαν δυνατότητα και στην δική τους γλώσσα προγραμματισμού.

Μια Lambda form δεν είναι τίποτε άλλο από μια mini ανώνυμη συνάρτηση που ορίζεται μέσα σε μία μεγαλύτερη ώστε  να επιτελεί κάποια συγκεκριμένη, απλή συνήθως διαδικασία.

Ας δούμε μαζί το ακόλουθο παράδειγμα

def counter(n):
return lambda x: x + n

με το οποίο, αν μη τι άλλο απομυθοποιείται η φήμη του ότι οι lambda forms είναι κάτι το περίπλοκο. Η παραπάνω συνάρτηση (counter) δέχεται σαν όρισμα έναν αριθμό n και επιστρέφεται (μέσω μιας lambda form που ορίζεται στο σώμα της counter) ο αριθμός n αυξημένος κατά x.

Ας το δούμε στην πράξη.

Για να χρησιμοποιήσουμε την συνάρτηση counter θα πρέπει με κάποιο τρόπο να καταφέρουμε να ζητήσουμε από τον χρήστη την τιμή της παραμέτρου x. Επομένως…

myCounter = counter(5)

αναθέτουμε μια κλήση της συνάρτησης counter με παράμετρο 5 (για το συγκεκριμένο παράδειγμα) σε μια μεταβλητή που ονομάζουμε myCounter.

?: Υπενθυμίζουμε σε αυτό το σημείο ότι οι μεταβλητές της Python

• Δεν έχουν τύπο
• Μπορούν να φιλοξενήσουν υπό μορφήν τιμής ακόμη  και ολόκληρες συναρτήσεις

Έτσι πλέον μπορούμε να καλούμε την myCounter με όρισμα κάποιον αριθμό (ο οποίος, αν επιστρέψουμε στον ορισμό της counter, θα αντιπροσωπεύει τον x).

print( myCounter( 1 ) )

η παραπάνω κλήση έχει σαν αποτέλεσμα η συνάρτηση myCounter να εκτελέσει εσωτερικά την συνάρτηση counter με x = 1 και n = 5 (το n έχει οριστεί απαξ στο σημείο που αναθέσαμε στην myCounter το counter(5)).

Έτσι το αποτέλεσμα της παραπάνω κλήσης θα είναι το x το οποίο μέσα στην lambda form ορίζεται ως x: x + n άρα x: 1 + 5. Δηλαδή η παραπάνω κλήση θα εκτυπώσει στην οθόνη 6.

print( myCounter( 30 ) )

Όμοια η κλήση αυτή θα δώσει… (αφήνεται ως άσκηση στον αναγνώστη).

Τεκμηρίωση / σχολιασμός συναρτήσεων

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

1. Κατασκευάζουμε το κομμάτι κώδικα που επιτελεί μια συγκεκριμένη διαδικασία χωρίς λάθη. Χρησιμοποιούμε για ένα διάστημα των κώδικα αυτό και στη συνέχεια τον εγκαταλείπουμε για λίγο. Αν ο κώδικάς μας δεν είναι καλά ή καθόλου τεκμηριωμένος υπάρχει πολύ μεγάλη πιθανότητα, όταν τον ανοίξουμε μετά από μερικούς μήνες να μην μπορούμε να θυμηθούμε τι ακριβώς κάνει.
2. Κατασκευάζουμε το κομμάτι κώδικα που επιτελεί μια συγκεκριμένη διαδικασία χωρίς λάθη. Στη συνέχεια μας ζητά τον κώδικα αυτόν κάποιος συνεργάτης. Αν ο κώδικάς μας δεν είναι τεκμηριωμένος υπάρχει πολύ μεγάλη πιθανότητα ο συνεργάτης να μην καταλάβει περί τίνος πρόκειται και, είτε να χάσει σημαντικό χρόνο προσπαθώντας να τον ερμηνεύσει, είτε να μην ασχοληθεί και να επιλέξει να τον ξαναγράψει από το μηδέν.

Η τεκμηρίωση των συναρτήσεών, όπως και κάθε γραμμής κώδικα, είναι σημαντικότατη. Ας δούμε πως το κάνουμε σε Python.

def hello():
""" Αυτή είναι μια απλή hello world συνάρτηση... """
print('Hello world')

Όπως εύκολα αντιλαμβάνεστε, το μόνο που χρειάζεται να κάνετε είναι να περικλείεται τα σχόλιά σας σε τριπλά διπλά εισαγωγικά J “”” … “””.

Χωρίς να βλέπω ιδιαίτερη χρησιμότητα, οφείλω να πω ότι υπάρχει τρόπος (με κώδικα) να εμφανίζεται τα σχόλια των συναρτήσεών σας.

hello()
print("Σχόλια: '" + hello.__doc__ + "'")

Η πρώτη γραμμή είναι η κλήση της συνάρτησης hello() ενώ η δεύτερη εκτυπώνει στην κονσόλα τα σχόλια της συνάρτησης hello.

Στην γενική της μορφή η εντολή εμφάνισης των σχολίων είναι η ακόλουθη:

<ΟΝΟΜΑ_ΣΥΝΑΡΤΗΣΗΣ>.__doc__

Με αυτό το άρθρο ολοκληρώσαμε το οδοιπορικό μας στον χώρο των συναρτήσεων σε Python. Πριν περάσουμε στο επόμενο αντικείμενο θα ξοδέψουμε λίγο χρόνο για ένα ειδικό θέμα.

Μέχρι τότε να μην ξεχνάτε…

να είστε καλά και να φροντίζεται τον εαυτό σας.

Μπορείτε να κατεβάσετε τα αρχεία του βοηθήματος εδώ

Αναλυτικότερα λοιπόν σήμερα θα μάθουμε:

• Να ορίσουμε συναρτήσεις με παραμέτρους που αποτελούν λέξεις – κλειδιά
• Να ορίσουμε συναρτήσεις με λίστες για παραμέτρους

Προαπαιτούμενα

Μαθαίνοντας Python:  Μέρος Ι, Μέρος  ΙΙ, Μέρος ΙΙΙ, Μέρος IV, Μέρος V, Μερος VI (α)

Πριν ξεκινήσουμε…

… θα ήθελα να επισημάνω ένα – δύο πρακτικά ζητήματα.

Στη συνέχεια παρουσιάζεται ο τρόπος για να επιτευχθούν οι στόχοι που περιγράψαμε στην εισαγωγή. Θα παρατηρήσετε ότι το άρθρο ακολουθεί τη δομή:

Μικρή περιγραφή του τι θέλουμε να επιτύχουμε (+ επιπλέον σχόλια)

Παράδειγμα κώδικα

Στο τέλος του αρχείου θα βρείτε συνημμένο ένα python script που περιέχει συγκεντρωμένα όλα τα παραδείγματα.

Για να τα χρησιμοποιήσετε, αντιγράφετε το εκάστοτε παράδειγμα σε ένα νέο αρχείο python και το εκτελείτε (βλ. Μαθαίνοντας Python – Μέρος 1ο ). Τα παραδείγματα είναι φτιαγμένα με τέτοιον τρόπο ώστε να τυπώνουν τα αποτελέσματα στην οθόνη ώστε να μπορείτε να πιστοποιήσετε εύκολα τη λειτουργικότητά τους. Για διευκόλυνσή σας έχουμε χωρίσει τα παραδείγματα με σχόλια που δίνουν μια μικρή περιγραφή του τι επιχειρούμε κάθε φορά.

Βεβαιωθείτε ότι δεν ξεχάσατε το μάτι της κουζίνας ανοικτό, ετοιμάστε μία κούπα καφέ ή τσάι, βάλτε απαλή μουσική και ξεκινάμε…

( ΦΡΕΣΚΑΡΟΝΤΑΣ ΤΑ ΒΑΣΙΚΑ… )

Σύνταξη μιας συνάρτησης

def triangle_area(a, b):
area = a * b / 2
print("Το εμβαδό του τριγώνου είναι:", area)

Καλώντας μια συνάρτηση

triangle_area(66, 2010)

και χωρίς παραμέτρους αν χρειαστεί…

def no_params_function():
print("Αυτή η συνάρτηση δε δέχεται παραμέτρους...")

Έχοντας στο μυαλό μας τα παραπάνω πάμε να δούμε τις περαιτέρω λειτουργίες που μπορεί να προσφέρει μια συνάρτηση γραμμένη σε γλώσσα Python.

Ορίζοντας προεπιλεγμένες τιμές στις παραμέτρους μιας συνάρτησης

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

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

• Αν ο χρήστης δώσει τιμή, το σύστημα θα αναγνώσει και θα χρησιμοποιήσει την τιμή αυτή.
• Αν ο χρήστης δε δώσει τιμή, το σύστημα θα χρησιμοποιήσει την τιμή που έχει οριστεί ως προεπιλογή.

Στην πράξη αυτό συμβαίνει ως εξής:

def dbConnect(username, password, database, server='localhost', port='3306'):
print('Το string σύνδεσης για την MySQL είναι: ')
print()
print('driver={MySQL};server=' + server + ':port=' + port + ';uid=' + username + ';pwd=' + password + ';database=' + database + ';')

?: Η συνάρτηση dbConnect αναλαμβάνει να κατασκευάσει ενα MySQL connection string ζητώντας μια σειρά από παραμέτρους από τον χρήστη. Όπως εύκολα μπορεί να δει κανείς, κάποιες από τις παραμέτρους έχουν λάβει προεπιλεγμένες τιμές.

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

dbConnect('akritiko', '123456', 'myDB', '127.0.0.1', '3333')

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

dbConnect('akritiko', '123456', 'myDB', '127.0.0.1')

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

dbConnect('akritiko', '123456', 'myDB')

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

dbConnect('akritiko', '123456', 'myDB', port = '3333')

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

dbConnect('akritiko', '123456', 'myDB', '3333')

η τιμή 3333 θα καταχωρούνταν στην παράμετρο server εφόσον προηγείται της port. Επομένως θα πρέπει με κάποιον τρόπο να δώσουμε στην Python να καταλάβει για ποια παράμετρο μιλάμε. Αυτό συμβαίνει χρησιμοποιώντας τη λέξη κλειδί (keyword) της παραμέτρου, που στην προκειμένη περίπτωση είναι το port, στη συνέχεια τον τελεστή ‘=’ και τέλος την επιθυμητή τιμή.

Προεπιλεγμένες τιμές και δυναμικά εξελισσόμενες παράμετροι

Είδαμε τι συμβαίνει με τις προεπιλεγμένες τιμές στις παραμέτρους – ορίσματα μιας συνάρτησης. Τι συμβαίνει όμως αν οι παράμετροι αυτοί είναι περισσότεροι πολύπλοκες (ως τύποι;). Ας ρίξουμε μια ματιά στον παρακάτω κώδικα:

def wishlist(item, Wishlist=[]):
Wishlist.append(item)
return Wishlist

Πρόκειται για μια συνάρτηση η οποία προσθέτει αντικείμενα σε μία Wishlist (λειτουργία που μπορείτε να βρείτε – σε μία ομολογουμένως πιο εξεζητημένη υλοποίηση – στο Amazon.com). Εν ολίγοις ο κώδικας απλά παίρνει σαν παραμέτρους το αντικείμενο (item) και την λίστα (Wishlist) και κάθε φορά που εκτελείται συμπεριλαμβάνει το εκάστοτε αντικείμενο στην λίστα.

?: Παρατηρήστε ότι η Wishlist έχει προεπιλεγμένη τιμή την κενή λίστα ( [] ).

Ας δούμε τώρα μια σειρά εκτελέσεων:

1. print(wishlist(‘Nokia N8′))
2. print(wishlist(‘Harry Potter and the Deathly Hallows’))
3. print(wishlist(‘Monty Python and The Holy Grail Blu-Ray Edition’))

Σε κάθε εκτέλεση η λίστα διαμορφώνεται ως ακολούθως

1. ['Nokia N8']
2. ['Nokia N8', 'Harry Potter and the Deathly Hallows']
3. ['Nokia N8', 'Harry Potter and the Deathly Hallows', 'Monty Python and The Holy Grail Blu-Ray Edition']

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

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

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

Μέχρι την ερχόμενη φορά λοιπόν…

να είστε καλά και να φροντίζεται τον εαυτό σας.

Μπορείτε να κατεβάσετε τα αρχεία του βοηθήματος εδώ

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

Ο Chuck Norris και η Python

Ο Chuck Norris αποτελεί πλέον persona – φαινόμενο χάρη στο διαδικτυακό καλαμπούρι που ξεκίνησε στις τάξεις των geeks του διαδικτύου (http://www.chucknorrisfacts.com/). Αποτελεί δηλαδή ένα παράδειγμα χαρακτήρα που, ενώ η πρωταρχική του ιδιότητα θα μπορούσε να χαρακτηρισθεί αδιάφορη, η χρήση του σε ένα πετυχημένο (και παράλληλα έξυπνο) project, όχι μόνον τον έφερε και πάλι στο προσκήνιο, αλλά εκτίναξε και το «κασέ» του, στα ύψη.

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

Αν λοιπόν η επιτυχία του Chuck Norris εκτινάχθηκε στα ύψη από την δημοσιοποίηση ενός καλοστημένου project σκεφθείτε που πρέπει να κατατάξουμε την γλώσσα Python μετά την παρουσίαση όχι μιας, ούτε δύο αλλά 4 + 1 εκπληκτικών εφαρμογών.

Έχετε δίπλα σας την κούπα με τον αγαπημένο καφέ ή τσάι; Ας ξεκινήσουμε…

Mercurial: Δουλέψτε ευκολότερα, δουλέψτε ταχύτερα

Αποτελεί εργαλείο που απευθύνεται κυρίως σε ανθρώπους που ασχολούνται με την ανάπτυξη λογισμικού. Πρόκειται για μια εφαρμογή ανοικτού λογισμικού (δηλαδή ο κώδικας διατίθεται ελεύθερα προς χρήση και τροποποίηση) η οποία λειτουργεί σε Windows, Mac OS X και στα περισσότερα συστήματα τύπου UNIX. Αποστολή του είναι η ομαδική ανάπτυξη ενός έργου λογισμικού με ταυτόχρονη παρακολούθηση, καταγραφή και τήρηση ιστορικού των αλλαγών που γίνονται από τους προγραμματιστές που συμμετέχουν στο έργο. Παρακολουθούνται αρχεία τύπου text αλλά και binary αρχεία.

Η εφαρμογή διατίθεται κάτω από άδεια GNU GPL ενώ ο δημιουργός και κύριος προγραμματιστής του έργου είναι ο Matt Mackall. Η υλοποίησή της βασίζεται στις γλώσσες Python και C.

Επίσημη ιστοσελίδα: http://mercurial.selenic.com/

Gwibber: Microblogging Freedom

Η εφαρμογή gwibber αποτελεί μια δωρεάν εφαρμογή πελάτη για τη διαχείριση γνωστών ιστοσελίδων κοινωνικής δικτύωσης (Twitter, Identi.ca, StatusNet, Facebook, FriendFeed, Digg, Flickr, Qaiku). Είναι φτιαγμένη για εμφανίζει στον χρήστη, ανά πάσα στιγμή, διαφορετικές ροές. Απευθύνεται σε λειτουργικά συστήματα Linux (είναι μάλιστα προεγκατεστημένη στην έκδοση 10.04 της διανομής Ubuntu).

Επίσημη ιστοσελίδα: http://gwibber.com/

Emesen: An IM for the WLM^TM network

Πρόκειται για μία από τις αγαπημένες μου εφαρμογές για λειτουργικά συστήματα Linux. Αντικαθιστά επάξια το MSN των Windows.

Αποστολή του είναι να «αντιγράψει» τις ιδιότητες του MSN προσφέροντας στον χρήστη Linux Λειτουργικών συστημάτων ένα εύχρηστο αλλά παράλληλα οικείο περιβάλλον αποστολής προσωπικών μηνυμάτων.

Λειτουργεί άψογα με λογαριασμούς Microsoft και φυσικά διατίθεται δωρεάν με άδεια GNU GPL.

Όπως και πριν, το Emesen είναι γραμμένο σε Python.

Επίσημη ιστοσελίδα: http://www.emesene.org/

Trac: Integrated SCM & Project Management

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

Επίσημη ιστοσελίδα: http://trac.edgewall.org/

(+1) Django: Web framework για τελειομανείς με deadlines

Το Jango αποτελεί στην κυριολεξία ένα trend της εποχής. Πρόκειται για ένα Web Framework που διατίθεται δωρεάν κάτω από BSD License και φυσικά ο κώδικάς του είναι ανοικτός. Η μυστήρια ονομασία του προέρχεται από τον τσιγγάνο κιθαρίστα Django Reinhardt. Είναι γραμμένο εξ’ ολοκλήρου σε Python.

Επίσημη ιστοσελίδα: http://www.djangoproject.com

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

Μέχρι την επόμενη λοιπόν φορά που θα τα πούμε…

…να είστε καλά και να προσέχετε τον εαυτό σας.

Στο τέλος του οδηγού θα μπορούμε:

• Να ορίσουμε συναρτήσεις με σταθερές τιμές παραμέτρων
• Να ορίσουμε συναρτήσεις με παραμέτρους που αποτελούν λέξεις – κλειδιά
• Να ορίσουμε συναρτήσεις με λίστες για παραμέτρους
• Να δημιουργήσουμε ανώνυμες συναρτήσεις τύπου lambda
• Να τεκμηριώνουμε σωστά τις συναρτήσεις μας

Για την καλύτερη κατανόηση αυτού του αντικειμένου ο συγκεκριμένος οδηγός χωρίστηκε σε δύο τμήματα…

Προαπαιτούμενα

Μαθαίνοντας Python:  Μέρος Ι, Μέρος  ΙΙ, Μέρος ΙΙΙ, Μέρος IV, Μέρος V

Πριν ξεκινήσουμε…

… θα ήθελα να επισημάνω ένα – δύο πρακτικά ζητήματα.

Στη συνέχεια παρουσιάζεται ο τρόπος για να επιτευχθούν οι στόχοι που περιγράψαμε στην εισαγωγή. Θα παρατηρήσετε ότι το άρθρο ακολουθεί τη δομή:

Μικρή περιγραφή του τι θέλουμε να επιτύχουμε (+ επιπλέον σχόλια)

Παράδειγμα κώδικα

Στο τέλος του αρχείου θα βρείτε συνημμένο ένα python script που περιέχει συγκεντρωμένα όλα τα παραδείγματα.

Για να τα χρησιμοποιήσετε, αντιγράφετε το εκάστοτε παράδειγμα σε ένα νέο αρχείο python και το εκτελείτε (βλ. Μαθαίνοντας Python – Μέρος 1ο ). Τα παραδείγματα είναι φτιαγμένα με τέτοιον τρόπο ώστε να τυπώνουν τα αποτελέσματα στην οθόνη ώστε να μπορείτε να πιστοποιήσετε εύκολα τη λειτουργικότητά τους. Για διευκόλυνσή σας έχουμε χωρίσει τα παραδείγματα με σχόλια που δίνουν μια μικρή περιγραφή του τι επιχειρούμε κάθε φορά.

Βεβαιωθείτε ότι δεν ξεχάσατε το μάτι της κουζίνας ανοικτό, ετοιμάστε μία κούπα καφέ ή τσάι, βάλτε απαλή μουσική και ξεκινάμε…

Συντάσσοντας μια συνάρτηση

def triangle_area(a, b):
area = a * b / 2
print("Το εμβαδό του τριγώνου είναι:", area)

Παραπάνω μπορείτε να δείτε την βασική δήλωση της συνάρτησης υπολογισμού του εμβασδού τριγώνου. Αρχικά δηλώνουμε τη συνάρτηση χρησιμοποιώντας την δεσμευμένη λέξη def ακολουθούμενη από το όνομα της συνάρτησης (στην προκειμένη περίπτωση triangle_area). Σε παρένθεση τοποθετούνται οι απαιτούμενες παράμετροι (a, b) που στην προκειμένη περίπτωση υποδηλώνουν την βάση και το ύψος του τριγώνου αντίστοιχα). Στη συνέχεια μια νέα μεταβλητή ορίζεται, η μεταβλητή area, στην οποία θα ανατεθεί το αποτέλεσμα της φόρμουλας υπολογισμού του εμβαδού του τριγώνου (βάση * ύψος / 2). Τέλος η συνάρτηση αναλαμβάνει να εκτυπώσει το αποτέλεσμα στην οθόνη.

Κλήση συνάρτησης

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

triangle_area(66, 2010)

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

def no_params_function():
print("Αυτή η συνάρτηση δε δέχεται παραμέτρους...")

Όπως παρατηρείτε η παρένθεση δεν περιέχει τίποτε, δηλαδή δεν έχουν δηλωθεί παράμετροι. Η κλήση αυτής της συνάρτησης γίνεται ως εξής…

no_params_function()

και όπως θα δείτε αν το δοκιμάσετε, δουλεύει άψογα παρόλη την απουσία των παραμέτρων.

Αναθέτοντας μια συνάρτηση σε μια μεταβλητή

Ναι! Είναι εφικτό. Στην Python μια συνάρτηση μπορεί να ανατεθεί σε μια μεταβλητή (ακόμη ένα σημείο που υποδηλώνει τη δύναμη της συγκεκριμένης γλώσσας προγραμματισμού.

aVariable = triangle_area
aVariable(5,8)

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

Στην πρώτη γραμμή αναθέτουμε την συνάρτησή μας στην μεταβλητή aVariable. Δώστε προσοχή στην απουσία παραμέτρων. Αυτό συμβαίνει γιατί δεν θέλουμε να γίνει ανάθεση της συνάρτησής μας για δύο συγκεκριμένες τιμές αλλά του μηχανισμού της.

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

Επιστροφή του αποτελέσματος αντί για εκτύπωση

Ας δούμε άλλη μια εκδοχή της αγαπημένης μας συνάρτησης υπολογισμού του εμβαδού τριγώνου J.

def triangle_area_return(a, b):
area = a * b / 2
return area

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

Έτσι, αν θέλουμε να εμφανίσουμε το αποτέλεσμα της συνάρτησης αυτής θα πρέπει να εκτελέσουμε την παρακάτω γραμμή κώδικα:

print( triangle_area_return( 5, 5 ) )

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

Πως το χρησιμοποιώ πραγματικά;

Οι συναρτήσεις χρησιμοποιούνται συνήθως για να υλοποιούν συχνά χρησιμοποιούμενες διαδικασίες. Πολύ συχνά το αποτέλεσμα μιας συνάρτησης χρειάζεται να τροφοδοτήσει μία άλλη. Αυτό επιτυγχάνεται με τη χρήση της return. Ας το δούμε στην πράξη:

Υπενθυμίζω την τελευταία έκδοση της συνάρτησής μας:

def triangle_area_return(a, b):
area = a * b / 2
return area

Δημιουργούμε μία δεύτερη, πολύ απλή συνάρτηση η οποία λαμβάνει στην είσοδο ένα εμβαδό και τυπώνει ένα ειδικά διαμορφωμένο μήνυμα…

def print_triangle_area_return(data):
print("Το εμβαδό του τριγώνου που διάβασα είναι:", data)

…στην τιμή myData ανατίθεται το αποτέλεσμα της συνάρτησης υπολογισμού του εμβαδού…

myData = triangle_area_return(2, 155)

…τέλος τροφοδοτούμε το περιεχόμενο του myData στην συνάρτηση εκτύπωσης:

print_triangle_area_return(myData)

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

Μέχρι τότε,

να είστε καλά και να φροντίζεται τον εαυτό σας.

Άν είστε ήδη συνδρομητής κάντε login με τα στοιχεία σας. Για να γίνετε συνδρομητής πατήστε εδώ

Στο τέλος του σημερινού οδηγού θα μπορούμε:

• Να επεμβαίνουμε στην εκτέλεση των βρόγχων for, while, κλπ. χρησιμοποιώντας τα break, continue, else, pass.

Προαπαιτούμενα

Μαθαίνοντας Python:  Μέρος Ι, Μέρος  ΙΙ, Μέρος ΙΙΙ, Μερος IV

Πριν ξεκινήσουμε…

… θα ήθελα να επισημάνω ένα – δύο πρακτικά ζητήματα.

Στη συνέχεια παρουσιάζεται ο τρόπος για να επιτευχθούν οι στόχοι που περιγράψαμε στην εισαγωγή. Θα παρατηρήσετε ότι το άρθρο ακολουθεί τη δομή:

Μικρή περιγραφή του τι θέλουμε να επιτύχουμε (+ επιπλέον σχόλια)

Παράδειγμα κώδικα

Στο τέλος του αρχείου θα βρείτε συνημμένο ένα python script που περιέχει συγκεντρωμένα όλα τα παραδείγματα.

Για να τα χρησιμοποιήσετε, αντιγράφετε το εκάστοτε παράδειγμα σε ένα νέο αρχείο python και το εκτελείτε (βλ. Μαθαίνοντας Python – Μέρος 1ο ). Τα παραδείγματα είναι φτιαγμένα με τέτοιον τρόπο ώστε να τυπώνουν τα αποτελέσματα στην οθόνη ώστε να μπορείτε να πιστοποιήσετε εύκολα τη λειτουργικότητά τους. Για διευκόλυνσή σας έχουμε χωρίσει τα παραδείγματα με σχόλια που δίνουν μια μικρή περιγραφή του τι επιχειρούμε κάθε φορά.

Βεβαιωθείτε ότι δεν ξεχάσατε το μάτι της κουζίνας ανοικτό, ετοιμάστε μία κούπα καφέ ή τσάι, βάλτε απαλή μουσική και ξεκινάμε…

Η δήλωση break

Για όσους από εσάς γνωρίζουν C / C++ η λειτουργία της δήλωση break πρέπει να είναι προφανής (λειτουργεί με τον ίδιο ακριβώς τρόπο και στην Python). Τοποθετώντας μια δήλωση break σε κάποιο σημείο ενός βρόγχου (for ή while) επιβάλλεται στον Διερμηνευτή της Python να διακόψει την λειτουργία του πλησιέστερου βρόγχου και να εξέλθει από αυτόν.

for i in range(10):
    if i == 5:
        break
    print(i)

Όπως παρατηρείτε στην οθόνη των αποτελεσμάτων σας έχετε νούμερα μέχρι κι το 4. Αυτό συμβαίνει διότι μόλις ο Διερμηνευτής της Python συνάντησε τον αριθμό 5, η εντολή break διέκοψε το βρόγχο.

H δήλωση continue

Αντίθετα με την break, η δήλωση continue, περνάει στο επόμενο βήμα του βρόγχου, αγνοώντας τις εντολές για το τρέχον βήμα.

for i in range(10):
    if i == 5:
        continue
    print(i)

Τρέχοντας το παραπάνω παράδειγμα θα διαπιστώσετε ότι στην οθόνη των αποτελεσμάτων σας εμφανίζονται όλοι οι αριθμοί εκτός του 5. Αυτό συμβαίνει διότι όταν ο βρόγχος φθάσει στον αριθμό 5 (έκτο βήμα του βρόγχου), αγνοεί, λόγω της continue την εντολή print(i) με αποτέλεσμα ο αριθμός 5 να μην τυπώνεται ποτέ.

Η δήλωση else (για έναν βρόγχο for)

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

myCellar = ['apples', 'pork', 'cranberries', 'oil', 'wine', 'retsina']
productsInDemand = ['retsina', 'ouzo']
for demand in productsInDemand:
    for supply in myCellar:
        if demand == supply:
            print("we do have ", demand)
            break
else:
    print("we ran out of ", demand)

Ας δούμε ένα παράδειγμα που συνδυάζει τη χρήση break και else σε βρόγχους τύπου for. Στο παραπάνω παράδειγμα υποθέτουμε ότι έχουμε ένα κελάρι με προϊόντα. Το απεικονίζουμε με μια λίστα myCellar στην οποία είναι παρόντα μόνον όσα προϊόντα υπάρχουν (ανεξαρτήτου ποσότητας) στο κελάρι. Μια δεύτερη λίστα (productsInDemand) περιλαμβάνει προϊόντα που μας ζητά κάποιος και εμείς πρέπει να ψάξουμε αν είναι διαθέσιμα στο κελάρι.

Το εξωτερικό for loop διατρέχει τα προϊόντα που ζητήθηκαν και, για κάθε ένα ζητούμενο, το εσωτερικό for τσεκάρει αν το ζητούμενο προϊόν υπάρχει στο κελάρι. Αν βρεθεί, τυπώνεται μήνυμα επιτυχίας της αναζήτησης και ο εσωτερικός βρόγχος σταματά να εκτελείται. Στην περίπτωση που τα στοιχεία της λίστας που διατρέχει ο εσωτερικός βρόγχος (myCellar)  εξαντληθούν, εκτελούνται οι εντολές του else, δηλαδή τυπώνεται μήνυμα αποτυχίας.

H δήλωση pass

Η δήλωση pass, είναι μια εξαιρετικά ενδιαφέρουσα δήλωση, ίσως η πιο χρήσιμη για έναν προγραμματιστή. Όταν ο Διερμηνευτής τη συναντήσει, δεν κάνει απολύτως τίποτε.

while True:
    pass

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

Γιατί είναι κάτι τέτοιο χρήσιμο; Θα αναρωτηθείτε εύλογα. Σκεφτείτε ότι έχετε να κατασκευάσετε ένα μεγάλο πρόγραμμα κάνοντας χρήση αντικειμενοστρεφούς σχεδίασης. Ο αντικειμενοστρέφής προγραμματισμός, όπως ίσως να ξέρετε, κάνει χρήση αντικειμένων (θα δούμε αναλυτικά το θέμα των αντικειμένων σε μεταγενέστερους οδηγούς). Ας υποθέσουμε λοιπόν ότι σχεδιάζεται ένα σκελετό του προγράμματός σας που αποτελείτε από τα αντικείμενα vehicle, car, human.

Κάνοντας αυτό:

class Vehicle:
    pass
class Car:
    pass
class Human:
    pass

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

Σκεφτείτε το και θα δείτε ότι θα κάνει τη ζωή σας ευκολότερη…

Mini Διαγωνισμός

Κατασκευάστε ένα πρόγραμμα σε Python το οποίο, δεδομένου ενός ονόματος (δωσμένο με λατινικούς χαρακτήρες), να εμφανίζει μόνον τα σύμφωνα.

Υποθέστε ότι έχουμε να κάνουμε με ονόματα στα λατινικά (John, Mary, Aristides, Isocrates, κλπ.), όχι Greeklish (Kwstas, Evgenia)

Το όνομα μπορεί να περιέχει κεφαλαίους και πεζούς χαρακτήρες (Christine, Apostolos)

Τα φωνήεντα στο αγγλικό αλφάβητο είναι τα a, o, e, i, u, y

Να γίνει χρήση break και else δηλώσεων

Μπορείτε να στείλετε τις απαντήσεις σας στο προσωπικό μου email (akritiko@gmail.com) με θέμα «GreekTuts: Διαγωνισμός Python». Οι 3 καλύτερες λύσεις (που δουλεύουν) μέχρι τέλος Δεκεμβρίου κερδίζουν από μια Basic συνδρομή ενός μηνός για την ιστοσελίδα μας.

Περιμένω τις σκέψεις σας… Μέχρι την επόμενη φορά,

να είστε καλά και να φροντίζεται τον εαυτό σας.

Μπορείτε να κατεβάσετε τα αρχεία του βοηθήματος εδώ

• Να εκτελούμε εντολές υπό συνθήκη με την εντολή if
• Να δημιουργούμε βρόγχους επαναλήψεων κάνοντας χρήση των εντολών
  • For
  • While
  • Να δημιουργούμε ακολουθίες αριθμών με την συνάρτηση range()

Προαπαιτούμενα

Μαθαίνοντας Python:  Μέρος Ι, Μέρος  ΙΙ, Μέρος ΙΙΙ

Πριν ξεκινήσουμε…

… θα ήθελα να επισημάνω ένα – δύο πρακτικά ζητήματα.

Στη συνέχεια παρουσιάζεται ο τρόπος για να επιτευχθούν οι στόχοι που περιγράψαμε στην εισαγωγή. Θα παρατηρήσετε ότι το άρθρο ακολουθεί τη δομή:

Μικρή περιγραφή του τι θέλουμε να επιτύχουμε (+ επιπλέον σχόλια)

Παράδειγμα κώδικα

Στο τέλος του άρθρου θα βρείτε συνημμένο ένα python script που περιέχει συγκεντρωμένα όλα τα παραδείγματα.

Για να τα χρησιμοποιήσετε, αντιγράφετε το εκάστοτε παράδειγμα σε ένα νέο αρχείο python και το εκτελείτε (βλ. Μαθαίνοντας Python – Μέρος 1ο ). Τα παραδείγματα είναι φτιαγμένα με τέτοιον τρόπο ώστε να τυπώνουν τα αποτελέσματα στην οθόνη ώστε να μπορείτε να πιστοποιήσετε εύκολα τη λειτουργικότητά τους. Για διευκόλυνσή σας έχουμε χωρίσει τα παραδείγματα με σχόλια που δίνουν μια μικρή περιγραφή του τι επιχειρούμε κάθε φορά.

Βεβαιωθείτε ότι δεν ξεχάσατε το μάτι της κουζίνας ανοικτό, ετοιμάστε μία κούπα καφέ ή τσάι, βάλτε απαλή μουσική και ξεκινάμε…

Εντολές υπό συνθήκη

Στην Python, όπως και στις περισσότερες γλώσσες υψηλού επιπέδου οι εντολές υπό συνθήκη πραγματοποιούνται κάνοντας χρήση της δήλωσης if.

Η σύνταξή της είναι η ακόλουθη:

if συνθήκη1:
    εντολή1
    εντολή2
    …
elif συνθήκη2:
    εντολή3
    εντολή4
    …
else:
    εντολή5
    εντολή6
    …

Παρατηρήσεις:

• Το τμήμα if … θα πρέπει να εμφανίζεται αυστηρά μία μόνον φορά σε μια δήλωση if
• Το τμήμα elif… μπορεί να εμφανίζεται καμία, μία, ή περισσότερες φορές
• Το τμήμα else μπορεί να εμφανιστεί καμία ή μία φορά
• Τα τμήματα if και elif πρέπει να ακολουθούνται υποχρεωτικά από μία συνθήκη και το σύμβολο ‘:’
• Το τμήμα else ακολουθείται μόνον από το σύμβολο ‘:’ (χωρίς συνθήκη)
• Οι εντολές στο σώμα¹ κάθε τμήματος πρέπει να εισέχουν ένα tab απόσταση από το αντίστοιχο τμήμα τους (If, elif, else)

[1] Σώμα ενός τμήματος καλούμε την εντολή ή τις εντολές που αφορούν το τμήμα αυτό. Στην Python ένα σώμα κειμένου διακρίνεται με τις εσοχές. Κάθε σύνολο εντολών που εισέχουν αποτελούν σώμα της αμέσως προηγούμενης γραμμής, που η δήλωσής της ξεκινά μία εσοχή αριστερότερα.

Ας δούμε ένα παράδειγμα:

number = int(input("Please enter an integer: "))
if number < 0:
    print("The number is a negative")
elif number > 0:
    print("The number is a positive")
else:
    print("The number is a zero")

Σας υποσχέθηκα ότι από αυτή τη φορά θα αρχίσουμε να γράφουμε mini προγράμματα και διατείνομαι ότι είμαι άνθρωπος που κρατά τον λόγο του. Στον παραπάνω κώδικα η πρώτη γραμμή ζητά έναν ακέραιο αριθμό από τον χρήστη. Επειδή όπως είπαμε η Python δεν έχει τύπους ουσιαστικά ζητούμε από τον χρήστη μια ροή χαρακτήρων με την input(“Please enter an integer: ”) και περικλείουμε την εντολή αυτή στην int( ) ώστε οι χαρακτήρες που δίνει ο χρήστης να μετατραπούν σε ακέραιο. Προφανώς δεν γίνεται κανένας έλεγχος για το αν πράγματι ο χρήστης έδωσε ακέραιο αλλά δεδομένου ότι ο σημερινός οδηγός έχει σαν θέμα τον έλεγχο ροής θα θεωρήσουμε δεδομένο ότι οι τιμές που θα δοθούν θα είναι ακέραιοι (αν θέλετε να δείτε τι γίνεται αν δώσετε κάποια άκυρη τιμή, π.χ. αλφαριθμητικό, δοκιμάστε το, απλά για πειραματισμό).

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

Δημιουργία βρόγχων επαναλήψεων (for)

Μία άλλη κλασική προγραμματιστική ανάγκη είναι η δημιουργία βρόγχων, τμημάτων δηλαδή που επαναλαμβάνονται έναν αριθμό Ν φορών , ανάλογα με τις ανάγκες της εκάστοτε εφαρμογής. Η δήλωση for κάνει ακριβώς αυτό.

Η σύνταξή της είναι η ακόλουθη:

for μεταβλητή in ακολουθία:
    εντολή1
    εντολή2
    …

Παρατηρήσεις:

• Με τον όρο “ακολουθία” στην Python εννοούμε τα αλφαριθμητικά και τις λίστες
• Η “μεταβλητή” μπορεί να ονομάζεται όπως θέλετε και το μόνο που κάνει είναι να παίρνει σαν τιμή, με τη σειρά, την τιμή κάθε ενός από τα στοιχεία που απαρτίζουν την ακολουθία

Για παράδειγμα:

fruits = ['apple', 'orange', 'strawbery', 'pineapple', 'cranberries']
for fruit in fruits:
    print(fruit)

Έχουμε την λίστα fruits που αποτελείται από τα στοιχεία που μπορείτε να δείτε στην πρώτη γραμμή του κώδικά μας. Δημιουργούμε ένα for (δηλαδή έναν βρόγχο επανάληψης) στον οποίο η μεταβλητή fruit θα πάρει μία – μία τις τιμές των στοιχείων της λίστας fruits και όπως ορίζει η εντολή στο σώμα της δήλωσης for, θα τις εκτυπώσει. Έτσι το αποτέλεσμά σας θα μοιάζει κάπως έτσι:

apple
orange
strawbery
pineapple
cranberries

Δημιουργία βρόγχων επαναλήψεων (while)

Με τον ίδιο ακριβώς τρόπο συντάσσεται δήλωση while.

while συνθήκη:
    εντολή1
    εντολή2
    …

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

Ας ρίξουμε μια ματιά στον παρακάτω κώδικα:

number = 500
current, next = 0, 1
while next < number:
    print(current, end=' ')
        current, next = next, current + next

Για όσους δεν τον αναγνώρισαν πρόκειται για τον αλγόριθμο υπολογισμού της ακολουθίας Fibonacci. Στην ακολουθία αυτή τα δύο πρώτα στοιχεία είναι τα 0 και 1 ενώ κάθε επόμενο στοιχείο αποτελεί το άθροισμα των δύο προηγούμενων στοιχείων. Έχουμε δηλαδή:

0
1
1 + 0 = 1
1 + 1 = 2
3 + 2 = 3
2 + 3 = 5
κλπ.

Στο παράδειγμά μας ορίζουμε σαν όριο τον αριθμό 500 δηλαδή ζητούμε τους αριθμούς Fibonacci που είναι μικρότεροι του 500. Στην δεύτερη γραμμή αναθέτουμε τις τιμές 0, 1 στις μεταβλητές current και next αντιστοίχως.

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

Όσο η μεταβλητή next είναι μικρότερη από τη μεταβλητή number (το όριο δηλαδή που θέσαμε στην αρχή), εκτελείτε το σώμα του while. Δηλαδή:

• Τυπώνεται ο αριθμός current
• Γίνονται δύο ταυτόχρονες αναθέσεις τιμών
  • Current γίνεται ο αριθμός next
  • Ο next παίρνει την τιμή current + next

Αν νιώθετε μπερδεμένοι, είναι λογικό και φταίει η Python για αυτό. Στην Python υπάρχει η «ψυχεδελική» ανάθεση μεταβλητών (π.χ. a, b = 5, 12 ). Οι τιμές όμως των μεταβλητών αλλάζουν πραγματικά από την αμέσως επόμενη εντολή.

Έτσι, στο παράδειγμα μας τα αποτελέσματα της εντολής current, next = next, current + next θα ισχύσουν από την επόμενη γραμμή κώδικα. Ας παρακολουθήσουμε τώρα κάτι το παρανοϊκό:

Η μεταβλητή current θα πάρει την τιμή next αφότου τελειώσει η εντολή current, next = next, current + next. Έτσι για την ανάθεση τιμής στην next (που βρίσκεται στην ίδια εντολή) η current έχει ακόμη την παλιά της τιμή.

Την πρώτη φορά που εισερχόμαστε στο while η μεταβλητή current έχει την τιμή 0 και η next την τιμή 1. Αφότου τυπωθεί 0 (η τιμή της current δηλαδή) η μεταβλητή current ΘΑ πάρει την τιμή την μεταβλητής next. Στην ίδια εντολή η μεταβλητή next θα πάρει την τιμή του αθροίσματος current + next (δηλαδή 0 + 1 αφού η ανάθεση της τιμής στην current δεν έχει ισχύ ακόμη εφόσον δεν άλλαξε η εντολή). Έτσι μετά την εκτέλεση της μυστήριας αυτής ανάθεσης, η μεταβλητή current έχει γίνει 1 και η next (0+1=) 1.

Για όσους προβληματίστηκαν με την εντολή print(current, end=’ ‘), το end=’ ‘ ουσιαστικά επιβάλει τις τιμές να εκτυπώνονται η μία δίπλα στην άλλη διαχωριζόμενες από τον κενό χαρακτήρα ‘ ‘. Αν στην θέση της βάλετε print(current) θα διαπιστώσετε ότι οι τιμές της ακολουθίας Fibonacci σας θα εμφανίζονται κατακόρυφα.

Η συνάρτηση range()

Η συνάρτηση range() δημιουργεί ακολουθίες αριθμών. Έχει διάφορες μορφές:

• range(number) : Δημιουργείται μια ακολουθία αριθμών από το 0 ως την προηγούμενη ακέραια τιμή της μεταβλητής number
• range(from, to) : Δημιουργείται μια ακολουθία αριθμών από την τιμή της μεταβλητής from μέχρι την προηγούμενη ακέραια τιμή της μεταβλητής to
• range(from, to, step) : Δημιουργείται μια ακολουθία αριθμών από την τιμή της μεταβλητής from μέχρι την προηγούμενη ακέραια τιμή της μεταβλητής to με βήμα step.

Στην πράξη:

for iterator in range(10):
    print(iterator, end=' ')

Θα δώσει σαν αποτέλεσμα: 0 1 2 3 4 5 6 7 8 9

for iterator in range(4, 10):
    print(iterator, end=' ')

Θα δώσει σαν αποτέλεσμα: 4 5 6 7 8 9

for iterator in range(1, 11, 2):
    print(iterator, end=' ')

Θα δώσει σαν αποτέλεσμα: 1 3 5 7 9

Η συνάρτηση range() αν συνδυαστεί με την συνάρτηση len() μπορεί να μας δώσει έναν πολύ ωραίο τρόπο να απαριθμούμε τα αποτελέσματα που τυπώνονται μέσα σε έναν βρόγχο επανάληψης.

Έχουμε το ακόλουθο πρόγραμμα που τυπώνει στην οθόνη τις 10+2 εντολές αγοράς gadget.

commandments = ["Thou shalt use a standard plug (preferably USB)",
    "Thou shalt have good battery life",
    "Thou shalt give nothing unneeded in the box, but always give necessary items",
    "Thou shalt offer accessories, or at least help partners to",
    "Thine gadgetry shall make sense",
    "Thou shalt have a reasonable price for the life of thine gadget",
    "Thou shalt not package crap software",
    "Thou shalt allow thine gadgetry to be hacked",
    "Thou shalt make thine gadgetry easy to interface",
    "Thou shalt allow thine gadgetry to be acted upon by standard OS means",
    "Thou shalt not cripple thine feature set",
    "Thou shalt allow thine gadget to do whatever it needs to on its own"]
print("The 10+2 commandments of Geek Gadgetry")
print()
for iterator in range(len(commandments)):
    print(iterator, commandments[iterator])

Δέχομαι την κατηγορία ότι ο ορισμός της λίστας των 10+2 εντολών πιάνει περισσότερο χώρο από το πρόγραμμα αυτό κάθε αυτό (μία δήλωση for των δύο γραμμών) αλλά πρέπει να παραδεχθείτε ότι είναι cool εντολές…

Μετά λοιπόν τη δήλωση της λίστας και την εκτύπωση ενός τίτλου (για αισθητικούς περισσότερο λόγους) έχουμε την δήλωση for.

Ο iterator είναι η μεταβλητή που θα πάρει την τιμή των στοιχείων που βρίσκονται μέσα στην λίστα commandments. Ωστόσο αντί να πούμε for iterator in commandments (πράγμα που θα ήταν απόλυτα σωστό) περικλείουμε το commandments σε μία συνάρτηση len() που θα μας επιστρέψει τον αριθμό τον στοιχείων της λίστας commandments. Η len() με τη σειρά της περικλείεται σε μια συνάρτηση range() η οποία θα μας επιστρέψει μια ακολουθία αριθμών με τόσα στοιχεία όσα και αυτά της λίστας commandments.

Στη συνέχεια η εντολή print τυπώνει:

• Τον αριθμό της θέσης του στοιχείου στη λίστα (0, 1, 2, 3). Υπενθυμίζουμε ότι στην Python η πρώτη θέση πινάκων και λιστών θεωρείται η θέση 0.
• Το στοιχείο που βρίσκεται στην εκάστοτε θέση της λίστας, στην περίπτωσή μας δηλαδή κάθε μία από τις 10 + 2 εντολές.

Αν όλα πήγαν καλά το αποτέλεσμά σας πρέπει να μοιάζει με το παρακάτω:

0 Thou shalt use a standard plug (preferably USB)
1 Thou shalt have good battery life
2 Thou shalt give nothing unneeded in the box, but always give necessary items
3 Thou shalt offer accessories, or at least help partners to
4 Thine gadgetry shall make sense
5 Thou shalt have a reasonable price for the life of thine gadget
6 Thou shalt not package crap software
7 Thou shalt allow thine gadgetry to be hacked
8 Thou shalt make thine gadgetry easy to interface
9 Thou shalt allow thine gadgetry to be acted upon by standard OS means
10 Thou shalt not cripple thine feature set
11 Thou shalt allow thine gadget to do whatever it needs to on its own

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

Να είστε καλά και να φροντίζεται τον εαυτό σας.

Μπορείτε να κατεβάσετε τα αρχεία του βοηθήματος εδώ