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
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_3.ipynb
{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Σημείωσεις για το μάθημα \"Προγραμματισμός σε python**\n",
"\n",
"Αλέξανδρος Καντεράκης [kantale@ics.forth.gr](mailto:kantale@ics.forth.gr)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Διάλεξη 3η, 27 Οκτωβρίου 2016"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ας ξεκινήσουμε με κάποια πράγματα που τα έχουμε πει σποραδικά αλλά δεν το έχω βάλει σε αυτές τις σημειώσεις"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Multiline string "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ένα string μπορεί να έχει παραπάνω από μία γραμμές αν το έχουμε εσωκλείσει σε τριπλά μονά ή διπλά εισαγωγικά:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n",
" Ενα string με παραπάνω από μία γραμές!\n",
" python is the best\n",
"\n"
]
}
],
"source": [
"a = '''\n",
" Ενα string με παραπάνω από μία γραμές!\n",
" python is the best\n",
"'''\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"H συνάρτηση ```split``` δημιουργεί μία λίστα, από ένα string, \"σπάζοντάς\" το εκεί που υπάρχει κάποιο υπο-string"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['', ' Ενα string με παραπάνω από μία γραμές!', ' python is the best', '']\n"
]
}
],
"source": [
"print (a.split('\\n'))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"H ```split``` μπορεί να μην πάρει κάποιο όρισμα. Σε αυτή τη περίπτωση σπάει ένα string με βάσει τα κενά, τα newlines (\\\\n) και τα tabs"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['Ενα', 'string', 'με', 'παραπάνω', 'από', 'μία', 'γραμές!', 'python', 'is', 'the', 'best']\n"
]
}
],
"source": [
"print (a.split())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Πότε μία έφραση είναι False και πότε είναι True;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Εχουμε δει την if:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"a is not 3\n"
]
}
],
"source": [
"if a==3:\n",
" print(\"a is 3\")\n",
"else:\n",
" print (\"a is not 3\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τι γίνεται όμως όταν στην if βάζουμε εκφράσεις που δεν έχουν λογικές συναρτήσεις; ('==', '<=', ```and```, ```or```, κτλ)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Φτιάχνω μία συνάρτηση που ελέγχει αν μία μεταβλητή είναι True ή False:"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def check(var):\n",
" if var:\n",
" print (\"TRUE!!\")\n",
" else:\n",
" print (\"FALSE!!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μεταβλητές που είναι άδειο string, άδεια λίστα, άδειο dictionary, άδειο tuple, το 0, το 0.0 και το ```None``` όλα είναι FALSE!"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"FALSE!!\n"
]
}
],
"source": [
"check('')"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"FALSE!!\n"
]
}
],
"source": [
"check([])"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"FALSE!!\n"
]
}
],
"source": [
"check({})"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"FALSE!!\n"
]
}
],
"source": [
"check(())"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"FALSE!!\n"
]
}
],
"source": [
"check(0)"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"FALSE!!\n"
]
}
],
"source": [
"check(0.0)"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"FALSE!!\n"
]
}
],
"source": [
"check(None)"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TRUE!!\n"
]
}
],
"source": [
"check(1)"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TRUE!!\n"
]
}
],
"source": [
"check('Mitsos')"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TRUE!!\n"
]
}
],
"source": [
"check([1])"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TRUE!!\n"
]
}
],
"source": [
"check([[]])"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TRUE!!\n"
]
}
],
"source": [
"check(0.000000000001)"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"TRUE!!\n"
]
}
],
"source": [
"check(-0.000000000001)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### None"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Το ```None``` είναι μία δεσμευμένη λέξη στη python που δηλώνει το απόλυτο τίποτα! Όταν μία συνάρτηση τερματίζει και δεν υπάρχει return τότε επιστρέφει ```None```."
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"def f(k):\n",
" if k == 1: # An to k den einai 1 tote den yparxei return!!!\n",
" return 42\n",
" "
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"42\n"
]
}
],
"source": [
"print (f(1))"
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
}
],
"source": [
"print (f(2))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορεί να το έχετε δει αν προσπαθήσετε να τυπώσετε το αποτέλεσμα συναρτήσεων που δεν επιστρέφουν τίποτα:"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"None\n"
]
}
],
"source": [
"a=[]\n",
"print(a.append(42))"
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[42]\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Η ```append``` προσθέτει ένα στοιχείο σε μία λίστα και δεν επιτρέφει τίποτα "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Στη python όταν δηλώνουμε ότι έχουμε κάποιο block που εκτελείται μέσα σε ένα ```for```, ```while```, ```if```, ```def``` τότε το block αυτό ΔΕΝ μπορεί να είναι άδειο!"
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "unexpected EOF while parsing (<ipython-input-29-b80835526ad8>, line 2)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"<ipython-input-29-b80835526ad8>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m # Το άφησα επίτηδες κενό\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m unexpected EOF while parsing\n"
]
}
],
"source": [
"if a == 3:\n",
" # Το άφησα επίτηδες κενό"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αν για κάποιο λόγο θέλουμε να μην βάλουμε τίποτα μέσα σε ένα block τότε μπορούμε να χρησιμοποιήσουμε τη ```pass```"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"if a== 3:\n",
" pass"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αυτό είναι χρήσιμο όταν θέλουμε να δείξουμε στον κώδικα ότι υπάρχει κάτι σαν επιλογή αλλά δεν θέλουμε να γίνεται τίποτα!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"## Dictionaries"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τα dictionaries είναι δομές δεδομένων όπου κάθε στοιχείο έχει ένα κλειδί (key) και ένα value"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'key2': 'value2', 'key1': 'value1', 'key3': 'value3'}\n"
]
}
],
"source": [
"a={\"key1\": \"value1\", \"key2\": \"value2\", \"key3\": \"value3\"}\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Υπάρχει και το άδειο dictionary"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"{}"
]
},
"execution_count": 32,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορούμε να προσπελάσουμε τα στοιχεία ενώς dictionary χρησιμοποιώντας τις αγκύλες"
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"'value1'"
]
},
"execution_count": 34,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[\"key1\"]"
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"'value2value3'"
]
},
"execution_count": 36,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a[\"key2\"] + a[\"key3\"]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορούμε να προσθέτουμε στοιχεία σε μία λίστα με αυτόν τον τρόπο:"
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'key4': 'value4', 'key2': 'value2', 'key1': 'value1', 'key3': 'value3'}\n"
]
}
],
"source": [
"a[\"key4\"] = \"value4\"\n",
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** ***ΠΡΟΣΟΧΗ*** \n",
"\n",
"Σε αντίθεση με τη λίστα που τα καινούργια στοιχεία προστίθονται πάντα στο τέλος, στα dictionaries κάθε στοιχείο προστίθεται σε τυχαία θέση!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορούμε να διαγράψουμε ένα στοιχείο με τη del:"
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"del a[\"key2\"]"
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'key4': 'value4', 'key1': 'value1', 'key3': 'value3'}\n"
]
}
],
"source": [
"print(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"H συνάρτηση ```keys``` μας δίνει τα κλειδιά ενώς dictionary μέσα σε μία λίστα:"
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"dict_keys(['key4', 'key1', 'key3'])"
]
},
"execution_count": 41,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a.keys()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Η συνάρτηση values μας δίνει τις τιμές ενώς dictionary μέσα σε μία λίστα:"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"dict_values(['value4', 'value1', 'value3'])"
]
},
"execution_count": 42,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a.values()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αν χρησιμοποιήσουμε το ```for x in <dictionary>``` τότε το χ θα παίρνει τα κλειδιά του dicitonary:"
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"key4\n",
"key1\n",
"key3\n"
]
}
],
"source": [
"for x in a:\n",
" print(x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορούμε όμως να χρησιμοποιήσουμε το [] για να πάρουμε και τα values:"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"key4 value4\n",
"key1 value1\n",
"key3 value3\n"
]
}
],
"source": [
"for x in a:\n",
" print(x, a[x])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Εναλλακτικά μπορούμε να χρησιμοποιήσουμε την items() για να πάρουμε και τα keys και τα values:"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"key4 value4\n",
"key1 value1\n",
"key3 value3\n"
]
}
],
"source": [
"for k,v in a.items():\n",
" print (k,v)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τα keys μπορεί να είναι strings, αριθμοί, True, False"
]
},
{
"cell_type": "code",
"execution_count": 96,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{0: 'value2', 's': 'value1', True: 'value4', 1.23: 'value3'}\n"
]
}
],
"source": [
"b = {\"s\": \"value1\", 0: \"value2\", 1.23: \"value3\", True: \"value4\"}\n",
"print(b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τα values μπορεί να είναι οτιδίποτε!"
]
},
{
"cell_type": "code",
"execution_count": 97,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{0: 'value2', 's': 'value1', 'e': False, 1.23: 'value3', 'b': [[[[[[[[[[[]]]]]]]]]]], 'c': {'key4': 'value4', 'key3': 'value3', 'key1': 'value1'}, True: 'value4', 'h': 'Mitsos', 'a': [1, 2, 3], 'd': <function check at 0x104072510>}\n"
]
}
],
"source": [
"b[\"a\"] = [1,2,3]\n",
"b[\"b\"] = [[[[[[[[[[[]]]]]]]]]]]\n",
"b[\"c\"] = {'key4': 'value4', 'key1': 'value1', 'key3': 'value3'}\n",
"b[\"d\"] = check # την θυμάστε την check που την ορίσαμε παραπάνω; (ναι το value μπορεί να είναι και μία συνάρτηση)\n",
"b[\"e\"] = 3>4\n",
"b[\"h\"] = \"Mitsos\"\n",
"\n",
"print(b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Επίσης μπορούμε να ελέγξουμε αν ένα κλειδί υπάρχει μέσα σε ένα dictionary:"
]
},
{
"cell_type": "code",
"execution_count": 98,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Exists!\n"
]
}
],
"source": [
"if \"a\" in b:\n",
" print (\"Exists!\")"
]
},
{
"cell_type": "code",
"execution_count": 100,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"b['Mitsos'] does not exist\n"
]
}
],
"source": [
"if not \"Mitsos\" in b:\n",
" print (\"b['Mitsos'] does not exist\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Όσους τους ενδιαφέρει το τεχνικό κομμάτι των dictionaries μπορείτε να διαβάσετε εδώ: https://en.wikipedia.org/wiki/Hash_table"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Dictionary comprehensions"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Όπως και με τα list dictionaries έτσι και με τα dictionaries μπορούμε να δημιουργήσουμε νέα dictionaries ως εξής:"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"{0: 0, 1: 10, 2: 20, 3: 30, 4: 40, 5: 50, 6: 60, 7: 70, 8: 80, 9: 90}"
]
},
"execution_count": 52,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{x:x*10 for x in range(10)}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Προσέχτε το ```x:x*10``` κομμάτι! Όταν γράφουμε ```x:y``` σε ένα list comprehension το ```x``` είναι το κλειδί και ```y``` είναι το value"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Παράδειγμα: Ας πάρουμε αυτό το dictionary:"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"lengths = {\n",
"\t\t\"1\" : 249250621,\n",
"\t\t\"2\" : 243199373,\n",
"\t\t\"3\" : 198022430,\n",
"\t\t\"4\" : 191154276,\n",
"\t\t\"5\" : 180915260,\n",
"\t\t\"6\" : 171115067,\n",
"\t\t\"7\" : 159138663,\n",
"\t\t\"8\" : 146364022,\n",
"\t\t\"9\" : 141213431,\n",
"\t\t\"10\" : 135534747,\n",
"\t\t\"11\" : 134996516,\n",
"\t\t\"12\" : 133851895,\n",
"\t\t\"13\" : 115169878,\n",
"\t\t\"14\" : 107349540,\n",
"\t\t\"15\" : 102531392,\n",
"\t\t\"16\" : 90354753,\n",
"\t\t\"17\" : 81195210,\n",
"\t\t\"18\" : 78077248,\n",
"\t\t\"19\" : 59128983,\n",
"\t\t\"20\" : 63025520,\n",
"\t\t\"21\" : 48129895,\n",
"\t\t\"22\" : 51304566,\n",
"\t\t\"X\" : 155270560,\n",
"\t\t\"Y\" : 59373566,\n",
"\t}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Το dictionary αυτό περιέχει το μήκος των χρωμοσομάτων σύμφωνα με το [Human Genome Build version 37](https://www.ncbi.nlm.nih.gov/grc/human)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Φτιάχνουμε ένα dictionary που περιέχει μόνο τα sex chromosomes:"
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"{'X': 155270560, 'Y': 59373566}"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{k:v for k,v in lengths.items() if k in [\"X\", \"Y\"]}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Φτιάχνουμε ένα dictionary που προσθέτει το \"chr\" σε όλα τα keys:"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"{'chr1': 249250621,\n",
" 'chr10': 135534747,\n",
" 'chr11': 134996516,\n",
" 'chr12': 133851895,\n",
" 'chr13': 115169878,\n",
" 'chr14': 107349540,\n",
" 'chr15': 102531392,\n",
" 'chr16': 90354753,\n",
" 'chr17': 81195210,\n",
" 'chr18': 78077248,\n",
" 'chr19': 59128983,\n",
" 'chr2': 243199373,\n",
" 'chr20': 63025520,\n",
" 'chr21': 48129895,\n",
" 'chr22': 51304566,\n",
" 'chr3': 198022430,\n",
" 'chr4': 191154276,\n",
" 'chr5': 180915260,\n",
" 'chr6': 171115067,\n",
" 'chr7': 159138663,\n",
" 'chr8': 146364022,\n",
" 'chr9': 141213431,\n",
" 'chrX': 155270560,\n",
" 'chrY': 59373566}"
]
},
"execution_count": 56,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{\"chr\" + k:v for k,v in lengths.items()}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ένα dictionary με όλα τα chromosomes που έχουν μέγεθος πάνω από 100.000.000:"
]
},
{
"cell_type": "code",
"execution_count": 59,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"{'1': 249250621,\n",
" '10': 135534747,\n",
" '11': 134996516,\n",
" '12': 133851895,\n",
" '13': 115169878,\n",
" '14': 107349540,\n",
" '15': 102531392,\n",
" '2': 243199373,\n",
" '3': 198022430,\n",
" '4': 191154276,\n",
" '5': 180915260,\n",
" '6': 171115067,\n",
" '7': 159138663,\n",
" '8': 146364022,\n",
" '9': 141213431,\n",
" 'X': 155270560}"
]
},
"execution_count": 59,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"{k:v for k,v in lengths.items() if v>100000000}"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Πόσο είναι το μήκος όλου του γονιδιώματος;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Πρώτος τρόπος:"
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"3095667412"
]
},
"execution_count": 54,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum(lengths.values())"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Δεύτερος τρόπος:"
]
},
{
"cell_type": "code",
"execution_count": 60,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"3095667412"
]
},
"execution_count": 60,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([lengths[x] for x in lengths])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τρίτος τρόπος:"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"3095667412"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"sum([v for k,v in lengths.items()])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Tuples"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τα tuple είναι η τρίτη (και τελευταία!) βασική δομή της python (μετά τα lists και τα dictionaries.). Τα tuples είναι ακριβώς τα ίδια με τις λίστες με μία τεράστια διαφορά: Δεν μπορούν να μεταβληθούν. Ένα tuple δηλώνεται με παρενθέσεις, σε αντίθεση με τις λίστες που δηλώνονται με αγκύλες."
]
},
{
"cell_type": "code",
"execution_count": 104,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"my_list = [1,2,3]\n",
"my_tuple = (1,2,3)"
]
},
{
"cell_type": "code",
"execution_count": 105,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 10, 3]\n"
]
}
],
"source": [
"my_list[1] = 10\n",
"print(my_list)"
]
},
{
"cell_type": "code",
"execution_count": 106,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "TypeError",
"evalue": "'tuple' object does not support item assignment",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-106-78e14473086f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmy_tuple\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
]
}
],
"source": [
"my_tuple[1] = 10"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αν παρόλα αυτά ένα tuple έχει μέσα μία λίστα (ή dictionary) τότε αυτή η λίστα μπορεί να μεταβληθεί!"
]
},
{
"cell_type": "code",
"execution_count": 108,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(1, [2, 10], 3)\n"
]
}
],
"source": [
"my_tuple = (1,[2], 3)\n",
"my_tuple[1].append(10)\n",
"print(my_tuple)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Επίσης παρόλο που τα lists και τα dictionaries ΔΕΝ μπορούν να είναι keys σε dictionaries, τα tuples μπορούν (με κάποιες εξαιρέσεις)"
]
},
{
"cell_type": "code",
"execution_count": 111,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{(1, 2, 3): 3}\n"
]
}
],
"source": [
"a={}\n",
"a[(1,2,3)] = 3 # AUTO EINAI OK\n",
"print(a)"
]
},
{
"cell_type": "code",
"execution_count": 110,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "can't assign to function call (<ipython-input-110-d7476ae082ae>, line 1)",
"output_type": "error",
"traceback": [
"\u001b[0;36m File \u001b[0;32m\"<ipython-input-110-d7476ae082ae>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m a([1,2,3]) = 3 # AYTO DEN EINAI OK\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m can't assign to function call\n"
]
}
],
"source": [
"a([1,2,3]) = 3 # AYTO DEN EINAI OK"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Η εξαίρεση είναι ότι για να γίνει key ενώς dictionary το tuple ΔΕΝ πρέπει να έχει μέσα του κάποιο list ή κάποιο dictionary!"
]
},
{
"cell_type": "code",
"execution_count": 112,
"metadata": {
"collapsed": false
},
"outputs": [
{
"ename": "TypeError",
"evalue": "unhashable type: 'list'",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m<ipython-input-112-868f092f6e26>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0ma\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[0ma\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m4\u001b[0m \u001b[0;31m# AUTO EINAI OK\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[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m4\u001b[0m \u001b[0;31m# AUTO DEN EINAI OK (to key είναι ένα tuple που περιέχει λίστα!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: unhashable type: 'list'"
]
}
],
"source": [
"a={}\n",
"a[(1,2,3)] = 4 # AUTO EINAI OK\n",
"a[(1,[2],3)] = 4 # AUTO DEN EINAI OK (to key είναι ένα tuple που περιέχει λίστα!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Επίσης υπάρχουν tuple comprehensions. Όπως ακριβώς υπάρχουν και list και dictionary comprehensions:"
]
},
{
"cell_type": "code",
"execution_count": 113,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"<generator object <genexpr> at 0x107374468>"
]
},
"execution_count": 113,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(x for x in range(10))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μα τι είναι αυτό το generator;;;;;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Όταν φτιάχνετε ένα tuple generator η python ΔΕΝ ξέρει πόσα και ποια στοιχεία έχει μέσα! Κρατά μόνο τον κώδικα που χρειάζεται για να το δημιουργήσει. Το tuple \"γεμίζει\" μόνο και όταν κάνετε κάποια επανάληψη πάνω σε αυτό!"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"[x for x in range(100000000)] # Dhmiourghse mia lista me 100 ekat ariumoys. \n",
" #Auto 8a parei poly wra kai pi8anon na sou krasarei ton upologisth..."
]
},
{
"cell_type": "code",
"execution_count": 114,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"<generator object <genexpr> at 0x107374360>"
]
},
"execution_count": 114,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(x for x in range(100000000)) # Auto DEN pairnei ka8olou xrono giati apla h python den to kanei evaluate!!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορώ φυσικά να πάρω στοιχεία από αυτό κανονικά..."
]
},
{
"cell_type": "code",
"execution_count": 115,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0\n",
"1\n",
"2\n",
"3\n",
"4\n",
"5\n",
"6\n",
"7\n",
"8\n",
"9\n",
"10\n"
]
}
],
"source": [
"big_range = (x for x in range(100000000))\n",
"for y in big_range:\n",
" if y>10:\n",
" break # Den 8elw na gemisei to jupyter auto me 100.000.000 ari8mous..\n",
" print(y)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αυτό ονομάζεται \"[lazy evaluation](https://en.wikipedia.org/wiki/Lazy_evaluation)\" και είναι πολύ χρήσιμο όταν το να φτιάξεις μία λίστα είναι πολύ αργό αλλά το να πάρεις όλα τα στοιχεία της είναι γρήγορο."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Κλάσεις (classes)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Οι κλάσεις είναι ένας τρόπος να οργανώνεται τον κώδικα σας σε \"οντότητες\". Μία κλασση μπορεί να έχει τις δικές τις μεταβλητές και συναρτήσεις. Για να αναφερθείτε σε μία μεταβλητή (ή συνάρτηση) της κλάσσης μέσα από την κλάση πρέπει να χρησιμοποιήσετε το ```self```"
]
},
{
"cell_type": "code",
"execution_count": 70,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"class Gene:\n",
" def set_name(self, name):\n",
" self.name = name"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Η παραπάνω κλάση ονομάζεται \"Gene\". Έχει μία συνάρτηση τη set_name η οποία παίρνει ένα όρισμα (και όχι 2!!). Η συνάρτηση set_name βάζει την τιμή της παραμέτρου ```name``` μέσα στην μεταβλητή ```name``` της κλάσσης. ***ΠΡΟΣΟΧΗ!*** Κάθε κλάση έχει τις δικές τις μεταβλητές!!! \n",
"\n",
"μπορούμε να προσπελαύνουμε (access) τις συναρτήσεις ή τις μεταβλητές μιας κλάσης μέσω της τελείας (.):"
]
},
{
"cell_type": "code",
"execution_count": 71,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"G6PD\n"
]
}
],
"source": [
"mygene = Gene()\n",
"mygene.set_name(\"G6PD\")\n",
"print (mygene.name)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Προσοχή στην ορολογία! Το mygene είναι αντικείμενο της κλάσης Gene. mygene is an object of class Gene"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Οι κλάσεις ανοίκουν σε ένα πολύ μεγάλο κομμάτι θεωρίας της επιστήμης υπολογιστών. Για περισσότερα μπορείτε να διαβάσετε εδώ: https://en.wikipedia.org/wiki/Object-oriented_programming Στα ελληνικά: αντικειμενοστραφής προγραμματισμός"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορούμε να αρχικοποιήσουμε ένα αντικείμενο με κάποιες τιμές χρησιμοποιώντας την συνάρτηση ```__init__```"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"G6PD\n"
]
}
],
"source": [
"class Gene:\n",
" def __init__(self, name):\n",
" self.name = name\n",
" \n",
"mygene = Gene('G6PD')\n",
"print (mygene.name)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Γενικότερα: Το να οργανώσεις τον κώδικά σου σε classes απαιτεί πολύ εμπειρία! Η χρήση των κλάσεων απλά και μόνο \"για να χρησιμοποιήσω κλάσεις\" μπορεί να κάνει πιο πολύπλοκο και δυσανάγνωστο τον κώδικά σας. Ο κυριότερος λόγος που τις αναφέρουμε είναι επειδή θα δούμε στο μέλλον κάποιες εντολές και εργαλεία τα οποία είναι φτιαγμένα με τη μορφή κλάσεων. Θα επανέλθουμε στις κλάσεις στο μέλλον"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Δουλεύοντας με αρχεία"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ένα αρχείο μπορούμε να το ανοίξουμε με την εντολή ```open```"
]
},
{
"cell_type": "code",
"execution_count": 73,
"metadata": {
"collapsed": false
},
"outputs": [],
"source": [
"f=open('test.vcf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"***ΠΡΟΣΟΧΗ!*** Το αρχείο πρέπει να υπάρχει!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τι κάνει όμως η open; Η open απλά κοιτάει αν υπάρχει το αρχείο και, αν υπάρχει, απλά φτιάχνει ένα αντικείμενο μίας ειδικής κλάσης η οποία περιέχει μεθόδους για να διαβάζουμε το αρχείο. (Να λοιπόν γιατί αναφέραμε τις κλάσεις πριν..)\n",
"\n",
"Μία από τις βασικές μεθόδους είναι η ```read```, η οποία διαβάζει όλο το αρχείο σαν ένα string."
]
},
{
"cell_type": "code",
"execution_count": 76,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"a=f.read()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Τώρα η a είναι ένα πολύ μεγάλο string..:"
]
},
{
"cell_type": "code",
"execution_count": 77,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"19384909"
]
},
"execution_count": 77,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"len(a)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Πόσες φορές περιέχεται το \"chr\" μέσα στο a;"
]
},
{
"cell_type": "code",
"execution_count": 78,
"metadata": {
"collapsed": false
},
"outputs": [
{
"data": {
"text/plain": [
"38324"
]
},
"execution_count": 78,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a.count('chr')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Μπορείτε να φτιάξετε μια λίστα που να περιέχει όλες τις γραμμές του αρχείου:"
]
},
{
"cell_type": "code",
"execution_count": 80,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"chr1\t883625\t.\tA\tG\t599.62\tPASS\tAF=1;AO=61;DP=61;FAO=64;FDP=64;FR=.;FRO=0;FSAF=19;FSAR=45;FSRF=0;FSRR=0;FWDB=0.0285303;FXX=0;HRUN=1;LEN=1;MLLD=167.678;PB=0.5;PBP=1;QD=37.476;RBI=0.0485312;REFB=0;REVB=0.0392593;RO=0;SAF=19;SAR=42;SRF=0;SRR=0;SSEN=0;SSEP=0;SSSB=0;STB=0.5;STBP=1;TYPE=snp;VARB=0.000122548;OID=.;OPOS=883625;OREF=A;OALT=G;OMAPALT=G\tGT:GQ:DP:FDP:RO:FRO:AO:FAO:AF:SAR:SAF:SRF:SRR:FSAR:FSAF:FSRF:FSRR\t1/1:29:61:64:0:0:61:64:1:42:19:0:0:45:19:0:0\n"
]
}
],
"source": [
"all_lines = a.split('\\n')\n",
"print (all_lines[100]) # H ekatosth grammh tou arxeiou"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Το συγκεκριμένο αρχείο είναι σε φορμάτ VCF. Σε αυτό το link: http://www.internationalgenome.org/wiki/Analysis/Variant%20Call%20Format/vcf-variant-call-format-version-40/ υπάρχει αναλυτική περιγραφή του φορμάτ"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Κάθε γραμμή αυτού του αρχείου περιέχει πολλά πεδία τα οποία διαχωρίζονται με tabs. Μπορούμε να φτιάξουμε μία λίστα με όλα τα πεδία μιας γραμμής:"
]
},
{
"cell_type": "code",
"execution_count": 82,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['chr1', '883625', '.', 'A', 'G', '599.62', 'PASS', 'AF=1;AO=61;DP=61;FAO=64;FDP=64;FR=.;FRO=0;FSAF=19;FSAR=45;FSRF=0;FSRR=0;FWDB=0.0285303;FXX=0;HRUN=1;LEN=1;MLLD=167.678;PB=0.5;PBP=1;QD=37.476;RBI=0.0485312;REFB=0;REVB=0.0392593;RO=0;SAF=19;SAR=42;SRF=0;SRR=0;SSEN=0;SSEP=0;SSSB=0;STB=0.5;STBP=1;TYPE=snp;VARB=0.000122548;OID=.;OPOS=883625;OREF=A;OALT=G;OMAPALT=G', 'GT:GQ:DP:FDP:RO:FRO:AO:FAO:AF:SAR:SAF:SRF:SRR:FSAR:FSAF:FSRF:FSRR', '1/1:29:61:64:0:0:61:64:1:42:19:0:0:45:19:0:0']\n"
]
}
],
"source": [
"line_100 = all_lines[100] # H ekatosth grammh\n",
"line_100_fields = line_100.split('\\t') # to \\t einai to tab\n",
"print(line_100_fields)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Οπότε μπορούμε να προσπελάσουμε οποιοδίποτε στοιχείο του αρχείου.\n",
"\n",
"Από τη στιγμή που έχουμε διαβάσει ένα αρχείο ΔΕΝ μπορούμε να το ξαναδιαβάσουμε!"
]
},
{
"cell_type": "code",
"execution_count": 84,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\n"
]
}
],
"source": [
"b=f.read()\n",
"print(b)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Δεν τυπώνει τίποτα! Για να το ξαναδιαβάσουμε πρέπει να το κλείσουμε και να το ξαναανοίξουμε:"
]
},
{
"cell_type": "code",
"execution_count": 85,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"f.close()\n",
"f = open('test.vcf')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Η εντολή readline() Διαβάζει μία γραμμή του αρχείου. Αν την ξανακαλέσουμε διαβάζει την επόμενη κτλ"
]
},
{
"cell_type": "code",
"execution_count": 86,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"##fileformat=VCFv4.1\n",
"\n"
]
}
],
"source": [
"print (f.readline()) # H prwth grammh tou arxeiou"
]
},
{
"cell_type": "code",
"execution_count": 88,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"##FILTER=<ID=NOCALL,Description=\"Generic filter. Filtering details stored in FR info tag.\">\n",
"\n"
]
}
],
"source": [
"print (f.readline()) # H deuterh grammh tou arxeiou"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ένας τρόπος για να διαβάσουμε μία-μία όλες τις γραμμές ενός αρχείου είναι να χρησιμοποιήσουμε τη for:"
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"f.close()\n",
"f = open('test.vcf')\n",
"for line in f:\n",
" print (line) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Αυτός ο τρόπος είναι πολύ χρήσιμος αν δεν θέλουμε να φορτώσουμε όλο το αρχείο στη μνήμη του υπολογιστή. Κάθε φορά η line παίρνει μία γραμμή του αρχείου."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ένα ολοκληρωμένο παράδειγμα. Απαιτεί να έχετε μελετήση λίγο το φορματ VCF!"
]
},
{
"cell_type": "code",
"execution_count": 89,
"metadata": {
"collapsed": false
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Deletions: 598\n"
]
}
],
"source": [
"f = open('test.vcf')\n",
"deletions = 0\n",
"for line in f:\n",
" # To VCF format periexei diafora sxolia sthn arxh. Ka8e sxolio 3ekinaei me \"#\"\n",
" # Opote mporoume na agnooume autes tis grammes:\n",
" if line[0] == '#':\n",
" continue\n",
" \n",
" #Oi grammes pou den einai sxolia periexoun kapoio variant pou exei bre8ei se ena h' perissotera samples\n",
" #Oi grammes autew periexoyn polla pedia ta opoia xwrizontai me tabs.\n",
" #As kanoume split me bash to tab\n",
" line_splitted = line.split('\\t')\n",
" \n",
" #To tetarto pedio periexei to reference sequence\n",
" reference = line_splitted[3]\n",
" \n",
" #To pempto pedia periexei to alternative sequence pou brikame se kapoio sample\n",
" alternative = line_splitted[4]\n",
" \n",
" # To arxeio epitrepei na exoume perissotera apo ena alternatives.\n",
" # Ta alternatives auta diaxwrisontai me ,\n",
" # As agnoisoume autes tis grammes\n",
" if ',' in alternative:\n",
" continue\n",
" \n",
" #As metrhsoume posa deletions uparxoun. \n",
" #Ena deletion einai otan to alternative exei mikrotero mhkos apo to reference\n",
" if len(alternative) < len(reference):\n",
" deletions = deletions + 1\n",
" \n",
"# Sto telos tupwse ola ta deletions\n",
"print ('Deletions: {}'.format(deletions))\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# ΑΣΚΗΣΕΙΣ!!"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Έστω το παρακάτω κείμενο: "
]
},
{
"cell_type": "code",
"execution_count": 91,
"metadata": {
"collapsed": true
},
"outputs": [],
"source": [
"text=\"\"\"Python is a widely used high-level, general-purpose, interpreted, dynamic programming language. \n",
"Its design philosophy emphasizes code readability, and its syntax allows programmers to express concepts\n",
"in fewer lines of code than possible in languages such as C++ or Java\"\"\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Φτιάχτε ένα dictionary το οποίο θα περιέχει πόσες φορές υπάρχει στο κείμενο το κάθε γραμμα. Δηλαδη κατι σαν..\n",
"\n",
"```{\"a\": 44, \"b\":555, \"c\":422, ...} ```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Ποιο είναι το γράμμα που εμφανίζεται τις περισσότερες φορές;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Φτιάχτε ένα dictionary to οποίο θα περιέχει όλους τους αριθμούς από το 1 μέχρι το 10 σαν κλειδιά και σαν τιμές θα περιέχει το άθροισμα από το 1 μέχρι τι κλειδί. Δηλαδή να πρέπει να δημιουργήσετε το:\n",
"\n",
"```{1: 1, 2: 3, 3: 6, 4: 10, 5: 15, 6: 21, 7: 28, 8: 36, 9: 45, 10: 55}```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Φτιάχτε ένα dictionary που θα περιέχει το μέγεθος μόνο από τα ζυγά χρωμοσώματα (chr2, chr4, chr6, ...) (χρησιμοποιήστε τα αρχικό dictionary που υπάρχει πιο πάνω) "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Χρησιμοποιώντας το αρχείο test.vcf:\n",
"\n",
"* Φτιάχτε ενα dictionary που να περιέχει το πλήθος των variants που υπάρχουν στο αρχείο ανά χρωμόσωμα. Δλδ κάτι σαν ```{\"chr1\":5429, \"chr2\" 432, ...}```"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Φτιάχτε ένα dictionary όπου το κλειδί θα είναι ένα tuple το οποίο θα περιέχει ένα [SNP](https://en.wikipedia.org/wiki/Single-nucleotide_polymorphism). Πάρτε μόνο ό,τι έχει μήκος reference 1 και μήκος alternative 1. To tuple πρεπει να έχει δύο στοιχεία: Το reference και το alternative. Tο value θα είναι μία λίστα με tuples τα οποία θα περιέχουν το chromosome και το position που βρέθηκε αυτό το SNP. Δηλαδή το αποτέλεσμα πρέπει να έχει τη μορφή:\n",
"\n",
"```python\n",
"{\n",
" (\"A\", \"C\") : [(\"chr4\", 1234), (\"chr8\", 4567)],\n",
" (\"A\", \"G\") : [(\"chr7\", 777), (\"chr10\", 888)],\n",
"}```\n",
"\n",
"Αυτό σημαίνει π.χ ότι το SNP A->C (reference=A, alternative=C) βρέθηκε στις θέσεις chr4:1235, chr8:4567"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"* Ποιο SNP έχει τη μεγαλύτερη συχνότητα;"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Extra δύσκολη άσκηση:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ποιο είναι το Ti/Tv ratio του αρχείου;\n",
"\n",
"Ti/Tv (sometimes called Ts/Tv): the ratio of transitions vs. transversions in SNPs. Transitions are mutations within the same type of nucleotide: pyrimidine-pyrimidine mutations (C <-> T) and purine-purine mutations (A <-> G). Transversions are mutations from a pyrimidine to a purine or vice versa. Transitions occur at a higher rate because C, particularly when it is adjacent to a G i.e. CpG, can easily get methylated; once methylated, if deaminated it turns into U (equivalent to T), causing G->A on the other hand. "
]
}
],
"metadata": {
"anaconda-cloud": {},
"kernelspec": {
"display_name": "Python 3",
"language": "python",
"name": "python3"
},
"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
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment