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. Αριθμοί
--------------

Ο διερμηνέας λειτουργεί ως μία απλή αριθμομηχανή: μπορείτε να
πληκτρολογήσετε μία έκφραση μέσα σε αυτή και εκείνη θα γράψει την
τιμή.  Το συντακτικό μίας έκφρασης είναι απλό: οι τελεστές "+", "-",
"*" και "/" μπορούν να χρησιμοποιηθούν για την εκτέλεση αριθμητικών
πράξεων∙ οι παρενθέσεις ("()") μπορούν να χρησιμοποιηθούν για
ομαδοποίηση. Για παράδειγμα:

   >>> 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. Κείμενο
--------------

Η Python μπορεί να χειριστεί κείμενο (που αντιπροσωπεύεται από τον
τύπο "str", τις λεγόμενες «συμβολοσειρές») καθώς και αριθμούς.  Αυτό
περιλαμβάνει χαρακτήρες «"!"», λέξεις «"κουνέλι"», ονόματα «"Παρίσι"»,
προτάσεις «"Καλύπτω τα νώτα σου."», κ.λπ. «"Ναι! :)"». Μπορούν να
περικλείονται σε μονά εισαγωγικά ("'...'") ή διπλά εισαγωγικά
(""..."") με το ίδιο αποτέλεσμα [2].

   >>> 'spam eggs'  # single quotes
   'spam eggs'
   >>> "Paris rabbit got your back :)! Yay!"  # double quotes
   'Paris rabbit got your back :)! Yay!'
   >>> '1975'  # digits and numerals enclosed in quotes are also strings
   '1975'

Για να προσθέσουμε ένα εισαγωγικό, πρέπει να το «κάνουμε escape»,
προτάσσοντάς του μία "\". Εναλλακτικά, μπορούμε να χρησιμοποιήσουμε
τον άλλο τύπο εισαγωγικών:

   >>> '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.'

Στο shell της Python, ο ορισμός συμβολοσειράς και η συμβολοσειρά
εξόδου μπορεί να μοιάζουν διαφορετικά.  Η συνάρτηση "print()" παράγει
μια πιο ευανάγνωστη έξοδο, παραλείποντας τα εισαγωγικά που περικλείουν
την συμβολοσειρά και εκτυπώνοντας escaped και ειδικούς χαρακτήρες:

   >>> s = 'First line.\nSecond line.'  # \n means newline
   >>> s  # without print(), special characters are included in the string
   'First line.\nSecond line.'
   >>> print(s)  # with print(), special characters are interpreted, so \n produces 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

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

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

   >>> print("""\
   ... Usage: thingy [OPTIONS]
   ...      -h                        Display this usage message
   ...      -H hostname               Hostname to connect to
   ... """)
   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.

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

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

  f-strings
     Κυριολεκτικές συμβολοσειρές που έχουν ενσωματωμένες εκφράσεις.

  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]

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

   >>> 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]

Μπορείτε επίσης να προσθέσετε νέα στοιχεία στο τέλος της λίστας,
χρησιμοποιώντας "list.append()" *μέθοδο* (θα δούμε περισσότερα για τις
μεθόδους αργότερα):

   >>> 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]

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

   >>> rgb = ["Red", "Green", "Blue"]
   >>> rgba = rgb
   >>> id(rgb) == id(rgba)  # they reference the same object
   True
   >>> rgba.append("Alph")
   >>> rgb
   ["Red", "Green", "Blue", "Alph"]

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

   >>> correct_rgba = rgba[:]
   >>> correct_rgba[-1] = "Alpha"
   >>> correct_rgba
   ["Red", "Green", "Blue", "Alpha"]
   >>> rgba
   ["Red", "Green", "Blue", "Alph"]

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

   >>> 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. Πρώτα Βήματα Προς Τον Προγραμματισμό
=========================================

Φυσικά, μπορούμε να χρησιμοποιήσουμε την Python για πιο περίπλοκες
εργασίες από την πρόσθεση δύο και δύο μαζί.  Για παράδειγμα, μπορούμε
να γράψουμε μια αρχική υπο-σειρά της Σειράς Fibonacci ως ακολουθεί:

   >>> # 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 με
  έναν επεξεργαστή κειμένου∙ όλοι οι αξιοπρεπείς επεξεργαστές κειμένου
  διαθέτουν την δυνατότητα αυτόματης εσοχής.  Όταν εισάγεται μια
  σύνθετη εντολή διαδραστικά, πρέπει να ακολουθείται από μια κενή
  γραμμή για να υποδηλώνει την ολοκλήρωση (αφού ο συντακτικός αναλυτής
  δεν μπορεί να μαντέψει πότε πληκτρολογήσατε την τελευταία γραμμή).
  Σημείωση ότι κάθε γραμμή μέσα σε ένα βασικό μπλοκ πρέπει να έχει την
  ίδια εσοχή.

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

     >>> 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"
    έχουν την ίδια σημασία τόσο με απλά ("'...'") όσο και με διπλά
    (""..."") εισαγωγικά. Η μόνη διαφορά μεταξύ των δύο είναι ότι μέσα
    σε απλά εισαγωγικά δεν χρειάζεται να αποφύγετε το """ (αλλά πρέπει
    να αποφύγετε το "\'") και το αντίστροφο.
