Μάθημα : Προγραμματισμός Υπολογιστών Γ' ετος 2025-2026

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

συνάρτησης κ.λπ. Τα αναγνωριστικά - ονόματα μπορεί να αποτελούνται από γράμματα του λατινικού αλφαβήτου (A - Z, a - z), τον χαρακτήρα _ (underline) και τα ψηφία (0 έως 9), αρκεί ο πρώτος χαρακτήρας να μην είναι ψηφίο. Π.χ. Έγκυρα ονόματα-αναγνωριστικά είναι: first_name, code1, x, a1, _a, price_sold.

Δεσμευμένες λέξεις: είναι οι λέξεις που χρησιμοποιεί η Python για εντολές.

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

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

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

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

Η Python χρησιμοποιεί τους παρακάτω αριθμητικούς τελεστές:

+ (πρόσθεση)

* ( αφαίρεση)

/ (διαίρεση)

** (δύναμη, πχ. 2 3-2**3)

% (το υπόλοιπο ακέραιας διαίρεσης)

Τύποι δεδομένων: Η Python υποστηρίζει τους παρακάτω τύπους δεδομένων

Ακέραιοι: είναι οι γνωστοί ακέραιοι αριθμοί από τα μαθηματικά. Π.χ. ο αριθμός 3, 198,-4, κ.λπ.

Κινητής υποδιαστολής: είναι οι πραγματικοί αριθμοί. Π.χ. 3.14 και 28.2Ε-5, όπου το Ε δηλώνει δύναμη του 10, δηλαδή ο αριθμός 28.2Ε-5 σημαίνει 28.2*10-5.

Λογικές: είναι ο τύπος που μπορεί να πάρει μόνο δύο τιμές True (Αληθής) ή False (Ψευδής).

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

1.2. Δομή ακολουθίας

Θα περιγράψουμε τις τρεις βασικές εντολές της Python για να δώσουμε τα πρώτα απλά παραδείγματα σε δομή ακολουθίας.

1.2.1. Εντολή εκχώρησης ή καταχώρησης τιμής

Γενική μορφή: <όνομα μεταβλητής ή μεταβλητών> = τιμή ή τιμές σε πλήρη αντιστοιχία.

Λειτουργία: Καταχωρείται η τιμή του δεξιού μέλους στη μνήμη στη μεταβλητή με το όνομα - αναγνωριστικό που έχουμε ορίσει στο αριστερό μέλος.

Π.χ. x=1 #καταχωρείται στη μεταβλητή x η τιμή 1

x=x+15 # αυξάνεται η τιμή της μεταβλητής x κατά 15

οnoma='Άννα’ #καταχωρείται στη μεταβλητή onoma η τιμή Άννα

m1=m2=m3=23 # στις μεταβλητές m1, m2, m3 καταχωρείται η ίδια τιμή 23

x,y=10,18 #στη μεταβλητή x εκχωρείται η τιμή 10 και στη y η τιμή 18

x,y,z=3,7,'Μαρία' #στη μεταβλητή χ εκχωρείται η τιμή 3, στη y η τιμή 7 και στη ζ η τιμή Μαρία.

1.2.2. Εκχώρηση τιμής σε μια μεταβλητή από το πληκτρολόγιο

Γενική μορφή: όνομα μεταβλητής=input( "κείμενο προς εμφάνιση ")

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

μέσα στην παρένθεση της ενσωματωμένης συνάρτησης (στις συναρτήσεις θα αναφερθούμε σε επόμενη παράγραφο) input. Στη συνέχεια, ο υπολογιστής περιμένει να πληκτρολογήσουμε μια τιμή.

Όταν πατήσουμε το Enter, η τιμή που πληκτρολογήσαμε καταχωρείται στη μεταβλητή.

1.2.3. Εμφάνιση τιμής

Γενική μορφή: print κείμενο ή όνομα μεταβλητής

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

Παράδειγμα 1-1. Θέλουμε να κατεβάσουμε στο κινητό μας τηλέφωνο μια εφαρμογή. Η ταχύτητα σύνδεσής μας στο διαδίκτυο είναι 1,6 ΜΒ/δευτερόλεπτο. Γράψτε σε γλώσσα Python πρόγραμμα, που δέχεται ως είσοδο το μέγεθος της εφαρμογής σε ΜΒ και υπολογίζει σε πόσο χρόνο θα κατέβει η εφαρμογή.

1.3.1. Λογικές εκφράσεις

Για την σύνταξη της συνθήκης που χρησιμοποιεί η εντολή της δομής επιλογής if, χρειάζεται να συνταχθεί μια λογική έκφραση, η οποία θα δίνει σαν αποτέλεσμα την τιμή Αληθής ή Ψευδής. Για την σύνταξη μιας λογικής έκφρασης χρησιμοποιούνται οι συγκριτικοί τελεστές:

> Μεγαλύτερο

>= Μεγαλύτερο ή ίσο

< Μικρότερο

<= Μικρότερο ή ίσο

!= Διάφορο

== Ισότητα

Τελεστές λογικών πράξεων: not, or, and, με τις ακόλουθες λογικές λειτουργίες

Π.χ.

1. a>=10 2. b!=0 3. (a<10) and (b<0)

Στην μεταβλητή timi να δώσετε την τιμή ενός εμπορεύματος. Να συντάξετε τις εκφράσεις Python ώστε:

1. Να υπολογίσετε έκπτωση 10%

2. Να υπολογίσετε την τιμή πώλησης εάν γίνει έκπτωση 20%

3. Να γίνει αύξηση της τιμής κατά 25%

4. Να εμφανίζεται την λιανική τιμή υπολογίζοντας ΦΠΑ 13%

5. Να εμφανίζεται την λιανική τιμή υπολογίζοντας ΦΠΑ 13% και

    κατόπιν να υπολογίζεται έκπτωση 15%

   Απάντηση:

   Ποσοστό (αύξηση τιμής)

   Στην περίπτωση που θέλουμε να υπολογίσουμε σε μία τιμή κέρδος, Φ.Π.Α, φόρο κτλ και προκαλείται αύξηση της τιμής.

   Τύπος με δύο εντολές: ΚέρδοςΦόροςΦΠΑ = Τιμή * Ποσοστό / 100.0 και ΝέαΤιμή = Τιμή + ΚέρδοςΦόροςΦΠΑ

   Είτε το ίδιο με μία εντολή: ΝέαΤιμή = Τιμή + Τιμή * Ποσοστό / 100.0

   Είτε το ίδιο με μία εντολή: ΝέαΤιμή = Τιμή * 1.Ποσοστό

   Παράδειγμα

   Υπολογισμός ΦΠΑ 24% στην τιμή ενός αγαθού

   timi=input("τιμή αγαθού> ")
   fpa=timi*24.0/100
   neaTimi=timi + fpa # Είτε neaTimi= timi + timi*24.0/100 Είτε neaTimi = timi * 1.24
   print 'Τιμή αγαθού με ΦΠΑ 24%:', neaTimi

   Ποσοστό (μείωση τιμής)

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

   Τύπος με δύο εντολές: Έκπτωση = Τιμή * Ποσοστό / 100.0 και ΝέαΤιμή = Τιμή - Έκπτωση

   Είτε το ίδιο με μία εντολή: ΝέαΤιμή = Τιμή - Τιμή * Ποσοστό / 100.0 

   Είτε το ίδιο με μία εντολή: ΝέαΤιμή = Τιμή * 1.Ποσοστό

   Παράδειγμα

   Yπολογισμός έκπτωσης 10% στην τιμή ενός αγαθού
   timi=input("αξία αγαθού> ")
   ekptosi=timi*10/100.0
   neaTimi=timi - ekptosi # Είτε neaTimi= timi - timi*10/100.0 Είτε neaTimi = timi * 1.10
   print 'Τιμή αγαθού με με έκπτωση 10%:', neaTimi

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

● Η float() μετατρέπει ακεραίους και συμβολοσειρές σε δεκαδικούς αριθμούς.
● Η int() δέχεται οποιαδήποτε αριθμητική τιμή και τη μετατρέπει σε ακέραιο  κόβοντας       τα δεκαδικά ψηφία, αν υπάρχουν.
● H str() δέχεται οποιαδήποτε τιμή και την μετατρέπει σε συμβολοσειρά.
● Η abs() επιστρέφει την απόλυτη τιμή ενός αριθμού.
● Η pow(a,b) επιστρέφει τη δύναμη του α υψωμένη στο β.
● H divmod(x,y) επιστρέφει το ακέραιο πηλίκο και το ακέραιο υπόλοιπο της
διαίρεσης x/y

>>> float(10)
10.0
>>> int(5.678)
5
>>> str(5.678)
5.678
>>> abs(-45)
45
>>> divmod(10,3)
(3, 1)
>>> pow(2,3)
8

