• Λίστες (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 πρόκειται να συνοδεύεται από πρακτικές καλής συγγραφής συναρτήσεων.

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

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

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

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

• Να ορίσουμε συναρτήσεις με σταθερές τιμές παραμέτρων
• Να ορίσουμε συναρτήσεις με παραμέτρους που αποτελούν λέξεις – κλειδιά
• Να ορίσουμε συναρτήσεις με λίστες για παραμέτρους
• Να δημιουργήσουμε ανώνυμες συναρτήσεις τύπου 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 με τα στοιχεία σας. Για να γίνετε συνδρομητής πατήστε εδώ

Η γλώσσα προγραμματισμού ASP (Active Server Pages) έχει το ιδιαίτερο χαρακτηριστικό ότι ο κώδικάς της πρώτα μεταγλωττίζεται στον server και μετά φορτώνεται σαν ένα κανονικό html έγγραφο, χωρίς ο χρήστης να είναι σε θέση να δει τον αρχικό κώδικα. Με την τεχνολογία της ASP μπορούμε να δημιουργήσουμε δυναμικές ιστοσελίδες (dynamic web pages).

Ανταγωνιστικές της τεχνολογίας ASP είναι η τεχνολογία Php (HyperText PreProcessor) καθώς και η τεχνολογία CFML (ColdFusion Markup Language).

Τι Είναι ένα Αρχείο ASP

• Ένα αρχείο ASP είναι ακριβώς το ίδιο όπως ένα αρχείο HTML.
• Ένα αρχείο ASP μπορεί να περιέχει κείμενο, HTML tags και scripts.
• Τα scripts σ’ ένα αρχείο ASP εκτελούνται στον server.
• Ένα αρχείο ASP έχει την επέκταση .asp.

Πώς Δουλεύει ένα Αρχείο ASP

• Όταν ένας φυλλομετρητής ζητάει ένα αρχείο HTML, ο server επιστρέφει το αρχείο.
• Όταν ένας φυλλομετρητής ζητάει ένα αρχείο ASP, ο server καλεί την ASP.
• Η ASP διαβάζει το αρχείο ASP και εκτελεί τα scripts που περιέχει.
• Τέλος, το αρχείο ASP επιστρέφεται στον φυλλομετρητή σαν ένα απλό αρχείο HTML.

Τι Μπορεί να Κάνει η ASP για μας

• Να τροποποιήσει δυναμικά το περιεχόμενο μιας ιστοσελίδας.
• Να απαντά σε ερωτήσεις χρήστη ή σε δεδομένα που υποβάλλονται από φόρμες HTML.
• Να έχει πρόσβαση σε δεδομένα ή σε βάσεις δεδομένων και να επιστρέφει τα αποτελέσματα σ’ έναν φυλλομετρητή.
• Να προσαρμόζει μια ιστοσελίδα ώστε να την κάνει πιο χρήσιμη στους χρήστες.
• Τα πλεονεκτήματα από την χρήση της ASP αντί για την CGI και την Perl είναι η απλότητα και η ταχύτητα.
• Παρέχει ασφάλεια εφόσον ο ASP κώδικάς μας δεν μπορεί να ειδωθεί από τον φυλλομετρητή.
• Εφόσον τα αρχεία ASP επιστρέφονται σαν απλή HTML, μπορούν να ειδωθούν από οποιονδήποτε φυλλομετρητή.
• Ο έξυπνος ASP προγραμματισμός μπορεί να ελαχιστοποιήσει την κυκλοφορία στο δίκτυο (network traffic).

Σύνταξη της ASP

Δεν μπορούμε να δούμε τον ASP κώδικα σ’ έναν φυλλομετρητή, αλλά μόνο την έξοδο από την ASP, που είναι απλή HTML. Και αυτό γιατί τα scripts εκτελούνται στον server πριν σταλεί το αποτέλεσμα στον φυλλομετρητή.

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

Εμφάνιση Κειμένου

Πώς να γράψουμε κάποιο κείμενο στο τμήμα <body> του HTML εγγράφου με την ASP.

<html>
<body>
<%
response.write"Hello World!"
%>
</body>
</html>

Κείμενο και HTML tags

Πώς να μορφοποιήσουμε το κείμενο με HTML tags.

<html>
<body>
<%
response.write("<h2> Hello World! <br> Αυτή η πρόταση χρησιμοποιεί
HTML tags για να μορφοποιήσει το κείμενο!
</h2>")
%>
</body>
</html>

Ο Βασικός Κανόνας Σύνταξης της ASP

Ενα αρχείο ASP περιέχει κανονικά HTML tags, όπως ένα κανονικό αρχείο HTML. Επιπλέον, ένα αρχείο ASP μπορεί να περιέχει server scripts, που περικλείονται από τους οριοθέτες (delimiters) <% και %>. Τα server scripts εκτελούνται στον server και μπορούν να περιέχουν οποιεσδήποτε εκφράσεις, εντολές, διαδικασίες ή τελεστές που είναι έγκυροι για τη γλώσσα συγγραφής που χρησιμοποιούμε.

Το Αντικείμενο Response

Η μέθοδος Write του αντικειμένου Response της ASP χρησιμοποιείται για να σταλεί περιεχόμενο (content) στον φυλλομετρητή. Για παράδειγμα, η επόμενη εντολή στέλνει το κείμενο Hello World στον φυλλομετρητή :

Response.Write("Hello World")

Η VBScript

Στην ASP μπορούμε να χρησιμοποιήσουμε διάφορες γλώσσες συγγραφής (scripting languages). Η προκαθορισμένη είναι η γλώσσα VBScript, όπως φαίνεται στο επόμενο παράδειγμα :

<html>
<body>
<%
response.write("Hello World!")
%>
</body>
</html>

Το παράδειγμα αυτό χρησιμοποιεί τη συνάρτηση response.write για να εμφανίσει το μήνυμα Hello World! στο τμήμα <body> του HTML εγγράφου.

Η JavaScript

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

<%@ language="javascript" %>
<html>
<body>
<%
Response.Write("Hello World!")
%>
</body>
</html>

Πρέπει να έχουμε υπόψη μας ότι σ’ αντίθεση με την VBScript, η JavaScript ξεχωρίζει τα πεζά από τα κεφαλαία γράμματα (case sensitive). Ετσι, θα πρέπει να γράψουμε τον ASP κώδικα με κεφαλαία ή πεζά γράμματα ανάλογα με τις απαιτήσεις της γλώσσας.

Αλλες Γλώσσες Συγγραφής (Scripting Languages)

Η ASP δίνεται με τις γλώσσες συγγραφής VBScript και JavaScript. Αν θέλουμε να γράψουμε κώδικα σε μια άλλη γλώσσα, όπως Perl, REXX ή Python, θα πρέπει να εγκαταστήσουμε τις αντίστοιχες μηχανές συγγραφής (scripting engines). Επειδή τα scripts εκτελούνται στον server, ο φυλλομετρητής που ζητάει το αρχείο ASP δεν είναι ανάγκη να υποστηρίζει scripting.

Μια κανονική έκφραση (regular expression) είναι ένα κομμάτι (string) κειμένου που περιέχει ειδικούς κωδικούς που του δίνουν τη δυνατότητα να μπορεί να χρησιμοποιηθεί με κάποιες συναρτήσεις της PHP για εντοπισμό και διαχείριση κειμένου. Για να μπορέσουμε να χρησιμοποιήσουμε μια κανονική έκφραση, πρέπει να είμαστε εξοικειωμένοι με τις συναρτήσεις των κανονικών εκφράσεων που υπάρχουν στην PHP. Η ereg() είναι η βασικότερη απ’ αυτές και μπορεί να χρησιμοποιηθεί για να καθορίσουμε αν μια κανονική έκφραση ικανοποιείται από ένα συγκεκριμένο string κειμένου. Ας δούμε τον επόμενο κώδικα :

$text = "Κανόνες της PHP!";
if (ereg("PHP", $text)) {
echo( '$το κείμενο περιέχει το string "PHP".' );
} else {
echo( '$το κείμενο δεν περιέχει το string "PHP".' );
}

Σ’ αυτό το παράδειγμα, η κανονική έκφραση ικανοποιείται επειδή το string που είναι αποθηκευμένο στη μεταβλητή $text περιέχει το PHP. Ο παραπάνω κώδικας θα εξάγει συνεπώς τα εξής :

$το κείμενο περιέχει το string “PHP”.

Δεν πρέπει να ξεχνάμε όταν τα μονά εισαγωγικά αποτρέπουν την PHP από το να εμφανίσει την τιμή της μεταβλητής $text.
Η eregi() είναι μια συνάρτηση που συμπεριφέρεται σχεδόν παρόμοια με την ereg(), εκτός από το ότι αγνοεί τα πεζά και τα κεφαλαία γράμματα όταν αναζητά ταιριάσματα :

$text = "Τι είναι η Php;";
if (eregi("PHP", $text)) {
echo( '$το κείμενο περιέχει το string "PHP".' );
} else {
echo( '$το κείμενο δεν περιέχει το string "PHP".' );
}

Αυτό εμφανίζει πάλι το ίδιο μήνυμα :

$το κείμενο περιέχει το string “PHP”.

Θα δούμε μερικά παραδείγματα για να μάθουμε τη βασική σύνταξη των κανονικών εκφράσεων. Πρώτα απ’ όλα, το σύμβολο caret () μπορεί να χρησιμοποιηθεί για να δείξει την αρχή ενός string, ενώ το σύμβολο του δολαρίου ($) χρησιμοποιείται για να δείξει το τέλος :

PHP // Ταιριάζει με το “What is PHP?”
PHP // Ταιριάζει με το “PHP rules!”, όχι με το “What is PHP?”
PHP$ // Ταιριάζει με το “I love PHP”, όχι με το “What is PHP?”
PHP$ // Ταιριάζει με το “PHP” και τίποτα άλλο

Προφανώς, θα υπάρχουν φορές που θα θέλουμε να χρησιμοποιήσουμε τα σύμβολα ^, $ ή και άλλους ειδικούς χαρακτήρες για να συμπεριλάβουμε τον αντίστοιχο χαρακτήρα στο string αναζήτησης. Για να αφαιρέσουμε το ειδικό νόημα ενός χαρακτήρα, προτάσσουμε τον χαρακτήρα \ (backslash), ως εξής :

\$\$\$  // Ταιριάζει με το "Show me the $$$!"

Οι αγκύλες μπορούν να χρησιμοποιηθούν για να ορίσουν ένα σύνολο χαρακτήρων που μπορεί να ταιριάξει. Για παράδειγμα, η ακόλουθη κανονική έκφραση ταιριάζει μ’ ένα μόνο από τα ψηφία 1 έως 5.

[12345] // Ταιριάζει με το “1″ και το “3″, αλλά όχι με το “a” ή το “12″

Μπορούμε να καθορίσουμε και περιοχές αριθμών ή γραμμάτων.

[1-5] // Το ίδιο όπως προηγουμένως
[a-z] // Ταιριάζει μ’ ένα οποιοδήποτε πεζό γράμμα
[0-9a-zA-Z] // Ταιριάζει μ’ ένα οποιοδήποτε γράμμα ή ψηφίο

Οι χαρακτήρες ?, + και * έχουν επίσης ειδικό νόημα. Συγκεκριμένα, το ? σημαίνει ότι ο προηγούμενος χαρακτήρας είναι προαιρετικός, το + σημαίνει έναν ή περισσότερους από τους προηγούμενους χαρακτήρες και το * σημαίνει κανέναν ή έναν από τους προηγούμενους χαρακτήρες.

bana?na // Ταιριάζει με τα “banana” και “banna”,
// αλλά όχι με το “banaana”
bana+na // Ταιριάζει με τα “banana” και “banaana”,
// αλλά όχι με το “banna”
bana*na // Ταιριάζει με τα “banna”, “banana” και “banaaana”,
// αλλά όχι με το “bnana”
[a-zA-z]+$ // Ταιριάζει μ’ ένα οποιοδήποτε string που έχει έναν
// τουλάχιστον χαρακτήρα

Οι παρενθέσεις μπορούν να χρησιμοποιηθούν για να ομαδοποιήσουμε strings και να εφαρμόσουμε τα ?, + ή * σ’ αυτά σαν σύνολο.

ba(na)+na // Ταιριάζει με τα “banana” και “banananana”,
// αλλά όχι με το “bana” ή το “banaana”

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

\n // Ταιριάζει μ’ έναν χαρακτήρα νέας γραμμής (newline character)
 // Ταιριάζει μ’ έναν οποιονδήποτε χαρακτήρα εκτός από τον
// χαρακτήρα νέας γραμμής
\r // Ταιριάζει μ’ έναν χαρακτήρα carriage return
\t // Ταιριάζει με τον χαρακτήρα tab

Αντικατάσταση Strings με Κανονικές Εκφράσεις

Χρησιμοποιώντας την ereg() ή την eregi() με τη σύνταξη των κανονικών εκφράσεων που μόλις είδαμε, μπορούμε να εντοπίσουμε εύκολα την παρουσία tags σ’ ένα δεδομένο string κειμένου. Αυτό που πρέπει να κάνουμε, όμως, είναι να σημειώσουμε με ακρίβεια αυτά τα tags και να τα αντικαταστήσουμε με κατάλληλα HTML tags.
Για να γίνει αυτό, πρέπει να δούμε μερικές ακόμα συναρτήσεις κανονικών εκφράσεων που υπάρχουν στην PHP :

 ereg_replace()

eregi_ replace().

Η ereg_replace(), σαν την ereg(), δέχεται μια κανονική έκφραση και ένα string κειμένου και προσπαθεί να ταιριάξει την κανονική έκφραση με το string. Επιπλέον, όμως, η ereg_replace() δέχεται ένα δεύτερο string κειμένου και αντικαθιστά κάθε ταίριασμα της κανονικής έκφρασης σ’ αυτό το string. Η σύνταξη της ereg_replace() είναι ως εξής :

$newstring = ereg_replace(, ,
);

όπου η είναι η κανονική έκφραση και το είναι το string που θα αντικαταστήσει τα ταιριάσματα στην όπου υπάρχει το
. Η συνάρτηση επιστρέφει το νέο string που προκύπτει από τη λειτουργία της αντικατάστασης. Στην παραπάνω πρόταση, αυτό απoθηκεύεται στη μεταβλητή $newstring.
Η eregi_replace(), όπως είναι αναμενόμενο, είναι παρόμοια με την ereg_replace(), εκτός από το ότι δεν ελέγχει τα πεζά/κεφαλαία όταν κάνει αναζήτηση για ταιριάσματα.
Είμαστε τώρα έτοιμοι να αρχίσουμε να δημιουργούμε τη δική μας προσαρμοσμένη γλώσσα σήμανσης (custom markup language).

Έντονο και Πλάγιο Κείμενο

Θα ξεκινήσουμε υλοποιώντας tags για να δημιουργήσουμε έντονο και πλάγιο κείμενο. Ας υποθέσουμε ότι θέλουμε το [B] να ξεκινάει το έντονο κείμενο (bold text) και το [EB] να τελειώνει το έντονο κείμενο. Προφανώς, θα πρέπει να αντικαταστήσουμε το [B] με το και το [EB] με το .
Η λειτουργία αυτή αποτελεί μια απλή εφαρμογή της συνάρτησης eregi_replace() :

$joketext = eregi_replace("\[b]", "", $joketext);
$joketext = eregi_replace("\[eb]", "", $joketext);

Εφόσον το [ κανονικά δείχνει την αρχή ενός συνόλου αποδεκτών χαρακτήρων σε μια κανονική έκφραση, τοποθετούμε τον χαρακτήρα \ (backslash) πριν απ’ αυτόν για να αφαιρέσουμε το ειδικό νόημα που έχει. Χωρίς ένα αντίστοιχο [, το ] χάνει το ειδικό νόημα που έχει και δεν χρειάζεται συνεπώς έναν χαρακτήρα backslash, αν και θα μπορούσαμε να τοποθετήσουμε ένα backslash μπροστά του επίσης.
Παρατηρούμε επίσης, ότι, εφόσον χρησιμοποιούμε τη συνάρτηση eregi_replace(), η οποία δεν ξεχωρίζει τα πεζά από τα κεφαλαία γράμματα (case insensitive), το [B] και το [b] θα εργάζονται σαν tags στη δική μας προσαρμοσμένη γλώσσα σήμανσης (custom markup language).
Το πλάγιο κείμενο μπορεί να γίνει με τον ίδιο τρόπο :

$joketext = eregi_replace("\[i]", "", $joketext);
$joketext = eregi_replace("\[ei]", "", $joketext);

Οι Παράγραφοι

Ενώ μπορούμε να δημιουργήσουμε tags για παραγράφους όπως ακριβώς κάναμε για το έντονο και πλάγιο κείμενο, υπάρχει και μια πιο απλή λύση. Εφόσον ο χρήστης θα καταχωρήσει το περιεχόμενο σ’ ένα πεδίο φόρμας (form field) που θα του δίνει τη δυνατότητα να μορφοποιήσει το κείμενο χρησιμοποιώντας το πλήκτρο enter, θα ορίσουμε το linefeed (\n) να δείχνει μια αλλαγή γραμμής (line break) και το διπλό linefeed (\n\n) να δείχνει μια νέα παράγραφο. Φυσικά, εφόσον τα PC’s παριστάνουν τις νέες γραμμές σαν ένα ζευγάρι του linefeed με το carriage return (\n\r) θα πρέπει πρώτα να αφαιρέσουμε τα carriage returns. Ο κώδικας γι’ όλα αυτά είναι ο εξής :

// Αφαιρεί τα carriage returns
$joketext = ereg_replace("\r", "", $joketext);
// Χειρισμός των παραγράφων
$joketext = ereg_replace("\n\n", "
", $joketext);
// Χειρισμός των αλλαγών γραμμής (line breaks)
$joketext = ereg_replace("\n", "
", $joketext);

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

Οι Υπερσύνδεσμοι (Hyperlinks)

Ενώ μπορεί να φανεί ανόητο το να υποστηρίζουμε τους υπερσυνδέσμους (hyperlinks) στο κείμενο των jokes, αυτό το χαρακτηριστικό έχει νόημα σ’ άλλες εφαρμογές. Οι υπερσύνδεσμοι είναι λίγο περισσότερο πολύπλοκοι από την απλή μετατροπή ενός κώδικα σ’ ένα HTML tag. Πρέπει να μπορούμε να εξάγουμε ένα URL όπως και το κείμενο που πρέπει να εμφανίζεται σαν ο σύνδεσμος (link).
Ένα άλλο χαρακτηριστικό των συναρτήσεων ereg_replace() και eregi_replace() θα φανεί εδώ. Περιβάλλοντας ένα τμήμα της κανονικής έκφρασης με παρενθέσεις, μπορούμε να αποσπάσουμε το αντίστοιχο τμήμα του κειμένου που ταιριάζει και να το χρησιμοποιήσουμε στο string αντικατάστασης με τον κώδικα \\n, όπου το n είναι 1 για το πρώτο τμήμα της κανονικής έκφρασης που βρίσκεται σε παρενθέσεις, 2 για το δεύτερο και έως 9 για το ένατο. Ας δούμε το ακόλουθο παράδειγμα :

$text = "banana";
$text = eregi_replace("(.*)(nana)", "\\2\\1", $text);
echo($text);               // εμφανίζει "nanaba"

Στο παραπάνω, το \\1 αντικαθίσταται με το ba στο string αντικατάστασης, το οποίο αντιστοιχεί στο (.*) (κανένας ή περισσότεροι χαρακτήρες διάφοροι της νέας γραμμής, new line) στην κανονική έκφραση. Το \\2 αντικαθίσταται με το nana, το οποίο αντιστοιχεί στο (nana) στην κανονική έκφραση.
Η ίδια αρχή μπορεί να χρησιμοποιηθεί για να δημιουργήσουμε τους υπερσυνδέσμους μας (hyperlinks). Θα ξεκινήσουμε με μια απλή φόρμα ενός link, όπου το κείμενο του link είναι το ίδιο με το URL. Θέλουμε να υποστηρίξουμε την εξής σύνταξη :

Visit [L]http://www.php.net/[EL].

Ο αντίστοιχος HTML κώδικας είναι ο εξής :

Visit  http://www.php.net/ 

Πρώτα, χρειαζόμαστε μια κανονική έκφραση που θα ταιριάζει με τους συνδέσμους (links) αυτής της φόρμας, ως εξής :

\[L][-_./a-zA-Z0-9!&%#?,'=:~]+\[EL]

Ξανά, έχουμε τοποθετήσει backslashes μπροστά από τις αγκύλες στα [L] και [EL] για να δείξουμε ότι θα τα αντιμετωπίσουμε κυριολεκτικά. Χρησιμοποιούμε μετά αγκύλες (square brackets) για να εμφανίσουμε όλους τους χαρακτήρες που θέλουμε να δεχθούμε σαν μέρος του URL. Τοποθετούμε ένα + μετά από τις αγκύλες για να δείξουμε ότι το URL θα αποτελείται από έναν ή περισσότερους χαρακτήρες που παίρνονται από τη λίστα.
Για να εξάγουμε το link, θα πρέπει να βρούμε το URL και να το εξάγουμε σαν το HREF attribute του tag Α καθώς και σαν το κείμενο του link. Για να βρούμε το URL, περιβάλλουμε το αντίστοιχο τμήμα της κανονικής έκφρασης με παρενθέσεις :

\[L]([-_./a-zA-Z0-9!&%#?,'=:~]+)\[EL]

Έτσι, κάνουμε τη μετατροπή link με τον εξής κώδικα :

$joketext = ereg_replace(
"\[L]([-_./a-zA-Z0-9!&%#?,'=:~]+)\[EL]",
"\\1", $joketext);

Έπρεπε να τοποθετήσουμε backslashes μπροστά από τα διπλά εισαγωγικά στον HTML κώδικα για να μην τα μπερδέψει η PHP με τα εισαγωγικά που περιβάλλουν το string αντικατάστασης. Το \\1 αντικαθίσταται με το URL για το link και η έξοδος είναι η αναμενόμενη.
Θα θέλαμε επίσης να υποστηρίξουμε τα hyperlinks που περιέχουν κείμενο link που διαφέρει από τα δικά τους URL. Ας υποθέσουμε ότι η μορφή του link μας είναι ως εξής :

Check out [L=http://www.php.net/]PHP[EL].

Ακολουθεί η κανονική έκφραση :

\[L=([-_./a-zA-Z0-9!&%#?,'=:~]+)]([-_./a-zA-Z0-9 !&%#?,'=:~]+)\[EL]

Το παραπάνω κάνει αυτό ακριβώς που θέλουμε, καθώς βρίσκει και το URL (\\1) και το κείμενο (\\2) για το link. Ο PHP κώδικας για να γίνει η αντικατάσταση είναι ο εξής :

$joketext = ereg_replace(
"\[L=([-_./a-zA-Z0-9!&%#?,'=:~]+)]".
"([-_./a-zA-Z0-9 !&%#?,'=:~]+)\[EL]",
"\\2", $joketext);

• Να εκτελούμε εντολές υπό συνθήκη με την εντολή 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 αφού δούμε κάποια συμπληρωματικά στοιχεία σε όσα έχουμε ήδη πει.

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

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