Tutorial: Python με απλά λόγια!

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

Του Βασίλη Καρακόιδα

Η Python είναι μια αντικειμενοστραφής scripting γλώσσα που δημιουργήθηκε από τον Guido Van Rossum το 1991. Είναι η γλώσσα που σύμφωνα με τον δημιουργό της έχει φτιαχτεί για να είναι ευχάριστη και να παρέχει μηχανισμούς που διευκολύνουν τον προγραμματισμό, αλλά ταυτόχρονα να είναι και αναγνώσιμη. Πρόσφατα ένας πολύ καλός φίλος είχε πει για την Python: “αν κάποιος ζητάει ταχύτητα και άπειρες βιβλιοθήκες, μπορεί να προγραμματίσει σε Perl. Αν κάποιος απαιτεί δυνατό Object-Oriented προγραμματισμό και Business Integration, τοτε μπορεί χρησιμοποιήσει την Ruby. Την Python μπορεί να την χρησιμοποιήσει κάποιος που θέλει να γράφει όμορφα προγράμματα, που θα μπορεί να τα διαβάσει και να τα τροποποιήσει μετά από πολύ καιρό, χωρίς να πρέπει να σχολιάζει κάθε γραμμή”.

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

apt-get install python

Εγχειρίδια χρήσης και tutorials για την Python μπορείτε να βρείτε στο http://www.python.org/doc. Από την διεύθυνση αυτή μπορείτε επίσης να κατεβάσετε την τελευταία έκδοση του πηγαίου κώδικα αλλά και έτοιμα binaries για διάφορα άλλα λειτουργικά.

Τα βασικά

Τι άλλο πρέπει να ξέρετε; Τον python interpreter και μερικά χαρακτηριστικά του που κάνουν την ζωή των developers πιο εύκολη. Για να τον τρέξουμε απλά δίνουμε στη γραμμή εντολών την εντολή python:

$ python
Python 2.7.3 (default, Sep 26 2012, 21:51:14)
[GCC 4.7.2] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>>

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

>>> print "hello linux inside"
hello linux inside
>>>

Η παραπάνω εντολή τυπώνει το string “hello linux inside στη στάνταρ έξοδο (συνήθως, την κονσόλα). Όπως θα παρατηρήσατε, η εντολή εκτελέστηκε ήδη και στην ακριβώς παρακάτω γραμμή βλέπουμε το αποτέλεσμα της. Τι θα γίνει όμως αν θέλουμε να γράψουμε κάτι πιο πολύπλοκο; Ας δούμε άλλο ένα παράδειγμα.

>>> list = [1,2,3]
>>> for i in list:
... print i
...
1
2
3
>>>

Στο παραπάνω παράδειγμα ορίσαμε μια λίστα με τρεις αριθμούς και με μια επανάληψη for τυπώσαμε τα περιεχόμενα της. Εδώ ερχόμαστε αντιμέτωποι με μία ιδιομορφία της Python. Όλες οι κλασσικές γλώσσες προγραμματισμού, για να ομαδοποιούν τον κώδικα, ορίζουν κάθε μπλοκ με ένα ζευγάρι συμβόλων. Για παράδειγμα, στην C/C++ χρησιμοποιούνται τα σύμβολα “{“ και “}”, για την αρχή και το τέλος αντίστοιχα του μπλοκ. Στην Python όμως τα μπλοκ κώδικα ορίζονται με βάση την στοίχιση του κώδικα. Είναι λίγο περίεργη πρακτική, αλλά πιστέψτε με είναι πολύ βολικό τελικά.

Για αυτό το λόγο στο παράδειγμα μας, το print πρέπει να είναι στοιχισμένο ένα Τab δεξιότερα σε σχέση με το for. Φυσικά μπορεί να χρησιμοποιηθεί και ο χαρακτήρας του κενού, αρκεί η στοίχιση να γίνεται ομοιόμορφα. Έτσι, δείχνουμε στην Python ότι θέλουμε το print να εκτελεστεί σε κάθε επανάληψη του for. Οι τρεις τελείες είναι του interpreter και πατώντας ξανά Enter εμφανίζονται τα αποτελέσματα.

Τεκμηρίωση

