Skip to content

Instantly share code, notes, and snippets.

@kantale

kantale/lesson_1.ipynb

Last active November 2, 2016 12:54
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save kantale/b32d686038b9ba1fb411fe049d7edb80 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save kantale/b32d686038b9ba1fb411fe049d7edb80 to your computer and use it in GitHub Desktop.
Download ZIP
Εισαγωγή στον προγραμματισμό με τη γλώσσα python
Display the source blob
Display the rendered blob
Raw
lesson_1.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Display the source blob
Display the rendered blob
Raw
lesson_2.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Σημείωσεις για το μάθημα \"Προγραμματισμός σε python\"\n",
"\n",
"Αλέξανδρος Καντεράκης [kantale@ics.forth.gr](mailto:kantale@ics.forth.gr)\n",
"## Διάλεξη 2η, 20 Οκτωβρίου 2016\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### List Comprehensions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Όπως έχουμε μάθει μία από τις κυριότερες δομές δεδομένων στη python είναι οι λίστες. Π.χ:"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[2, 4, 6, 8]\n"
]
}
],
"source": [
"a = [2,4,6,8]\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τα list comprehensions είναι ένας πολύ βολικός τρόπος για να μετασχηματίζεις λίστες δημιουργώντας νέες λίστες. Η βασική τους δομή είναι:\n",
"\n",
"```[μία έκφραση (expression) που χρησιμοποιεί τη <μεταβλητή> for <μεταβλητή> in <λίστα>]```\n",
"\n",
"Παράδειγμα:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[3, 5, 7, 9]"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x+1 for x in a]"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[4, 8, 12, 16]"
]
},
"execution_count": 5,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x*2 for x in a]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορείτε να χρησιμοποιείτε ΟΤΙΔΗΠΟΤΕ είναι αποδεκτό από τη python ως έκφραση:"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[[2], [4], [6], [8]]"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[[x] for x in a]"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[[3, 5, 7, 9], [3, 5, 7, 9], [3, 5, 7, 9], [3, 5, 7, 9]]"
]
},
"execution_count": 7,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[[x+1 for x in a] for x in a]"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[[2, 'Mitsos'], [4, 'Mitsos'], [6, 'Mitsos'], [8, 'Mitsos']]"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[[x, \"Mitsos\"] for x in a]"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[['p', 'p'],\n",
" ['p', 'p', 'p', 'p'],\n",
" ['p', 'p', 'p', 'p', 'p', 'p'],\n",
" ['p', 'p', 'p', 'p', 'p', 'p', 'p', 'p']]"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[['p']*x for x in a]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορείτε να χρησιμοποιείσετε το ```if``` στο τέλος του list comprehension για να ελέγξετε ποιες τιμές θα περιέχει η νέα λίστα"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"a = [2,4,6,8]"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[6, 8]"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x for x in a if x>5]"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[7, 9]"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x+1 for x in a if x>5]"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['python', 'python']"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x for x in [\"python\", \"perl\", \"perl\", \"python\", \"perl\"] if x == \"python\"]"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['python', 'python']"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x for x in [\"python\", \"perl\", \"perl\", \"python\", \"perl\"] if x != \"perl\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Τελεστές και δυαδική λογική (binary logic)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"...(θα επανέλθουμε στις λίστες αργότερα)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Οι τελεστές ```==``` και ```!=``` ελέγχουν αν τα δύο μέρη (π.χ. δύο μεταβλητές) είναι ίσα ή αν διαφέρουν αντίστοιχα"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print(3 == 4)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print([1,2,3] == [3,2,1])"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(2 == 4/2)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(\"python\" != \"perl\")"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print(\"perl\" == \"great\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Άλλοι τελεστές είναι οι: \n",
"* μεγαλύτερο από: ```>```\n",
"* μικρότερο από: ```<```\n",
"* μεγαλύτερο ή ίσο από: ```>=``` \n",
" * ***Προσοχή το ```=>``` δεν υπάρχει!***\n",
"* μικρότερο από: ```<=```"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(3<4)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print(4<=4)"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print(4>4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Οι τελεστές αυτοί αν εφαρμοστούν σε ```strings``` τότε ελέγχουν την αλφαβητική σειρά. Δηλαδή όποιο είναι αλφαβητικά πρώτο είναι μικρότερο!"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print (\"a\"<\"b\")"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print (\"Ηράκλειο\" > \"Θεσαλλονίκη\")"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print (\"Ηράκλειο\" < \"Θεσσαλονίκη\")"
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"True\n"
]
}
],
"source": [
"print (\"9\" > \"100000\")"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print (9 > 100000)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορείτε να εξηγήσετε την παραπάνω συμπεριφόρα; Γιατί το \"9\" είναι μεγαλύτερο από το \"100000\";"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Εκτώς από τους τελεστές ```<, >, <=, >=``` υπάρχουν και οι λεγόμενοι \"λογικοί τελεστές\" (binary operators) οι οποίοι ελέγχουν την ορθότητα μίας λογικής πρότασης (binary expression). Οι βασικοί (ναι.. υπάρχουν πιο πολλοί..) είναι:\n",
"* ```and``` . Είναι ```True``` ΜΟΝΟ αν και τα δύο μέρη είναι ```TRUE```\n",
"* ```or```. Είναι ```True``` Αν τουλάχιστον ένα από τα δύο μέρη είναι ```True```"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"True and True"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"True and False"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"False and True"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"False and False"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"True or True"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"True or False"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"False or True"
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"False or False"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"hello\n"
]
}
],
"source": [
"if (3<4) and (4<5): print(\"hello\")"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"if (3<4) and (4>4): print(\"hello\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Η τελευταία εντολή δεν τυπώνει τίποτα"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Η εντολή ```if``` μπορεί να γραφεί και ως εξής:\n",
"\n",
"<έκφραση αν είναι ```True```> ```if``` <λογική πρόταση> ```else``` <έκφραση αν ```False```>"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3 if 5<6 else 4"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"3 if 5>6 else 4"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αυτό ονομάζεται [ternary operator](https://en.wikipedia.org/wiki/%3F:)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Περισσότερα παραδείγματα"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"a = [1,2,3,4,5,6,7,8,9,10]"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 7, 8, 9, 10]"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x for x in a if x<2 or x>6]"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[6, 8, 10]"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x for x in a if x>5 and x/2==x//2] # Πάρε όλους τους ζυγούς που είναι πάνω από 5"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"(Θυμηθείτε ότι το x/2 δίνει την δεκαδική διαίρεση ενώ το x//2 δίνει την ακέραιη διαίρεση) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Εναλλακτικά μπορούσαμε να χρησιμοποιήσουμε τον τελεστή ```%``` ο οποίος δίνει το υπόλοιπο μιας διαίρεσης. Δηλαδή το x%y μας δίνει το υπόλοιπο της διαίρεσης του x με το y. "
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"5%2"
]
},
{
"cell_type": "code",
"execution_count": 171,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 171,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"13%5"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Δηλαδή το υπόλοιπο της διαίρεση του 10 με το 4 είναι 2. Οπότε για να ελέγξουμε αν ένας αριθμός είναι μονός ή ζυγός απλά κοιτάμε το υπόλοιπο της διαίρεσης του αριθμού με το 2:"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"1"
]
},
"execution_count": 51,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"11%2"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αν το αποτέλεσμα είναι 0 τότε είναι ζυγός, αλλιώς είναι μονός"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"a = [1,2,3,4,5,6,7,8,9,10]"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[6, 8, 10]"
]
},
"execution_count": 53,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x for x in a if x>5 and x%2 ==0] # Πάρε όλους τους ζυγούς που είναι μεγαλύτερους από 5"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορούμε επίσης να βάλουμε τo ternary operator μέσα στο list comprehension"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['MONOS',\n",
" 'ZIGOS',\n",
" 'MONOS',\n",
" 'ZIGOS',\n",
" 'MONOS',\n",
" 'ZIGOS',\n",
" 'MONOS',\n",
" 'ZIGOS',\n",
" 'MONOS',\n",
" 'ZIGOS']"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[\"ZIGOS\" if x%2 ==0 else \"MONOS\" for x in a]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ας θυμηθούμε λίγο τη range:"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
]
},
"execution_count": 56,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(range(10))"
]
},
{
"cell_type": "code",
"execution_count": 57,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[10, 11, 12, 13, 14, 15, 16, 17, 18, 19]"
]
},
"execution_count": 57,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(range(10,20))"
]
},
{
"cell_type": "code",
"execution_count": 58,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[10, 13, 16, 19]"
]
},
"execution_count": 58,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(range(10,20,3))"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[10, 9, 8, 7, 6, 5, 4, 3, 2]"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(range(10,1,-1))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Η range μπορεί να χρησιμοποιειθεί στα list comprehensions:"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x for x in range(10)]"
]
},
{
"cell_type": "code",
"execution_count": 64,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[2, 4, 6, 8, 10, 12, 14, 16, 18, 20]"
]
},
"execution_count": 64,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x for x in range(1,21) if x%2==0] # Όλοι οι ζυγοί από το 1 μέχρι και το 20"
]
},
{
"cell_type": "code",
"execution_count": 65,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[4, 16, 36, 64, 100, 144, 196, 256, 324, 400]"
]
},
"execution_count": 65,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x**2 for x in range(1,21) if x%2==0] # το τετράγωνο όλων των αριθμών από το 1 μέχρι το 20"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### List comprehensions με λίστες μέσα σε λίστες"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αν έχουμε μία λίστα μέσα σε λίστα τότε μπορούμε να έχουμε περισσότερες από μία μεταβλητές μέσα στο list comprehension"
]
},
{
"cell_type": "code",
"execution_count": 66,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"a=[[1,2], [3,4], [5,6]]"
]
},
{
"cell_type": "code",
"execution_count": 67,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[3, 7, 11]"
]
},
"execution_count": 67,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x+y for x,y in a]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"το οποίο είναι ισοδύναμε με:"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[3, 7, 11]"
]
},
"execution_count": 68,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[sum(x) for x in a]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"το οποίο είναι ισοδύναμο με:"
]
},
{
"cell_type": "code",
"execution_count": 69,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[3, 7, 11]"
]
},
"execution_count": 69,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x[0]+x[1] for x in a]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Επιπλέον μπορουμε να έχουμε παραπάνω από μία ```for``` μέσα σε ένα list comprehension:"
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3, 4, 5, 6]"
]
},
"execution_count": 70,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[y for x in a for y in x]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Enumeration"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"το ```enumeration``` μας δίνει το index μαζί με την τιμή όλων των στοιχείων μίας λίστας"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"a=[\"Athens\", \"Heraklion\", \"Thessalonikh\"]"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"[(0, 'Athens'), (1, 'Heraklion'), (2, 'Thessalonikh')]"
]
},
"execution_count": 73,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list(enumerate(a))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αυτό είναι χρήσιμο αν θέλουμε να \"φιλτράρουμε\" μία λίστα με βάση την θέση που βρίσκοντε τα στοιχεία της (και όχι τα στοιχεία αυτά καθ' αυτά)"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['Athens', 'Thessalonikh']"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x for i,x in enumerate(a) if i%2==0] # Πάρε τα στοιχεία που βρίσκονται σε ζυγή θέση"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Το ηράκλειο είναι στην 1η θέση (θυμηθείτε ότι ξεκινάνε από την μηδενική) οπότε δεν συμπεριλαμβάνεται"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"list comprehension + if + range + λογικοί τελεστές + ternary operator + enumeration + for μέσα σε for = Εξαιρετικά γρήγοροι τρόποι για να κάνεται πολύπλοκα πράγματα!"
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"a=[[\"Heraklion\", 200000], [\"Patra\", 168000], [\"Thessalonikh\", 770000], [\"Larisa\", 145000]]"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['Heraklion', 'Patra', 'Thessalonikh', 'Larisa']"
]
},
"execution_count": 77,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[x[0] for x in a] # Πάρε όλες τις πόλεις"
]
},
{
"cell_type": "code",
"execution_count": 79,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['Heraklion', 'Thessalonikh']"
]
},
"execution_count": 79,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[name for name,population in a if population>190000] # Όλες οι πόλεις με πλυθυσμός πάνω από 190000"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"1283000"
]
},
"execution_count": 80,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([population for name, population in a]) # Το πλήθος όλων των πόλεων"
]
},
{
"cell_type": "code",
"execution_count": 83,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['Heraklion', 'Thessalonikh']"
]
},
"execution_count": 83,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[name for name, population in a if 'k' in name ] #Ολες οι πόλεις που έχουν το \"k\" μέσα"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['H poly Heraklion EXEI k',\n",
" 'H poly Patra DEN EXEI k',\n",
" 'H poly Thessalonikh EXEI k',\n",
" 'H poly Larisa DEN EXEI k']"
]
},
"execution_count": 85,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[\"H poly {} {} k\".format(name, \"EXEI\" if 'k' in name else \"DEN EXEI\") for name, population in a]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## for, while, if"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### for"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Με τη ```for``` μπορούμε να κάνουμε μία επανάληψη όταν γνωρίζουμε το πλήθος των επαναλήψεων:"
]
},
{
"cell_type": "code",
"execution_count": 87,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n"
]
}
],
"source": [
"for x in [1,2,3]:\n",
" print (x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ:*** \n",
"\n",
"Η python σε αντίθεση ίσως με όλες τις υπόλοιπες γλώσσες ΕΠΙΒΑΛΕΙ την χρηση κενών (whitespace) μετά από κάθε for, while, if (και κάποια άλλα που θα δούμε μετά)"
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n",
"3\n",
"3\n",
"4\n",
"4\n",
"5\n"
]
}
],
"source": [
"for x in [1,2,3]:\n",
" print(x+1)\n",
" print(x+2)"
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "IndentationError",
"evalue": "unindent does not match any outer indentation level (<ipython-input-89-a0481df57965>, line 3)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"<ipython-input-89-a0481df57965>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m print(x+1)\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unindent does not match any outer indentation level\n"
]
}
],
"source": [
"for x in [1,2,3]:\n",
" print (x+1)\n",
" print(x+1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ολες οι εντολές που ακολουθούν μία for και είναι μέρος της επανάληψης πρέπει να έχουν τα ίδια κενά (indentation)"
]
},
{
"cell_type": "code",
"execution_count": 90,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "IndentationError",
"evalue": "unexpected indent (<ipython-input-90-840bbabbeec3>, line 3)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"<ipython-input-90-840bbabbeec3>\"\u001b[0;36m, line \u001b[0;32m3\u001b[0m\n\u001b[0;31m print(x+1)\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m unexpected indent\n"
]
}
],
"source": [
"for x in [1,2,3]:\n",
" print(x+1)\n",
" print(x+1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αν μία for (ή while ή if) έχει μόνο μία εντολή τότε είναι ok να την βάλουμε στην ίδια γραμμή (ugly..)"
]
},
{
"cell_type": "code",
"execution_count": 92,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n"
]
}
],
"source": [
"for x in [1,2,3]: print (x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Παράδειγμα: Η προπαίδεια του 10:"
]
},
{
"cell_type": "code",
"execution_count": 94,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Το γινόμενο του 1χ1=1\n",
"Το γινόμενο του 1χ2=2\n",
"Το γινόμενο του 1χ3=3\n",
"Το γινόμενο του 1χ4=4\n",
"Το γινόμενο του 1χ5=5\n",
"Το γινόμενο του 1χ6=6\n",
"Το γινόμενο του 1χ7=7\n",
"Το γινόμενο του 1χ8=8\n",
"Το γινόμενο του 1χ9=9\n",
"Το γινόμενο του 1χ10=10\n",
"Το γινόμενο του 2χ1=2\n",
"Το γινόμενο του 2χ2=4\n",
"Το γινόμενο του 2χ3=6\n",
"Το γινόμενο του 2χ4=8\n",
"Το γινόμενο του 2χ5=10\n",
"Το γινόμενο του 2χ6=12\n",
"Το γινόμενο του 2χ7=14\n",
"Το γινόμενο του 2χ8=16\n",
"Το γινόμενο του 2χ9=18\n",
"Το γινόμενο του 2χ10=20\n",
"Το γινόμενο του 3χ1=3\n",
"Το γινόμενο του 3χ2=6\n",
"Το γινόμενο του 3χ3=9\n",
"Το γινόμενο του 3χ4=12\n",
"Το γινόμενο του 3χ5=15\n",
"Το γινόμενο του 3χ6=18\n",
"Το γινόμενο του 3χ7=21\n",
"Το γινόμενο του 3χ8=24\n",
"Το γινόμενο του 3χ9=27\n",
"Το γινόμενο του 3χ10=30\n",
"Το γινόμενο του 4χ1=4\n",
"Το γινόμενο του 4χ2=8\n",
"Το γινόμενο του 4χ3=12\n",
"Το γινόμενο του 4χ4=16\n",
"Το γινόμενο του 4χ5=20\n",
"Το γινόμενο του 4χ6=24\n",
"Το γινόμενο του 4χ7=28\n",
"Το γινόμενο του 4χ8=32\n",
"Το γινόμενο του 4χ9=36\n",
"Το γινόμενο του 4χ10=40\n",
"Το γινόμενο του 5χ1=5\n",
"Το γινόμενο του 5χ2=10\n",
"Το γινόμενο του 5χ3=15\n",
"Το γινόμενο του 5χ4=20\n",
"Το γινόμενο του 5χ5=25\n",
"Το γινόμενο του 5χ6=30\n",
"Το γινόμενο του 5χ7=35\n",
"Το γινόμενο του 5χ8=40\n",
"Το γινόμενο του 5χ9=45\n",
"Το γινόμενο του 5χ10=50\n",
"Το γινόμενο του 6χ1=6\n",
"Το γινόμενο του 6χ2=12\n",
"Το γινόμενο του 6χ3=18\n",
"Το γινόμενο του 6χ4=24\n",
"Το γινόμενο του 6χ5=30\n",
"Το γινόμενο του 6χ6=36\n",
"Το γινόμενο του 6χ7=42\n",
"Το γινόμενο του 6χ8=48\n",
"Το γινόμενο του 6χ9=54\n",
"Το γινόμενο του 6χ10=60\n",
"Το γινόμενο του 7χ1=7\n",
"Το γινόμενο του 7χ2=14\n",
"Το γινόμενο του 7χ3=21\n",
"Το γινόμενο του 7χ4=28\n",
"Το γινόμενο του 7χ5=35\n",
"Το γινόμενο του 7χ6=42\n",
"Το γινόμενο του 7χ7=49\n",
"Το γινόμενο του 7χ8=56\n",
"Το γινόμενο του 7χ9=63\n",
"Το γινόμενο του 7χ10=70\n",
"Το γινόμενο του 8χ1=8\n",
"Το γινόμενο του 8χ2=16\n",
"Το γινόμενο του 8χ3=24\n",
"Το γινόμενο του 8χ4=32\n",
"Το γινόμενο του 8χ5=40\n",
"Το γινόμενο του 8χ6=48\n",
"Το γινόμενο του 8χ7=56\n",
"Το γινόμενο του 8χ8=64\n",
"Το γινόμενο του 8χ9=72\n",
"Το γινόμενο του 8χ10=80\n",
"Το γινόμενο του 9χ1=9\n",
"Το γινόμενο του 9χ2=18\n",
"Το γινόμενο του 9χ3=27\n",
"Το γινόμενο του 9χ4=36\n",
"Το γινόμενο του 9χ5=45\n",
"Το γινόμενο του 9χ6=54\n",
"Το γινόμενο του 9χ7=63\n",
"Το γινόμενο του 9χ8=72\n",
"Το γινόμενο του 9χ9=81\n",
"Το γινόμενο του 9χ10=90\n",
"Το γινόμενο του 10χ1=10\n",
"Το γινόμενο του 10χ2=20\n",
"Το γινόμενο του 10χ3=30\n",
"Το γινόμενο του 10χ4=40\n",
"Το γινόμενο του 10χ5=50\n",
"Το γινόμενο του 10χ6=60\n",
"Το γινόμενο του 10χ7=70\n",
"Το γινόμενο του 10χ8=80\n",
"Το γινόμενο του 10χ9=90\n",
"Το γινόμενο του 10χ10=100\n"
]
}
],
"source": [
"for x in range(1,11):\n",
" for y in range(1,11):\n",
" print ('Το γινόμενο του {}χ{}={}'.format(x,y,x*y))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αυτό μπορούμε να το κάνουμε και με list comprehension (ε ρε κόλημα με τα list comprehensions..)"
]
},
{
"cell_type": "code",
"execution_count": 95,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"['το γινόμενο του 1χ1=1',\n",
" 'το γινόμενο του 1χ2=2',\n",
" 'το γινόμενο του 1χ3=3',\n",
" 'το γινόμενο του 1χ4=4',\n",
" 'το γινόμενο του 1χ5=5',\n",
" 'το γινόμενο του 1χ6=6',\n",
" 'το γινόμενο του 1χ7=7',\n",
" 'το γινόμενο του 1χ8=8',\n",
" 'το γινόμενο του 1χ9=9',\n",
" 'το γινόμενο του 1χ10=10',\n",
" 'το γινόμενο του 2χ1=2',\n",
" 'το γινόμενο του 2χ2=4',\n",
" 'το γινόμενο του 2χ3=6',\n",
" 'το γινόμενο του 2χ4=8',\n",
" 'το γινόμενο του 2χ5=10',\n",
" 'το γινόμενο του 2χ6=12',\n",
" 'το γινόμενο του 2χ7=14',\n",
" 'το γινόμενο του 2χ8=16',\n",
" 'το γινόμενο του 2χ9=18',\n",
" 'το γινόμενο του 2χ10=20',\n",
" 'το γινόμενο του 3χ1=3',\n",
" 'το γινόμενο του 3χ2=6',\n",
" 'το γινόμενο του 3χ3=9',\n",
" 'το γινόμενο του 3χ4=12',\n",
" 'το γινόμενο του 3χ5=15',\n",
" 'το γινόμενο του 3χ6=18',\n",
" 'το γινόμενο του 3χ7=21',\n",
" 'το γινόμενο του 3χ8=24',\n",
" 'το γινόμενο του 3χ9=27',\n",
" 'το γινόμενο του 3χ10=30',\n",
" 'το γινόμενο του 4χ1=4',\n",
" 'το γινόμενο του 4χ2=8',\n",
" 'το γινόμενο του 4χ3=12',\n",
" 'το γινόμενο του 4χ4=16',\n",
" 'το γινόμενο του 4χ5=20',\n",
" 'το γινόμενο του 4χ6=24',\n",
" 'το γινόμενο του 4χ7=28',\n",
" 'το γινόμενο του 4χ8=32',\n",
" 'το γινόμενο του 4χ9=36',\n",
" 'το γινόμενο του 4χ10=40',\n",
" 'το γινόμενο του 5χ1=5',\n",
" 'το γινόμενο του 5χ2=10',\n",
" 'το γινόμενο του 5χ3=15',\n",
" 'το γινόμενο του 5χ4=20',\n",
" 'το γινόμενο του 5χ5=25',\n",
" 'το γινόμενο του 5χ6=30',\n",
" 'το γινόμενο του 5χ7=35',\n",
" 'το γινόμενο του 5χ8=40',\n",
" 'το γινόμενο του 5χ9=45',\n",
" 'το γινόμενο του 5χ10=50',\n",
" 'το γινόμενο του 6χ1=6',\n",
" 'το γινόμενο του 6χ2=12',\n",
" 'το γινόμενο του 6χ3=18',\n",
" 'το γινόμενο του 6χ4=24',\n",
" 'το γινόμενο του 6χ5=30',\n",
" 'το γινόμενο του 6χ6=36',\n",
" 'το γινόμενο του 6χ7=42',\n",
" 'το γινόμενο του 6χ8=48',\n",
" 'το γινόμενο του 6χ9=54',\n",
" 'το γινόμενο του 6χ10=60',\n",
" 'το γινόμενο του 7χ1=7',\n",
" 'το γινόμενο του 7χ2=14',\n",
" 'το γινόμενο του 7χ3=21',\n",
" 'το γινόμενο του 7χ4=28',\n",
" 'το γινόμενο του 7χ5=35',\n",
" 'το γινόμενο του 7χ6=42',\n",
" 'το γινόμενο του 7χ7=49',\n",
" 'το γινόμενο του 7χ8=56',\n",
" 'το γινόμενο του 7χ9=63',\n",
" 'το γινόμενο του 7χ10=70',\n",
" 'το γινόμενο του 8χ1=8',\n",
" 'το γινόμενο του 8χ2=16',\n",
" 'το γινόμενο του 8χ3=24',\n",
" 'το γινόμενο του 8χ4=32',\n",
" 'το γινόμενο του 8χ5=40',\n",
" 'το γινόμενο του 8χ6=48',\n",
" 'το γινόμενο του 8χ7=56',\n",
" 'το γινόμενο του 8χ8=64',\n",
" 'το γινόμενο του 8χ9=72',\n",
" 'το γινόμενο του 8χ10=80',\n",
" 'το γινόμενο του 9χ1=9',\n",
" 'το γινόμενο του 9χ2=18',\n",
" 'το γινόμενο του 9χ3=27',\n",
" 'το γινόμενο του 9χ4=36',\n",
" 'το γινόμενο του 9χ5=45',\n",
" 'το γινόμενο του 9χ6=54',\n",
" 'το γινόμενο του 9χ7=63',\n",
" 'το γινόμενο του 9χ8=72',\n",
" 'το γινόμενο του 9χ9=81',\n",
" 'το γινόμενο του 9χ10=90',\n",
" 'το γινόμενο του 10χ1=10',\n",
" 'το γινόμενο του 10χ2=20',\n",
" 'το γινόμενο του 10χ3=30',\n",
" 'το γινόμενο του 10χ4=40',\n",
" 'το γινόμενο του 10χ5=50',\n",
" 'το γινόμενο του 10χ6=60',\n",
" 'το γινόμενο του 10χ7=70',\n",
" 'το γινόμενο του 10χ8=80',\n",
" 'το γινόμενο του 10χ9=90',\n",
" 'το γινόμενο του 10χ10=100']"
]
},
"execution_count": 95,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"[\"το γινόμενο του {}χ{}={}\".format(x,y,x*y) for x in range(1,11) for y in range(1,11)]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Προσέξτε ότι επέστρεψε μία λίστα. Μπορούμε όμως να εννώσουμε όλα τα στοιχεία μίας λίστας σε ένα string με την εντολή ```join```. H join εννώνει όλα τα strings μίας λίστας σε ένα string:"
]
},
{
"cell_type": "code",
"execution_count": 96,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"'abc'"
]
},
"execution_count": 96,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"''.join([\"a\", \"b\", \"c\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μα τι είναι αυτό το '' μπροστα;; Αυτό είναι το υπο-string που θέλουμε να έχουν μεταξύ τους τα στοιχεία (στη συγκεκριμένη περίπτωση δεν θέλουμε να έχουν τίποτα μεταξύ τους."
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"'a-b-c'"
]
},
"execution_count": 98,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"'-'.join([\"a\", \"b\", \"c\"])"
]
},
{
"cell_type": "code",
"execution_count": 99,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"'a b c'"
]
},
"execution_count": 99,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"' '.join([\"a\", \"b\", \"c\"])"
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"'a HELLO b HELLO c'"
]
},
"execution_count": 100,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"' HELLO '.join([\"a\", \"b\", \"c\"])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Υπάρχει ο ειδικός χαρακτήρας: '\\n' οποίος αναπαριστάει το \"νέα γραμμη\". Είναι δηλαδή σαν να υπάρχει ένα ```<enter>``` σε αυτό το σημεία του string:"
]
},
{
"cell_type": "code",
"execution_count": 102,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"abc\n",
"deg\n"
]
}
],
"source": [
"a=\"abc\\ndeg\"\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 103,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
"\n",
"python\n",
"\n",
"\n"
]
}
],
"source": [
"a = \"\\n\\npython\\n\\n\"\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αν θέλουμε να τυπώσουμε \"\\n\", μπορούμε να το κάνουμε τυπώνοντας \"\\\\\\n\":"
]
},
{
"cell_type": "code",
"execution_count": 104,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"με το \\n πάμε σε μία νέα γραμμή\n"
]
}
],
"source": [
"print(\"με το \\\\n πάμε σε μία νέα γραμμή\")"
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"με το \n",
" πάμε σε μία νέα γραμμή\n"
]
}
],
"source": [
"print (\"με το \\n πάμε σε μία νέα γραμμή\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Οπότε κάνοντας join με το \\n μπορούμε να έχουμε μία νέα γραμμή για κάθε string μίας λίστας"
]
},
{
"cell_type": "code",
"execution_count": 107,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a\n",
"b\n",
"c\n"
]
}
],
"source": [
"print('\\n'.join([\"a\", \"b\", \"c\"]))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Οπότε το:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"print('\\n'.join([\"το γινόμενο του {}χ{}={}\".format(x,y,x*y) for x in range(1,11) for y in range(1,11)]))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"είναι ισοδύναμο με:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"for x in range(1,11):\n",
" for y in range(1,11):\n",
" print ('Το γινόμενο του {}χ{}={}'.format(x,y,x*y))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### while"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Η ```while``` έχει τη μορφή:\n",
"\n",
"while <έκφραση>:\n",
"\n",
" <εντολές που επαναλαμβάνονται μέχρι η <έκφραση να γίνει False> >"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Παράδειγμα:"
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"50.0\n",
"25.0\n",
"12.5\n",
"6.25\n",
"3.125\n",
"1.5625\n",
"0.78125\n"
]
}
],
"source": [
"a=100\n",
"while a>1:\n",
" a = a/2\n",
" print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Διαίρεε (ή διαίρει;;) το 100 με το 2 μέχρι το αποτέλεσμα να γίνει μικρότερο του 1"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορεί να γραφεί το παραπάνω με list comprehension; (λύσαξες ποια με δ'αύτα). Μπορεί αλλά είναι άσχημο το αποτέλεσμα (και αργό).."
]
},
{
"cell_type": "code",
"execution_count": 168,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[50.0, 25.0, 12.5, 6.25, 3.125, 1.5625, 0.78125]\n"
]
}
],
"source": [
"a = [];\n",
"b=[a.append(100/2**x) for x in range(1,100) if (not len(a)) or a[-1]>1.0 ]\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τα list comprehensions είναι βολικά για μετασχηματισμούς σε λίστες και όχι για επαναλήψεις όπου δεν ξέρουμε από πριν το πλήθος των επαναλήψεων. Η python έχει μία βασική φιλοσοφία: μεταξύ δύο προσεγγίσεων διάλεξε την πιο ευανάγνωστη και την πιο \"όμορφη\"."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τόσο η ```for``` όσο και η ```while``` δέχονται δύο ειδικές εντολές. Τη ```break``` και τη ```continue```\n",
"* ```break``` : Βγες από την επανάληψη τώρα!\n",
"* ```continue```: Αγνόησε τις υπόλοιπες εντολές της επανάληψης και συνέχισε στον επόμενο \"κύκλο\" της επανάληψης"
]
},
{
"cell_type": "code",
"execution_count": 120,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"2\n",
"3\n",
"4\n",
"5\n"
]
}
],
"source": [
"for x in [1,2,3,4,5,6,7,8,9,10]:\n",
" if x>5:\n",
" break # Αν το x είναι μεγαλυτερο από 5 τότε σταμάτα!\n",
" print (x)\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 121,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n",
"3\n",
"5\n",
"7\n",
"9\n"
]
}
],
"source": [
"for x in [1,2,3,4,5,6,7,8,9,10]:\n",
" if x%2 == 0:\n",
" continue # Αν το x είναι ζυγός τότε πάρε το επόμενο χ, συνεχίζοντας την επανάληψη\n",
" print (x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Το if το έχουμε δει πιο πριν. Ας το αναλύσουμε εδώ περισσότερο. To ```if``` έχει την δομή:"
]
},
{
"cell_type": "raw",
"metadata": {},
"source": [
"if <λογική έκφραση 1>:\n",
"\n",
" <εντολές που εκτελούντε αν η εκφραση 1 είναι True>\n",
"\n",
"elif <λογική έκφραση 2>:\n",
"\n",
" <εντολές που εκτελούντε αν η εκφραση 1 είναι False αλλά η έκφραση 2 είναι True>\n",
"\n",
"elif <λογική έκφραση 3>:\n",
"\n",
" <εντολές που εκτελούντα αν η έκφραση 1 είναι False, η έκφραση 2 είναι False, αλλά η έφραση 3 είναι True>\n",
"\n",
"... (μπορούμε να έχουμε όσες elif θέλουμε.. ή και καμία!)\n",
"\n",
"else:\n",
"\n",
" <Εντολές που εκτελούντε αν η έκφραση 1, 2, και 3 είναι False>"
]
},
{
"cell_type": "code",
"execution_count": 127,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"To x Den einai oute TRIA oute TESSERA oute EXI\n"
]
}
],
"source": [
"x=5\n",
"if x==3:\n",
" print (\"TRIA\")\n",
"elif x==4:\n",
" print (\"TESSERA\")\n",
"elif x==6:\n",
" print (\"EXI\")\n",
"else:\n",
" print (\"To x Den einai oute TRIA oute TESSERA oute EXI\")"
]
},
{
"cell_type": "code",
"execution_count": 128,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"To x Den einai oute TRIA oute TESSERA oute 6\n",
"To x Den einai oute TRIA oute TESSERA oute 6\n",
"TRIA\n",
"TESSERA\n",
"To x Den einai oute TRIA oute TESSERA oute 6\n",
"EXI\n",
"To x Den einai oute TRIA oute TESSERA oute 6\n",
"To x Den einai oute TRIA oute TESSERA oute 6\n",
"To x Den einai oute TRIA oute TESSERA oute 6\n",
"To x Den einai oute TRIA oute TESSERA oute 6\n"
]
}
],
"source": [
"for x in [1,2,3,4,5,6,7,8,9,10]:\n",
" if x==3:\n",
" print (\"TRIA\")\n",
" elif x==4:\n",
" print (\"TESSERA\")\n",
" elif x==6:\n",
" print (\"EXI\")\n",
" else:\n",
" print (\"To x Den einai oute TRIA oute TESSERA oute 6\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Συναρτήσεις (functions)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορείτε να φτιάξετε τις δικές σας συναρτήσεις με τον εξής τρόπο:"
]
},
{
"cell_type": "code",
"execution_count": 129,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def f():\n",
" print (\"hello\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Στη συνέχεια μπορείτε να τις καλέσετε:"
]
},
{
"cell_type": "code",
"execution_count": 130,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"hello\n"
]
}
],
"source": [
"f()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μία συνάρτηση μπορεί να επιστρέφει τιμές σε αυτόν που τις κάλεσε:"
]
},
{
"cell_type": "code",
"execution_count": 134,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"42\n"
]
}
],
"source": [
"def f():\n",
" return 42\n",
"\n",
"solution = f()\n",
"print(solution) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μία συνάρτηση μπορεί να δέχεται ένα ή περισσότερα ορίσματα:"
]
},
{
"cell_type": "code",
"execution_count": 136,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"30\n"
]
}
],
"source": [
"def f(x,y):\n",
" return x*y\n",
"\n",
"ginomeno = f(5,6)\n",
"print(ginomeno)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"***ΠΡΟΣΟΧΗ*** αν αλλάξετε την τιμή μίας παραμέτρου μέσα σε μία συνάρτηση, αυτή ΔΕΝ αλλάζει από εκεί που καλέστηκε.."
]
},
{
"cell_type": "code",
"execution_count": 140,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Πριν καλέσω την f η τιμή της x είναι: 3\n",
"Μέσα στην f, Αρχικά η τιμή της x είναι: 3\n",
"Η νέα τιμή της x μέσα στην f είναι: 5\n",
"Μετά που κάλεσα την f η τιμή της x είναι: 3\n"
]
}
],
"source": [
"def f(x):\n",
" print ('Μέσα στην f, Αρχικά η τιμή της x είναι: {}'.format(x))\n",
" x=5\n",
" print ('Η νέα τιμή της x μέσα στην f είναι: {}'.format(x)) \n",
" \n",
"x=3\n",
"print ('Πριν καλέσω την f η τιμή της x είναι: {}'.format(x))\n",
"f(x)\n",
"print ('Μετά που κάλεσα την f η τιμή της x είναι: {}'.format(x))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Παρόλα αυτά μπορείτε να μεταβάλετε μία λίστα μέσα από μία συνάρτηση:"
]
},
{
"cell_type": "code",
"execution_count": 141,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[42]\n"
]
}
],
"source": [
"def f(l):\n",
" l.append(42)\n",
" \n",
"a=[]\n",
"f(a)\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Επίσης μία συνάρτηση μπορεί να επιστρέφει περισσότερο από μία τιμές:"
]
},
{
"cell_type": "code",
"execution_count": 142,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 2\n"
]
}
],
"source": [
"def f():\n",
" return 1,2\n",
"\n",
"a,b = f()\n",
"print(a, b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αν μία συνάρτηση επιστρέφει παραπάνω από μία τιμές μπορείτε να πάρετε το αποτέλεσμα σαν λίστα:"
]
},
{
"cell_type": "code",
"execution_count": 143,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2]\n"
]
}
],
"source": [
"def f():\n",
" return 1,2\n",
"\n",
"a=list(f())\n",
"print (a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"***ΠΡΟΣΟΧΗ*** Αυτό επιτρέπεται ΜΟΝΟ αν η συνάρτηση επιστρέφει παραπάνω από μία τιμές"
]
},
{
"cell_type": "code",
"execution_count": 145,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "TypeError",
"evalue": "'int' object is not iterable",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-145-ab34c9e8d57e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 2\u001b[0m \u001b[0;32mreturn\u001b[0m \u001b[0;36m42\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0ma\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: 'int' object is not iterable"
]
}
],
"source": [
"def f():\n",
" return 42\n",
"\n",
"a=list(f())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ένα ολοκληρωμένο παράδειγμα: Φτιάχνω μία συνάρτηση που λύει την εξίσωση αχ^2+βχ+γ=0 . (Ελπίζω να θυμάστε τη λύση από το λύκειο!!!)"
]
},
{
"cell_type": "code",
"execution_count": 147,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"import math # Αυτή η εντολή \"εισάγει\" διάφορες μαθηματικές συναρτήσεις. Θα την εξηγήσουμε αναλυτικά στο μέλλον\n",
"\n",
"def solve(a,b,c):\n",
" # Τα a,b,c είναι οι παράγοντες της συνάρτησης ax^2+bx+c=0\n",
" \n",
" #Τσεκάρουμε αν το α είναι 0\n",
" if a == 0:\n",
" #Είμαστε στη περίπτωση βχ+γ=0.\n",
" \n",
" #Τσεκάρουμε αν το β είναι 0\n",
" if b == 0:\n",
" #Είμαστε στη περίπτωση γ=0\n",
" \n",
" #Τσεκάρουμε αν το γ είναι 0\n",
" if c == 0:\n",
" #Είμαστε στη περίπτωση: 0=0. ΤΑΥΤΟΤΗΤΑ!!\n",
" return \"ΤΑΥΤΟΤΗΤΑ\"\n",
" else:\n",
" # Είμαστε στη περίπτωση c=0, c διάφορο του 0. ΑΔΥΝΑΤΟ!\n",
" return \"DEN EXEI LUSEIS!\"\n",
" else:\n",
" #Είμαστε στη περίπτωση bx+c = 0, b διάφορο του 0. Έχει μία λυση:\n",
" return -c/b\n",
" else:\n",
" #Είμαστε στη περίπτωση που αχ^2+βχ+γ =0, όπου το α είναι διάφορο το 0\n",
" \n",
" #Υπολόγισε τη διακρίνουσα: β^2-4αγ\n",
" d = (b**2)-(4*a*c)\n",
" \n",
" #Δες αν είναι θετική η διακρίνουσα\n",
" if d > 0:\n",
" #Πάρε τη τετραγωνική ρίζα της.\n",
" d_sqr = math.sqrt(d) # Η συνάρτηση math.sqrt επιστρέφει τη τετραγωνική ρίζα\n",
"\n",
" #Έχει δύο λύσεις\n",
" solution_1 = (-b + d_sqr) / (2*a) # (-β+√δ)/(2α)\n",
" solution_2 = (-b - d_sqr) / (2*a) # (-β-√δ)/(2α)\n",
" return solution_1, solution_2\n",
"\n",
" elif (d==0):\n",
" # Η διακρίνουσα είναι 0, άρα έχει μία λύση\n",
" solution = -b/(2*a)\n",
" return solution\n",
" else:\n",
" # Η διακρίνουσα είναι αρνητική. Δεν έχει λύσεις\n",
" return \"DEN EXEI LUSEIS\"\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 150,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"(1.0, -2.5)"
]
},
"execution_count": 150,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"solve(2,3,-5) # 2χ^2 + 4χ -5 = 0"
]
},
{
"cell_type": "code",
"execution_count": 152,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"'ΤΑΥΤΟΤΗΤΑ'"
]
},
"execution_count": 152,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"solve(0,0,0)"
]
},
{
"cell_type": "code",
"execution_count": 153,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"-2.0"
]
},
"execution_count": 153,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"solve(0,5,10)"
]
},
{
"cell_type": "code",
"execution_count": 155,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"'DEN EXEI LUSEIS!'"
]
},
"execution_count": 155,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"solve(0,0,1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# ΑΣΚΗΣΕΙΣ !!\n",
"\n",
"Σημείωση: το google-άρισμα επιτρέπεται και ενθαρύνεται!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Φτιάχτε τις εξής λίστες (με κάποιον αυτόματο τρόπο, κατα προτίμηση list comprehensions)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Όλοι οι αριθμοί που διαιρούνται με το 3 από το 1 μέχρι το 100"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Όπως παραπάνω αλλά σε αντίστροφη σειρά: 99, 96, 93, .."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Βρείτε όλους τους ζυγούς αριθμούς από το 1 μέχρι το 100 που ΔΕΝ διαιρούντε με το 3. (π.χ. δεν θέλουμε το 6)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Ένα έτος είναι δίσεκτο αν διαιρείται με το 4. Από αυτόν τον κανόνα εξαιρούνται τα έτη που διαιρούνται με το 100 (το 1900 δεν ήταν δίσεκτο) και από αυτόν τον κανόνα εξαιρούνται τα έτη που διαιρούνται με το 400 (το 2000 ήταν δίσεκτο!). Φτιάξτε μία συνάρτηση που δέχεται σαν όρισμα ένα έτος και επιστρέφει True ή False ανάλογα με το αν το έτος είναι δίσεκτο"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Πόσα έτη από το 1 μέχρι το 2500 είναι δίσεκτα;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Κατασκευάστε τη παρακάτω λίστα:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"[[1], [1,2], [1,2,3], [1,2,3,4], [1,2,3,4,5], [1,2,3,4,5,6], [1,2,3,4,5,6,7], [1,2,3,4,5,6,7,8], [1,2,3,4,5,6,7,8,9], [1,2,3,4,5,6,7,8,9,10]]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Κατασκευάστε τη παρακάτω λίστα:\n",
"\n",
" Το 1 μία φορά το 2 δύο φορές, το 3 τρεις φορές κτλ μέχρι και το 10\n",
"\n",
" Δηλαδή:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"[1, 2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 9, 9, 9, 10, 10, 10, 10, 10, 10, 10, 10, 10, 10]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Φτιάχτε μία συνάρτηση που θα δέχεται ένα όρισμα και θα βρίσκει αν ο αριθμός αυτός είναι πρώτος ή όχι. (πρώτος είναι ο αριθμός που διαιρείται μόνο με το 1 και με τον εαυτό του. Παραδείγματα πρώτων: 5,11,23, παραδείγματ ΜΗ-πρώτων: 10, 21, 24)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Ποιο είναι το άθροισμα όλων των πρώτων αριθμών από το 1 μέχρι το 1000;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Έστω η παρακάτω λίστα (κάθε ζευγάρι αποτελείται από πόλη, πληθυσμό):"
]
},
{
"cell_type": "code",
"execution_count": 165,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"towns=[[\"Heraklion\", 200000], [\"Patra\", 168000], [\"Thessalonikh\", 770000], [\"Larisa\", 145000]]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ποια πόλη έχει τον μεγαλύτερο πληθυσμό; Hint: η συνάρτηση ```max``` επιτρέφει το μεγαλύτερο στοιχείο μίας λίστας. Ομοίως η συνάρτηση ```min``` επιστρέφει το μικρότερο"
]
},
{
"cell_type": "code",
"execution_count": 166,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 166,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"min([4,5,3,7,8,6])"
]
},
{
"cell_type": "code",
"execution_count": 167,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 167,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"max([4,5,3,7,8,6])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Έξτρα δύσκολη άσκηση:\n",
" \n",
"Ποιος είναι ο μέσος όρος πλυθυσμών των πόλεων που έχουν το \"s\" στο όνομά τους;"
]
}
],
"metadata": {
"anaconda-cloud": {},
"kernelspec": {
"display_name": "Python [conda env:py3k]",
"language": "python",
"name": "conda-env-py3k-py"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.5.2"
}
},
"nbformat": 4,
"nbformat_minor": 1
}
Display the source blob
Display the rendered blob
Raw
lesson_3.ipynb
Loading
Sorry, something went wrong. Reload?
Sorry, we cannot display this file.
Sorry, this file is invalid so it cannot be displayed.
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment