3. Μία Άτυπη Εισαγωγή στην Python
*********************************

Στα ακόλουθα παραδείγματα, η είσοδος και η έξοδος διακρίνονται από την
παρουσία ή την απουσία prompts (*>>>* και *...*): για να επαναλάβετε
το παράδειγμα, πρέπει να πληκτρολογήσετε τα πάντα μετά το prompt, όταν
αυτό υπάρχει∙ οι γραμμές που δεν αρχίζουν με prompt είναι έξοδος από
τον διερμηνέα. Σημείωση ότι ένα δευτερεύον prompt μόνο του σε μια
γραμμή σε ένα παράδειγμα σημαίνει ότι πρέπει να πληκτρολογήσετε μια
κενή γραμμή∙ αυτό χρησιμοποιείται για να τερματίσετε μια εντολή πολλών
γραμμών.

Πολλά από τα παραδείγματα σε αυτόν τον οδηγό, ακόμη και αυτά που
εισάγονται στο διαδραστικό prompt, περιέχουν σχόλια.  Τα σχόλια στην
Python ξεκινούν με τον χαρακτήρα hashtag, "#", και εκτείνονται μέχρι
το τέλος της γραμμής.  Ένα σχόλιο μπορεί να εμφανιστεί στην αρχή μιας
σειράς ή μετά από κενά διαστήματα ή κώδικα, αλλά όχι μέσα σε μία
συμβολοσειρά.  Ένας χαρακτήρας hashtag μέσα σε μία συμβολοσειρά είναι
απλώς ένας χαρακτήρας hashtag. Δεδομένου ότι τα σχόλια αποσκοπούν στην
αποσαφήνιση του κώδικα και δεν ερμηνεύονται από την Python, μπορούν να
παραλείπονται κατά την πληκτρολόγηση παραδειγμάτων.

Μερικά παραδείγματα:

   # this is the first comment
   spam = 1  # and this is the second comment
             # ... and now a third!
   text = "# This is not a comment because it's inside quotes."


3.1. Χρησιμοποιώντας την Python ως Αριθμομηχανή
===============================================

Ας δοκιμάσουμε μερικές απλές εντολές της Python. Ξεκινήστε τον
διερμηνέα και περιμένετε το πρώτο prompt, "`>>>`".  (Δεν θα πάρει πολύ
χρόνο.)


3.1.1. Αριθμοί
--------------

The interpreter acts as a simple calculator: you can type an
expression at it and it will write the value.  Expression syntax is
straightforward: the operators "+", "-", "*" and "/" work just like in
most other languages (for example, Pascal or C); parentheses ("()")
can be used for grouping. For example:

   >>> 2 + 2
   4
   >>> 50 - 5*6
   20
   >>> (50 - 5*6) / 4
   5.0
   >>> 8 / 5  # division always returns a floating point number
   1.6

Οι ακέραιοι αριθμοί (π.χ. "2", "4", "20") έχουν τον τύπο "int", οι
αριθμοί με δεκαδικά ψηφία (π.χ. "5.0", "1.6") έχουν τον τύπο "float".
Θα δούμε περισσότερα για τους αριθμητικούς τύπους αργότερα σε αυτόν
τον οδηγό.

Η διαίρεση ("/") πάντα επιστρέφει ένα float.  Για να κάνετε *floor
division* (ακέραια διαίρεση) και να πάρετε ένα ακέραιο αποτέλεσμα,
μπορείτε να χρησιμοποιήσετε τον τελεστή "//``∙ για να υπολογίσετε το
το υπόλοιπο μίας διαίρεσης, χρησιμοποιήστε τον τελεστή ``%":

   >>> 17 / 3  # classic division returns a float
   5.666666666666667
   >>>
   >>> 17 // 3  # floor division discards the fractional part
   5
   >>> 17 % 3  # the % operator returns the remainder of the division
   2
   >>> 5 * 3 + 2  # floored quotient * divisor + remainder
   17

Στην Python, είναι εφικτό να χρησιμοποιήσετε τον τελεστή "**" για να
υπολογίσετε δυνάμεις [1]:

   >>> 5 ** 2  # 5 squared
   25
   >>> 2 ** 7  # 2 to the power of 7
   128

Το σύμβολο της ισότητας ("=") χρησιμοποιείται για την ανάθεση μιας
τιμής σε μια μεταβλητή. Στη συνέχεια, δεν εμφανίζεται αποτέλεσμα πριν
από το επόμενο διαδραστικό prompt:

   >>> width = 20
   >>> height = 5 * 9
   >>> width * height
   900

Αν μία μεταβλητή δεν έχει «οριστεί» (δεν της έχει αποδοθεί κάποια
τιμή), η προσπάθεια χρήσης της θα σας δώσει ένα σφάλμα:

   >>> n  # try to access an undefined variable
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   NameError: name 'n' is not defined

Υπάρχει πλήρης υποστήριξη για δεκαδικά ψηφία∙ τελεστές με τελεστέους
μικτού τύπου μετατρέπουν τον ακέραιο τελεστέο σε δεκαδικό:

   >>> 4 * 3.75 - 1
   14.0

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

   >>> tax = 12.5 / 100
   >>> price = 100.50
   >>> price * tax
   12.5625
   >>> price + _
   113.0625
   >>> round(_, 2)
   113.06

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

Εκτός από "int" και "float", η Python υποστηρίζει και άλλους τύπους
αριθμών, όπως "Decimal" και "Fraction". Η Python έχει επίσης
ενσωματωμένη υποστήριξη για complex numbers (μιγαδικούς αριθμούς), και
χρησιμοποιεί την κατάληξη "j" ή "J" για να δηλώσει το φανταστικό μέρος
(π.χ. "3+5j").


3.1.2. Strings
--------------

Besides numbers, Python can also manipulate strings, which can be
expressed in several ways.  They can be enclosed in single quotes
("'...'") or double quotes (""..."") with the same result [2].  "\"
can be used to escape quotes:

   >>> 'spam eggs'  # single quotes
   'spam eggs'
   >>> 'doesn\'t'  # use \' to escape the single quote...
   "doesn't"
   >>> "doesn't"  # ...or use double quotes instead
   "doesn't"
   >>> '"Yes," they said.'
   '"Yes," they said.'
   >>> "\"Yes,\" they said."
   '"Yes," they said.'
   >>> '"Isn\'t," they said.'
   '"Isn\'t," they said.'

In the interactive interpreter, the output string is enclosed in
quotes and special characters are escaped with backslashes.  While
this might sometimes look different from the input (the enclosing
quotes could change), the two strings are equivalent.  The string is
enclosed in double quotes if the string contains a single quote and no
double quotes, otherwise it is enclosed in single quotes.  The
"print()" function produces a more readable output, by omitting the
enclosing quotes and by printing escaped and special characters:

   >>> '"Isn\'t," they said.'
   '"Isn\'t," they said.'
   >>> print('"Isn\'t," they said.')
   "Isn't," they said.
   >>> s = 'First line.\nSecond line.'  # \n means newline
   >>> s  # without print(), \n is included in the output
   'First line.\nSecond line.'
   >>> print(s)  # with print(), \n produces a new line
   First line.
   Second line.

Εάν δεν θέλετε οι χαρακτήρες που προηγούνται από μία "\" να
ερμηνεύονται ως ειδικοί χαρακτήρες, μπορείτε να χρησιμοποιήσετε
*ακατέργαστες συμβολοσειρές* προσθέτοντας ένα "r" πριν από το πρώτο
εισαγωγικό:

   >>> print('C:\some\name')  # here \n means newline!
   C:\some
   ame
   >>> print(r'C:\some\name')  # note the r before the quote
   C:\some\name

Υπάρχει μια δυσδιάκριτη πτυχή στις ακατέργαστες συμβολοσειρές: μια
ακατέργαστη συμβολοσειρά δεν μπορεί να τελειώνει σε περιττό αριθμό
χαρακτήρων "\"' δείτε το λήμμα των Συχνών Ερωτήσεων για περισσότερες
πληροφορίες και λύσεις.

String literals can span multiple lines.  One way is using triple-
quotes: """"..."""" or "'''...'''".  End of lines are automatically
included in the string, but it's possible to prevent this by adding a
"\" at the end of the line.  The following example:

   print("""\
   Usage: thingy [OPTIONS]
        -h                        Display this usage message
        -H hostname               Hostname to connect to
   """)

produces the following output (note that the initial newline is not
included):

   Usage: thingy [OPTIONS]
        -h                        Display this usage message
        -H hostname               Hostname to connect to

Οι συμβολοσειρές μπορούν να συνδεθούν (κολληθούν η μία στην άλλη) με
τον τελεστή "+", και να επαναληφθούν με τον τελεστή "*":

   >>> # 3 times 'un', followed by 'ium'
   >>> 3 * 'un' + 'ium'
   'unununium'

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

   >>> 'Py' 'thon'
   'Python'

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

   >>> text = ('Put several strings within parentheses '
   ...         'to have them joined together.')
   >>> text
   'Put several strings within parentheses to have them joined together.'

Ωστόσο, αυτό λειτουργεί μόνο με κυριολεκτικές συμβολοσειρές, όχι με
μεταβλητές ή εκφράσεις:

   >>> prefix = 'Py'
   >>> prefix 'thon'  # can't concatenate a variable and a string literal
     File "<stdin>", line 1
       prefix 'thon'
              ^^^^^^
   SyntaxError: invalid syntax
   >>> ('un' * 3) 'ium'
     File "<stdin>", line 1
       ('un' * 3) 'ium'
                  ^^^^^
   SyntaxError: invalid syntax

Αν θέλετε να συνδέσετε μεταβλητές ή μία μεταβλητή και μία κυριολεκτική
συμβολοσειρά, χρησιμοποιήστε το "+":

   >>> prefix + 'thon'
   'Python'

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

   >>> word = 'Python'
   >>> word[0]  # character in position 0
   'P'
   >>> word[5]  # character in position 5
   'n'

Οι δείκτες μπορούν να είναι και αρνητικοί αριθμοί, για να ξεκινήσετε
την αρίθμηση από τα δεξιά:

   >>> word[-1]  # last character
   'n'
   >>> word[-2]  # second-last character
   'o'
   >>> word[-6]
   'P'

Σημειώστε ότι αφού το -0 είναι το ίδιο με το 0, οι αρνητικοί δείκτες
ξεκινούν από το -1.

In addition to indexing, *slicing* is also supported.  While indexing
is used to obtain individual characters, *slicing* allows you to
obtain substring:

   >>> word[0:2]  # characters from position 0 (included) to 2 (excluded)
   'Py'
   >>> word[2:5]  # characters from position 2 (included) to 5 (excluded)
   'tho'

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

   >>> word[:2]   # character from the beginning to position 2 (excluded)
   'Py'
   >>> word[4:]   # characters from position 4 (included) to the end
   'on'
   >>> word[-2:]  # characters from the second-last (included) to the end
   'on'

Προσέξτε πώς η αρχή περιλαμβάνεται πάντα, ενώ το τέλος πάντα
εξαιρείται.  Αυτό εξασφαλίζει ότι το "s[:i] + s[i:]" είναι πάντα ίσο
με "s":

   >>> word[:2] + word[2:]
   'Python'
   >>> word[:4] + word[4:]
   'Python'

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

    +---+---+---+---+---+---+
    | P | y | t | h | o | n |
    +---+---+---+---+---+---+
    0   1   2   3   4   5   6
   -6  -5  -4  -3  -2  -1

Η πρώτη σειρά αριθμών δίνει τη θέση των δεικτών 0...6 στην
συμβολοσειρά∙ η δεύτερη σειρά δίνει τους αντίστοιχους αρνητικούς
δείκτες. Ο τεμαχισμός από *i* έως *j* αποτελείται από όλους τους
χαρακτήρες μεταξύ των άκρων με ετικέτες *i* και *j*, αντίστοιχα.

Για μη αρνητικούς δείκτες, το μήκος ενός τεμαχισμού είναι η διαφορά
των δεικτών, εάν και οι δύο είναι εντός των ορίων.  Για παράδειγμα, το
μήκος του "word[1:3]" είναι 2.

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

   >>> word[42]  # the word only has 6 characters
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   IndexError: string index out of range

Ωστόσο, οι δείκτες εκτός εύρους αντιμετωπίζονται χωρίς σφάλμα όταν
χρησιμοποιούνται για τεμαχισμούς:

   >>> word[4:42]
   'on'
   >>> word[42:]
   ''