Ο interpreter όμως έχει επίσης άλλη μία πολύ σημαντική χρήση. Εκτός από εργαλείο για γρήγορους πειραματισμούς μπορεί να χρησιμοποιηθεί και ως ένα online βοήθεια για τον προγραμματιστή. Αυτό γίνεται μέσω των εντολών dir και help. Για παράδειγμα, σε περίπτωση που δεν θυμόμαστε πως χρησιμοποιείται ένα module ή μια κλάση, μπορούμε απλά να πληκτρολογήσουμε help <όνομα module ή κλάσης>. Για παράδειγμα, έστω ότι στο πρόγραμμα μας θέλουμε να χρησιμοποιήσουμε κανονικές εκφράσεις αλλά δεν ξέρουμε την χρήση τους. Με λίγη έρευνα στην τεκμηρίωση της Python θα δούμε ότι πρέπει να εισάγουμε το module re (από το regular expressions):

>>> import re
>>> help(re)

Επίσης μπορεί να θέλουμε να δούμε στα γρήγορα τις συναρτήσεις που εισάγουμε με το module re. Τότε χρησιμοποιούμε την συνάρτηση dir:

>>> import re
>>> dir(re)
['DEBUG', 'DOTALL', ...μπλα μπλα... '__doc__', '__file__', '__name__', ...μπλα μπλα ...'sys', 'template']

Η Python διαθέτει μία από τις πλουσιότερες συλλογές βιβλιοθηκών για μια πληθώρα χρήσεων, όπως XML parsing, regular expressions, pop3 servers και clients. Ο πίνακας 1 έχει ένα κατάλογο των πιο χρήσιμών βιβλιοθηκών που παρέχονται σε μια κλασσική διανομή της Python.

Δομικά Χαρακτηριστικά

Αν εξαιρέσουμε την ιδιομορφία της Python με την στοίχιση, στους υπόλοιπους τομείς θα σας θυμίσει άλλες γλώσσες προγραμματισμού. Οι βρόχοι επανάληψης θα σας φανούν ιδιαίτερα γνώριμοι, υπάρχει το κλασσικό for και while, ενώ για έλεγχο ροής θα βρείτε το παραδοσιακό (σε όλες τις γλώσσες σχεδόν) if. Άλλα δομικά χαρακτηριστικά της Python είναι τα strings, οι λίστες, τα dictionaries, τα tuples, οι συναρτήσεις και οι κλάσεις. Ας τα δούμε περιληπτικά.

Strings

Τα String δεν είναι τίποτα άλλο από σειρές χαρακτήρων. Ανάλογα με τον ορισμό τους έχουν διαφορετικά χαρακτηριστικά. Μπορούν να οριστούν με μονά (‘foo’) ή διπλά εισαγωγικά (“foo”).

Σε περίπτωση που θέλουμε το string να είναι Unicode, τότε κατά τον ορισμό γράφουμε τον χαρακτήρα “u” πριν την δήλωση. Στο παρακάτω παράδειγμα δηλώνουμε δύο φορές το string “hello” την μία φορά ως unicode και την άλλη ως απλό string. Η εντολή type μας επιστρέφει τον τύπο μιας μεταβλητής (αn είναι string, ακέραιος κλπ):

>>> foo = u'hello'
>>> type(foo)
<type 'unicode'>
>>> bar = 'hello'
>>> type(bar)
<type 'str'>

Επίσης στα strings για να δηλώσουμε ορισμένους χαρακτήρες χρησιμοποιούμε escape sequences, όπως στην C και Perl. Ως escape character, χρησιμοποιείται ο χαρακτήρας “\”. Για παράδειγμα με το “\n” δηλώνουμε μια νέα γραμμή:

>>> print 'hello\n'
hello
>>>

Η Python δίνει επίσης την δυνατότητα να αγνοούνται τα escape sequences, αν κατά τον ορισμό των string χρησιμοποιήσουμε τον χαρακτήρα “r”. Τα strings αυτά είναι γνωστά και ως raw strings:

>>> print r'hello\n'
hello\n

Για την μορφοποίηση των strings, η γλώσσα έχει ένα συντακτικό παρόμοιο με αυτό που χρησιμοποιείται στην εντολή printf της C. Για παράδειγμα έστω ότι θέλουμε να τυπώσουμε τα περιεχόμενα μιας λίστας στην μορφή “<θέση>:<τιμή>”.

>>> i = 0
>>> for v in [1,2,3]:
...    s = "[%d]:%s" % (i, v)
...    i = i + 1
...    print s
...
[0]:1
[1]:2
[2]:3

Σε αυτό το παράδειγμα, δημιουργούμε το string “s”, ως ένα αλφαριθμητικό που θα αποτελείται από ένα ακέραιο (%d) και ένα string (%s), τα οποία καθορίζονται από τις μεταβλητές “i” και “v”.

Λίστες & Tuples

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

 >>> list = [ ]

