Python - Εισαγωγή

Για να εγκαταστήσετε την python θα πρέπει να πάτε http://www.python.org/downloads και να κατεβάσετε την κατάλληλη έκδοση. Κατά την εγκατάσταση θα πρέπει να τσεκάρετε την επιλογή Add Python to PATH (δείτε εικόνα δίπλα).
Για να γράφετε κώδικα και να τον τρέχετε μπορείτε να χρησιμοποιήσετε ένα από τα ακόλουθα:

  • το IDLE που εγκαθίσταται μαζί με την python
  • κάποιο εξειδικευμένο πρόγραμμα στον υπολογιστή σας όπως π.χ. PyCharmCommunityEdition (δωρεάν).
  • Κάποιον online επεξεργαστή (editor) και μεταγλωτιστή (compiler)  όπως π.χ. https://www.onlinegdb.com/online_python_compiler

Κάποια από τα παιχνίδια που θα κατασκευάσουμε στη συνέχεια χρειάζονται το pygame το οποίο και μπορούμε να εγκαταστήσουμε ανοίγοντας το Command Prompt (Γραμμή Εντολών) και πληκτρολογώντας : $ python -m pip install –user pygame

  • Τα αρχεία με κώδικα Python πρέπει να έχουν την κατάληξη (.py) στο τέλος του ονόματος τους.
  • H python είναι η μόνη ίσως γλώσσα που απαιτεί να γράφουμε στοιχειοθετημένα (άρα και ευανάγνωστα) προγράμματα.Οι εντολές που πάνε μαζί, πρέπει να έχουν το ίδιο επίπεδο εσοχής (συνήθως 4 κενά αλλά μπορώ να χρησιμοποιήσω και λιγότερα). Κάθε τέτοια ομάδα εντολών ονομάζεται μπλοκ (block). Θυμίζουμε ότι σε άλλες γλώσσες όπως C, Java, Javascript κλπ χρησιμοποιούμε άγκιστρα για τα μπλοκ.
  • Για σχόλιο μιας γραμμής χρησιμοποιούμε το σύμβολο #.
  • Η συνάρτηση print(“κείμενο προς εμφάνιση”) εμφανίζει ένα μήνυμα/αποτέλεσμα στην οθόνη και πηγαίνει τον κέρσορα στην επόμενη γραμμή. Για να μην κατεβαίνει μια γραμμή πρέπει να γράψουμε print(“κείμενο προς εμφάνιση”, end=””). Επίσης μπορούμε να συμπεριλάβουμε πολλές τιμές στην ίδια print αρκεί να διαχωρίζονται με κόμμα. Θα εμφανιστούν όλες οι τιμές στην ίδια γραμμή με ένα κενό μεταξύ τους. Μπορούμε αντί για κενό να παρεμβάλλεται κάτι άλλο όπως π.χ. το σύμβολο ?. Σε αυτή την περίπτωση θα γράψουμε print(“ένα”,”ένα”,”ένα”,sep=”?”) .
  • Η συνάρτηση input( “κείμενο προς εμφάνιση”) διαβάζει τιμή από το πληκτρολόγιο. Π.χ. χ=input( “Πληκτρολογήστε το όνομα σας”). Η input επιστρέφει πάντα κείμενο ακόμη και αν ο χρήστης πληκτρολογήσει αριθμό. Σε αυτή την περίπτωση θα πρέπει να γράψουμε int() ή float(). Π.χ. int(input(“Πληκτρολογήστε την ηλικία σας:”)).
  • Η συνάρτηση len (“κάποιο κείμενο ή μεταβλητή”) που υπολογίζει το πλήθος των χαρακτήρων ενός κειμένου. Π.χ. η εντολή print (len(“Καλημέρα”)) θα εμφανίσει την τιμή 8.
  • Οι μεταβλητές συχνά παρουσιάζονται ως μικρά “κουτάκια” στην μνήμη, μέσα στα οποία μπορούμε να αποθηκεύσουμε τιμές. Όσο εμβαθύνουμε στην Python θα δούμε ότι είναι καλύτερα να θεωρούμε τις μεταβλητές ως “ετικέτες” που “προσκολλούμε” στις τιμές.  Όταν χρησιμοποιούμε μεταβλητές θα πρέπει να τηρούμε τους παρακάτω κανόνες:

    • Στην Python (σε αντίθεση με τις περισσότερες γλώσσες προγραμματισμού) δεν δηλώνεται ο τύπος μιας μεταβλητές.
    • τα ονόματα των μεταβλητών μπορούν να περιέχουν γράμματα (κεφαλαία και πεζά), ψηφία και κάτω παύλα (_). Δεν μπορούν όμως να ξεκινούν με ψηφίο. Δεν επιτρέπονται τα κενά.
    • δεν πρέπει να χρησιμοποιούνται ως ονόματα μεταβλητών οι δεσμευμένες λέξεις της Python (π.χ. print).
    • Καλό είναι τα ονόματα να είναι μεν μικρά αλλά να περιγράφουν όσο γίνεται καλύτερα τις τιμές που θα δεχτούν. Είναι προτιμότερο να ονομάσουμε την μεταβλητή μέγιστη_ηλικία παρά max ή χ ή η_μεγαλύτερη_ηλικία_των_εργαζομένων .
    • Προσοχή όταν γίνεται χρήση του l (αγγλικό λ) και του Ο (κεφαλαίου ο στα Αγγλικά και Ελληνικά) διότι μπορεί να γίνει σύγχυση με τους αριθμούς 1 και 0.
    • Αν και δεν είναι υποχρεωτικό, καλό είναι τα ονόματα των μεταβλητών να γράφονται με πεζά γράμματα. Θα δούμε παρακάτω πότε πρέπει να χρησιμοποιούνται κεφαλαία.

Τύποι Δεδομένων: Ακέραιοι (π.χ. 3 , -4), Κινητής υποδιαστολής (π.χ. 3.14, ) και Μιγαδικοί αριθμοί (π.χ. 1-2j), Λογικές (True ή False),  Συμβολοσειρές (κείμενο), Λίστες (π.χ. [5,7,9,11]) και Tuples .

Τα παρακάτω παραδείγματα είναι αποδεκτά:

akeraios1=7
akeraios2=int(7.0)
Pragmatikos1 = 7.0
Pragmatikos2 = float(7)
keimeno1 = 'hello'
keimeno2 = "hello"
Lista=["Κώστας","Νίκος","Μαρία"]

x,y,z = 5, 9,"Ελένη"
x=y=5

# Εμφανίζει παράθυρο με το κείμενο που γράψαμε, και η τιμή που θα πληκτρολογήσει ο χρήστης καταχωρείται στην μεταβλητή z
z=input("Πληκτρολογήστε το όνομα")

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

Ακολουθούν μερικές χρήσιμες μέθοδοι για μετατροπές κειμένου σε μεταβλητές.
όνομα="μπάμπης σουγιάς"
print(όνομα.title())  # Κάθε λέξη ξεκινά με κεφαλαίο
print(όνομα.upper())  # Όλα κεφαλαία
print(όνομα.lower())
Έστω οτι έχουμε δύο μεταβλητές και θέλουμε να εμφανίσουμε μια πρόταση που να περιέχει κείμενο και τις τιμές των μεταβλητών μαζί. Αυτό μπορεί να γίνει εύκολα με την χρήση f-strings :
όνομα="Μπάμπης"
επίθετο ="Σουγιάς"
ονοματεπώνυμο=f"Το όνομα σας είναι: {όνομα} και το επίθετο σας: {επίθετο}"
print(ονοματεπώνυμο)
Αν θέλουμε να εισάγουμε μία νέα γραμμή ή ένα tab τότε θα πρέπει να χρησιμοποιήσουμε αντίστοιχα /n και /t .
print("Τα νησιά:\n\tΠάρος\n\tΝάξος\n\tΜύκονος")
Προσοχή στα κενά. Οι δύο παρακάτω μεταβλητές δεν είναι ίσες. Το πρόβλημα μπορεί να αντιμετωπιστεί εύκολα με τις μεθόδους rstrip() , lstrip() και strip().
νησί1 = "Χίος"
νησί2 = "  Χίος  "
print(νησί2.rstrip())   # αφαιρεί όλα τα κενά από δεξιά
print(νησί2.lstrip()) # αφαιρεί όλα τα κενά από αριστερά
print(νησί2.strip()) # αφαιρεί όλα τα κενά από δεξιά και αριστερά
Για τις συμβολοσειρές (κείμενο) μπορούν να χρησιμοποιηθούν τόσο τα μονά εισαγωγικά ‘ όσο και τα διπλά “. Όταν χρησιμοποιούμε διπλά εισαγωγικά τότε το κείμενο μπορεί να έχει μονά. Ισχύει και το αντίστροφο.
print(" Το είδες τ' άλογο;")
print('Έπεσε στα "σαγόνια" της εφορίας!')
  • Αριθμητικοί:  +, -, *, / (διαίρεση), ** (δύναμη), % (το υπόλοιπο ακέραιας διαίρεσης), // (Ακέραια Διαίρεση όπου το υπόλοιπο αγνοείται! π.χ. 20 // 6 = 3)
  • Συγκριτικοί:  > , >= , < ,<= , != (Διάφορο), == (Ισότητα)
  • Λογικοί: not (όχι), and (και), or (ή)

Οι λογικοί τελεστές είναι short-circuit, δηλαδή εάν έχουμε την έκφραση (2>1) or (6<1) τότε η Python θα δεί οτι ο πρώτος τελεστέος είναι αληθής και δεν θα προχωρήσει στον υπολογισμό της τιμής του δεύτερου τελεστέου αφού έτσι και αλλιώς η έκφαρση είναι αληθής.

Οι τελεστέοι δεν έχουν την ίδια προταιρεότητα. Έστω π.χ. η έκφραση 2+5*3. Πρώτα θα εκτελεστεί ο πολλαπλασιασμός και μετά η πρόσθεση. Εάν έχουμε τελεστές με την ίδια προτεραιότητα τότε εκτελείτε αυτός που είναι αριστερά.  Η ιεραρχία των τελεστών είναι ως εξής:

  • (  )
  • **, * , /, //, %
  • +, _
  •  > , >= , < ,<= , != (Διάφορο), == (Ισότητα)
  • not, and,  or

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

Η Python κάνει διάκριση μεταξύ πεζών και κεφαλαίων (case sensitive) οπότε η ισότητα ‘Python’==’python’ δεν είναι αληθής.

Για να είναι πιο ευανάγνωστοι οι μεγάλοι αριθμοί (ακέραιοι ή κινητής υποδιαστολής) μπορεί να χρησιμοποιηθεί η κάτω παύλα (π.χ.  1_000_000).

Μπορούμε να εκχωρήσουμε τιμές σε πολλές μεταβλητές σε μία μόνο γραμμή (π.χ.   x,y,z = 1, 2, 3).

H Python δεν υποστηρίζει σταθερές. Μια συνήθης πρακτική που εφαρμόζουν πολλοί προγραμματιστές είναι να χρησιμοποιούν κεφαλαία στα ονόματα των μεταβλητών που δεν θέλουν να τροποποιηθούν (π.χ. ΦΠΑ = 0.24).

Οι τελεστές + και * μπορούν να χρησιμοποιηθούν και για κείμενα. Δείτε δύο παραδείγματα: x=”Καλη”+”μέρα” y=”αβγ”*3. Οι τιμές των μεταβλητών x και y θα είναι Καλημέρα και αβγαβγαβγ.

Ο τελεστές in επιστρέφει την τιμή αληθής εάν ο τελεστέος αριστερά συμπεριλαμβάνεται στον τελεστέο δεξιά. Ο τελεστής not in κάνει το αντίθετο.

lista1= ["Κρήτη", "Χίος", "Σάμος", "Κύπρος"]
print("Πάρος" in lista1)    # Θα επιστρέψει την τιμή Ψευδής
print("Πάρος" not in lista1)    # Θα επιστρέψει την τιμή Αληθής

Η εντολή x=x+1 μπορεί να γραφεί και ως εξής : x+=1. Αντίστοιχοι τελεστές υπάρχουν και για την αφαίρεση (-=), διαίρεση (/=), πολλαπλασιασμό (*/) κλπ.