Αν θέλουμε να διαβάσουμε από το πληκτρολόγιο έναν ακέραιο αριθμό με τη συνάρτηση input(), πρέπει να χρησιμοποιούμε και τη συνάρτηση int()
a=int(input(‘Δώσε έναν αριθμό :’)

Εκτός από τις ενσωματωμένες συναρτήσεις οι οποίες περιλαμβάνονται στη γλώσσα Python, υπάρχουν και οι εξωτερικές Βιβλιοθήκες .Μια βιβλιοθήκη είναι ένα αρχείο το οποίο περιέχει μια συλλογή από σχετικές συναρτήσεις. Για παράδειγμα, προκειμένου να χρησιμοποιήσουμε μαθηματικές συναρτήσεις σε ένα πρόγραμμα, θα πρέπει μία από τις αρχικές εντολές του προγράμματός μας να είναι: import math

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

>>> import math
>>> riza = math.sqrt(2)
>>> print riza
1.41421356237

H δομή επιλογής if (AN) χρησιμοποιείται, όταν θέλουμε να εκτελεστεί μια ακολουθία εντολών, μόνον, εφόσον πληρείται μία συγκεκριμένη συνθήκη.

Αν η συνθήκη είναι αληθής, τότε το σύνολο των εντολών που περιέχονται στην δομή if, θα εκτελεστούν. Αλλιώς, η ροή του προγράμματος θα προσπεράσει τη δομή if και θα συνεχίσει από την εντολή που βρίσκεται αμέσως μετά το τέλος της if.
if <συνθήκη ελέγχου>:
# εντολές που θα εκτελεσθούν αν ισχύει (αληθής-True) η συνθήκη ελέγχου

1. Να ζητείται αριθμός και να εμφανίζεται η απόλυτός τιμή του

a=input('arithmos> ')
if a>=0:
   print a
if a<0:
   print -a

2. Να ζητείται αριθμός και να εμφανίζεται το μήνυμα θετικός / αρνητικός / μηδέν

a=input('arithmos> ')
if a>=0:
   print 'Θετικός'
if a<0:
   print 'Αρνητικός'
if a==0:
   print 'Μηδέν'

Σύνθετη δομή επιλογής
Αν, ανάλογα με την αποτίμηση μιας συνθήκης, θέλουμε να εκτελεστούν διαφορετικές ακολουθίες εντολών, τότε μπορούμε να χρησιμοποιήσουμε τη δομή
επιλογής if…else (AN…ΑΛΛΙΩΣ).
Αν ισχύει η συνθήκη (έχει τιμή TRUE), θα εκτελεστεί η Α ομάδα εντολών της if,
αλλιώς (αν δεν ισχύει-έχει τιμή FALSE), θα εκτελεστεί η Β ομάδα εντολών της else.
Η εντολή ελέγχου if …. else συντάσσεται:
if <συνθήκη ελέγχου>:
#εντολές που θα εκτελεσθούν, αν η συνθήκη ελέγχου είναι αληθής
else:
#εντολές που θα εκτελεσθούν αν η συνθήκη ελέγχου είναι ψευδής

3. Η ασκ. 1 με χρήση if / else

a=input('arithmos> ')
if a>=0:
   print a
else:
   print -a

Πολλαπλή Επιλογή: Η Python προσφέρει τη δυνατότητα για σύνταξη σύνθετων δομών επιλογής με τη χρήση της εντολής elif.
Η σύνταξη είναι η εξής:
if <συνθήκη>:
<εντολές>
elif <συνθήκη2>:
<εντολές_2>
else:
<εντολές_3>

4  Η ασκ.2 με χρήση if / elif / else

a=input('arithmos> ')
if a>=0:
   print 'Θετικός'
elif a<0:
   print 'Αρνητικός'
else:
   print 'Μηδέν'

Εμφωλευμένες δομές επιλογής: Οι πολλαπλές επιλογές μπορούν να υλοποιηθούν και με εμφωλευμένες δομές Αν-αλλιώς, όπως στη ασκηση 5 :

Συχνά σε ένα πρόγραμμα, μια ομάδα εντολών είναι αναγκαίο να εκτελείται περισσότερες από μία φορές. Υπάρχουν δύο τύποι επαναλήψεων:
● Οι προκαθορισμένοι, όπου το πλήθος των επαναλήψεων είναι δεδομένο, πριν αρχίσουν οι επαναλήψεις. Για παράδειγμα: ο υπολογισμός του μέσου όρου βαθμολογίας των μαθητών ενός τμήματος 22 μαθητών.
● Οι μη προκαθορισμένοι, όπου το πλήθος των επαναλήψεων καθορίζεται κατά τη διάρκεια της εκτέλεσης των εντολών του σώματος της επανάληψης. Για παράδειγμα: ο υπολογισμός των μορίων όσων υποβάλλουν αίτηση σε ένα διαγωνισμό του Δημοσίου.
Στη γλώσσα προγραμματισμού Python, χρησιμοποιούμε την εντολή for για να εκτελεστεί ένα τμήμα του κώδικα για έναν καθορισμένο αριθμό επαναλήψεων, ενώ την εντολή while για να εκτελείται υπό συνθήκη και μάλιστα, όσο αυτή είναι αληθής.
Στην εντολή for χρησιμοποιείται η συνάρτηση range() για τον καθορισμό των επαναλήψεων

for onoma_metavlitis in range (αρχή, μέχρι, βήμα):
   Εντολή_1
   Εντολή_2 
   …..
   Εντολή_ν

Σύνταξη συνάρτησης range: range([αρχή],τέλος,[βήμα])

Η range φτιάχνει λίστες ακεραίων αριθμών

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

range(5) είτε range(0,5) είτε range(0,5,1) Φτιάχνουν την λίστα: [0,1,2,3,4]

range(2,8) είτε (2,8,1) Φτιάχνουν την λίστα: [2,3,4,5,6,7]

range(5,0,-1) Φτιάχνουν την λίστα: [5,4,3,2,1]

range (4,8,2) Φτιάχνει την λίστα: [4,6]

range(2,17,5) Φτιάχνειτην λίστα: [2,7,12]

range (3,-3,-1) Φτιάχνει την λίστα: [3,2,1,0,-1,-2]

range (3,-3,-2) Φτιάχνει την λίστα: [3,1,-1]

range(10,2) είτε range(2,10,-1) Φτιάχνουν την λίστα: [] (κενή λίστα)

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

for x in [4,2.5,'Maria',True]:
   print x,

Εμφανίζει: 4 2.5 Maria True

L=[40,20.5,'Maria',True]:
for x in L:
   print x,

Εμφανίζει: 40 20.5 Maria True

for x in range(4):
   print x,

Εμφανίζει: 0 1 2 3

Άθροιση στοιχείων αριθμητικής λίστας με την εντολή for:

Εάν L μία λίστα με αριθμούς (ακέραιους ή δεκαδικούς) τότε οι εντολές εμφανίζουν το άθροισμα των στοιχείων της.

s=0 # Εδώ θα αθροισθούν τα στοιχεία της λίστας L
for a in L:
   s+=a
print s

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

L=[3,-4,10,5.5,-0.5]
s=0 # Εδώ θα αθροισθούν τα στοιχεία της λίστας L
for a in L:
   s+=a
print s

Εμφανίζει: 14.0

s=0 # Εδώ θα αθροισθούν τα στοιχεία της λίστας range(6): [0, 1, 2, 3, 4, 5]
for a in range(6):
   s+=a
print s

Εμφανίζει: 15 (To άθροισμα:0+1+2+3+4+5)

Άθροιση αριθμών που δίνονται από το πληκτρολόγιο (γνωστο το πλήθος των αριθμών).

plithos = input("πόσους αιθμούς θα αθροίσω; ")
s=0 # Εδώ θα αθροισθούν οι αριθμοί
for a in range(plithos):
   a = input('αριθμός> ')
   s+=a
print s

Παράδειγμα

Να γραφεί πρόγραμμα σε γλώσσα Python που να υπολογίζει το άθροισμα των περιττών αριθμών από το 1 έως και το 100.

# Πρόγραμμα, αθροίζω περιττούς
athroisma = 0
for i in range(1,100,2):
        athroisma = athroisma + i
print ' To αποτέλεσμα είναι ', athroisma

Εύρεση μεγίστου και μέσου όρου με την εντολή for (όταν γνωρίζω το πλήθος των τιμών):

Να βρεθεί η μέγιστη θερμοκρασία της τελευταίας εβδομάδας (Οι τιμές μεγ. θερμοκρασίας κάθε ημέρας δίνονται από το πληκτρολόγιο)

A' Λύση (Πάντα αποτελεσματική)

megisti=input("Θερμοκρασία> ")
for i in range(6):
   t=input("Θερμοκρασία> ")
      if t > megisti:
          megisti = t
print 'Μεγαλύτερη θερμ.',megisti

Β' Λύση (Όταν γνωρίζουμε το κατώτερο όριο δυνατών τιμών)

megisti=-273.15 # Απόλυτο μηδέν, η ελάχιστη δυνατή θερμοκρασία στην φύση
for i in range(7):
   t=input("Θερμοκρασία> ")
      if t > megisti:
         megisti = t
print 'Μεγαλύτερη θερμ.',megisti

Να βρεθεί ο μικρότερος βαθμός ενός τμήματος 10 μαθητών. (Ο βαθμός κάθε μαθητή δίδεται από το πληκτρολόγιο)

A' Λύση (Πάντα αποτελεσματική)

mikroteros=input("Βαθμός> ")
for i in range(9):
   v=input("Βαθμός> ")
      if v < mikroteros:
         mikroteros = v
print 'Μικρότερος Βαθμός', mikroteros

Β' Λύση (Όταν γνωρίζουμε το ανώτερο όριο δυνατών τιμών)

mikroteros= 21# Γνωρίζουμε ότι ο μεγαλύτερος βαθμός είναι ο 20
for i in range(10):
   v=input("Βαθμός> ")
      if v < mikroteros:
         mikroteros = v
print 'Μικρότερος Βαθμός', mikroteros

Να βρεθεί η μεγαλύτερη τιμή μιας λίστας.

L = [755,9,980,99, 55,  . . . ]
megisti= L[0]
for st in L:
   if st > megisti:
      megisti = st
print 'Μεγαλύτερη τιμή λίστας',megisti

Να βρεθεί η μικρότερη τιμή μιας λίστας.

L = [755,9,980,99, 55,  . . . ] 
elexisti= L[0]
for st in L:
   if st < elaxisti:
      elaxisti= st
print 'Μικρότερη τιμή λίστας', elaxisti

Ασκηση  με συνάρτηση (randint)

Να γραφεί πρόγραμμα το οποίο διαβάζει 50  τυχαίους  ακεραίους αριθμούς και θα εκτυπώνει τα ποσοστά των μονοψήφιων, διψήφιων  και τριψήφιων αριθμών που  παρήγαγε η μέθοδος  random.radint.

Λύση

import random

pl_mono=0
pl_dipsi=0
pl_tripsi=0

for i in range(50):
    number=random.randint(1,150)
    if number <10:
         pl_mono+=1
   elif number <100:
         pl_dipsi+=1
  else:
         pl_tripsi+=1

pososto_mono=(pl_mono/50.0)*100
pososto_dipsi=(pl_dipsi/50.0)*100
pososto_tripsi=(pl_tripsi/50.0)*100

print "pososto monopsiphion:",pososto_mono, "%"
print "pososto dipsiphion:",pososto_dipsi, "%"
print "pososto tripsiphion:",pososto_tripsi, "%"

Ασκηση με εμφωλευμένο for (διπλό for)

Να γραφτεί πρόγραμμα το οποίο θα διαβάζει έναν ακέραιο αριθμό και θα εκτυπώνει την προπαίδεια εως αυτόν  τον αριθμό.

number=input("Dose enan akeraio:")
for i in range(1,number+1):
       for j in range(1,11):
             print i,"*",j,"=", i*j
             print

Δομή Επανάληψης με while βρόχο

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

Αρχική τιμή μεταβλητής
while ονομα_μεταβλητής <συνθήκη>:
Εντολή_1
Εντολή_2
….
Εντολή_κ
: θα πρέπει μέσα στο μπλοκ εντολών να υπάρχει κατάλληλη εντολή, ώστε να εξασφαλίζεται ότι κάποια στιγμή η συνθήκη θα γίνει ψευδής και θα διακοπεί ο βρόχος. Διαφορετικά ο βρόχος δε θα τερματίζει.
: πριν το βρόχο while θα πρέπει αρχικά να δώσουμε μία τιμή στη μεταβλητή που ελέγχει τη συνθήκη του βρόχου, ώστε ανάλογα να εκτελεστεί ή όχι ο βρόχος

Άθροιση άγνωστου πλήθος αριθμών που δίδονται από το πληκτρολόγιο

s=0 # η μεταβλητή όπου θα γίνεται η άθροιση

a=input('προσθετέος> ')

while a!=-1000: # Για τέλος των αριθμών δίδεται ο -1000

   s+=a # είτε s=s+a

   a=input('προσθαιτέος> ')

print 'Το άθροισμα είναι:', s

Μέτρηση αγνώστου πλήθους λέξεων που δίδονται από το πληκτρολόγιο

m=0 # η μεταβλητή όπου θα γίνεται η μέτρηση

lexi=raw_input('λέξη> ')

while lexi!=’’: # Για τέλος δίδεται κενή λέξη

   m+=1 # είτε m=m+1

   lexi=raw_input('λέξη> ')

print 'Έγραψες’,m,’λέξεις’

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

Εξάσκηση την λογική διαδικασία εύρεσης μέγιστου

a=input('αριθμός> ')

megistos = a # η μεταβλητή όπου φυλάσσεται ο μέγιστος

while a!=-1000: # Για τέλος των αριθμών δίδεται ο -1000

   if a > megistos:#άν βρήκα αριθμό μεγαλύτερο από τον μέγιστο

      megistos = a # αυτός θα είναι ο μέχρι τώρα μέγιστος

   a=input('αριθμός> ')

print 'Ο μέγιστος είναι:', megistos

Μικρότερος από άγνωστο πλήθος αριθμών που δίδονται από το πληκτρολόγιο

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

a=input('αριθμός> ')

elaxistos = a # η μεταβλητή όπου φυλάσσεται ο ελάχιστος

while a!=-1000:# Για τέλος των αριθμών δίδεται ο -1000

   if a < elaxistos: # Παρατηρούμε ότι η μόνη διαφορά με τον μέγιστο είναι η φορά της ανισότητας

      elaxistos = a

   a=input('αριθμός> ')

print 'Ο ελάχιστος είναι:', elaxistos

Να μετρήσετε τα  γράμματα μιας φράσης που δίδεται από το πληκτρολόγιο (δεν μετράτε τα κενά)

frasi=raw_input("γράψε μια φράση")
metritis = 0
for xaraktiras in frasi:
    if xaraktiras != " ":
       metritis += 1
print "τα γράμματα είναι", metritis

Λύση με while (δεν συνιστάται)

frasi=raw_input("γράψε μια φράση")
i = metritis = 0
while i < len(frasi):
    if frasi[i] != " ":
       metritis += 1
    i += 1
print "τα γράμματα είναι", metritis

Να μετρήσετε τα  γράμματα μιας φράσης που δίδεται από το πληκτρολόγιο (δεν μετράτε τα κενά κόμματα και τελείες)

frasi=raw_input("γράψε μια φράση")
metritis = 0
for xaraktiras in frasi:
    if not (xaraktiras == " " or xaraktiras == "," or xaraktiras == "."): # xaraktiras not in " ,."
       metritis += 1
print "τα γράμματα είναι", metritis

Να μετρήσετε τα μικρά γράμματα μιας φράσης που δίδεται από το πληκτρολόγιο (μετράτε ΜΟΝΟ τα μικρά γράμματα)

frasi=raw_input("γράψε μια φράση")
metritis = 0
for xaraktiras in frasi:
    if xaraktiras  in "qwertyuioplkjhgfdsazxcvnm"
       metritis += 1
print "τα γράμματα είναι", metritis

Μετρητής μικρών γραμμάτων κειμένου (πολλών γραμμών, κενή γραμμή: τέλος κειμένου)

print 'Γράψε κείμενο'
grammi=raw_input("> ")
metritis = 0
while grammi != "":
   for xaraktiras in grammi:
      if xaraktiras in "qwertyuioplkjhgfdsazxcvbnm":
         metritis += 1
   grammi=raw_input("> ")
print "τα μικρά γράμματα είναι", metritis

Άθροιση - μέτρηση τιμών. Το πρόβλημα του ανελκυστήρα.

Εμφάνιση αποτρεπτικού μηνύματος εάν με τον τελευτάιος που εισέρχεται έχουμε υπέρβαση του βάρους ανύψωσης

varos=input('Varos ? ')
megisto=300
m=0
while megisto - varos >=0:
   m +=1
   megisto -= varos
   print 'OK mesa einai'
   varos=input('Varos ? ')
print 'Ypervaros o ',m+1,'os'

Σύγκριση αλφαριθμητικών. Λαχειοφόρος

Να γίνει προγραμμα σε python ετσι ωστε να δημιουργήται ενα τυχαίο 5ψήφιο αλφαριθμητικό ως κλήρωση και να εισαγεται εσεις ενα 5ψήφιο αλφαριθμητικο Για κάθε ταύτιση ψηφίου του λαχείου  με τον αριθμό της κλήρωσης κερδίζετε αντίστοιχα 10 / 100 / 1000 / 10000 / 100000 €. Να υπολογίσετε  το συνολικό  κέρδος και να το εμφανίσετε .

import random
klirwsi=str(random.randint(10000,99999)) 
laxeio=str(input('Laxeio> ')) # είτε laxeio=raw_input('Laxeio> ')
kerdos=1
for i in range(5):
   if klirwsi[i]==laxeio[i]:
      kerdos*=10
print 'Kerdises',kerdos,'Euro'

Μέσος όρος

Να υπολογισθεί ο μέσος όρος του ελέγχου ενός μαθητή. Αποδεκτοί οι βαθμοί [1, 2, ..., 20]. Τέλος των βαθμών ο -1

m=s=0
v=input('Bathmos elegxou> ')
while v!=-1:
   while v < 1 or 20 < v:
      v=input('Swsto bthmo elegxou> ')
   s += v # Άθροιση βαθμών
   m += 1 # Μέτρηση βαθμών
   v=input('Bathmos elegxou> ')
mo = 1.0*s/m
print 'M.O. elegxoy', mo

Διαδοχικές ίδιες τιμές

Ρίχνω το ζάρι μέχρι να φέρω δυο διαδοχικές ίδιες ζαριές

import random
m = 0
pz=-1 # Το προηγούμενο ζάρι
z=random.randint(1,6)
while z!=pz:
   print 'eferes',z
   m += 1 # Μέτρηση ζαριών
   raw_input('Pata Enter gia na rixeis xana') #Λειτουργεί σαν φρένο, δεν χρειάζεται να φυλάξω την τιμή
   pz = z
   z=random.randint(1,6)
print 'eferes',z
print 'Erixes',m,'zaries gia na fereis 2 diadoxika idies'

Μετατροπή For  σε While

for i in range (1, 10, 3) :                             i=1

   x = input ("Δώστε έναν αριθμό")          while i<10:

   if x == 0 :                                                      if x == 0 :  

      print "Ίσος με το μηδέν"                             print "Ίσος με το μηδέν"

   elif x < 0 :                                                    elif x < 0 : 

      print "Αρνητικός"                                         print "Αρνητικός"

   else::                                                            else: 

     print "Θετικός"                                               print "Θετικός"

                                                                         i+=3

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

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

Παράδειγμα

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

def name(first,surname):      # (α) επιστρέφει string
    s = first + ' ' + surname
    return s

result = name('kitsos','Tzavelas') # κλήση συνάρτησης
print(result)

def name0(first,surname):      # (β) δεν επιστρέφει κάτι
    s = first + ' ' + surname
    print(s)

name('Kitsos','Tzavelas')      # κλήση συνάρτησης

 Μπορεί να επιστρέφει στο κύριο πρόγραμμα μία περισσότερες τιμές.

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

• Ορισμός
def όνομα_συνάρτησης():
... εντολές .....
• Κλήση
όνομα_συνάρτησης()

Παράμετροι σε συνάρτηση
• Μία συνάρτηση μπορεί να δεχθεί παραμέτρους (formal parameters ή απλά parameters), οι οποίες αποτελούν τιμές στη συνάρτηση ως είσοδος
• Ορίζονται κατά την κλήση της συνάρτησης και ονομάζονται ορίσματα 
Ορισμός
def examble(a,b):
... εντολές .....
Κλήση
examble(1,3)

Εμβέλεια
• Η εμβέλεια μιας μεταβλητής ή μιας συνάρτησης αφορά στην περιοχή τουπρογράμματος στην οποία μπορεί να προσπελαστεί ή με άλλα λόγια να είναι ορατή
• Όταν δημιουργούμε μία μεταβλητή μέσα σε μία συνάρτηση, αυτή ονομάζεται τοπική μεταβλητή (local variable) και «υπάρχει» μόνο μέσα στη συνάρτηση, δεν μπορούμε να τη χρησιμοποιήσουμε έξω από αυτή
• Οι τοπικές μεταβλητές «ζουν» όσο διαρκεί η εκτέλεση της συνάρτησης στην οποία έχουν οριστεί, και καταστρέφονται, όταν ολοκληρωθεί η εκτέλεση της συνάρτησης
• Κάθε νέα κλήση μιας συνάρτησης δημιουργεί νέες τοπικές μεταβλητές

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

• Πέρασμα μέσω αναφοράς (pass by reference)

Όταν οι παράμετροι περνάνε με αναφορά, σημαίνει ότι αν αλλάξουμε μια παράμετρο μέσα στη συνάρτηση, η αλλαγή είναι μόνιμη και μετά την κλήση της συνάρτησης. Για παράδειγμα:

def a1(lista):
    lista.append(2)
    print'times mesa stin synartisi ' ,lista
    return
lista1=[1,3,5,6]
a1(lista1)
print 'times exo apo thn synartisi ',lista1

Αποτελεσμα 

times mesa stin synartisi [1, 3, 5, 6, 2]
times exo apo thn synartisi [1, 3, 5, 6, 2]

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

Πέρασμα παραμέτρου με τιμή.

Τι θα τυπώσoυν  τα παρακάτω προγράμματα και γιατί;

def a1(x):                                                def a2(x,y)

    print x                                                       s=x+y

    x=x+1                                                        return s

    print x                                                  print a2(7,5)

a=3                                                           print s

print a

print a1(a)

print a

Αποτέλεσμα                                           Αποτελεσμα

3                                                                12

3                                                                error  s is not define

4

3

( Πέρασμα παραμέτρου με τιμή).

Χρήση της εντολής global

Πώς δουλεύει:

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

Μπορείτε να καθορίσετε περισσότερες από μία καθολικές μεταβλητές χρησιμοποιώντας την ίδια εντολή global. Για παράδειγμα global x, y, z.

x = 50
def func():

    global x
    print'to x einai ', x
    x = 2
    print'allaxa to katholiko x se ', x
func()
print'h timi toy x einai', x

Εξοδος

to x einai 50
allaxa to katholiko x se 2
h timi toy x einai 2

Τα αλφαριθμητικά ή συμβολοσειρές στην Python είναι ακολουθίες από χαρακτήρες που έχουν σταθερό μέγεθος και μη μεταβαλλόμενα περιεχόμενα. Δηλαδή, δεν μπορούμε να προσθέσουμε ή να αφαιρέσουμε χαρακτήρες, ούτε να τροποποιήσουμε τα περιεχόμενα του αλφαριθμητικού. Γι' αυτό λέμε ότι η δομή αυτή ανήκει στις μη μεταβαλλόμενες (immutable) δομές της Python. Η αρίθμηση των χαρακτήρων σε ένα αλφαριθμητικό ξεκινάει από το 0.

Για παράδειγμα: αν word = “PYTHON”, η αναπαράσταση του αλφαριθμητικού μοιάζει με το παρακάτω σχήμα:
                                           0   1   2    3    4    5
                                          ‘P’  ‘Y’  ‘T’  ‘H’  ‘O’  ‘N

● η συνάρτηση len επιστρέφει το μήκος, δηλαδή το πλήθος των χαρακτήρων του αλφαριθμητικού
● ο τελεστής + όταν εφαρμόζεται σε αντικείμενα τύπου string, έχει σαν αποτέλεσμα τη συνένωσή τους σε μια συμβολοσειρά
● η συνάρτηση str μετατρέπει μια τιμή σε συμβολοσειρά
● με τη συνάρτηση int μπορούμε να μετατρέψουμε ένα αλφαριθμητικό στον ακέραιο αριθμό που αναπαριστά.

Ένας σημαντικός τελεστής που θα συναντήσουμε και αργότερα στις λίστες, είναι ο υπαρξιακός τελεστής in, ο οποίος ελέγχει, αν ένα αντικείμενο ανήκει σε ένα σύνολο αντικειμένων. Δεδομένου ότι οι συμβολοσειρές μπορούν να θεωρηθούν ως σύνολα χαρακτήρων, μπορούμε να τον χρησιμοποιήσουμε όπως φαίνεται παρακάτω.
>>> “Py” in “Python

True

Παραδείγματα για μελέτη

Με κίτρινο εμφανίζεται το αποτέλεσμα της ετολής στην οθόνη. Για βοήθεια εμφανίζεται η lexi με την αρίθμηση τωνθέσεων των γραμμάτων από κάτω:

a program
012345678

lexi='a program'
print len(lexi) 9
print lexi[2] p
print lexi[2]+lexi[5] pg
print lexi[len(lexi)-1] m
print lexi[8]+lexi[7]+lexi[6]+lexi[5] marg
print str(2)=='2' True
print '12'+'3' 123
print str(12)+str(6) 126
print lexi[0]*5 aaaaa
print str(32)<str(5) True
print 'Anna'=='anna','Anna'<'anna' False True
print 'Emy'=='Emy ','Emy'<'Emy ' Fasle True
print "'Emy'=='EEEEmy'" 'Emy'=='EEEEmy'
print 'Emy' in 'EEEEmy' True
print 'Ria' in 'Maria', 'Ria' not in 'Maria' False True
print 'pg' in lexi False
print lexi[2:5] pro
print lexi[5:8] gra
print lexi[2:2]   τίποτα 
print lexi[5:len(lexi)-1] gra
print lexi[5:2]   τίποτα 
print lexi[50:500]   τίποτα 
print lexi[:5] a pro
print lexi[5:] gram
print lexi[:3]+lexi[3:] a program
print lexi[:] a program
print lexi[:2]+'P'+lexi[3:] a Program

Πόσα κενά έχει μια φράση

def kena(frasi):
    metritis=0
    for charachtiras in frasi:
        if charachtiras == " ":
           metritis+=1
    return metritis

Καταμέτρηση φωνηέντων μιας φράσης 
def count_fon( word ):
  fon = “AEIOUaeiou”
  count = 0
  for letter in word :
      if letter in fon:
            count += 1
  return count

Δημιουργήστε μια συνάρτηση που δέχεται ένα string και επιστρέφει το αντίστροφό του. Για παράδειγμα, δέχεται το "ΜΕΡΑ" και επιστρέφει το "ΑΡΕΜ". Με τη χρήση αυτής της συνάρτησης γράψτε πρόγραμμα το οποίο διαβάζει μία λέξη και ελέγχει αν είναι παλίνδρομη  ή όχι (διαβάζεται το ίδιο αν πάμε από το τέλος στην αρχή π.χ. "ΑΝΝΑ").

def AntistrStr(st):

    N=len(st)

    nealexi=""

    for i in range(N-1,-1,-1):

        nealexi = nealexi+st[i]

    return nealexi

string1=raw_input("Text:")

string2=AntistrStr(string1)

if string1==string2:

    print "παλίνδρομη"

else:

    print "όχι παλίνδρομη"

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

Σημείωση: Μία πρόταση τελειώνει με τελεία (".") και κάθε λέξη διαχωρίζεται από την άλλη με ένα space (" ").

def LexeisSeProt(keimeno):

    diax=" ."

    lexeis=0

   for xar in keimeno:

     if xar in diax:

       lexeis += 1

 return lexeis

prot=raw_input("...")

print LexeisSeProt(prot)

Εύρεση της θέσης μιας λέξης μέσα σε μια φράση

Είναι υλοποίηση της επιλογής "εύρεση " όλων των προγραμμάτων σύνταξης κεμένου (Find). Στον IDLE της Python στο menu επιλέγουμε Edit --> Find

def poyEinai(lexi,frasi):# Επιστρέφει -1 όταν δεν υπάρχει η λέξη στην φράση αλλιώς την θέση που το βρήκε.
    for i in range(len(frasi)):
        if lexi == frasi[i:i+len(lexi)]:
            return i
    return -1

Αντικατάσταση λέξης με άλλη λέξη μέσα σε μια φράση [Δύσκολο]

Γίνεται χρήση της συνάρτησης εύρεσης poyEinai(lexi,frasi). Είναι υλοποίηση της επιλογής "εύρεση  και αντικατάσταση" όλων των προγραμμάτων σύνταξης κεμένου (Find and Replace all). Στον IDLE της Python στο menu επιλέγουμε Edit --> Replace

def antikatastasi(lexi,neaLexi,frasi): # Επιστρέφει την φράση μετά την αντικατάσταση
    thesi = poyEinai(lexi,frasi)
    while thesi >= 0:
        frasi = frasi[:thesi]+neaLexi+frasi[thesi+len(lexi):]
        neaThesi = poyEinai(lexi,frasi[thesi+len(neaLexi):])
        if neaThesi == -1:
             thesi = -1
        else:
             thesi += neaThesi + len(neaLexi)
    return frasi

Η λίστα είναι μια διατεταγμένη ακολουθία αντικειμένων, όχι απαραίτητα του ίδιου τύπου και αποτελεί τη βασική δομή δεδομένων της Python. Η λίστα, σε αντίθεση με τη συμβολοσειρά , είναι μια δυναμική δομή στην οποία μπορούμε να προσθέτουμε ή να αφαιρούμε στοιχεία (mutable).
o Οι τιμές που θα περιέχονται στη λίστα εσωκλείονται σε αγκύλες [ ] και χωρίζονται με κόμμα.
o Οι τιμές καταχωρούνται ακολουθιακά, η μια μετά την άλλη.
Παραδείγματα:
numera = [6,5,8,13,,21,15,3]
poleis= ['Τρίκαλα', 'Καρδίτσα', 'Λάρισα','Βόλος']

keni = [ ]
Πρόσβαση σε στοιχείο της λίστας
o Αποκτούμε πρόσβαση σε ένα στοιχείο της λίστας γράφοντας το όνομα της λίστας και τη θέση του στοιχείου μέσα σε [ ].
o Η αρίθμηση των θέσεων ξεκινάει πάντα από το 0 και φτάνει μέχρι το πλήθος των στοιχείων της λίστας μειωμένο κατά 1.
o Εναλλακτικά, η αρίθμηση των θέσεων γίνεται κι αντίστροφα, με την τελευταία θέση να αντιστοιχεί στον αριθμό -1.
o Μέσα στις αγκύλες μπορούμε να γράψουμε οποιαδήποτε ακέραια έκφραση.
o Σε περίπτωση που αναφερθούμε σε μια θέση που δεν υπάρχει στη λίστα, δηλαδή σε έναν αριθμό μεγαλύτερο ή ίσο με το πλήθος των στοιχείων της τότε προκύπτει σφάλμα.
Παραδείγματα:
numera[3] = 1, δίνει στο τέταρτο στοιχείο την τιμή 1
numera[-1] = 89, δίνει στο τελευταίο στοιχείο την τιμή 89
print(numera[0]), εμφανίζει το πρώτο στοιχείο της λίστας
Πλήθος στοιχείων
Συνάρτηση len

Επιστρέφει το πλήθος των στοιχείων μιας  λίστας.
Παράδειγμα:
print  len(numera)
7
Απαρίθμηση στοιχείων λίστας
Eντολή for
Η εντολή for είναι μια εντολή επανάληψης που διατρέχει τα στοιχεία μιας ακολουθίας τιμών, όπως μια λίστα, με τη σειρά που εμφανίζονται.
o Σε κάθε επανάληψη η τιμή του επόμενου στοιχείου της ακολουθίας ανατίθεται σε μια μεταβλητή απαρίθμησης που χρησιμοποιούμε στην for.
Παράδειγμα:
for i in numera:
print(i)

Οταν θέλουμε να διατρέξουμε τα στοιχεία μιας λίστας χρησιμοποιούμε for i in List:

Αν θέλουμε να βρούμε τη θέση του στοιχείου στην λίστα χρησιμοποιούμε

for i in range (len(list)):
Πράξεις
Τελεστής διαμέρισης :
Δημιουργεί μια νέα λίστα που αντιστοιχεί σε ένα «τεμαχισμένο» τμήμα της αρχικής
o Για να τεμαχίσουμε μια λίστα γράφουμε μέσα σε αγκύλες [ ] τρεις αριθμούς: την αρχική θέση του τεμαχισμού, τη θέση τερματισμού του τεμαχισμού (που δεν περιλαμβάνεται στο τελικό τμήμα) και ανά πόσα στοιχεία θα περιλαμβάνονται στο τεμαχισμένο τμήμα, ξεκινώντας από την αρχική θέση.
o Αν παραλείψουμε την αρχική θέση, ο τεμαχισμός ξεκινάει από το πρώτο στοιχείο της λίστας.
o Αν παραλείψουμε την τελική θέση τότε ο τεμαχισμός φτάνει μέχρι το τέλος της λίστας.
o Αν παραλείψουμε το βήμα τότε παίρνει την τιμή +1.
Παραδείγματα:
numera[1:4], δημιουργεί μια νέα λίστα που περιέχει τα στοιχεία στις θέσεις 1 έως και 3 της αρχικής λίστας

numera[::2], ξεκινώντας από την αρχή της λίστας, δημιουργεί μια νέα λίστα που περιέχει τα στοιχεία της αρχικής που βρίσκονται σε ζυγές θέσεις

numera[::-1], δημιουργεί νέα λίστα, αντίστροφη της αρχικής

Συνένωση και πολλαπλασιασμός
Τελεστές +, *
Ο τελεστής + (συνένωση) χρησιμοποιείται ανάμεσα σε δύο λίστες και δημιουργεί μια νέα λίστα που περιέχει όλα τα στοιχεία των αρχικών.
Ο τελεστής * έχει ως αποτέλεσμα τη δημιουργία μιας νέας λίστας που περιέχει πολλές φορές τα στοιχεία της αρχικής.
num = [1,2,3] + [4,5,6], το num θα περιέχει τα [1,2,3,4,5,6]
num = [1,2,3] * 3, το num περιέχει τα [1,2,3,1,2,3,1,2,3]
Έλεγχος ύπαρξης τιμής σε λίστα
Τελεστής in
Ελέγχει αν η τιμή βρίσκεται στη λίστα και επιστρέφει αντίστοιχα την τιμή True ή False.
if 21 in numera:  print True

else: print False

Μέθοδοι
Οι λίστες, όπως και οι συμβολοσειρές, διαθέτουν μεγάλη ποικιλία μεθόδων, η χρήση των οποίων μπορεί να επεκτείνει, σε μεγάλο βαθμό, τη λειτουργικότητά τους. Εμείς  θα χρησιμοποιήσουμε μόνο τις παρακάτω μεθόδους.
Προσθήκη νέου στοιχείου
Μέθοδος append()
Προσθέτει ένα νέο στοιχείο στο τέλος της λίστας.
numera.append(8)
poleis.append('lamia')

Αφαίρεση στοιχείου
Μέθοδος pop()
Αφαιρεί το τελευταίο στοιχείο της λίστας 

numera.pop()

Μέθοδος insert()
Εισάγει ένα νέο στοιχείο σε οποιαδήποτε θέση της λίστας.
Η θέση και το στοιχείο εισαγωγής δίνονται ως παράμετροι.
poleis.insert(1, 'kalampaka'), εισάγει την τιμή 'kalampaka' στη 2η θέση της λίστας

Παραδείγματα για μελέτη

Με κίτρινο εμφανίζεται το αποτέλεσμα της ετολής στην οθόνη. Για βοήθεια εμφανίζεται η lexi με την αρίθμηση τωνθέσεων των γραμμάτων από κάτω:

'a'  'b'  'c'  'd'  'e'
 0    1    2    3    4

L=['a','b','c','d','e']
print len(L)   5
print L[2]   c
print L[2]+L[4]  ce
print L[len(L)-1]  e
print L[4]+L[3]+L[2]  edc
print list('Anna')   ['A','n','n','a']
print L + [10,20]    ['a','b','c','d','e',10,20]
print [-5, 3.14] + L   [-5, 3.14,'a','b','c','d','e',10,20]
print L + ['f']    ['a','b','c','d','e','f']
print L[1:3] ['b', 'c']
print L[5:8] []
print L[3:len(L)-1] ['d']
print L[4:2]   []
print L[50:500]   []
print L[:2]   ['a','b']
print L[2:]   ['c','d','e']
print L[:3]+L[3:] ['a','b','c','d','e']
print L[:] ['a','b','c','d','e']

N = [-1, 2, 10]
print N[0]+N[2]   9
N[1] = N[0] + N[2]
print N   [-1,9,10]

L=['a','b','c','d','e']
M = L
print M   ['a','b','c','d','e']
L[1]=10
M[3]=-2
print L, M    ['a',10,'c',-2,'e']  ['a',10,'c',-2,'e']

L=['a','b','c','d','e']
M = L[:]
print M  ['a','b','c','d','e']
L[1]=10
M[3]=-2
print L, M    ['a',10,'c','d','e']  ['a','b','c',-2,'e']

L=['a','b','c','d','e']
print L.pop(), L    'e'  ['a','b','c','d']
print L.pop(2), L    'c'  ['a','b','d']
print L.pop(0), L    'a'  ['b','d']

L=['a','b','c','d','e']
L.append('Z')
print L   ['a','b','c','d','e','Z']
L = L + ['A', 'B']
print L  ['a','b','c','d','e','Z','A','B']
L = ['A','B'] + L
print L ['A','B','a','b','c','d','e','Z',"A','B']

L=['a','b','c','d','e']
L.insert(2,'X')
print L ['a','b','X','c','d','e']
L.insert(0,'A')
print L ['A','a','b','X','c','d','e']
L.insert(len(L),'Z')
print L ['A','a','b','X','c','d','e','Z']
L.insert(1000,'ZZ')
print L ['A','a','b','X','c','d','e','Z','ZZ']

Προσπέλαση στοιχείων λίστας
Τα στοιχεία εμφανίζονται στην οθόνη

Α' Λύση (όταν δεν χρειάζεται να γνωρίζουμε την θέση του στοιχείου)

L=range(0,101,10)
for stx in L:
    print stx

Β' Λύση (όταν χρειάζεται να γνωρίζουμε την θέση του στοιχείου)

L=range(0,101,10)
for i in range(len(L)):
    print L[i]

Αναζήτηση στοιχείου σε λίστα

def einaiStinLista(x,L):
    for stx in L:
        if stx == x:
            return True
    return False

Μέσος όρος στοιχείων λίστας

def meosOros(L):
    if len(L) == 0:
        return None
    s = 0
    for st in L:
        s += st
    return 1.0 * s / len(L)

Μέγιστο στοιχείο λίστας

Α Λύση Επιστρέφει τον μέγιστο της λίστας

def megistosListas(L):
      megistos=L[0]
      for stx in L:
           if stx >= megistos:
                megistos = stx
     return megistos

Β Λύση Επιστρέφει την θέση του μέγιστου της λίστας

def thesiMegistoyListas(L):
      thesi=0
      for i in range(1,len(L)):
            if L[i] >= L[thesi]:
                 thesi = i
      return thesi

Ελάχιστο στοιχείο λίστας

Α Λύση Επιστρέφει τον ελάχιστο της λίστας

def elaxistosListas(L):
      elaxistos=L[0]
      for stx in L:
           if stx <= elaxistos:
                elaxistos = stx
     return megistos

Α Λύση Επιστρέφει του ελάχιστου της λίστας

def thesiElaxistoyListas(L):
      thesi=0
      for i in range(1,len(L)):
            if L[i] <= L[thesi]:
                 thesi = i
      return thesi

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

Προσοχή! Γίνεται μόνο με χρήση του while (To for συνήθως προκαλεί λάθος χρήσης δείκτη έξω από τα όριο - index out or range)

def diagrafiApoLista(x, L)# Διαγράφει το στοιχείο από την λίστα όλες τις φορές υπάρχει
    i=0
    while i<len(L):
          if x == L[i]:
               L.pop(i)
          else:
               i +=1
     return

Ο αλγόρισθμος της δυαδικής αναζήτησης

Δυαδική αναζήτηση με επιστροφή θέσης 

Η λύση του βιβλίου με τροποποίηση ώστε να επιστρέφει την θέση του αναζητούμενου

def binarySearch( array, key ) :#array: η λίστα και key: το αναζητούμενο
    first = 0
    last = len(array) - 1
    while first <= last:
       mid = ( first + last ) / 2
       if array[ mid ] == key :
          return mid #Επιστρέφει την θέση του αναζητούμενου στην λίστα
       elif array[ mid ] < key :
          first = mid + 1
       else :
          last = mid - 1
    return -1 #Επιστρέφει -1 όταν δεν υπάρχει το αναζητούμενο στην λίστα

def anazitisi(A,key):#Με αλλον τρόπο  
N=len(A)
pos=-1
first=0
last=N-1
while first<=last and pos==-1:
      mid=(first+last)/2
      if A[mid]==key:
           pos=mid
     elif A[mid]<key:
           first=mid+1
     else:
           last=mid-1
return pos

Αλγόριθμος της ταξινόμησης ανταλλαγής (Φυσαλίδα)

Ο αλγόριθμος του βιβλίου αλλιώς

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

N = len(A)
for i in range( N-1 ): # range(0, N–1, 1)
    for j in range( N-1 , i , -1 ): # μέχρι και i–1
        if A[ j ] < A[ j-1 ] :
             A[ j ] , A[ j-1 ] = A[ j-1 ] , A[ j ]

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

N = len(A)
for i in range( N-1,0,-1 ): 
    for j in range( 0 , i): 
        if A[ j ] > A[ j+1 ] :
              A[ j ] , A[ j+1 ] = A[ j+1 ] , A[ j ]

Ο αλγόριθμος του βιβλίου ως συνάρτηση

def bubbleSort(A):
    N = len(A)
    for i in range( N-1 ): # range(0, N–1, 1)
         for j in range( N-1 , i , -1 ): # μέχρι και i–1
             if A[ j ] < A[ j-1 ] :
                  A[ j ] , A[ j-1 ] = A[ j-1 ] , A[ j ]

   return

Βελτιωμένος αλγόριθμος 

Ο αλγόριθμος εάν σε κάποιο πέρασμα δεν κάνει καμία αντιμετάθεση τότε σημαίνει ότι η ταξινόμηση ολοκληρώθηκε και διακόπτεται

def bubbleSort(A):
    N = len(A)
    for i in range( N-1 ): # range(0, N–1, 1)
        sorted=True
        for j in range( N-1 , i , -1 ): # μέχρι και i–1
             if A[ j ] < A[ j-1 ] :
                  A[ j ] , A[ j-1 ] = A[ j-1 ] , A[ j ]
                  sorted=False
        if sorted:
            return
    return

Οι 4 εκδοχές της ταξινόμησης ανταλλαγής

Εκδοχή που υπάρχει στο βιβλίο, τοποθετεί αριστερά τους μικρότερους (αύξουσα ταξινόμιση)

Όλες οι εδοχές μετατρέπονται σε φθίνουσες ταξινομίσεις με αντιστροφή της ανισότητας στο IF

def bubleSort1(A):
    N=len(A)
    for i in range(N-1):
        for j in range(N-1,i,-1):
            if A[j]<A[j-1]:
                A[j],A[j-1] = A[j-1],A[j]
        print i+1,'Per:',A #Εμφανίζει τα διαδοχική περάσματα, δεν είναι απαραίτητη
    return

Το ίδιο με το παραπάνω αλλά ξεκινάει το i από 1 και για αυτό σταματάει όταν το j γίνει i-1

def bubleSort2(A):
    N=len(A)
    for i in range(1,N):
        for j in range(N-1,i-1,-1):
            if A[j]<A[j-1]:
                A[j],A[j-1] = A[j-1],A[j]
        print i,'Per:',A #Εμφανίζει τα διαδοχική περάσματα, δεν είναι απαραίτητη
    return

Εκδοχή που τοποθετεί τα μεγαλύτερα δεξιά (αύξουσα ταξινόμιση)

def bubleSort3(A):
    N=len(A)
    for i in range(N-1,0,-1):
        for j in range(0,i):
            if A[j]>A[j+1]:
                A[j],A[j+1] = A[j+1],A[j]
        print N-i,'Per:',A #Εμφανίζει τα διαδοχική περάσματα, δεν είναι απαραίτητη
    return

Το ίδιο με το παραπάνω αλλά ξεκινάει το i από Ν και για αυτό σταματάει όταν το j γίνει i-1

def bubleSort4(A):
    N=len(A)
    for i in range(N,1,-1):
        for j in range(0,i-1):
            if A[j]>A[j+1]:
                A[j],A[j+1] = A[j+1],A[j]
        print N-i+1,'Per:',A #Εμφανίζει τα διαδοχική περάσματα, δεν είναι απαραίτητη
    return

Στοίβα (stack)
Last In First Out - LIFO
Όταν η στοίβα είναι άδεια, είναι προφανές ότι δεν μπορείνα γίνει απώθηση. Άρα, όταν απωθούμε ένα στοιχείο απότη στοίβα, θα πρέπει προηγουμένως να έχουμε εξασφαλίσει ότι η στοίβα δεν είναι κενή. Για αυτό το λόγο, εκτός από την ώθηση και την απώθηση, πρέπει να υλοποιήσουμε και τον έλεγχο, αν η στοίβα είναι κενή.
Οι βασικές λειτουργίες που πρέπει να υποστηρίζει η υλοποίηση μιας στοίβας είναι:
● Δημιουργία μιας κενής στοίβας.      

● Έλεγχος, αν η στοίβα είναι κενή.     

● Ώθηση ενός στοιχείου στη στοίβα.

● Απώθηση ενός στοιχείου από τη στοίβα.

def push(stack, item) :
         stack.append( item )
def pop(stack) :
          return stack.pop( )
def isEmpty(stack) :
         return len(stack) == 0
def createStack( ) :

        return []

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

def push(stack,i):
      stack.insert(0,i)
def pop(stack):
     return stack.pop(0)
def isempty(stack):
    return len(stack)==0
def createstack():
    return []
s=createstack()
number=int(raw_input('dose aritmo '))
while number!=0:
          push(s,number)
          print s
          number=int(raw_input('dose aritmo '))
print s
while not isempty(s):
           number=pop(s)
           print number
           print s

Μια δομή δεδομένων που χρησιμοποιείται για την μοντελοποίηση και προσομοίωση πραγματικών φαινομένων, είναι η δομή της ουράς. Τα φαινόμενα πουμοντελοποιούνται αναφέρονται στην εξυπηρέτηση ανθρώπων, αντικειμένων ή προγραμμάτων. Τέτοια παραδείγματα ουρών είναι:
● Οι ουρές στις τράπεζες και τα σούπερ-μάρκετ.
● Η ουρά των προγραμμάτων που περιμένουν να εξυπηρετηθούν από τον επεξεργαστή του υπολογιστή σας.
● Η ουρά των αιτήσεων προς το διακομιστή ιστού (web server) ενός δικτυακού τόπου.

Σε αντίθεση με τη στοίβα, που η λειτουργία της χαρακτηρίζεται ως LIFO (Last In First Out), η λειτουργία της ουράς είναι γνωστή στη βιβλιογραφία ως FIFO (First In First Out), αφού το κάθε στοιχείο της ουράς εξυπηρετείται με τη σειρά που έφτασε στην ουρά

Δύο είναι οι βασικές λειτουργίες μιας ουράς:
● Εισαγωγή στοιχείου, η οποία γίνεται στο πίσω μέρος της ουράς.
● Εξαγωγή στοιχείου, η οποία γίνεται από το εμπρός μέρος της ουράς.
Οι βασικές λειτουργίες που πρέπει να υποστηρίζει η υλοποίηση μιας ουράς είναι:
● Δημιουργία μιας κενής ουράς.
● Έλεγχος, αν η ουρά είναι κενή.
● Εισαγωγή στοιχείου.
● Εξαγωγή στοιχείου.
def enqueue(q,item):
       q.append(item)
def dequeue(q):
      return q.pop(0)
def isEmpty(q):
       return len(q) == 0
def createQueue():
       return []

Δημιουργία ουράς

def enqueue(queue,i):
       queue.append(i)
def dequeue(queue):
       return queue.pop(0)
def isempty(queue):
       return len(queue)==0
def createqueue():
        return []
q=createqueue()
number=int(raw_input( 'dose stoixe;io'))
while number!=0:
         enqueue(q,number)
         print q
         number=int(raw_input('dose stoixeio'))
print q
while not isempty(q):
          number=dequeue(q)
          print number
          print q

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

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

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


Η δήλωση import
Η import έχει την ακόλουθη σύνταξη:
import module1[, module2[,... moduleN]
Η from...import
Η from...import δίνει τη δυνατότητα εισαγωγής συγκεκριμένων χαρακτηριστικών - δυνατοτήτων του αρθρώματος, χωρίς να εισάγει όλο το άρθρωμα και έχει την ακόλουθη σύνταξη:
from modname import name1[, name2[, ... nameN]]
Η δήλωση from...import *
Είναι δυνατό να εισάγουμε όλα τα περιεχόμενα από ένα άρθρωμα, με χρήση της ακόλουθης δήλωσης import:
from modname import *
Όμως δεν ενδείκνυται η συχνή χρήση του.
Για να έχουμε πρόσβαση σε μια από τις συναρτήσεις, θα πρέπει να προσδιορίσουμε το όνομα της μονάδας και το όνομα της συνάρτησης, χωρισμένα με μία τελεία.

Αυτή η μορφή ονομάζεται συμβολισμός με τελεία (dot notation).
Σε ένα πρόγραμμα μπορούν να συνυπάρχουν τρεις κατηγορίες συναρτήσεων.
Μπορούν να υπάρχουν συναρτήσεις ενσωματωμένες στο περιβάλλον (built-in) που είναι πάντα διαθέσιμες για χρήση, συναρτήσεις που περιέχονται σε εξωτερικά αρθρώματα, τα οποία πρέπει πρώτα να εισαχθούν και τέλος συναρτήσεις
που ορίζονται από τον προγραμματιστή (με το def ).
Για παράδειγμα στο παρακάτω πρόγραμμα εκτελούνται ορισμένες μαθηματικές
πράξεις:
from math import sqrt
def cube(x):
return x * x * x
>>> print abs(-1)
>>> print cube(9)
>>> print sqrt(81)

Για τις ακόλουθες δηλώσεις παρατηρούμε τα:
from math import sqrt
Η sqrt() συνάρτηση εισάγεται από το math module.
def cube(x):
return x * x * x
Η cube() συνάρτηση είναι μια συνάρτηση οριζόμενη από τον προγραμματιστή.
print abs(-1)
Η abs() συνάρτηση είναι μια ενσωματωμένη built-in συνάρτηση, προσβάσιμη καθολικά και αποτελεί μέρος του πυρήνα (core) της γλώσσας.

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

Οι βιβλιοθήκες είναι πολύ σημαντικές στον προγραμματισμό, γιατί μας δίνουν τη δυνατότητα να χρησιμοποιούμε τα εργαλεία που περιλαμβάνονται σε αυτές.
Η πρότυπη βιβλιοθήκη της Python περιέχει έναν τεράστιο αριθμό χρήσιμων αρθρωμάτων και είναι μέρος κάθε πρότυπης εγκατάστασης Python. Είναι σημαντικό να εξοικειωθούμε με την πρότυπη βιβλιοθήκη, επειδή πολλά προβλή ματα μπορούν να λυθούν γρήγορα, αν αξιοποιηθεί το εύρος των δυνατοτήτων που έχουν οι βιβλιοθήκες. Περιλαμβάνει τμήματα για προγραμματισμό γραφικών (Tkinter), αριθμητική επεξεργασία, web συνδεσιμότητα, βάσεις δεδομένων (Sqlite3, Anydbm), Βιοπληροφορική (Biopython) κ.ά.

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

Η Python διαθέτει μια μαθηματική μονάδα λογισμικού (math module), η οποία περιέχει τις δημοφιλέστερες μαθηματικές συναρτήσεις. Προτού χρησιμοποιήσουμε μια μονάδα, άρα και τη math, πρέπει να την εισάγουμε.

Παράδειγμα 1.

Μαθηματική μονάδα λογισμικού α)

>>> import math >>>

print math <module 'math' (built-in)>

>>> print math.pi 3.14159265359 >>>

print math.cos(math.pi / 4.0)

0.70710678118654757

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

β) Εναλλακτικά, μπορούμε να εισάγουμε ένα αντικείμενο από μια μονάδα ως εξής:

>>> from math import pi

Τώρα μπορούμε να έχουμε απευθείας πρόσβαση στην pi, χωρίς το συμβολισμό τελείας.

>>> print pi 3.14159265359

Επίσης μπορούμε να χρησιμοποιήσουμε τον τελεστή αστεράκι για να τα εισάγουμε όλα από τη μονάδα:
>>> from math import *
>>> cos(pi)
-1.0
Παράδειγμα 2. Μονάδα Λογισμικού random
Το random module διαθέτει εργαλεία δημιουργίας ψευδοτυχαίων αριθμών:
>>> import random
>>> random.choice(['apple', 'pear', 'banana'])
'apple'
# τυχαία δειγματοληψία
>>> random.sample(xrange(100), 10)
[30, 83, 16, 4, 8, 81, 41, 50, 18, 33]
# τυχαίος κινητής υποδιαστολής (float)
>>> random.random()
0.17970987693706186
# τυχαίος ακέραιος στο διάστημα range(6)
>>> random.randrange(6)

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

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

Κάθε κατάλογος με ένα —init—.py αρχείο αναφέρεται ως ένα Python πακέτο.

Διαχείριση Αρχείων

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

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

6.2 Ανάγνωση και εγγραφή σε αρχείο

Δημιουργία - Άνοιγμα - Κλείσιμο Αρχείων
Ανοιγμα αρχείου
open ("όνομα_αρχείου", "τρόπος προσπέλασης")
Τρόποι Προσπέλασης:

Αν παραλειφθεί, προεπιλεγμένη τιμή είναι το "r".
Παράδειγμα
>>> fin = open('words.txt')
>>> print fin

Στην πρώτη γραμμή ανοίγουμε το αρχείο κειμένου “words.txt” και αποδίδουμε το αποτέλεσμα στον περιγραφέα αρχείου fin. Στη δεύτερη γραμμή τυπώνουμε τα χαρακτηριστικά του περιγραφέα fin. Όλες οι λειτουργίες που πρόκειται να εκτελεστούν στο αρχείο words.txt θα εκτελεστούν μέσω του fin
Δημιουργία  αρχείου
open ("όνομα_αρχείου", "w")
open ("όνομα_αρχείου", "a")
Παραδείγματα
f = open("words.txt", "w")
Αν το αρχείο words.txt δεν υπάρχει τότε δημιουργείται ενώ αν υπάρχει, χάνεται το περιεχόμενό του.
f = open("words.txt", "a")
Αν το αρχείο words.txt δεν υπάρχει τότε δημιουργείται ενώ αν υπάρχει, μπορούμε να προσθέσουμε δεδομένα στο τέλος του.

Μέθοδοι  διαχείρισης αρχείων
Οι πιο διαδεδομένες μέθοδοι για διάβασμα των περιεχομένων ενός αρχείου, είναι η read() και η readline(), όπου διαβάζει ένα πλήθος χαρακτήρων από την αρχή του αρχείου.
η readline()διαβάζει διαδοχικούς χαρακτήρες από ένα αρχείο μέχρι να συναντήσει το χαρακτήρα νέας γραμμής και επιστρέφει το αποτέλεσμα:
write()Το όρισμα της μεθόδου write πρέπει να είναι συμβολοσειρά. Αν θέλουμε να
εισάγουμε κάτι διαφορετικό, όπως για παράδειγμα έναν αριθμό, ο ευκολότερος τρόπος είναι, να μετατρέψουμε τον αριθμό σε συμβολοσειρά, με χρήση της συνάρτησης str.
>>> x = 52
>>> keimeno.write(str(x)
close()H συνάρτηση close() αναλαµβάνει να κλείσει το αρχείο και να απελευθερώσει
έτσι πόρους του συστήµατος.
tell()H μέθοδος tell() επιστρέφει έναν ακέραιο που περιέχει την τρέχουσα θέση στο αρχείο, υπολογισμένη σε χαρακτήρες (bytes) από την αρχή του αρχείου.
Με άλλα λόγια, η επόμενη ανάγνωση ή εγγραφή θα γίνει σε εκείνη τη θέση του αρχείου

seek() Για να αλλάξουμε την τρέχουσα θέση του αρχείου, μπορούμε να χρησιμοποιήσουμε την seek() (offset[, from_what]). Η θέση υπολογίζεται προσθέτοντας offset (πλήθος bytes) σε ένα σημείο αναφοράς, το οποίο επιλέγεται από το from_what όρισμα. Αν το from_what έχει τιμή 0, μετρά από την αρχή του αρχείου, αν έχει 1, χρησιμοποιεί την τρέχουσα θέση του αρχείου και αν έχει 2, χρησιμοποιεί το τέλος του αρχείου.
seek(Θ,Σ)
όπου Σ λαμβάνει τιμές 0,1,2
Αν Σ=0, πάει στη θέση Θ μετρώντας από την αρχή του
αρχείου
Αν Σ=1, προχωράει Θ θέσεις ξεκινώντας από την
τρέχουσα θέση
Αν Σ=2, πάει στη θέση Θ μετρώντας από το τέλος του
αρχείου
Αν δεν προσδιοριστεί, θεωρείται ότι είναι Σ=1.

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

Παράδειγμα 1
>>>fin = open("words.txt","w")
>>>fin.write('This is line 1.\n')
>>>fin.write('This is line 2.\n')
>>>fin.write('This is line3.\n')
>>>fin.close()
Δημιουργήθηκε το αρχείο words.txt και περιέχει τρεις γραμμές:
This is line 1
This is line 2
This is line 3
Παράδειγμα 2

>>> fin=open("words.txt")
>>> print fin.read()
This is line 1
This is line 2
This is line 3
Παράδειγμα 3
>>> fin=open("words.txt")
>>> print fin.readline()
This is line 1
>>> print fin.read()
This is line 2

This is line 3
>>> fin.close()
Παράδειγμα 4
>>> fin=open('words.txt','a')
>>> x=52
>>> keimeno=str(x)
>>> fin.write(keimeno)
>>> fin.close()
>>> fin=open('words.txt')
>>> print fin.read()
>>> fin.closed

This is line 1
This is line 2
This is line 3

52

False
Παράδειγμα 5
>>> fin=open('words.txt')
>>> print fin.read(2)
This is line 2
>>> f.close()

Παράδειγμα 6

>>> fin = open(“workfile”, “r+”)
>>> fin.write(“0123456789abcdef”)
>>> fin.seek(5) # πηγαίνει στο 6ο byte στο αρχείο
>>> fin.read(1)
5
>>> fin.seek(-3, 2) # πηγαίνει στο 3ο byte πριν το τέλος
>>> fin.read(1)
d

Ασκηση 1

Να γραφει προγραμμα σε Python, το οποίο διαβάζει το αρχείο “words.txt” και το ξαναγράφει στο νέο αρχείο “output_words.txt”, όπου πριν από κάθε γραμμή θα προσθέτει τον αύξοντα αριθμό της. Τα αρχεία θεωρούμε ότι βρίσκονται στον τρέχοντα κατάλογο 

inputfile = open("words.txt", "r")
outputFile = open("output_words.txt","w")
linecounter = 1
for line in inputfile:
    outputFile.write(str(linecounter)+". "+line)
    linecounter = linecounter + 1
outputFile=open ("output_words.txt","r")
print outputFile.read()
inputfile.close()
outputFile.close()

Ασκηση 2  Μελετήστε και εξηγήστε τον  τον παρακάτω κώδικα

my_list = [i**2 for i in range(1,11)]
f = open("output.txt", "w")
for item in my_list:
     f.write(str(item) + "\n") # δέχεται string όρισμα η write
f.close()
f = open("output.txt", "r")
print f.read()
f.close()

Ασκηση 3

Υποθέτουμε ότι έχουμε ένα πρόγραμμα σε Python που έχει αποθηκευθεί στο αρχείο με όνομα demo.py και με τον ακόλουθο κώδικα: Τι θα εμφανισει στην οθόνη;
def linecount(filename):
     count = 0
     for line in open(filename):
          count += 1
     return count
print linecount('demo.py')

Δραστηριότητα 2( τετράδιο εργασιών)

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

Απάντηση

f = open('demo.txt', 'r')
for line in f:
              word_list = [ ]
              word = “”
              for symbol in line:
                     if symbol == “ “ :
                          word_list.insert(0,word)
                          word = “”
                    elif symbol == “.” :
                            word_list.insert(0,word)

                             word=''
                     else :
                             word += symbol

for word in word_list:
          print word,

print
input.close()

Δραστηριότητα 3 (τετραδιο εργασιών)

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

outfile = open('demo.txt', 'a')
infile = open('words.txt', 'r')
for line in infile:
         outfile.write(line)
outfile=open('demo.txt','r')
print outfile.read()
infile.close()
outfile.close()

Ασκηση 4

Να γίνει πρόγραμμα που ανοίγει ένα αρχείο κειμένου που περιέχει ακέραιους θετικούς αριθμούς.
Διαβάζει μία μία τις γραμμές του αρχείου με τη χρήση της δομής while και τη μέθοδο readline() και προσθέτει τις γραμμές στο άθροισμα αφού τις μετατρέψει σε ακέραια μορφή.
Το αρχείο τελειώνει όταν η readline() επιστρέψει κενή συμβολοσειρά ""

Απαντηση

file1=open("demonumbers.txt","r")
s=0.0
x=file1.readline()
while x!="":
           print x
           s=s+int(x)
           x=file1.readline()
file1.close()
print "το αθροισμα ειναι :",s

11.1 Η μέθοδος συγγραφής προγραμμάτων, η οποία συνδυάζει δεδομένα και λειτουργικότητα εμπερικλείοντάς τα σε ένα αντικείμενο, ονομάζεται αντικειμενοστραφής προγραμματισμός (object-oriented programming) (Booch, 2007).

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

Αντικείμενο και ιδιότητες

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

• Κλάση (class) : ένας νέος τύπος δεδομένων που ορίζει τη δομή μιας κατηγορίας αντικειμένων. Περιλαμβάνει δεδομένα και τη συμπεριφορά τους (μεθόδους)
• Στιγμιότυπα (instances) μιας κλάσης είναι αντικείμενα που δημιουργούνται σύμφωνα
με τον ορισμό της κλάσης

Ενα αντικείμενο δημιουργείται από μια ειδική μέθοδο που στην αντικειμενοστρεφή ορολογία ονομάζεται κατασκευαστής (constructor)

Ορισμός κλάσης στην Python και αρχικοποίηση τιμών
Ο ορισμός μιας κλάσης στην Python είναι παρόμοιος με τον αυτόν μιας συνάρτησης .  Μόνο που, αντί για τη λέξη def, χρησιμοποιούμε τη λέξη κλειδί class. Για παράδειγμα, αν θέλουμε να ορίσουμε την κλάση όχημα με ορισμένες ιδιότητες και αρχικοποίηση τιμών 

class Vehicle:
          def__init__( self, color, price, wheels, speed):
                  self.color=color
                  self.price=price
                  self.wheels=wheels
                  self.speed=speed

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

Για να δημιουργήσουμε τώρα ενα αντικείμενο πρέπει να καλέσουμε την κλάση Vehicle, με ορίσματα ή τιμές για κάθε μία από τις ιδιότητες του αντικειμένου που αντιστοιχούν στις παραμέτρους της μεθόδου—init—. Στο αντικείμενο που δημιουργείται δίνουμε ένα όνομα , όπως για παράδειγμα:
mybeetle = Vehicle('yellow', 2000.00, 4, 80).
Έχουμε τώρα δημιουργήσει ένα όχημα κίτρινο, με τιμή 2000 ευρώ, τέσσερις τροχούς και ταχύτητα 80 χιλιόμετρα την ώρα. Το όνομά του είναι mybeetle. To mybeetle είναι ένα αντικείμενο, ανήκει στην κλάση όχημα (Vehicle) και έχει συγκεκριμένες τιμές για τις ιδιότητες του οχήματος, αυτές που ορίσαμε με την κλήση της. Ένα τέτοιο αντικείμενο ονομάζεται στιγμιότυπο της κλάσης.
Δεν καλέσαμε ονομαστικά τη μέθοδο —init—, απλώς καλέσαμε την κλάση σχεδόν ως συνάρτηση, με τις τιμές που αφορούν το αντικείμενο που θέλουμε να δημιουργήσουμε για τις ιδιότητες της κλάσης, όπως αυτές εμφανίζονται ως μεταβλητές της μεθόδου.

Μέθοδος

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

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

 Ισότητα

Η έννοια της «ισότητας» στα αντικείμενα μπορεί να οριστεί με δύο τρόπους. Δύο αντικείμενα μπορούμε να πούμε ότι είναι ίδια, είτε αν περιέχουν τα ίδια δεδομένα ή αν είναι στην πραγματικότητα το ίδιο αντικείμενο.

Ο γνωστός μας τελεστής == ελέγχει αν δύο αναφορές δείχνουν στο ίδιο ακριβώς αντικείμενο. Για παράδειγμα, κάνουμε τη σύγκριση δύο διαφορετικών αντικειμένων p1 και p2, τα οποία έχουν, όμως, τα ίδια περιεχόμενα. Παρόλο που τα p1 και p2 περιέχουν γνωρίσματα με τις ίδιες τιμές, δεν είναι το ίδιο αντικείμενο και άρα η σύγκριση μέσω του == επιστρέφει «ψευδές».

 Αν, ωστόσο, εκχωρήσουμε το p1 στο p2, τότε οι δύο μεταβλητές είναι ψευδώνυμα του ίδιου αντικειμένου και άρα η σύγκρισή τους μέσω του τελεστή == επιστρέφει «αληθές»:

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

Ασκήσεις εμπέδωσης

Ασκηση 1.

Να ορίσετε κλάση που περιγράφει μια αμαξοστοιχία με όνομα Traino που έχει:

1. Τις ιδιότητες όνομα αμαξοστοιχίας, αρ. βαγονιών ,αρ. επιβατών, ταχύτητα.
2. Μία μέθοδο αρχικοποίησης των ιδιοτήτων δίνοντας αρχική ταχύτητα 0.
3. Μία μέθοδο εμφάνισης των τιμών των ιδιοτήτων της κλάσης.
4. Μία μέθοδο τροποποίησης της ταχύτητας της αμαξοστοιχίας σύμφωνα με την τιμή που δέχεται ως παράμετρο
5. Mε τις κατάλληλες εντολές να δημιουργήσετε ένα αντικείμενο με όνομα trenoexpress με τιμές στις ιδιότητες ‘Τρίκαλα’,’6’,’110’ Με την βοήθεια της κατάλληλης μεθόδου να εμφανίζονται οι ιδιότητες του αντικειμένου

Απάντηση

class Traino:

     def __init__(self,onomasia,ar_vagoniwn,ar_epivatwn):

       self.onomasia=onomasia

       self.ar_vagoniwn=ar_vagoniwn

       self.ar_epivatwn=ar_epivatwn

       self.taxitita=0

     def display():

        print "ONOMASIA         :",self.onomasia

        print "ARITHMOS BAGONIWN:",self.ar_vagoniwn

        print "ARITHMOS EPIBATWN:",self.ar_epivatwn

        print "TAXYTHTA         :",self.taxitita

    def change_speed(self,posotita):

          self.taxitita=self.taxitita+posotita

taxiaexpres=Traino('trikala','6','110')

taxiaexpres.change_speed(100)

taxiaexpres.display()

Ασκηση 2

Δίνεται η κάτωθι κλάση:

1.Να γράψετε τις ιδιότητες και τις μεθόδους της κλάσης

2.Να προσθέσετε μια ιδιότητα Χρώμα και να την αρχικοποιήσετε.

3.Να τροποποιήσετε την μέθοδο strofi  ώστε να δέχεται ως  παράμετρο μια συμβολοσειρά που να ορίζει αν το ποδήλατο στρίβει αριστερά η δεξιά.

4.να δημιουργήσετε τα παρακάτω στιγμιότυπα

    Α)Αντικείμενο με όνομα podbounou με τύπο ‘βουνού’ και χρώμα ‘άσπρο’

    Β) Αντικείμενο με όνομα podpolis με τύπο ‘πόλης ‘ και χρώμα ‘μπλέ’