Η λίστα είναι αντικείμενο και, όπως ήδη έχουμε πει, μπορούμε να μάθουμε τις συναρτήσεις και τα χαρακτηριστικά ενός αντικειμένου μέσω της εντολής dir. Να τι θα δούμε:

>>> dir(list)
['__add__', '__class__', '__contains__', ...μπλα μπλα..., '__str__', 'append', 'count', ...μπλα μπλα.., 'pop', 'remove', 'reverse', 'sort']

Με μια πρώτη ματιά, παρατηρούμε ότι υπάρχουν δύο είδη συναρτήσεων. Εκείνες που το όνομα τους ξεκινά με τους χαρακτήρες “__”, όπως η “__str__”, αλλά και άλλες που έχουν 'τυπική' όνομασία όπως η “append”. Σε αυτό το tutorial, θα θεωρήσουμε ότι οι συναρτήσεις που το όνομα τους περικλείεται σε “__” είναι εσωτερικές του αντικειμένου και δεν αποτελεί καλή πρακτική να τα χρησιμοποιούμε. Άρα για εμάς μια λίστα θα έχει τις εξής συναρτήσεις που μπορούμε να χρησιμοποιήσουμε: append, count, extend, index, insert, pop, remove, reverse και sort.

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

>>> s = [1,2,3]
>>> len(s)
3

Στο σημείο αυτό πρέπει να τονίσουμε οτι η len() δεν χρησιμοποιείται μόνο στις λίστες, αλλά και στα strings, τα dictionaries και τα tuples.

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

>>> s = [1,2,3]
>>> s[0]
1

Η Python παρέχει επίσης ένα πολύ κομψό και γρήγορο τρόπο για δημιουργία διαμερίσεων σε μία λίστα. Αυτό επιτυγχάνεται με την χρήση του τελεστή “:” στο συντακτικό που είδαμε πριν:

>>> s = [1,2,3]
>>> s[1:]
[2, 3]

Το παραπάνω κομμάτι κώδικα επιστρέφει όλα τα στοιχεία της λίστας “s” μετά το πρώτο. Ομοίως:

>>> s[2:]
[3]

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

>>> s[:len(s) - 1]
[1, 2]
>>> s[1:len(s) - 1]
[2]

Τα αποτελέσματα των παραπάνω εντολών είναι πάντα λίστες. Σε περίπτωση που αυτό που ζητάμε είναι εκτός ορίων, τότε επιστρέφεται η κενή λίστα.

>>> s[5:6]
[ ]
>>> len(s[5:6])
0

Τα tuples είναι και αυτά λίστες, με τη μόνη διαφορά ότι είναι “immutable”. Αυτό σημαίνει ότι τα στοιχεία τους μπορούν μόνο να διαβαστούν και όχι να διαγραφούν ή να προστεθούν νέα στοιχεία. Τα tuples ορίζονται με παρόμοιο συντακτικό με τις λίστες, αλλά με παρενθέσεις αντί για αγκύλες:

>>> s = (1,2,3)
>>> print s
(1, 2, 3)
>>> print s[2]
3

Dictionaries

Αφού είδαμε τα βασικά χαρακτηριστικά των λιστών και τα καταλάβαμε, είναι πολύ εύκολο πλέον να κατανοήσουμε και τα dictionaries. Αυτά αποτελούνται από δεδομένα τα οποία συσχετίζονται ως ζευγάρια της μορφής key-value (κλειδί-τιμή). Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να συσχετίσουμε τα ονόματα κάποιων ανθρώπων με τις e-mail διευθύνσεις τους. Να τι γράφουμε:

>>> dict = {}
>>> dict['bob'] = "[email protected]"
>>> dict['lisa'] = "[email protected]"

Το dictionary που δημιουργήσαμε λέγεται dict και έχουμε θέσει ότι το κλειδί “bob”, αντιστοιχίζεται με την τιμή “[email protected]”. Άρα αν ζητήσουμε την τιμή του “bob” στο dictionary, θα δούμε το εξής:

>>> print dict['bob']
[email protected]

Φυσικά, είναι εύκολο να πάρουμε όλες τις τιμές από ένα dictionary χρησιμοποιώντας μια επανάληψη for:

>>> for k in dict.keys():
...     print k + " - " + dict[k]
...
lisa - [email protected]
bob - [email protected]

Στην πρώτη γραμμή, η συνάρτηση keys() επιστρέφει μια λίστα με τα κλειδιά που έχει εκείνη την στιγμή το dictionary dict.

Συναρτήσεις