Ασκήσεις

  1. Να γραφεί πρόγραμμα που να διαβάζει την ακτίνα ενός κύκλου και να υπολογίζει και να εμφανίζει το μήκος της περιφέρειας του κύκλου και το εμβαδόν του.
    r=float(input('Δώσε ακτίνα κύκλου'))
    pi=3.14
    periferia=2*pi*r
    emvadon=pi*r**2
    print ('Μήκος περιφέρειας κύκλου:',periferia)
    print ('Εμβαδόν κύκλο:', emvadon)
  2. Να γραφεί πρόγραμμα που να διαβάζει έναν αριθμό (σε δευτερόλεπτα) και να τον μετατρέπει σε ώρες, λεπτά και δευτερόλεπτα. Παράδειγμα: 3750 δευτ. αντιστοιχούν σε 1 ώρα, 2 λεπτά και 30 δευτερόλεπτα.
    s=int(input('Πληκτρολόγησε τα δευτερόλεπτα: '))
    ores=s//3600
    lepta=(s%3600)//60
    deuterolepta=(s%3600)%60
    print('Ώρες:',ores)
    print("Λεπτά:", lepta)
    print("Δευτερόλεπτα:", deuterolepta)
  3. Η μετατροπή της θερμοκρασίας από βαθμούς Κελσίου σε Φαρενάιτ δίνεται από τον τύπο F=9C/5+32. Nα γράψετε πρόγραμμα το οποίο θα διαβάζει τη θερμοκρασία σε βαθμούς Κελσίου και θα την υπολογίζει και θα την εμφανίζει σε βαθμούς Φαρενάιτ.
  4. Nα αναπτύξετε πρόγραμμα που διαβάζει το πλήθος των ανδρών, των γυναικών και των παιδιών σε ένα πλοίο και στη συνέχεια υπολογίζει και εμφανίζει το ποσοστό των ανδρών επί του συνόλου των ενηλίκων και το ποσοστό των ενηλίκων επί του συνόλου των επιβατών..
  5. Να γράψετε πρόγραμμα που διαβάζει ένα τριψήφιο αριθμό και εμφανίζει τον αριθμό που προκύπτει αν αλλάξουμε τη σειρά των ψηφίων δηλαδή το πρώτο ψηφίο να γίνει τρίτο και το τρίτο πρώτο (368 -> 863).
  6. Ο βασικός μισθός ενός υπαλλήλου είναι 1000 ευρώ. για κάθε έτος υπηρεσίας ο υπάλληλος λαμβάνει χρονοεπίδομα 20 ευρώ ενώ για κάθε παιδί επίδομα τέκνων 50 ευρώ. Τέλος για ασφαλιστικές εισφορές του παρακρατείται το 20% του μισθού του. Να αναπτύξετε πρόγραμμα που διαβάζει το ονοματεπώνυμο ενός υπαλλήλου, το πλήθος των ετών υπηρεσίας του και το πλήθος των παιδιών του. Στη συνέχεια να υπολογίζει και να εμφανίζει τις καθαρές αποδοχές του υπαλλήλου καθώς και το ποσό των κρατήσεων.
  7. Το ΑΤΜ μιας Τράπεζας διαθέτει χαρτονομίσματα των 50, 20 και 10 ευρώ. να αναπτύξετε πρόγραμμα που αφού διαβάσει το ποσό της ανάληψης που επιθυμεί ο πελάτης, στη συνέχεια να υπολογίζει και να εμφανίζει το πλήθος των χαρτονομισμάτων από κάθε είδος που θα πρέπει να δώσει. Είναι προφανές ότι τα ποσά της ανάληψης θα είναι πολλαπλάσια του 10 και ότι το ATM προσπαθεί να δώσει όσο γίνεται μεγαλύτερα χαρτονομίσματα.
    Παράδειγμα: Αν ένας πελάτης θέλει να κάνει Ανάληψη 380 ευρώ τότε το ATM θα πρέπει να του δώσει 7 χαρτονομίσματα των 50 ευρώ ένα χαρτονόμισμα των 20 ευρώ και ένα χαρτονόμισμα των 10 ευρώ.
  8. Να γράψετε πρόγραμμα αφού διαβάσει το πλήθος των ατόμων που θα πάνε εκδρομή στη συνέχεια να υπολογίζει και να εμφανίζει το συνολικό πλήθος τον πούλμαν που θα πρέπει να ναυλωθούν. Κάθε πούλμαν χωράει 50 επιβάτες.
  9. Ένας τηλεοπτικός σταθμός θέλει να παρεμβάλει διαφημίσεις στις ταινίες που προβάλλει. Πιο συγκεκριμένα θέλει κάθε 30 λεπτά να παρεμβάλλονται διαφημίσεις συνολικής διάρκειας 5 λεπτών. Να αναπτύξετε πρόγραμμα αφού διαβάσει συνολική διάρκεια μιας ταινίας τα εμφανίζει το πλήθος των διακοπών καθώς και τη συνολική διάρκεια προβολής της ταινίας.
if έκφραση:
   εντολές
if έκφραση:
   εντολές
else:
   εντολές
if έκφραση1:
   εντολές
elif έκφραση2:
   εντολές
elif έκφραση3:
   εντολές
else:
   εντολές
Παρατήρηση: Τα μπλοκ των εντολών αποτελούνται από εντολές με την ίδια εσοχή. Αν το μπλοκ αποτελείται από μια μόνο εντολή, τότε μπορεί να γραφτεί στην ίδια γραμμή με την if ή την elif ή την else. Π.χ.
if έκφραση: εντολή1
else: εντολή2
Ασκήσεις
  1. Να γραφεί πρόγραμμα που να δέχεται 2 αριθμούς και ένα τελεστή (+ , – , * , /). Στη συνέχεια, να υπολογίζει και να εμφανίζει το αποτέλεσμα της πράξης που δέχθηκε με τους δύο αριθμούς, εμφανίζοντας κατάλληλο μήνυμα.
  2. Να γραφτεί πρόγραμμα που να υπολογίζει το μισθό μιας εργαζόμενης, η οποία αμοίβεται με την ώρα. Το πρόγραμμα, θα διαβάζει το όνομά της, τις ώρες εργασίας της για τον μήνα, το ωρομίσθιό της και αν είναι έγγαμη ή άγαμη. Οι κρατήσεις, εξαρτώνται από το ύψος του μισθού. Αν ο μισθός είναι μέχρι 1000€ το μήνα, έχει 15% κρατήσεις, διαφορετικά 25%. Οι έγγαμοι, δικαιούνται ένα επίδομα 50€.
while έκφραση:
   εντολές
for μεταβλητή in range (αρχή, μέχρι, βήμα):
    εντολές
Παρατήρηση: Η τιμή του μέχρι που είναι μέσα στη παρένθεση του range δεν είναι η τελική τιμή. Η τελική τιμή της μεταβλητής είναι (μέχρι – βήμα). Επίσης οι τιμές αρχή και βήμα είναι προεραιτικές, εαν παραλειφθούν παίρνουν τις τιμές 0 και 1 αντίστοιχα. Η εντολή break μέσα σε μια while ή for τερματίζει τις επαναλήψεις. Η εντολή continue αγνοεί τις εντολές που ακολουθούν στην while ή for και πηγαίνει στην αρχή της επανάληψης. Η χρήση και των δύο συναρτήσεων πρέπει να γίνεται με φειδώ. Αν το πρόγραμμα μας πέσει σε ατέρμωνη επανάληψη τότε για να την διακόψουμε πρέπει να πατήσουμε Ctrl+C. Ασκήσεις
  1. Να γραφτεί πρόγραμμα που να διαβάζει βαθμούς μέχρι να δεχθεί αρνητικό αριθμό. Στην συνέχεια να εμφανίζει το μέσο όρο τους.
  2. Να γραφτεί πρόγραμμα που να διαβάζει 100 ηλικίες και να υπολογίζει τον μέσο όρο τους.
  3. Να γραφτεί πρόγραμμα σε γλώσσα Python, που να δέχεται 100 αριθμούς από τον χρήστη και να εμφανίζει το πλήθος των άρτιων αριθμών που πληκτρολογήθηκαν.
  4. Να γραφτεί πρόγραμμα σε γλώσσα Python, που να δέχεται αριθμούς από τον χρήστη μέχρι να δώσει το μηδέν και να εμφανίζει το πλήθος των περιττών που πληκτρολογήθηκαν.
  5. Να γραφτεί πρόγραμμα σε γλώσσα Python, που να δέχεται 100 αριθμούς από το πληκτρολόγιο. Στη συνέχεια να υπολογίζει και να εμφανίζει το πλήθος των θετικών, το πλήθος των αρνητικών και το πλήθος των μηδενικών που δόθηκαν.
  6. Να γραφτεί πρόγραμμα που να υπολογίζει το άθροισμα 1+2+3+…+100.
  7. Να γραφτεί πρόγραμμα που να υπολογίζει το άθροισμα 12+32+52+…+502.
  8. Σε ένα τμήμα 27 μαθητών Γ΄ Λυκείου, θέλουμε να υπολογίσουμε το ποσοστό των μαθητών που πήραν γραπτό βαθμό στη Πληροφορική κάτω από 10, το ποσοστό των μαθητών που πήραν βαθμό από 10 μέχρι 15 και το ποσοστό με βαθμό μεγαλύτερο του 15. Να γραφτεί πρόγραμμα, που να δέχεται τους βαθμούς των μαθητών, να υπολογίζει και να εμφανίζει τα παραπάνω ποσοστά.
  9. Για κάθε μαθητή δίνονται τα στοιχεία: ονοματεπώνυμο, προφορικός και γραπτός βαθμός ενός μαθήματος. Να γραφτεί πρόγραμμα που να εκτελεί τις παρακάτω λειτουργίες: i. Να διαβάζει τα στοιχεία πολλών μαθητών και σταματά, όταν δοθεί ως ονοματεπώνυμο το κενό. ii. Να ελέγχει αν ο προφορικός και ο γραπτός βαθμός είναι από 0 μέχρι 20. Στην περίπτωση που δεν είναι ο βαθμός στα επιτρεπτά όρια, να ξαναδιαβάζεται ο βαθμός μέχρι να δώσουμε τον σωστό βαθμό. iii. Να υπολογίζει τον τελικό βαθμό του μαθήματος, ο οποίος είναι άθροισμα του 30% του προφορικού βαθμού και του 70% του γραπτού βαθμού. Επίσης, να εμφανίζει το ονοματεπώνυμο του μαθητή και τον τελικό βαθμό του μαθήματος. iv. Να υπολογίζει και να εμφανίζει το πλήθος των μαθητών που έχουν βαθμό μεγαλύτερο του 18.
  10. Μία εταιρεία δημοσκοπήσεων θέτει σ’ ένα δείγμα 500 πολιτών ένα ερώτημα. Για την επεξεργασία των δεδομένων να αναπτυχθεί πρόγραμμα που: i. Να διαβάζει το φύλλο του πολίτη (Α= Άνδρας, Γ= Γυναίκα). ii. Να διαβάζει την απάντηση στο ερώτημα, η οποία μπορεί να είναι ‘ΝΑΙ’ ή ‘ΟΧΙ’ ή ‘ΔΕΝ ΞΕΡΩ’ . iii. Να υπολογίζει και να εμφανίζει το πλήθος των ατόμων που απάντησαν ‘ΝΑΙ’. iv. Να υπολογίζει και να εμφανίζει το πλήθος των ατόμων που απάντησαν ‘ΟΧΙ’. v. Στο πλήθος των ατόμων που απάντησαν ‘ΝΑΙ’ να υπολογίζει και να εμφανίζει το ποσοστό των ανδρών και το ποσοστό των γυναικών.
  11. Ένα σχολείο αποφάσισε να πάει μια 3ήμερη εκδρομή. Να γίνει πρόγραμμα που θα εκτελεί τα παρακάτω: i. Να δίνει το σύνολο των μαθητών του σχολείου. ii. Για κάθε μαθητή θα δίνεται το ερώτημα “Θέλεις να πας εκδρομή (ΝΑΙ/ΟΧΙ) ;” iii. Ο μαθητής θα απαντά στο παραπάνω ερώτημα με ΝΑΙ ή ΟΧΙ. iv. Να υπολογίζει και να εμφανίζει το πλήθος και το ποσοστό των μαθητών που απάντησαν “ΝΑΙ”.
  12. Να γραφτεί πρόγραμμα που να δέχεται αριθμούς μέχρι να πληκτρολογήσουμε το 100. Το πρόγραμμα να υπολογίζει και να εμφανίζει το άθροισμα, το πλήθος και το μέσο όρο των αριθμών που δόθηκαν. Ο αριθμός 100, που σηματοδοτεί και το τέλος της πληκτρολόγησης, να λαμβάνεται υπόψη στους παραπάνω υπολογισμούς.
  13. Στα Μαθηματικά, οι Αριθμοί Φιμπονάτσι (Fibonacci ) είναι οι αριθμοί της παρακάτω ακέραιης ακολουθίας: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, …  Εξ ορισμού, οι πρώτοι δύο αριθμοί Φιμπονάτσι είναι το 0 και το 1, και κάθε επόμενος αριθμός είναι το άθροισμα των δύο προηγούμενων. Να γραφτεί πρόγραμμα που να διαβάζει ένα ακέραιο αριθμό και να υπολογίζει και να εμφανίζει τους όρους της ακολουθίας Fibonacci που είναι μικρότεροι από τον αριθμό αυτό. Λύση
    # Αριθμοί Fibonacci (κάθε αριθμός είναι άθροισμα των 2 προηγούμενων)
    orio=int(input("Δώστε το ανώτατο όριο για την ακολουθία Fibonacci: "))
    a, b = 0, 1
     
    while b < orio:
        temp=a
        a=b
        b=temp+b
        print(b, end="/")
    Ακολουθεί μια δεύτερη πιο σύντομη λύση
    # Αριθμοί Fibonacci (κάθε αριθμός είναι άθροισμα των 2 προηγούμενων)
    orio=int(input("Δώστε το ανώτατο όριο για την ακολουθία Fibonacci: "))
    a, b = 0, 1
    
    while b < orio:
        print(b, end="/")
        a, b = b, a+b
  14. Να γραφτεί πρόγραμμα για 35 μαθητές, που να δίνονται οι μέσοι όροι των βαθμών τους. Το πρόγραμμα να υπολογίζει και να εμφανίζει: i. Τον μεγαλύτερο βαθμό ii. Τον μικρότερο βαθμό, και iii. Τον μέσο όρο όλων των βαθμών.
  15. Η εικασία του Lothar  Collatz διατυπώθηκε από τον ίδιο το 1937 και μέχρι τώρα δεν έχει αποδειχθεί: Έστω ν ένας τυχαίος ακέραιος αριθμός. Αν ο ω είναι άρτιος τότε πρέπει να τον διαρέσουμε με το 2 ενώ αν είναι περιττός να τον πολλαπλασιάσουμε με το 3 και να προσθέσουμε 1. Αν επαναλάβετε αυτή την απλή διαδικασία στο τέλος θα καταλήξουμε με  τον αριθμό 1. Να γραφεί πρόγραμμα που διαβάζει ένα τυχαίο ακέραιο αριθμό και εμφανίζει όλες τις μετατροπές του μέχρι να γίνει 1. Λύση
    x=int(input("Δώσε αριθμό:"))
    
    while x!=1:
        if x%2==0 :
            x=int(x/2)
            print(x)
        else:
            x=3*x+1
            print(x)
  16. Να γραφτεί πρόγραμμα που επιλέγει ένα τυχαίο ακέραιο αριθμό μεταξύ 1 εως 100 και στην συνέχεια μας ζητάει να μαντέψουμε τον αριθμό. Αν δεν τον βρούμε τότε μας ενημερώνει για το αν ο αριθμός που μαντέψαμε είναι μικρότερος ή μεγαλύτερος από αυτον που επέλεξε το πρόγραμμα. Ο χρήστης επιτρέπεται να δοκιμάσει μέχρι και 7 φορές. Λύση
    import random
    tyxaios = random.randint(1, 100)
    
    for n in range(1, 7):
        print("Έχετε "+str(8-n)+' προσπάθειες. Ποιός είναι ο αριθμός;')
        x= int(input())
        if x< tyxaios : 
            print('Μαντέψατε μικρότερο αριθμό.') 
        elif x> tyxaios :
            print('Μαντέψατε μεγαλύτερο αριθμό')
        else:
            print('Μπράβο το βρήκατε έπειτα από '+str(n)+" προσπάθειες")
            break
    
    if x!= tyxaios :
        print('Δεν τα καταφέρατε. Ο μυστικός αριθμός ήταν: ' + str(tyxaios))