5.Να καλέσετε την κατάλληλη μέθοδο έτσι ώστε το αντικείμενο podbounou να στρίψει αριστερά.

6. Να καλέσετε την κατάλληλη μέθοδο έτσι ώστε το αντικείμενο podpolis τρέχει με 40χμ /ωρα

def__init__(self,typos):

     self.typos=typos

     self.taxitita=20

def speed(self,taxitita)

     self.taxitita=taxitita

     print ‘η ταχυτητα είναι’,self.taxitita

def strofi(self):

     print “Το ποδήλατο στρίβει:”

Απάντηση

ΙΔΙΟΤΗΤΕΣ ΚΛΑΣΗΣ: typos,taxitita

ΜΕΘΟΔΟΙ ΚΛΑΣΗΣ:speed(self,taxitita) , strofi(self)

Β)προσθήκη ιδιότητας xroma

def__init__(self,typos,xroma):

    self.typos=typos

    self.xroma=xroma

     self.taxitita=20

Γ) τροποποίηση της μεθόδου strofi:

    def strofi(self,turn):

            print “Το ποδήλατο στρίβει:”,self.turn

Δ)τα στιγμιότυπα:

PodBounou=Podilato(“Βουνού”,”Άσπρο/Γκρι”)

PodPolis=Podilato(“Πόλης”,”Άσπρο/Μπλε”)