Όλες οι σύγχρονες γλώσσες προγραμματισμού περιλαμβάνουν και υλοποιούν την έννοια των συναρτήσεων. Αυτές χρησιμοποιούνται συνήθως για επαναχρησιμοποίηση κώδικα μέσα στα πλαίσια ενός μεγαλύτερου προγράμματος. Στην Python, οι συναρτήσεις ορίζονται με την χρήση του συντακτικού: def <όνομα> (<παράμετροι>):. Να ένα παράδειγμα:

>>> def foo():
...    print "hello from foo"
...
>>> foo()
hello from foo
>>>

Οπως συμβαίνει παντού, οι συναρτήσεις μπορούν να δέχονται παραμέτρους, αλλά και να επιστρέφουν τιμές μέσω τις εντολής return:

>>> def foo(i):
...    print "i have " + str(i),
...    if(i > 1):
...      print "apples"
...    else:
...      print "apple"
...

>>> foo(1)
i have 1 apple
>>> foo(3)
i have 3 apples

Το παραπάνω πρόγραμμα δηλώνει μια συνάρτηση foo με παράμετρο “i”. Παρατηρήστε ότι στη Python δεν δηλώνουμε το τύπο της παραμέτρου, όπως στην C/C++. H συνάρτηση str() μετατρέπει την τιμή της μεταβλητής “i” σε string, ώστε να πραγματοποιηθεί η ένωση (+) με το “i have”. Σημαντική είναι και η κόμμα “,” που βρίσκεται στο τέλος της print (δεν είναι τυπογραφικό λάθος!). Η κόμμα είναι παράμετρος της εντολής print και υποδεικνύει ότι δεν πρέπει να τυπωθεί χαρακτήρας νέας γραμμής. Την βάζουμε εκεί γιατί η προεπιλεγμένη λειτουργία της print είναι να αλλάζει γραμμή στο τέλος κάθε string που τυπώνει.

Και κάτι ακόμα. Οι παράμετροι στις συναρτήσεις μπορούν να αρχικοποιούνται και να παραλείπονται κατά την κλήση.

>>> def foo(b, bb = 2):
...     print "b=%d & bb=%d" % (b,bb)
...

>>> foo(1)
b=1 & bb=2

>>> foo(1,5)
b=1 & bb=5

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

Κλάσεις

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

Οι κλάσεις ορίζονται με το keyword class και μπορούν να περιέχουν μεταβλητές και συναρτήσεις. Το συντακτικό τους είναι σχετικά απλοποίημένο και δεν υπάρχουν keywords που να ορίζουν την “ορατότητα” στα μέλη της κλάσης, όπως public, private κτλ. Η Python υποστηρίζει πάντως κληρονομικότητα. Να ένα απλό παράδειγμα κλάσης:

>>> class Foo:
...    bar = 1
...    def method(self):
...      print "hello from class Foo"
...

>>> Foo().method()
hello from class Foo

Ορίσαμε λοιπόν την κλάση “Foo” με μια μεταβλητή “bar” που έχει τιμή “1”. Επίσης ορίσαμε μια συνάρτηση με όνομα method. Στο σημείο αυτό πρέπει να τονίσουμε ότι όλες οι μέθοδοι των κλάσεων (και μόνο των κλάσεων) πρέπει ως πρώτο όρισμα να έχουν το keyword self. Η μεταβλητή “bar” ονομάζεται και μεταβλητή κλάσης, επειδή ορίζεται στο σώμα της κλάσης και αντιγράφετε, σε κάθε instance της κλάσης.

Για να χρησιμοποιήσουμε τη συνάρτηση method πρέπει να δημιουργήσουμε ένα αντικείμενο (instance) της κλάσης Foo. Αυτό γίνεται σε μια γραμμή κώδικα. Καλούμε τη Foo ως συνάρτηση με τις παραμέτρους που δέχεται (προς το παρόν καμία), και μετά την τελεία γράφουμε το όνομα της συνάρτησης:

>>> Foo().method()

Λίγο πριν αναφέραμε ότι η bar είναι μεταβλητή της κλάσης Foo. Γίνεται λοιπόν το εξής πρωτότυπο: αν προσπαθήσουμε να πάρουμε την τιμή της bar μέσω της Foo, χωρίς όμως να δημιουργήσουμε instance, μας το επιστρέφει κανονικά:

>>> Foo.bar
1

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

>>> Foo().bar
1