Python - Συναρτήσεις- Αντικειμενοστραφής Προγραμματισμός

Συναρτήσεις

Υπάρχουν κάποιες συναρτήσεις που όταν τις χρειαστούμε απλά τις καλούμε όπως π.χ. input, print και len. Αυτές καλούνται built-in (ενσωματωμένες). Για να δείτε όλες τις ενσωματωμένες συναρτήσεις κάντε κλικ εδώ. Οι υπόλοιπες συναρτήσεις είναι ομαδοποιημένες. Για να χρησιμοποιήσουμε μία τέτοια συνάρτηση θα πρέπει πρώτα να γράψουμε import όνομα_ομάδας. Παραδείγματα:
  • Η συνάρτηση randint(x,y) επιστρέφει ένα τυχαίο ακέραιο μεταξύ x και y και ανήκει στην ομάδα με όνομα random. Για να την χρησιμοποιήσουμε πρέπει πρώτα να γράψουμε import random. Στην Python οι ομάδες αποκαλούνται βιβλιοθήκες (modules).
  • Ένα πρόγραμμα τερματίζεται αυτόματα όταν εκτελεστεί και η τελευταία εντολή. Για να προκαλέσουμε τερματισμό νωρίτερα μπορούμε να χρησιμοποιήσουμε την συνάρτηση sys.exit()  που ανήκει στην ομάδα (module) sys. Άρα πρέπει κάπου στην αρχή να έχουμε γράψει import sys.
Μπορούμε να φτιάξουμε και δικές μας συναρτήσεις. Η σύνταξη είναι:
def    όνομα_συνάρτησης ( παράμετροι ):
    """ Σύντομη περιγραφή του τι κάνει η συνάρτηση """
    Εντολές 
    return αποτέλεσμα
και ένα παράδειγμα:
def artios_perittos (x):      # Η μεταβλητή x λέγεται παράμετρος (parameter)
    if x % 2 == 0:
        return "Είναι άρτιος"
    else:
        return "Είναι περιττός"

print(artios_perittos(345))  # το 345 λέγεται Όρισμα (argument)
Προσοχή! Οι εντολές που ακολουθούν την εντολή return δεν εκτελούνται. Στην περίπτωση που μια συνάρτηση δεν περιλαμβάνει την εντολή return τότε επιστρέφει την τιμή None. Αν μία συνάρτηση έχει περισσότερες από μία παραμέτρους και φοβόμαστε μήπως μπερδέψουμε την σειρά των μεταβλητών όταν την καλούμε:
def συνάρτηση1 (ηλικία, βάρος):
    print("Η ηλικία μου είναι:", ηλικία, "ενώ το βάρος μου είναι :", βάρος)

συνάρτηση1(βάρος=90, ηλικία=53)
Οι μεταβλητές σε μια συνάρτηση είναι τοπικές, δηλαδή όταν ολοκληρωθεί μία συνάρτηση αυτές διαγράφονται από την μνήμη. Οι μεταβλητές στο κυρίως πρόγραμμα είναι καθολικές, δηλαδή διαγράφονται όταν τερματίσει το πρόγραμμα. Με τις μεταβλητές ισχύουν τα ακόλουθα:
  • Δεν μπορούμε να χρησιμοποιήσουμε μία τοπική μεταβλητή πουθενά αλλού παρά μόνο μέσα στην συνάρτηση της.
  • Αντίθετα, μπορούμε να χρησιμοποιήσουμε μία καθολική μεταβλητή μέσα σε οποιαδήποτε συνάρτηση.
  • Επιτρέπεται η χρήση του ίδιου ονόματος για δύο (ή περιοσσότερες) μεταβλητές αρκεί να μην βρίσκονται στην ίδια συνάρτηση ή και οι δύο στο κυρίως πρόγραμμα.
  • Οι αλλαγές που κάνει μια συνάρτηση σε μία λίστα που έχει λάβει ως παράμετρο, είναι μόνιμες.
Όπως αναφέρθηκε νωρίτερα, τα αρθρώματα (Modules) είναι ομάδες συναρτήσεων. Υπάρχουν διάφορες μέθοδοι γα να γράφετε αρθρώματα, αλλά ο απλούστερος τρόπος είναι δημιουργώντας ένα αρχείο με επέκταση .py το οποίο θα περιέχει συναρτήσεις. Έστω το αρχείο οι_συναρτήσεις_μου.py που περιέχει τις εξείς δύο συναρτήσεις:
def μέσος_όρος (x,y):
    return((x+y)/2)
        
def μέγιστος (x,y):
    if x > y:
        return(x)
    else:
        return(y)
Έστω ακόμη ένα αρχείο με το όνομα το_πρόγραμμα_μου.py . Αν θέλουμε να χρησιμοποιήσουμε μέσα σε αυτό τις συναρτήσεις του αρχείου οι_συναρτήσεις_μου.py τότε θα πρέπει να γράψουμε:
import οι_συναρτήσεις_μου      # ή εναλλακτικά: from οι_συναρτήσεις_μου import *
οι_συναρτήσεις_μου.μέσος_όρος(4,8)
οι_συναρτήσεις_μου.μέγιστος(4,8))
Επειδή το όνομα οι_συναρτήσεις_μου είναι μεγάλο μπορούμε να το αντικαταστήσουμε με κάτι πιο χρηστικό:
import οι_συναρτήσεις_μου as δ
δ.μέσος_όρος(4,8)
δ.μέγιστος(4,8))
Ασκήσεις
  1. Να γραφτεί συνάρτηση που δέχεται έναν αριθμό και επιστρέφει την απόλυτη τιμή του.
  2. Να γραφτεί συνάρτηση που δέχεται τρες; ακέραιους αριθμούς (ώρες, λεπτά και δευτερόλεπτα) και επιστρέφει  πόσα είναι τα συνολικά δευτερόλεπτα.
  3. Να γραφτεί συνάρτηση που δέχεται δύο αριθμούς ή δύο συμβολοσειρές και επιστρέφει ως τιμή το άθροισμα των αριθμών ή τη συνένωση των συμβολοσειρών αντίστοιχα.
  4. Να γραφτεί συνάρτηση που δέχεται ένα όνομα και το έτος γέννησης κάποιου ανθρώπου και επιστρέφει το έτος κατά το οποίο θα γίνει 100 χρονών.
  5. Να γραφτεί συνάρτηση που διαβάζει έναν ακέραιο αριθμό και επιστρέφει το παραγοντικό του. Υπενθύμιση:  ν!=1*2* … *ν.
  6. Να γραφτεί συνάρτηση που θα δέχεται ακέραιο αριθμό και θα εμφανίζει μήνυμα αν είναι πρώτος ή όχι. (Πρώτοι ονομάζονται οι ακέραιο αριθμοί μεγαλύτεροι του 1 που διαιρούνται μόνο με τον εαυτό τους και το 1). Με την βοήθεια αυτής της συνάρτησης εμφανίστε τους πρώτους αριθμούς μέχρι το 1000.
  7. Να γραφούν 6 συναρτήσεις που κάνουν μετατροπή από μια μονάδα μέτρησης σε άλλη, σύμφωνα με τον πίνακα που ακολουθεί .  Να γραφεί πρόγραμμα που διαβάζει την ποσότητα και ένα αριθμό από 1-6 που αντιστοιχεί σε μία από τις μεταροπές και εμφανίζει το τελικό αποτέλεσμα της μεταροπής. Αν λοιπόν κάποιος θέλει να μετατρέψει τα 20 ναυτικά μίλια σε χιλιόμετρα θα πρέπει να δώσει τους αριθμούς 20 και 1 και θα εμφανίσει  37,04 χιλιόμετρα (20*1.852).
    Τι μετατρέπει όνομα συνάρτησης συντελεστής μεταροπής
    1 ναυτικά μίλια σε χιλιόμετρα nm2km 1,852
    2 χιλιόμετρα σε  ναυτικά μίλια km2nm 0.54
    3 πόδια σε μέτρα feet2m 0.3048
    4 μέτρα σε πόδια m2feet 3.28
    5 γαλόνια σε λίτρα gallons2lt 3.78
    6 λίτρα σε γαλόνια lt2gallons 0.2641