Ε) PodBounou.strofi(“aristera”)

Ζ) PodPolis.speed(40)

Ασκηση 3.

Δίνεται η παρακάτω κλάση:

class ypallilos:

    def _ _init_ _ (self, eponymo, onoma,misthos):

       self.eponymo=eponymo

       self.onoma=onoma

       self.misthos=misthos

def afksisemistho(self,amount):

       self.misthos=self.misthos+amount

def emfanise_stoixeia(self):

       print "Επώνυμο ",self.eponymo

       print "Όνομα ",self.onoma

      print "Μισθός ",self.misthos

α. Ποιος είναι ο κατασκευαστής (constructor) της κλάσης;

 β Ποιες είναι οι ιδιότητες της κλάσης;

 γ. Ποιες είναι οι τις μέθοδοι της κλάσης.

 δ. Να προσθέσετε την ιδιότητα xronia που θα αφορά τα χρόνια υπηρεσίας του         υπαλλήλου και να αρχικοποιείται στον κατασκευαστή (Δεν χρειάζεται να εμφανίζεται         στην emfanise_stoixeia()).

 ε. Να προσθέσετε μία μέθοδο afxisexronia(self,amount) η οποία να αυξάνει τα χρόνια υπηρεσίας κατά amount.

 στ. Να δημιουργήσετε τα παρακάτω στιγμιότυπα της κλάσης: I. Αντικείμενο με όνομα αντικειμένου yp1 και Επώνυμο ΑΝΤΩΝΙΟΥ, όνομα ΑΝΤΩΝΙΟΣ, Μισθό 1500 και χρόνια υπηρεσίας 15.

 ζ. Αντικείμενο με όνομα αντικειμένου yp2 και Επώνυμο ΠΑΠΑΔΟΠΟΥΛΟΥ, όνομα ΕΛΕΝΗ, Μισθό 2000 και χρόνια υπηρεσίας 20.