Οι συμβολοσειρές της Python δεν μπορούν να αλλάξουν --- είναι
*immutable*. Επομένως, η ανάθεση σε μια συγκεκριμένη θέση στη
συμβολοσειρά οδηγεί σε σφάλμα:

   >>> word[0] = 'J'
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: 'str' object does not support item assignment
   >>> word[2:] = 'py'
   Traceback (most recent call last):
     File "<stdin>", line 1, in <module>
   TypeError: 'str' object does not support item assignment

Εάν χρειάζεστε μια διαφορετική συμβολοσειρά, θα πρέπει να
δημιουργήσετε μια νέα:

   >>> 'J' + word[1:]
   'Jython'
   >>> word[:2] + 'py'
   'Pypy'

Η ενσωματωμένη συνάρτηση "len()" επιστρέφει το μήκος μιας
συμβολοσειράς:

   >>> s = 'supercalifragilisticexpialidocious'
   >>> len(s)
   34

Δείτε επίσης:

  Τύπος Ακολουθίας (Sequence) Κειμένου --- str
     Οι συμβολοσειρές είναι παραδείγματα *τύπων ακολουθίας* και
     υποστηρίζουν τις κοινές πράξεις που υποστηρίζονται από τέτοιους
     τύπους.

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

  Formatted string literals
     Κυριολεκτικές συμβολοσειρές που έχουν ενσωματωμένες εκφράσεις.

  Format String Syntax
     Πληροφορίες σχετικά με τη μορφοποίηση συμβολοσειρών με τη μέθοδο
     "str.format()".

  printf-style String Formatting
     Οι παλιές λειτουργίες μορφοποίησης που καλούνται όταν οι
     συμβολοσειρές είναι ο αριστερός τελεστέος του τελεστή "%"
     περιγράφονται λεπτομερέστερα εδώ.


3.1.3. Λίστες
-------------

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

   >>> squares = [1, 4, 9, 16, 25]
   >>> squares
   [1, 4, 9, 16, 25]

Όπως οι συμβολοσειρές (και όλοι οι άλλοι ενσωματωμένοι τύποι
*sequence*), οι λίστες μπορούν να δεικτοδοτηθούν και να τεμαχιστούν:

   >>> squares[0]  # indexing returns the item
   1
   >>> squares[-1]
   25
   >>> squares[-3:]  # slicing returns a new list
   [9, 16, 25]

Όλοι οι τεμαχισμοί επιστρέφουν μια νέα λίστα που περιέχει τα ζητούμενα
στοιχεία.  Αυτό σημαίνει ότι ο ακόλουθος τεμαχισμός επιστρέφει ένα
shallow copy (ρηχό αντίγραφο) της λίστας:

   >>> squares[:]
   [1, 4, 9, 16, 25]

Οι λίστες υποστηρίζουν επίσης λειτουργίες όπως σύνδεση:

   >>> squares + [36, 49, 64, 81, 100]
   [1, 4, 9, 16, 25, 36, 49, 64, 81, 100]

Σε αντίθεση με τις συμβολοσειρές, οι οποίες είναι *immutable*, οι
λίστες είναι *mutable* τύπος, δηλαδή είναι δυνατόν να αλλάξετε το
περιεχόμενό τους:

   >>> cubes = [1, 8, 27, 65, 125]  # something's wrong here
   >>> 4 ** 3  # the cube of 4 is 64, not 65!
   64
   >>> cubes[3] = 64  # replace the wrong value
   >>> cubes
   [1, 8, 27, 64, 125]

You can also add new items at the end of the list, by using the
"append()" *method* (we will see more about methods later):

   >>> cubes.append(216)  # add the cube of 6
   >>> cubes.append(7 ** 3)  # and the cube of 7
   >>> cubes
   [1, 8, 27, 64, 125, 216, 343]

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

   >>> letters = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
   >>> letters
   ['a', 'b', 'c', 'd', 'e', 'f', 'g']
   >>> # replace some values
   >>> letters[2:5] = ['C', 'D', 'E']
   >>> letters
   ['a', 'b', 'C', 'D', 'E', 'f', 'g']
   >>> # now remove them
   >>> letters[2:5] = []
   >>> letters
   ['a', 'b', 'f', 'g']
   >>> # clear the list by replacing all the elements with an empty list
   >>> letters[:] = []
   >>> letters
   []