Λίστες

Μοιάζουν με τους πίνακες που συναντάμε στις περισσότερες γλώσσες προγραμματισμού αλλά μας παρέχουν περισσότερη ευελιξία. Η Λίστα είναι μια δομή δεδομένων. Είναι ένα διατεταγμένο σύνολο στοιχείων/αντικειμένων όχι κατ’ανάγκη του ίδιου τύπου (συνήθως είναι του ίδιου τύπου) και περιλαμβάνονται μεταξύ των συμβόλων των αγκυλών [  … ].Ένα στοιχείο μιας Λίστας μπορεί να επαναλαμβάνεται περισσότερες από μία φορές.
lista1=[1,5,"Κώστας",9,1,"Κώστας"]
lista2=[]   # κενή λίστα
Για να αναφερθούμε στο 1ο στοιχείο μιας λίστας πρέπει να γράψουμε όνομα_λίστας[0], για το δεύτερο όνομα_λίστας[1] κοκ. Επίσης για το τελευταίο στοιχείο , το προτελευταίο, κοκ μπορούμε να γράψουμε αντίστοιχα όνομα_λίστας[-1], όνομα_λίστας[-2] κοκ.
lista1=[1,5,"Κώστας",9,1,"Κώστας"]
print(lista1[0])        #Θα εμφανίσει 1
print(lista1[2:5])        #Θα εμφανίσει ["Κώστας",9,1]
print(lista1[-3])       #Θα εμφανίσει το τρίτο στοιχείο από το τέλος (9) 

print(lista1)           #Πρώτος τρόπς να εμφανιστεί ολόκληρη η λίστα

for x in lista1:        #Δεύτερος τρόπος να εμφανιστεί ολόκληρη η λίστα
    print (x)

for x in range(0,6,1):  #Τρίτος τρόπος να εμφανιστεί ολόκληρη η λίστα (lista1[0]) εως lista1[5])
    print (lista1[x])
while lista1:    #Τέταρτος τρόπος να εμφανιστεί ολόκληρη η λίστα. Για να τερματιστεί η while πρέπει η λίστα να είναι άδεια
    x=lista1.pop()
    print (x)
Επιτρέπεται λίστα μέσα σε λίστα.
lista2 = [['Τήνος', 'Σύρος', "Πάρος"], [10, 20, 30, 40, 50]]
print(lista2[0][1])    # θα εμφανίσει την λέξη Σύρος
Μπορούμε να διαγράψουμε διαδοχικά στοιχεία της λίστας με την εντολή del Όνομα_λίστας[ν1:ν2], όπου ν1 η θέση του πρώτου στοιχείου προς διαγραφή και ν2 η θέση του επόμενου από το τελευταίο προς διαγραφή. Θα διαγράψει δηλ τα στοιχεία που είναι στις θέσεις ν1, ν1+1, …, ν2-1. Θυμίζουμε οτι το πρώτο κελί είναι στην θέση 0.
lista1=[1,5,"Κώστας",9,1,"Κώστας"]
del lista1[1:4]
print(lista1)    # θα εμφανίσει [1, 1, 'Κώστας']
Για να τροποποίησουμε ένα στοιχείο απλά εκχωρούμε μία τιμή σε αυτό.
lista1=[1,5,"Κώστας",9,1,"Κώστας"]
lista1[2]="Μαρία"
print(lista1)    # θα εμφανίσει [1, 5, 'Μαρία', 9, 1, 'Κώστας']
Χρήσιμοι Μέθοδοι για Λίστες
lista1= ["Κρήτη", "Χίος", "Σάμος", "Κύπρος"]

print(lista1.index("Χίος"))      # Θα επιστρέψει την τιμή 1

lista1.append("Ρόδος")    # Θα προσθέση την Ρόδο στο τέλος της λίστας.
print(lista1)     # Θα εμφανίσει ['Κρήτη', 'Χίος', 'Κύπρος', 'Ρόδος']

lista1.insert(2,"Άνδρος")    # Θα προσθέση την Άνδρο ανάμεσα στο 2ο και 3ο στοιχείο.
print(lista1)     # Θα εμφανίσει ['Κρήτη', 'Χίος', 'Άνδρος', 'Κύπρος', 'Ρόδος']

lista1.remove("Χίος")  # Θα διαγράψει το στοιχείο Χίος
lista1.pop(2) # Θα διαγράψει το 3o στοιχείο και θα επιστρέψει την τιμή του - Ρόδος
print(lista1) # Θα εμφανίσει ['Κρήτη', 'Άνδρος', 'Κύπρος', 'Ρόδος']

lista1.sort()    # Ταξινομεί τα στοιχεία κατά αύξουσα σειρά
print(lista1) # Θα εμφανίσει ['Άνδρος', 'Κρήτη', 'Κύπρος', 'Ρόδος', 'Σάμος']

lista1.sort(reverse=True) # Ταξινομεί τα στοιχεία κατά φθίνουσα σειρά
print(lista1) # Θα εμφανίσει ['Σάμος', 'Ρόδος', 'Κύπρος', 'Κρήτη', 'Άνδρος']


lista1= ["κρήτη", "Χίος", "σάμος", "Κύπρος"]
lista1.sort()  # Ταξινομεί τα στοιχεία κατά αύξουσα σειρά αλλά τα κεφαλαία γράμματα προηγούνται των πεζών
print(lista1) # Θα εμφανίσει ['Κύπρος', 'Χίος', 'κρήτη', 'σάμος']

lista1.sort(key=str.lower)  # Ταξινομεί τα στοιχεία κατά αύξουσα σειρά χωρίς διάκριση πεζών-κεφαλαίων
print(lista1) # Θα εμφανίσει ['κρήτη', 'Κύπρος', 'σάμος', 'Χίος']

lista1.sort(key=str.lower,reverse=True )  # Ταξινομεί τα στοιχεία κατά φθίνουσα σειρά χωρίς διάκριση πεζών-κεφαλαίων
print(lista1) # Θα εμφανίσει ['Χίος', 'σάμος', 'Κύπρος', 'κρήτη']
print(sorted(lista1)) # Θα εμφανίσει την λίστα ταξινομημένη αλλά μόνο για αυτή την εντολή.
lista1.reverse()  # αντιστρέφει μόνιμα, την διάταξη των στοιχείων
Το κείμενο δεν είναι παρά μία λίστα χαρακτήρων. Κάθε χαρακτήρας και ένα διαφορετικό στοιχείο της λίστας.
for x in "Αρνάκι άσπρο και παχύ":
    print(x)      # Εμφανίζει ένα ένα τα γράμματα του κειμένου
Προσοχή: Σε αντίθεση με τις λίστες στο κείμενο δεν μπορούμε να αλλάξουμε κάποιους χαρακτήρες. Το ακόλουθο τμήμα προγράμματος είναι λάθος.
x="Αρνάκι άσπρο και παχύ"
x[0:5]="Παπάκι"
print(x)
Ο σωστός τρόπος είναι :
x="Αρνάκι άσπρο και παχύ"
y="Παπάκι"+x[6:len(x)]
print(y)
Ένας τρόπος να φτιάξουμε μία λίστα αριθμών
άρτιοι=list(range(2,101,2)) # η λίστα θα περιλαμβάνει 2,4,6, ... 100
print(άρτιοι)
Κάποιες χρήσιμες συναρτήσεις για αριθμητικές λίστες:
άρτιοι=[12, 3, 55, 6, 31, 2, 9, 100, 23, 45]
print(min(άρτιοι))
print(max(άρτιοι))
print(sum(άρτιοι))
Δημιουργία λίστας σε μία γραμμή:
τετράγωνα =[x**2 for x in range(1, 101, 1)]
print(τετράγωνα)
Δημιουργία λίστας αντίγραφο μιας άλλης:
Λίστα1 =[1,2,3,4,5,6,7,8,9]
Λίστα2=Λίστα1[:]
print(Λίστα2)
Ένας τρόπος να ελέγξουμε αν μία λίστα είναι άδεια:
Λίστα1 =[]
if Λίστα1:
    print('θα εκτελεστούν οι εντολές που βρίσκονται εδώ αν η λίστα δεν είναι άδεια')
else:
    print('θα εκτελεστούν οι εντολές που βρίσκονται εδώ αν η λίστα είναι άδεια')
print(Λίστα2)

Δημιουργία λίστας

lista1=[1,5,"Κώστας",9,1,"Κώστας"]
lista2=[]   # κενή λίστα
nums = list(range(1, 101))   # [1,2,3, ..., 100] 
tel_tetragona = [x**2 for x in nums]
tel_tetragona = [x**2 for x in range(1, 101)]

Πρόσβαση σε στοιχεία της λίστας

proto = lista1[0]  # πρώτο στοιχείο
teleutaio= lista1[-1] # τελευταίο στοιχείο

Μετατροπή στοιχείου

lista1[0]=100      # πρώτο στοιχείο
lista1[-1]="Νίκος" # τελευταίο στοιχείο
lista1[1:3]        # από 2ο μέχρι 3ο

Προσθήκη στοιχείου

lista1.append("Ρόδος") # Θα προσθέση την Ρόδο στο τέλος της λίστας. 
lista1.insert(2,"Άνδρος") # Θα προσθέση την Άνδρο ανάμεσα στο 2ο και 3ο στοιχείο. print(lista1)

Διαγραφή στοιχείου

lista1.remove("Χίος") # Θα διαγράψει το στοιχείο Χίος 
del lista1[2] # Θα διαγράψει το 3o στοιχείο
lista1.pop(2) # Θα διαγράψει το 3o στοιχείο και θα επιστρέψει την τιμή του

Πλήθος στοιχείων λίστας

len(lista1)

Ταξινόμηση

lista1.sort() # Ταξινομεί τα στοιχεία κατά αύξουσα σειρά αλλά τα κεφαλαία γράμματα προηγούνται των πεζών 
lista1.sort(key=str.lower) # Ταξινομεί τα στοιχεία κατά αύξουσα σειρά χωρίς διάκριση πεζών-κεφαλαίων 
lista1.sort(key=str.lower,reverse=True ) # Ταξινομεί τα στοιχεία κατά φθίνουσα σειρά χωρίς διάκριση πεζών-κεφαλαίων 
sorted(lista1) # Θα εμφανίσει την λίστα ταξινομημένη ΠΡΟΣΩΡΙΝΑ. 
lista1.reverse() # αντιστρέφει μόνιμα, την διάταξη των στοιχείων

Σάρωση όλων στοιχείων λίστας

for x in lista1:         #Πρώτος τρόπος να εμφανιστεί ολόκληρη η λίστα 
    print (x)
for x in range(0,6,1): #Δεύτερος τρόπος να εμφανιστεί ολόκληρη η λίστα (lista1[0]) εως lista1[5]) print (lista1[x]) while lista1: #Τρίτοςτρόπος να εμφανιστεί ολόκληρη η λίστα. Για να τερματιστεί η while πρέπει η λίστα να είναι άδεια x=lista1.pop() print (x)

Μέγιστο , Ελάχιστο, Άθροισμα

max(lista1)
min(lista1)
sum(lista1)

Τμήμα λίστας

lista1[1:3]   # από το 2ο μέχρι 3ο
lista2=lista1[:]     # δημιουργεί αντίγραφο της λίστας

xxxxxxxxxxxxxxxxxxxxxx