η. Να καλέσετε την κατάλληλη μέθοδο, ώστε ο μισθός της ΠΑΠΑΔΟΠΟΥΛΟΥ να αυξηθεί κατά 200.

Απάντηση

Ασκηση 4

Δίνεται η παρακάτω κλάση:
class Student:
      def __init__(self, onoma, vath1, vath2):
           self.onoma=onoma
           self.vath1=vath1
           self.vath2=vath2

όπου onoma είναι το όνομα του σπουδαστή, vath1 η βαθμολογία του στο πρώτο εξάμηνο και vath2 η βαθμολογία του στο δεύτερο εξάμηνο.
α) Να δημιουργήσετε τη μέθοδο με όνομα find_mo(), η οποία θα υπολογίζει και θα επιστρέφει τον μέσο όρο των vath1 και vath2 του σπουδαστή 
β) Να δημιουργήσετε δύο (2) στιγμιότυπα της κλάσης ως εξής: student1, με τιμές των ιδιοτήτων του onoma="Ιωάννου", vath1=7, vath2=6 και student2, με τιμές των ιδιοτήτων του onoma="Αναστασίου", vath1=10, vath2=9 .
γ) Να βρείτε και να εμφανίσετε το όνομα του στιγμιοτύπου που έχει τον μεγαλύτερο μέσο όρο με χρήση της μεθόδου find_mo() που περιγράφεται στο ερώτημα α. Στην
περίπτωση που και τα δύο (2) στιγμιότυπα έχουν τον ίδιο μέσο όρο, να εμφανίσετε και τα δύο (2) ονόματα των στιγμιοτύπων .