Πως εξηγείται αυτό; Το bar, όπως αναφέραμε και πριν είναι μεταβλητή της κλάσης, οπότε όλα τα αντικείμενά της που δημιουργούνται, έχουν και ένα αντίγραφο του. Συν τοις άλλοις, η Python αντιμετωπίζει την bar ως στατική μεταβλητή, η οποία ανήκει στο αντικείμενο Foo. Ας προσπαθήσουμε να δούμε γιατί όμως μας τυπώνει η κλάση Foo την τιμή της bar χωρίς να έχει δημιουργηθεί κάποιο instance αυτής:

>>> class Foo:
...   bar = 1
...

>>> Foo
<class __main__.Foo at 0x694e0>

>>> Foo()
<__main__.Foo instance at 0x50288>

Όπως βλέπουμε, το περιβάλλον εκτέλεσης της Python έχει ήδη δημιουργήσει κάποιο αντικείμενο της κλάσης Foo κατά τον ορισμό της. Οπότε μπορούμε να υποθέσουμε ότι οι μεταβλητές είναι δηλωμένες πάντα ως στατικές σε κάθε κλάση, δηλαδή ως μεταβλητές για τις οποίες δεν χρειάζεται να δημιουργήσουμε instance για να τις προσπελάσουμε. Αυτό συμβαίνει γιατί στην Python οι κλάσεις είναι “first class citizens”. Θα μπορούσαμε να παίξουμε λίγο ακόμα με το default instance που δημιουργεί η Python για κάθε κλάση και να κάνουμε το εξής:

>>> class Foo:
... bar = 1
...
>>> s = Foo
>>> s.bar
1

>>> s().bar
1

Εδώ ορίσαμε την κλάση Foo, την οποία μπορούμε να εξισώσουμε με την μεταβλητή s και μετά να προσπελάσουμε την μεταβλητή bar. Προσοχή: στο παραπάνω παράδειγμα δεν δημιουργούμε instance της Foo κατά την ανάθεση του “s”. Στην συνέχεια δημιουργούμε και instance της κλάσης “s” και ξανακάνουμε προσπέλαση της bar. Για να το καταλάβουμε καλύτερα, ας δούμε το παρακάτω παράδειγμα:

>>> class Foo:
...   bar = 1
...   def getBar(self):
...       return self.bar
...   def setBar(self,b):
...       self.bar = b
...

>>> Foo.bar
1

>>> f = Foo()
>>> f.setBar(5)
>>> f.getBar()
5

Το self.bar είναι η τιμή που έχει το αντίγραφο της “bar” που δημιουργείται στο αντικείμενο f. Γιατί είναι σημαντικά όλα αυτά; Διότι θεωρείται κακή πρακτική στη Python να ορίζονται μεταβλητές κλάσεων, εκτός από μερικές περιπτώσεις όπου χρειάζεται τέτοια λειτουργικότητα. Για να είναι “σωστός” ο ορισμός της κλάσης Foo, πρέπει να γραφεί ως εξής:

>>> class Foo:
...   def __init__(self):
...       self.bar = 1
...   def getBar(self):
...       return self.bar
...   def setBar(self,b):
...       self.bar = b
...

Στο παραπάνω παράδειγμα ορίσαμε την μεταβλητή “bar” ως μεταβλητή του instance, κοινώς το χαρακτηριστικό αυτό υπάρχει μόνο για το instance κάθε κλάσης. Με αυτή την τακτική ορίζουμε ακριβώς αυτό που θέλαμε, μια μεταβλητή στα αντικείμενα της κλάσης Foo. Το καταπληκτικό χαρακτηριστικό της Python είναι ότι δυναμικά μπορούμε να ορίζουμε μεταβλητές στα instances. Σε επόμενα μέρη του tutorial, θα δούμε παραδείγματα χρήσης αυτής της τεχνικής.

Η μέθοδος __init__ είναι ο constructor της κλάσης. Δηλαδή όταν δημιουργούμε την κλάση, o constructor είναι η πρώτη συνάρτηση που καλείται. Σε αντίθεση με της άλλες αντικειμενοστραφείς γλώσσες, στην Python δεν επιτρέπεται να έχουμε συναρτήσεις με το ίδιο όνομα και διαφορετικά ορίσματα (overloading). Για παράδειγμα, αν στην κλάση Foo θέλουμε να έχουμε δύο constructors, όπως στο παρακάτω παράδειγμα,

>>> class Foo:
...   def __init__(self):
...        self.bar = 1
...   def __init__(self,b):
...       self.bar = b
...

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

>>> Foo()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: __init__() takes exactly 2 arguments (1 given)

Επίλογος

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

ΟΙ ΒΑΣΙΚΕΣ ΒΙΒΛΙΟΘΗΚΕΣ ΤΗΣ PYTHON