xxxxxxxxxxxxxxxxxxxxxxxxxx
Ασκήσεις (https://www.w3resource.com/python-exercises/list/)
  1. Να γραφεί συνάρτηση που δέχεται μια λίστα αριθμών και επιστρέφει τον μεγαλύτερο αριθμό.
  2. Να γραφεί συνάρτηση που δέχεται μια λίστα λέξεων(αλφαριθμητικών) και επιστρέφει το πλήθος των λέξεων  που έχουν τουλάχιστον δύο χαρακτήρες και ο πρώτος με τον τελευταίο είναι ακριβώς ίδιοι.
  3. Να γραφεί συνάρτηση που δέχεται έναν ακέραιο αριθμό και επιστρέφει μία λίστα με όλους τους διαιρέτες του.
  4. Να γραφεί συνάρτηση που δέχεται λίστα αριθμών και δημιουργεί νέα λίστα με τους ίδιους αριθμούς αλλά χωρίς διπλοεγγαφές.
  5. Να γραφεί συνάρτηση που δέχεται δύο λίστες και επιστρέφει την τιμή Αληθής εάν αυτές έχουν έστω και ένα κοινό στοιχείο.
  6. Να γραφεί συνάρτηση που δέχεται μια λίστα ακέραιων τιμών και επιστρέφει την λίστα χωρίς τις άρτιες τιμές.
  7. Έστω η λίστα months = [“Ιανουάριος”, “Φεβρουάριος”, “Μαρτιος”, “Απριλιος”, “Μάριος”, “Ιουνιος”, “Ιουλιος”, “Αύγουστος”, “Σεπτέμβριος”, “Οκτωβριος”, “Νοεμβριος”, “Δεκεμβριος”]. Να γραφεί πρόγραμμα που διαβάζει ένα ακέραιο από 1 μέχρι 12 και εμφανίζει το όνομα του αντίστοιχου μήνα.
  8. Να γραφεί συνάρτηση που δέχεται μια άδεια λίστα και ένα ακέραιο αριθμό έστω ν και  επιστρέφει την λίστα με με ν τυχαίους ακέραιους αριθμούς, Στην συνέχεια να φραφεί πρόγραμμα που με την βοήθεια της συνάρτησης αυτής θα δημιουργεί δύο λίστες με 10 και 20 τιμές και θα δημιουργεί και θα εμφανίζει μία τρίτη λίστα που θα έχει τους αριθμούς που είναι κοινοί στις δύο λίστες.
  9. Κάθε χαρακτήρας αποθηκευέται στο υπολογιστή σαν αριθμός. Το σύστημα που χρησιμοποιείται για την μετατροπή χαρακτήρων σε αριθμούς και αντίστροφα λέγεται Unicode (utf-8). Η συνάρτηση ord(“Α”) επιστρέφει τον αριθμό που αντιστοιχεί στον χαρακτήρα Α (για το ελληνικό Α είναι 913), η συνάρτηση chr(913) κάνει το αντίθετο. Να φτιάξετε πρόγραμμα που διαβάζει ένα κείμενο και το κωδικοποιεί μετατρέποντας κάθε χαρακτήρα στον επόμενο του σύμφωνα με το σύστημα utf-8. Στο τέλος να εμφανίζει το κωδικοποιημένο κείμενο. Να φτιάξετε ένα δεύτερο πρόγραμμα που θα αποκωδικοποιεί τα κρυπτογραφημένα μηνύματα του πρώτου προγράμματος και θα το εμφανίζει.
Ασκήσεις
  1. def find_max(lista):
        max=lista[0]
        for i in lista:
           if i>max:
               max=i
        return max
    
    l=[1,2,33,4,5,6,7,8,9,0]
    print(find_max(l))
  2. def πλήθος(lista):
        m=0
        for i in lista:
            if len(i)>1 and i[0]==i[-1]:
                m=m+1
        return m
    l=[“aba”, “asdfas”, “sfghfs”] print(πλήθος(l))
  3. n = int(input("Πληκτρολογήστε έναν ακέραιο αριθμό."))
    ολοι = list(range(1,n+1))
    διαιρέτες = []
    for number in ολοι:
        if num % number == 0:
        διαιρέτες .append(number)
    
    print(divisorList)
  4. xxxxxxxxxxxxxxxxxx
  5. xxxxxxxxxxxxxxxxxx
  6. months = ["Ιανουάριος", "Φεβρουάριος", "Μαρτιος", "Απριλιος", "Μάριος", "Ιουνιος", "Ιουλιος", "Αύγουστος", "Σεπτέμβριος", "Οκτωβριος", "Νοεμβριος", "Δεκεμβριος"]
    x = int(input("Πληκτρολογήστε αριθμό μήνα:"))
    print(months[x-1])
  7. import random
    list1=[]
    list2=[]
    list3=[]
    
    def random_list(my_list,n):
        for i in range(1,n+1,1):
            x =random.randint(0,20)
            my_list.append(x)
    
    random_list(list1, 10)
    random_list(list2, 20)
    
    for i in list1:
        if i in list2 and i not in list3:
            list3.append(i)
    
    print(list1,list2, list3, sep="\n")
    
  8. # Πρόγραμμα κρυπτογράφησης 
    keimeno1=input("Δώστε κείμενο προς κρυπτογράφηση:")
    
    keimeno2=""
    for x in keimeno1:
        keimeno2=keimeno2+chr(ord(x)+1)
    
    print(keimeno2)
    # Πρόγραμμα αποκρυπτογράφησης
    keimeno2=input("Δώστε κείμενο προς αποκρυπτογράφηση:")
    
    keimeno1=""
    for x in keimeno2:
        keimeno1=keimeno1+chr(ord(x)-1)
    
    print(keimeno1)
  9. χχχχχχχχ
  10. xxxxxxxxxxxxxxxxxx
  11. xxxxxxxxxxxxxxxxxx
  12. xxxxxxxxxxxxxxxxxx
Lorem ipsum dolor sit amet, consectetur adipiscing elit. Ut elit tellus, luctus nec ullamcorper mattis, pulvinar dapibus leo.

Tuple και Dictionary

Tuples (Πλειάδες). Μοιάζουν καταπληκτικά με τις λίστες. Έχουν όμως δύο διαφορές:
  • αντί για αγκύλες [ ] χρησιμοποιούμε παρενθέσεις ( ) και
  • Τα στοιχεία τους δεν μπορούν να τροποποιηθούν (παραμένει σταθερή).
Δύο χρήσιμες συναρτήσεις για μετατροπή σε λίστα ή tuple είναι η tuple() και list().
x=tuple(['ένα', 'δύο', 15])
print(x)    # Θα εμφανίσει ('ένα', 'δύο', 15)

y=list(('ένα', 'δύο', 15))
['ένα', 'δύο', 15]

z=list('hello')
['h', 'e', 'l', 'l', 'o']
Dictionaries. Μοιάζουν με τις λίστες. Αντί για αγκύλες έχουν άγκιστρα {“κλειδί1” : “τιμή1”, “κλειδ2” : “τιμή2”, “κλειδί3” : “τιμή3” } Η σημαντικότερη διαφορά είναι οτι κάθε στοιχείο τους (value) πρέπει να συνδυάζεται με μία τιμή (key). Η σειρά είναι key (κλειδί)-value (τιμή). Για παράδειγμα, ας υποθέσουμε ότι θέλουμε να συσχετίσουμε κάποιους Αγγλικούς όρους με τους αντίστοιχους ελληνικούς.
x={"Γεια":"hello", "Καλημέρα":"Goodmorning", "Καληνύχτα":"Goodnight"}   # Γειά είναι το κλειδί, ενώ hello είναι η τιμή
x['Αετός']="Eag"     # από python 3.7 και μετά κάθε νέο στοιχείο μπαίνει τελευταίο
x['Αετός']="Eagle" # επειδή ήδη υπάρχει το τροποποιεί
del x['Γεια']  # διαγράφει το αντίστοιχο στοιχείο
print(x['Νησί'])  # Θα εμφανίσει λάθος διότι δεν υπάρχει. Καλύτερα να χρησιμοποιηθεί η get που ακολουθεί
print(x.get('Νησί', 'Μήνυμα που θα εμφανιστεί αν δεν υπάρχει το Νησί'))
Για να διατρέξουμε όλα τα ζεύγη κλειδί-τιμή γράφουμε:
x = {"Κική": "26/08/66","Χαρά": "12/03/87", "Νίκος": "02/10/99"}
for όνομα, ημερομηνία in x.items():
    print(όνομα, ημερομηνία)
Για να διατρέξουμε όλα τα κλειδιά γράφουμε:
x = {"Κική": "26/08/66","Χαρά": "12/03/87", "Νίκος": "02/10/99"}
for όνομα in x.keys():
    print(όνομα)
for όνομα, ημερομηνία in sorted(x.keys()):  # γίνεται πρώτα ταξινόμηση ως προς τα κλειδιά 
    print(όνομα)
Για να διατρέξουμε όλες τις τιμές γράφουμε:
x = {"Κική": "26/08/66","Χαρά": "12/03/87", "Νίκος": "02/10/99"}
for όνομα in x.values():
    print(ημερομηνία )
Στο πρόγραμμα που ακολουθεί έχουν ήδη καταχωρηθεί τα ονόματα και οι ημερομηνίες γέννησης κάποιων ανθρώπων. Ο χρήστης καλείται να πληκτρολογήσει ένα όνομα. Αν το όνομα υπάρχει καταχωρημένο τότε εμφανίζεται η ημερομηνία γέννησης αλλιώς εμφανίζεται μήνυμα που ζητάει την ημερομηνία γέννησης. Το νέο όνομα και η ημερομηνία προστίθενται στο dictionary και η διαδικασία επαναλαμβάνεται μέχρι ο χρήστης να πληκτρολογήσει την λέξη ΤΕΛΟΣ.
x = {"Κική": "26/08/66","Χαρά": "12/03/87", "Νίκος": "02/10/99"}


while True:
    onoma = input("Γράψτε το όνομα ή την λέξη ΤΕΛΟΣ για να τερματίσετε το πρόγραμμα)")
    if onoma == "ΤΕΛΟΣ":
        break
    if onoma in x:
        print("Το όνομα που ζητήσατε είναι: "+onoma+". Τα γενέθλια είναι:"+x[onoma])
    else:
        print("Δεν ξέρω κανέναν με το όνομα: " + onoma)
        x[onoma] = input("Δώστε ημερομηνία γέννησης: ")
        print("Το όνομα και η ημερομηνία γεννήσεως προστέθηκαν!")

Κλάσεις

Στον αντικειμενστραφή προγραμματισμό οι κλάσεις αντικατοπτρίζουν αντικείμενα από τον κόσμο στον οποίο ζούμε. Η παρακάτω κλάση αντιστοιχεί στο αυτοκίνητο.
class Αμάξι:             # CamelCase notation
    """Μια απλή αναπαράσταση αυτοκινήτου"""

    def __init__(self,κατασκευαστής, μοντέλο, χρονιά):            # Οι μεταβλητές στην παρένθεση ονομάζονται παράμετροι
        """Αρχικοποίηση ιδιοτήτων (χαρακτηριστικών- atributes)"""
        self.κατασκευαστής=κατασκευαστής                          # Οι μεταβλητές μέσα στην συνάρτηση ονομάζονται ιδιότητες ή χαρακτηριστικά (attributes)  
        self.μοντέλο = μοντέλο
        self.χρονιά = χρονιά
        self.χιλιόμετρα=0

    def πληροφορίες(self):
        """Εμφανίζει συγκεντρωμένες όλες τις πληροφορίες του αυτοκινήτου"""
        print("Κατασκευατής: "+self.κατασκευαστής)
        print("Μοντέλο: "+self.μοντέλο)
        print("Χρονολογία: "+self.χρονιά)
Η κλάση είναι το “καλούπι” από το οποίο κατασκευάζονται τα αυτοκίνητα (αντικείμενα ή αλλιώς στιγμιότυπα) που θέλουμε να έχουμε σε ένα πρόγραμμα. Η πρώτη εντολή παρακάτω δημιουργεί ένα αντικείμενο από την κλάση Αμάξι, δηλαδή ένα αυτοκίνητο με συγκεκριμένα χαρακτηριστικά. Η δεύτερη εντολή καλεί την συνάρτηση πληροφορίες από το ίδιο αντικείμενο.
Αμάξι1=Αμάξι("Opel", "Astra", "2007")
Αμάξι1.πληροφορίες()
print(Αμάξι1.__doc__)   # εμφανίζει το docstring της κλάσης
Μια καλή αναλογία για να περιγράψουμε την σχέση κλάσης και αντικειμένου είναι τα διάφορα έντυπα/φόρμες που μας ζητάνε να συμπληρώσουμε. Η πρωτότυπη φόρμα από την οποία βγάζουμε αντίγραφα (φωτοτυπίες) είναι η κλάση. Το αντίγραφο όταν συμπληρωθεί αποτελεί ένα αντικείμενο (στιγμιότυπο). Παρατηρήσεις
  • Μία κλάση μπορεί να έχει όσες συναρτήσεις θέλουμε. Οι συναρτήσεις ονομάζονται μέθοδοι.
  • Η συνάρτηση  __init__ εκτελείται αυτόματα κάθε φορά που δημιουργούμε ένα αντικείμενο.
Οι ιδιότητες μπορούν να περιέχουν αντικείμενα.
class Μπαταρία:
    def __init__(self, ημ_λήξης, χωρητικότητα):
        self.ημ_λήξης=ημ_λήξης
        self.χωρητικότητα=χωρητικότητα
    def χρόνος_απομένει(self):
        pass

class Αμάξι: # CamelCase notation
    def __init__(self,κατασκευαστής, μοντέλο, χρονιά, ημ_λήξης, χωρητικότητα):
        self.κατασκευαστής=κατασκευαστής
        self.μοντέλο = μοντέλο
        self.χρονιά = χρονιά
        self.χιλιόμετρα=0
        self.μπαταρία=Μπαταρία(ημ_λήξης, χωρητικότητα) # Η ιδιότητα μπαταρία είναι αντικείμενο από την κλάση Μπαταρία

def πληροφορίες(self):
print("Κατασκευατής: "+self.κατασκευαστής)
print("Μοντέλο: "+self.μοντέλο)
print("Χρονολογία: "+self.χρονιά)

Αμάξι1 = Αμάξι("Opel", "Astra", "2007", "24/03/2025", 60)
print(Αμάξι1.μπαταρία.ημ_λήξης)
Κληρονομικότητα (Inheritance) Με τον όρο κληρονομικότητα, εννοούμε τη δυνατότητα που έχει μια κλάση να κληρονομεί κάποιες ή όλες τις ιδιότητες και τις μεθόδους μιας άλλης κλάσης. H κλάση που ορίζεται πρώτη ονομάζεται υπερκλάση (βασική κλάση – base class) και η κλάση που κληρονομεί τη βασική κλάση ονομάζεται υποκλάση (παράγωγη κλάση -derived class). Στο παρακάτω πρόγραμμα η υποκλάση Ηλεκτρικό_αυτοκίνητο κληρονομεί όλες τις ιδιότητες και μεθόδους της υπερκλάσης Αμάξι.
class Αμάξι:
    """Μια απλή αναπαράσταση αυτοκινήτου"""
def __init__(self, κατασκευαστής, μοντέλο, χρονιά):
        """Αρχικοποίηση ιδιοτήτων (χαρακτηριστικών- atributes)"""
        self.κατασκευαστής = κατασκευαστής
        self.μοντέλο = μοντέλο
        self.χρονιά = χρονιά
def πληροφορίες(self): “””Εμφανίζει συγκεντρωμένες όλες τις πληροφορίες του αυτοκινήτου””” print(“Κατασκευατής: ” + self.κατασκευαστής) print(“Μοντέλο: ” + self.μοντέλο) print(“Χρονολογία: ” + self.χρονιά) return (111111111) class Ηλεκτρικό_αυτοκίνητο(Αμάξι): “”” Κλάση για τα ηλεκτρικά αυτοκίνητα””” def __init__(self, κατασκευαστής, μοντέλο, χρονιά): super().__init__(κατασκευαστής, μοντέλο, χρονιά) Αμάξι1 = Ηλεκτρικό_αυτοκίνητο(“Tesla”, “model s”, “2020”) Αμάξι1.πληροφορίες() Μπορούμε να προσθέσουμε επιπλέον ιδιότητες και μεθόδους σε μια υποκλάση.  Χωρίς να πειράξουμε την υπερκλάση θα προσθέσουμε μία ιδιότητα και μία μέθοδο στην υποκλάση.
class Αμάξι:
    """Μια απλή αναπαράσταση αυτοκινήτου"""
def __init__(self, κατασκευαστής, μοντέλο, χρονιά):
        """Αρχικοποίηση ιδιοτήτων (χαρακτηριστικών- atributes)"""
        self.κατασκευαστής = κατασκευαστής
        self.μοντέλο = μοντέλο
        self.χρονιά = χρονιά
def πληροφορίες(self): “””Εμφανίζει συγκεντρωμένες όλες τις πληροφορίες του αυτοκινήτου””” print(“Κατασκευατής: ” + self.κατασκευαστής) print(“Μοντέλο: ” + self.μοντέλο) print(“Χρονολογία: ” + self.χρονιά) class Ηλεκτρικό_αυτοκίνητο(Αμάξι): “”” Κλάση για τα ηλεκτρικά αυτοκίνητα””” def __init__(self, κατασκευαστής, μοντέλο, χρονιά): super().__init__(κατασκευαστής, μοντέλο, χρονιά) self.τύπος_μπαταρίας=100 def παρουσίαση_μπαταρίας(self): print(“Η διάσταση της μπαταρίας είναι: “,self.τύπος_μπαταρίας) Αμάξι1 = Ηλεκτρικό_αυτοκίνητο(“Tesla”, “model s”, “2020”)Αμάξι1.πληροφορίες() Αμάξι1.παρουσίαση_μπαταρίας() Μπορούμε μία οι περισσότερες ιδιότητες ή μεθόδους να τις συμπεριλάβουμε σε μία νέα κλάση. Στο πρόγραμμα που ακολουθεί η ιδιότητα τύπος_μπαταρίας και η μέθοδος παρουσίαση_μπαταρίας έχουν ενσωματωθεί στην κλάση Μπαταρία. Στην κλάση Ηλεκτρικό_αυτοκίνητο η ιδιότητα μπαταρία περιλαμβάνει ένα αντικείμενο της νέας κλάσης (Μπαταρία).
class Αμάξι:
    """Μια απλή αναπαράσταση αυτοκινήτου"""
def __init__(self, κατασκευαστής, μοντέλο, χρονιά):
        """Αρχικοποίηση ιδιοτήτων (χαρακτηριστικών- atributes)"""
        self.κατασκευαστής = κατασκευαστής
        self.μοντέλο = μοντέλο
        self.χρονιά = χρονιά
def πληροφορίες(self): “””Εμφανίζει συγκεντρωμένες όλες τις πληροφορίες του αυτοκινήτου””” print(“Κατασκευατής: ” + self.κατασκευαστής) print(“Μοντέλο: ” + self.μοντέλο) print(“Χρονολογία: ” + self.χρονιά) class Μπαταρία: def __init__(self, τύπος_μπαταρίας): self.τύπος_μπαταρίας = τύπος_μπαταρίας def παρουσίαση_μπαταρίας(self): print(“Η διάσταση της μπαταρίας είναι: “, self.τύπος_μπαταρίας) class Ηλεκτρικό_αυτοκίνητο(Αμάξι): “”” Κλάση για τα ηλεκτρικά αυτοκίνητα””” def __init__(self, κατασκευαστής, μοντέλο, χρονιά): super().__init__(κατασκευαστής, μοντέλο, χρονιά) self.μπαταρία=Μπαταρία(100) Αμάξι1 = Ηλεκτρικό_αυτοκίνητο(“Tesla”, “model s”, “2020”) Αμάξι1.πληροφορίες() Αμάξι1.μπαταρία.παρουσίαση_μπαταρίας() Importing Classes Μπορούμε μέσα σε ένα αρχείο με κατάληξη  .py (module) να έχουμε πολλές κλάσεις. Έστω ότι το αρχείο οι_κλάσεις_μου.py περιέχει τις κλάσεις Αμάξι, Μπαταρία και Ηλεκτρικό_αυτοκίνητο.   οι_κλάσεις_μου.py
class Αμάξι:
    """Μια απλή αναπαράσταση αυτοκινήτου"""
def __init__(self, κατασκευαστής, μοντέλο, χρονιά):
        """Αρχικοποίηση ιδιοτήτων (χαρακτηριστικών- atributes)"""
        self.κατασκευαστής = κατασκευαστής
        self.μοντέλο = μοντέλο
        self.χρονιά = χρονιά
def πληροφορίες(self): “””Εμφανίζει συγκεντρωμένες όλες τις πληροφορίες του αυτοκινήτου””” print(“Κατασκευατής: ” + self.κατασκευαστής) print(“Μοντέλο: ” + self.μοντέλο) print(“Χρονολογία: ” + self.χρονιά) class Μπαταρία: def __init__(self, τύπος_μπαταρίας): self.τύπος_μπαταρίας = τύπος_μπαταρίας def παρουσίαση_μπαταρίας(self): print(“Η διάσταση της μπαταρίας είναι: “, self.τύπος_μπαταρίας) class Ηλεκτρικό_αυτοκίνητο(Αμάξι): “”” Κλάση για τα ηλεκτρικά αυτοκίνητα””” def __init__(self, κατασκευαστής, μοντέλο, χρονιά): super().__init__(κατασκευαστής, μοντέλο, χρονιά) self.μπαταρία=Μπαταρία(100)

Θα δημιουργήσουμε ένα νέο αρχείο το_πρόγραμμα_μου.py στο οποίο θα εισάγουμε μία ή περισσότερες κλάσεις.

 

το_πρόγραμμα_μου1.py
from  οι_κλάσεις_μου import  Αμάξι
Αμάξι1 = Αμάξι(“TOYOTA”,”COROLLA”,”2020″ ) Αμάξι1.πληροφορίες() Μπορούμε να εισάγουμε περισσότερες από μια κλάσεις. το_πρόγραμμα_μου2.py
from  οι_κλάσεις_μου  import  Αμάξι, Ηλεκτρικό_αυτοκίνητο 
Αμάξι1 = Αμάξι("TOYOTA","COROLLA","2020" )
Αμάξι1.πληροφορίες()Αμάξι2 = Ηλεκτρικό_αυτοκίνητο("Tesla", "model s", "2020")
Αμάξι2.πληροφορίες()
Αμάξι2.μπαταρία.παρουσίαση_μπαταρίας()
Για να εισάγουμε όλες τις κλάσεις από ένα αρχείο (module) ο καλύτερος τρόπος είναι: το_πρόγραμμα_μου3.py
import οι_κλάσεις_μου
Αμάξι1 = οι_κλάσεις_μου.Αμάξι("TOYOTA","COROLLA","2020" )
Αμάξι1.πληροφορίες()
Αμάξι2 = οι_κλάσεις_μου.Ηλεκτρικό_αυτοκίνητο("Tesla", "model s", "2020")
Αμάξι2.πληροφορίες()
Αμάξι2.μπαταρία.παρουσίαση_μπαταρίας()
Ασκήσεις
  1. Φτιάξτε κλάση με το όνομα Εστιατόριο. Η συνάρτηση __init__ να έχει δύο ιδιότητες (χαρακτηριστικά) : όνομα και τύπος_κουζίνας. Επίσης θα περιέχει δύο μεθόδους. Η πρώτη με όνομα πληροφορίες να εμφανίζει μια πρόταση με το όνομα και τον τύπο της κουζίνας που σερβίρει ενώ η δεύτερη (με όνομα ωράριο) να εμφανίζει το ωράριο.  Στην συνέχεια να δημιουργήσετε  ένα αντικειμένου, να εμφανίσετε τις δύο ιδιότητες του (χαρακτηριστικά) και να καλέσετε τις δύο μεθόδους του.
  2. Τι θα εμφανίσει το παρακάτω πρόγραμμα;
    class Πελάτης():
        """Περιλαμβάνει το προφίλ του πελάτη."""
    
        def __init__(self, όνομα, επίθετο, όνομα_χρήστη, email, τοποθεσία):
            """Initialize the user."""
            self.όνομα = όνομα.title()
            self.επίθετο = επίθετο.title()
            self.όνομα_χρήστη = όνομα_χρήστη
            self.email = email
            self.τοποθεσία = τοποθεσία.title()
    
        def περιγραφή(self):
            """Display a summary of the user's information."""
            print(f"\n{self.όνομα} {self.επίθετο}")
            print(f" Όνομα_χρήστη: {self.όνομα_χρήστη}")
            print(f" Email: {self.email}")
            print(f" Τοποθεσία: {self.τοποθεσία}")
    
        def χαιρετισμός(self):
            """Display a personalized greeting to the user."""
            print(f"\n{self.όνομα_χρήστη}, Καλως ήρθες!")
    
    eric = Πελάτης('Μπάμπης', 'Σουγιάς', 'Babis', 'babis@example.com', 'Σεπόλια')
    eric.περιγραφή()
    eric.χαιρετισμός()
    
    willie = Πελάτης('Δημήτρης', 'Παππάς', 'Dimis', 'test@example.com', 'Λάρισα')
    willie.περιγραφή()
    willie.χαιρετισμός()
  3. Στην κλάση Εστιατόριο της άσκησης 1, να προσθέσετε την ιδιότητα (χαρακτηριστικό) πλήθος_πελατών, του οποίου η αρχική τιμή να είναι 0. α)Δημιουργήστε ένα αντικείμενο, εμφανίστε το πλήθος των πελατών, μεταβάλετε το πλήθος αυτό και ξαναεμφανίστε το. β) προσθέστε μια μέθοδο με το όνομα καθορισμός_πελατών() που θα επιτρέπει να ορίζουμε απευθείας το πλήθος των πελατών. γ) προσθέστε μια δεύτερη μέθοδο με το όνομα προσθήκη_πελατών() που θα επιτρέπει να προσθέτουμε στο υπάρχον πλήθος πελατών ένα νέο πλήθος.
  4. xxxxxxxxxxxxxxx
  5. xxxxxxxxxxxxxxx
  6. xxxxxxxxxxxxxxx
  7. xxxxxxxxxxxxxxx
  8. xxxxxxxxxxxxxxx