Η ενσωματωμένη συνάρτηση "len()" εφαρμόζεται επίσης στις λίστες:

   >>> letters = ['a', 'b', 'c', 'd']
   >>> len(letters)
   4

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

   >>> a = ['a', 'b', 'c']
   >>> n = [1, 2, 3]
   >>> x = [a, n]
   >>> x
   [['a', 'b', 'c'], [1, 2, 3]]
   >>> x[0]
   ['a', 'b', 'c']
   >>> x[0][1]
   'b'


3.2. Πρώτα Βήματα Προς Τον Προγραμματισμό
=========================================

Of course, we can use Python for more complicated tasks than adding
two and two together.  For instance, we can write an initial sub-
sequence of the Fibonacci series as follows:

   >>> # Fibonacci series:
   ... # the sum of two elements defines the next
   ... a, b = 0, 1
   >>> while a < 10:
   ...     print(a)
   ...     a, b = b, a+b
   ...
   0
   1
   1
   2
   3
   5
   8

Αυτό το παράδειγμα εισάγει διάφορα νέα χαρακτηριστικά.

* Η πρώτη γραμμή περιέχει μια *πολλαπλή ανάθεση*: οι μεταβλητές "a"
  και "b" παίρνουν ταυτόχρονα τις νέες τιμές 0 και 1. Στην τελευταία
  γραμμή αυτό χρησιμοποιείται ξανά, αποδεικνύοντας ότι οι εκφράσεις
  στη δεξιά πλευρά αξιολογούνται όλες πρώτα πριν γίνει οποιαδήποτε
  ανάθεση.  Οι εκφράσεις στην δεξιά πλευρά αξιολογούνται  από αριστερά
  προς τα δεξιά.

* Ο βρόχος "while" εκτελείται όσο η συνθήκη (εδώ: "a < 10") παραμένει
  αληθής.  Στην Python, όπως και στη C, οποιαδήποτε μη μηδενική
  ακέραια τιμή είναι αληθής, το μηδέν είναι ψευδές.  Η συνθήκη μπορεί
  επίσης να είναι μια συμβολοσειρά ή μια λίστα, στην πραγματικότητα
  οποιαδήποτε ακολουθία∙ οτιδήποτε με μη μηδενικό μήκος είναι αληθές,
  κενές ακολουθίες είναι ψευδείς.  Το τεστ που χρησιμοποιείται στο
  παράδειγμα είναι μια απλή σύγκριση.  Οι τυπικοί τελεστές σύγκρισης
  γράφονται όπως στη C: "<" (μικρότερο από), ">" (μεγαλύτερο από),
  "==" (ίσο με), "<=" (μικρότερο ή ίσο με), ">=" (μεγαλύτερο ή ίσο με)
  και "!=" (μη ίσο με).

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

* The "print()" function writes the value of the argument(s) it is
  given. It differs from just writing the expression you want to write
  (as we did earlier in the calculator examples) in the way it handles
  multiple arguments, floating point quantities, and strings.  Strings
  are printed without quotes, and a space is inserted between items,
  so you can format things nicely, like this:

     >>> i = 256*256
     >>> print('The value of i is', i)
     The value of i is 65536

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

     >>> a, b = 0, 1
     >>> while a < 1000:
     ...     print(a, end=',')
     ...     a, b = b, a+b
     ...
     0,1,1,2,3,5,8,13,21,34,55,89,144,233,377,610,987,

-[ Υποσημειώσεις ]-

[1] Δεδομένου ότι το "**" έχει μεγαλύτερη προτεραιότητα από το "-", το
    "-3**2" θα ερμηνευτεί ως "-(3**2)" και έτσι θα προκύψει "-9".  Για
    να το αποφύγετε αυτό και να πάρετε "9", μπορείτε να
    χρησιμοποιήσετε "(-3)**2".

[2] Σε αντίθεση με άλλες γλώσσες, οι ειδικοί χαρακτήρες όπως το "\n"
    έχουν την ίδια σημασία τόσο με απλά ("'...'") όσο και με διπλά
    (""..."") εισαγωγικά. Η μόνη διαφορά μεταξύ των δύο είναι ότι μέσα
    σε απλά εισαγωγικά δεν χρειάζεται να αποφύγετε το """ (αλλά πρέπει
    να αποφύγετε το "\'") και το αντίστροφο.