Απάντηση

def find_mo(self):
      return (self.vath1+self.vath2)/2.0
student1=Student('Ιωάννου',7,6)
student2=Student('Αναστασίου',10,9)

mo1=student1.find_mo()
mo2=student2.find_mo()
if mo1>mo2:
       print student1.onoma
elif mo1<mo2:
      print student2.onoma
else:
     print student1.onoma
     print student2.onoma

Ασκηση 5

Δίνεται η παρακάτω κλάση:
class Mathitis:
      def __init__(self,am,onoma,vathmos):
              self.am=am
              self.onoma=onoma
              self.vathmos=vathmos

όπου am είναι ο αριθμός μητρώου του μαθητή, onoma το όνομά του και vathmos ο βαθμός του.
α) Να δημιουργήσετε τη μέθοδο με όνομα tipose() η οποία θα ελέγχει τον βαθμό του αντικειμένου και, αν αυτός
είναι μεγαλύτερος ή ίσος του 10, να εμφανίζει το μήνυμα “Προάγεται”, αλλιώς να εμφανίζει το μήνυμα “Παραπέμπεται” 
β) Να δημιουργήσετε δύο αντικείμενα της κλάσης ως εξής:
mathitis1, με τιμές των ιδιοτήτων του am=103, onoma=”Νικολάου”, vathmos=19 και
mathitis2, με τιμές των ιδιοτήτων του am=105, onoma=”Γεωργίου” και vathmos=9 (μον.2).
γ) Για το αντικείμενο mathitis1 να καλέσετε τη μέθοδο tipose() .
δ) Να υπολογίσετε και να εμφανίσετε τον μέσο όρο των βαθμών των δύο αντικειμένων .

Απαντηση

α. def tipose():

       if self.vathmos >= 10:
              print “Προάγεται”
       else:
              print “Παραπέμπτεται”

β.  mathitis1 = Mathitis(103,”Νικολάου”,19)
     mathitis2 = Mathitis(105,”Γεωργίου”,9)
γ.  mathitis1.tipose()
δ.  mo = (mathitis1.vathmos + mathitis2.vathmos)/2