Άσκηση 1
class Εστιατόριο():
    """Η Κλάση αντιστοιχεί σε εστιατόριο"""
    def __init__(self, όνομα, τύπος_κουζίνας):
        """Initialize the restaurant."""
        self.όνομα= όνομα.title()
        self.τύπος_κουζίνας = τύπος_κουζίνας

    def πληροφορίες(self):
        """Εμφανίζει το όνομα και τον τύπο της κουζίνας"""
        print("\n Το εστιατόριο "+self.όνομα+" σερβίρει "+self.τύπος_κουζίνας+" Κουζίνα")
    def ωράριο(self, έναρξη, λήξη):
        """Εμφανίζει πληροφορίες για το ωράριο"""
        self.έναρξη=έναρξη
        self.λήξη=λήξη
        print("\nΤο ωράριο του καταστήματος είναι από "+ self.έναρξη+ " μέχρι "+self.λήξη)



Εστιατόριο1= Εστιατόριο('Η ωραία θέα', 'Ελληνική')
print(Εστιατόριο1.όνομα)
print(Εστιατόριο1.τύπος_κουζίνας)
Εστιατόριο1.πληροφορίες()
Εστιατόριο1.ωράριο("18:00", "01:00")
Άσκηση2 Μπάμπης Σουγιάς Όνομα_χρήστη: Babis Email: babis@example.com Τοποθεσία: Σεπόλια Babis, Καλως ήρθες! Δημήτρης Παππάς Όνομα_χρήστη: Dimis Email: test@example.com Τοποθεσία: Λάρισα Dimis, Καλως ήρθες!

Προσπέλαση αρχείων για ανάγνωση και εγγραφή

Η εντολή with εχει το πλεονέκτημα ότι θα κλείσει το αρχείο όταν πάψουμε να το χρειαζόμαστε.
with open("φακελος/text.txt", "r",encoding="utf-8") as το_αρχείο_μου:
    κείμενο=το_αρχείο_μου.read()
print(κείμενο)
Αν θέλουμε να εμφανίζουμε μια μια τις γραμμές , γράφουμε:
with open("φακελος/text.txt", "r",encoding="utf-8") as το_αρχείο_μου:
    for line in το_αρχείο_μου:
        print(line.rstrip())   #rstrip() εξαφανίζει άδειες γραμμές
Αν θέλουμε να αποθηκεύσουμε τις γραμμές σε μία λίστα, γράφουμε:
with open("text.txt", "r",encoding="utf-8") as το_αρχείο_μου:
    όλες_οι_γραμμές=το_αρχείο_μου.readlines()
for i in όλες_οι_γραμμές: print(i.rstrip()) Αν θέλουμε όλο το κείμενο να είναι σε μία γραμμή:
τελικό=""
with open("text.txt", "r",encoding="utf-8") as το_αρχείο_μου:
    for i in το_αρχείο_μου:
        τελικό=τελικό+i.strip()
print(τελικό)
Η Python μπορεί να σώσει μόνο κείμενο σε ένα αρχείο. Αν θέλουμε να σώσουμε αριθμούς θα πρέπει να τους μετατρέψουμε σε κείμενο με την βοήθεια της str().
with open("text2.txt", "w",encoding="utf-8") as το_αρχείο_μου:
    το_αρχείο_μου.write("Η ζωή είναι ωραία")
Αν θέλουμε να προσθέσουμε κείμενο σε αυτό που ήδη υπάρχει τότε γράφουμε:
with open("text2.txt", "a",encoding="utf-8") as το_αρχείο_μου: 
    το_αρχείο_μου.write("\nΗ ζωή είναι ωραία")
Αν θέλουμε να αποθηκεύσουμε τις γραμμές σε μία λίστα, γράφουμε:
with open("text.txt", "r",encoding="utf-8") as το_αρχείο_μου:
    όλες_οι_γραμμές=το_αρχείο_μου.readlines()
for i in όλες_οι_γραμμές: print(i.rstrip()) Αν θέλουμε όλο το κείμενο να είναι σε μία γραμμή:
τελικό=""
with open("text.txt", "r",encoding="utf-8") as το_αρχείο_μου:
    for i in το_αρχείο_μου:
        τελικό=τελικό+i.strip()
print(τελικό)

Παιχνίδι με τράπουλα

Κανόνες
  1. Πρόκειται για παιχνίδι ανθρώπου – υπολογιστή.
  2. Θα χρησιμοποιείται μια μόνο τράπουλα (52 φύλλα).
  3. Αρχικά, κάθε παίχτης παίρνει 7 φύλλα (τυχαία) και 1 (τυχαίο) τοποθετείται στο τραπέζι
  4. Τυχαία επιλέγεται το ποιος θα παίξει πρώτος.
  5. Κάθε παίχτης ρίχνει ένα φύλλο που να ταιριάζει η αξία ή το σύμβολο με το φύλλο στο τραπέζι. Αν δεν έχει τέτοιο φύλλο, τότε παίρνει από την τράπουλα  ξανά και ξανά μέχρι είτε να βρει το κατάλληλο είτε να τελειώσουν τα φύλλα.
  6. Το παιχνίδι σταματά όταν τελειώσουν τα φύλλα κάποιου παίχτη ή της τράπουλας.
  7. Νικητής όποιος έχει τα λιγότερα φύλλα αλλιώς ισοπαλία.
Η κλάση Card δημιουργεί ένα φύλλο τράπουλας. Από αυτή θα δημιουργηθούν τα 52 φύλλα της τράπουλας.
class Card:
    # αξία Α23456789ΔΒΝΡ
    # σύμβολα  σ,μ,α,ο       Σπαθί, Μπαστούνι, Καρό, Κούπα

    def __init__(self,αξία, σύμβολο):
        self.αξία=αξία
        self.σύμβολο=σύμβολο
        if self.σύμβολο=="σ" or self.σύμβολο=="μ" :
            self.χρώμα="Μ"          # Μαύρο
        else:
            self.χρώμα="Κ"          # Κόκκινο

        if self.αξία=="Β" or self.αξία=="Ν" or self.αξία=="Ρ":
            self.φιγούρα = True
        else:
            self.φιγούρα = False

    def __str__(self):
        return self.αξία + self.σύμβολο

    def detailed_info(self):
        print("Η αξία της κάρτας:", self.αξία, "  -   Το σύμβολο της είναι :", self.σύμβολο)
        print("Το χρώμα της κάρτας:", self.χρώμα, "  -   Η φιγούρα της είναι :", self.φιγούρα)
Η κλάση Deck δημιουργεί μία τράπουλας.
import random
class Deck:                 #τράπουλα
    values = "Α23456789ΔΒΝΡ"
    symbols = "σμαο"
    def __init__(self):
        self.content=[]     # χαρτιά τράπουλας που δεν έχουν μοιραστεί. Λίστα που θα περιλαμβάνει αντικείμενα από την κλάση Cards
        self.pile=[]        # χαρτιά παιχτών και πάνω στο τραπέζι (content+pile=52).
        for i in Deck.values:
            for j in Deck.symbols:
                c=Card(i,j)
                self.content.append(c)
    def __str__(self):
        s=""
        πλ=0
        for i in self.content:
            s=s+str(i)+" "
            πλ=πλ+1
            if πλ%13==0:
                s=s+"\n"
        print("πλήθος χαρτιών στην τράπουλα και τραπέζι: ", len(self.content), "-", len(self.pile))
        return s
    def ανακάτεψε(self):
        random.shuffle(self.content)    # λόγος που κάναμε import random
    def τράβα_χαρτί(self):
        """Αντράπουλα άδεια εμφανίζει μήνυμα αλλίως παίρνει πρώτο φύλλο από content και το βάζει στην pile"""
        if len(self.content)==0:
            return "Άδεια τράπουλα"
        else:
            c=self.content[0]
            self.pile.append(c)
            self.content=self.content[1:]
            return c
    def μάζεψε_χαρτιά(self):
        self.content=self.content+self.pile
        self.pile=[]
Θα αποθηκεύσουμε και τις δύο κλάσεις σε ένα αρχείο με το όνομα playing_cards.py .
Το κυρίως πρόγραμμα περιλαμβάνει τις παρακάτω εντολές και κάποιες συναρτήσεις.
import playing_cards, random

d=playing_cards.Deck()           #καθολική μεταβλητή
τραπέζι=[]                       #καθολική μεταβλητή
κατάσταση_παιχνιδιού=""          #καθολική μεταβλητή
φύλλα_παίχτη=[]                  #καθολική μεταβλητή
φύλλα_υπολογιστή=[]              #καθολική μεταβλητή
επ="Ναί"
while επ=="Ναί":
    κατάσταση_παιχνιδιού = "Έναρξη"
    next_turn()
    επ=input("Για να ξαναπαίξεις πληκτρολόγησε Ναί, οτιδήποτε άλλο για τερματισμό: ")
print("Τέλος Προγράμματος! Αντίο!")

Η πρώτη συνάρτηση που καλείται είναι η next_turn η οποία και ανάλογα με το ποιανού η σειρά είναι καλεί τις αντίστοιχες συναρτήσεις.
def next_turn():
    global κατάσταση_παιχνιδιού
    while True:
        if κατάσταση_παιχνιδιού=="Έναρξη":                                # θα εκτελεστεί μόνο στην έναρξη του παιχνιδιού
            initial()
        elif κατάσταση_παιχνιδιού=="Σειρά του υπολογιστή":      
            if len(φύλλα_παίχτη)==0:                                      # Νίκησε ο άνθρωπος
                κατάσταση_παιχνιδιού="Νίκησε άνθρωπος"
                evaluate()
                break
            else:
                print("------ Σειρά του υπολογιστή ------")               # Σειρά του υπολογιστή να παίξει
                computer_plays()
        elif κατάσταση_παιχνιδιού=="Σειρά του ανθρώπου":
            if len(φύλλα_υπολογιστή)==0:                                  # Νίκησε ο υπολογιστής
                κατάσταση_παιχνιδιού="Νίκησε υπολογιστής"
                evaluate()
                break
            else:
                print("------ Σειρά του ανθρώπου ------")                 # Σειρά του ανθρώπου να παίξει
                human_plays()
        elif κατάσταση_παιχνιδιού=="Τελείωσαν τα φύλλα":                  # Τελείωσαν τα φύλλα της τράπουλας
            evaluate()
            break
Η initial συνάρτηση ετοιμάζει τις καθολικές μεταβλητές για να ξεκινήσει το παιχνίδι.
def initial():
    global d, κατάσταση_παιχνιδιού, φύλλα_παίχτη, φύλλα_υπολογιστή, τραπέζι  # global ώστε οι αλλαγές να διατηρηθούν στο υπόλοιπο πρόγραμμα
    print("Μαζεύω τα χαρτιά ...")
    d.μάζεψε_χαρτιά()
    τραπέζι=[]      #λίστα με αντικείμενα
    φύλλα_υπολογιστή=[]
    φύλλα_παίχτη=[]
    print("Ανακατεύω την τράπουλα ...")
    d.ανακάτεψε()

    τραπέζι.append(d.τράβα_χαρτί())
    print("Στο τραπέζι μπαίνει το φύλλο :", τραπέζι[-1])
    for i in range(1,8,1):
        φύλλα_παίχτη.append(d.τράβα_χαρτί())
        φύλλα_υπολογιστή.append(d.τράβα_χαρτί())
    if random.randint(1,2) ==1:
        κατάσταση_παιχνιδιού = "Σειρά του ανθρώπου"
        print("Παίζει πρώτα ο άνθρωπος")
    else:
        κατάσταση_παιχνιδιού = "Σειρά του υπολογιστή"
        print("Παίζει πρώτα ο υπολογιστής")
Η computer_plays συνάρτηση.
def computer_plays():
    global d, κατάσταση_παιχνιδιού, φύλλα_υπολογιστή, τραπέζι
    αξία_φύλλου_τραπέζι = τραπέζι[-1].αξία
    σύμβολο_φύλλου_τραπέζι = τραπέζι[-1].σύμβολο
    while True:
        for i in φύλλα_υπολογιστή:
            if i.αξία == αξία_φύλλου_τραπέζι or i.σύμβολο == σύμβολο_φύλλου_τραπέζι:
                print("Ο υπολογιστής έριξε", i)
                φύλλα_υπολογιστή.remove(i)
                τραπέζι.append(i)
                κατάσταση_παιχνιδιού = "Σειρά του ανθρώπου"
                return
        νέα_κάρτα = d.τράβα_χαρτί()
        if νέα_κάρτα == "Άδεια τράπουλα":
            κατάσταση_παιχνιδιού = "Τελείωσαν τα φύλλα"
            return
        else:
                print("Ο υπολογιστής τράβηξε νέο φύλλο")
                φύλλα_υπολογιστή.append(νέα_κάρτα)
Η human_plays συνάρτηση.
def human_plays():
    global d, κατάσταση_παιχνιδιού, φύλλα_παίχτη, τραπέζι
    while True:
        print("Πλήθος φύλλων τράπουλας - υπολογιστή - τραπεζιού :", len(d.content), " - ",len(φύλλα_υπολογιστή), " - ", len(τραπέζι))
        print("Το πάνω φύλλο είναι ", τραπέζι[-1])
        s=""
        for i in φύλλα_παίχτη:
            s=s+str(i)+" "
        print("Έχεις ", len(φύλλα_παίχτη), " φύλλα τα οποία είναι:", s)
        επ=input("Πληκτρολόγησε το φύλλο που θες να ρίξεις αλλιώς ENTER για να τραβήξεις νέο φύλλο.")
        if επ=="":          #Θα τραβήξει νέο χαρτί
            νεα_κάρτα=d.τράβα_χαρτί()
            if νεα_κάρτα=="Άδεια τράπουλα":
                κατάσταση_παιχνιδιού = "Τελείωσαν τα φύλλα"
                return
            else:
                φύλλα_παίχτη.append(νεα_κάρτα)
        else:               # ο χρήστης πληκτρολόγησε φύλλο
            φύλλα_παίχτη_string=[str(i) for i in φύλλα_παίχτη]
            if not(επ in φύλλα_παίχτη_string):
                print("Δεν έχεις τέτοιο φύλλο!")
            elif (επ[0]!=τραπέζι[-1].αξία and επ[1]!=τραπέζι[-1].σύμβολο):
                print("Δεν ταιριάζει με το φύλλο στο τραπέζι!")
            else:
                i=φύλλα_παίχτη_string.index(επ)
                τραπέζι.append(φύλλα_παίχτη[i])
                φύλλα_παίχτη.pop(i)
                κατάσταση_παιχνιδιού = "Σειρά του υπολογιστή"
                return
Η evalutae συνάρτηση.
def evaluate():
    global κατάσταση_παιχνιδιού, φύλλα_παίχτη, φύλλα_υπολογιστή
    if κατάσταση_παιχνιδιού=="Νίκησε άνθρωπος":
        print("Κέρδισες!")
    elif κατάσταση_παιχνιδιού=="Νίκησε υπολογιστής":
        print("Κέρδισε ο Υπολογιστής")
    elif κατάσταση_παιχνιδιού=="Τελείωσαν τα φύλλα":
        πλ1=len(φύλλα_υπολογιστή)
        πλ2=len(φύλλα_παίχτη)
        print("Πλήθος φύλλων ΗΥ-Παίχτη:", πλ1,"-", πλ2 )
        if πλ1>πλ2:
            print("Κέρδισε ο Υπολογιστής")
        elif πλ1<πλ2:
            print("Κέρδισες!")
        else:
            print("Ισοπαλία!")
    print()

Pong (1972)

Ένα από τα πρώτα βιντεοπαιχνίδια είναι το θρυλικό Pong. Το παιχνίδι κυκλοφόρησε σε καμπίνα το ‘72 από την Atari, και μοιάζει με πινγκ πονγκ σε δύο διαστάσεις. Στο παιχνίδι υπάρχουν δύο παίχτες , που μπορούν να κινηθούν κατακόρυφα των δύο πλαϊνών γραμμών, και ένα “μπαλάκι” το οποίο πρέπει να περάσει από την γραμμή του αντιπάλου για να κερδηθεί ο πόντος. Το “μπαλάκι” αναπηδάει στις οριζόντιες γραμμές.

Η πρώτη κλάση Ρυθμίσεις περιέχει όλες τις ρυθμίσεις του παιχνιδιού.
class Ρυθμίσεις:
    def __init__(self):
        self.πλάτος_παραθύρου=1200
        self.ύψος_παραθύρου=800
        self.ακτίνα_μπάλας=20
        self.βήμα_οριζόντια=1
        self.βήμα_κατακόρυφα = 1
        self.άσπρο=(255,255,255)
        self.κόκκινο=(255,0,0)
        self.μαύρο=(0,0,0)
        self.μπλέ=(0,0,255)
        self.φόντο=(221, 185, 160)
        self.ταχύτητα=300
        self.πλάτος_ρακέτας=20
        self.ύψος_ρακέτας = 100
Η κλάση Μπάλα.
import pygame, ρυθμίσεις
class Μπάλα: def __init__(self): self.ρυθμ=ρυθμίσεις.Ρυθμίσεις() self.x=self.ρυθμ.πλάτος_παραθύρου // 2 self.y = self.ρυθμ.ύψος_παραθύρου // 2 def ζωγράφισε(self, screen): pygame.draw.circle(screen, self.ρυθμ.κόκκινο, (self.x, self.y), self.ρυθμ.ακτίνα_μπάλας) def νέα_θέση(self): self.x=self.x+self.ρυθμ.βήμα_οριζόντια self.y = self.y + self.ρυθμ.βήμα_κατακόρυφα if self.y>self.ρυθμ.ύψος_παραθύρου-self.ρυθμ.ακτίνα_μπάλας: self.ρυθμ.βήμα_κατακόρυφα=self.ρυθμ.βήμα_κατακόρυφα*(-1) if self.y < self.ρυθμ.ακτίνα_μπάλας: self.ρυθμ.βήμα_κατακόρυφα = self.ρυθμ.βήμα_κατακόρυφα * (-1) if self.x > self.ρυθμ.πλάτος_παραθύρου – self.ρυθμ.ακτίνα_μπάλας: self.ρυθμ.βήμα_οριζόντια = self.ρυθμ.βήμα_οριζόντια * (-1) if self.x < self.ρυθμ.ακτίνα_μπάλας: self.ρυθμ.βήμα_οριζόντια = self.ρυθμ.βήμα_οριζόντια * (-1) Η κλάση Ρακέτα.
import pygame, ρυθμίσεις
class Ρακέτα: def __init__(self, πλευρά): self.ρυθμ = ρυθμίσεις.Ρυθμίσεις() self.x = self.ρυθμ.πλάτος_παραθύρου // 2 self.y = self.ρυθμ.ύψος_παραθύρου // 2 if πλευρά==”Α”: self.παραλληλόγραμμο=pygame.Rect(10,self.ρυθμ.ύψος_παραθύρου//2-self.ρυθμ.ύψος_ρακέτας//2,self.ρυθμ.πλάτος_ρακέτας, self.ρυθμ.ύψος_ρακέτας ) else: self.παραλληλόγραμμο = pygame.Rect(self.ρυθμ.πλάτος_παραθύρου-10-self.ρυθμ.πλάτος_ρακέτας, self.ρυθμ.ύψος_παραθύρου // 2 – self.ρυθμ.ύψος_ρακέτας // 2,self.ρυθμ.πλάτος_ρακέτας, self.ρυθμ.ύψος_ρακέτας) def ζωγράφισε(self, screen): pygame.draw.rect(screen, self.ρυθμ.μπλέ,self.παραλληλόγραμμο )   xxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxx
xxxxxxxxxxx
Το κυρίως πρόγραμμα περιλαμβάνει τις παρακάτω εντολές και κάποιες συναρτήσεις.
xxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxxx
xxxxxxxxxxxx
xxxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxx
xxxxxxxxxxxxxxxxx
xxxxxxxxxxxx
xxxxxxxxxxxxxxxxxxxxxxx

Bricks (1976)

Space Invaders (1978)

Το Space Invaders είναι ένα από τα παλαιότερα και δημοφιλέστερα βιντεοπαιχνίδια που αναπτύχθηκε από τον Τομοχίρο Νισικάντο και κυκλοφόρησε το 1978. 

Το Space Invaders είναι παιχνίδι βολών στο οποίο ο παίκτης ελέγχει ένα κανόνι λέιζερ σε έναν οριζόντιο άξονα στο κατώτερο σημείο της οθόνης και πυροβολεί εξωγήινους εισβολείς, οι οποίοι πλησιάζουν όλο και πιο γρήγορα. Ο στόχος του παιχνιδιού είναι η εξόντωση όλων των εξωγήινων, οι οποίοι κινούνται οριζόντια και κάθετα προς το κανόνι. Όταν ο παίκτης καταστρέφει έναν εξωγήινο κερδίζει πόντους και όσο περισσότερους καταστρέφει, τόσο πιο γρήγορα οι υπόλοιπο κινούνται. Παράλληλα οι εξωγήινοι ρίχνουν βόμβες με σκοπό να καταστρέψουν το κανόνι. Αν φτάσουν στο τέλος της οθόνης, η εισβολή είναι επιτυχής και το παιχνίδι τελειώνει. Το κανόνι λέιζερ που χειρίζεται ο παίκτης προστατεύεται από στατικά οχυρά, τα οποία καταστρέφονται σιγά σιγά από τα πυρά των εξωγήινων αλλά και του ίδιου.

Καλές ιστοσελίδες:

Σχολικό βιβλίο: εδώ.