{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Praktikum 7, lahendused\n", "\n", "Allolevad ülesanded on kusrsuse \"Sissejuhatus programmeerimisse Pythoni baasil\" YFX0500 **praktikumis** koos kursusega ja **kodus** iseseisvalt lahendamiseks. Kuidas lahendada allolevaid ülesandeid? Uuri ja kasuta loengus kommenteeritud süntaksi näiteid, abiinfot (Pythoni sisseehitatud funktsioon `help`, jne.), Internetti ja enda aju. Küsimuste korral, mis tekivad praktikumi ajal, pöördu õppejõu või õppejõudude poole. Iganädalaselt peale praktikumi toimumist avaldatakse ülesannete lahendused kursuse kodulehel.\n", "\n", "
Viimati uuendatud 14.10.2024.
\n", "\n", "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 1:**\n", "\n", "Järgmises jubedas koodis:\n", "```python\n", "def nimi_1():\n", " yield 7777\n", " yield 777\n", " yield 77\n", " yield 7\n", "\n", "nimi_2 = nimi_1()\n", "nimi_3 = next(nimi_2)\n", "nimi_4 = next(nimi_1())\n", "\n", "print(nimi_1)\n", "print(nimi_2)\n", "print(nimi_3)\n", "print(nimi_4)\n", "```\n", "Mis on generaatori nimi? Mis on iteraatori nimi? Mis on esimese iteratsiooni või iteraadi nimi?" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "\n", "\n", "7777\n", "7777\n" ] } ], "source": [ "def nimi_1():\n", " yield 7777\n", " yield 777\n", " yield 77\n", " yield 7\n", "\n", "nimi_2 = nimi_1() # Iteraatori defineerimine, Generator instance.\n", "nimi_3 = next(nimi_2) # Iteraat\n", "nimi_4 = next(nimi_1()) # Iteraat, funktsiooniga next jooksvalt üle terve generaatori ei saa, vt. loengu materjal.\n", "\n", "print(nimi_1)\n", "print(nimi_2)\n", "print(nimi_3)\n", "print(nimi_4)\n", "\n", "# Vastus: nimi_1 on generaator, nimi_2 on iteraator, nimi_3 ja nimi_4 on iteraadid." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 2:**\n", "\n", "Kasuta generaatori definitsiooni kujul:\n", "```python\n", "def gen():\n", " yield 7777\n", " yield 777\n", " yield 77\n", " yield 7\n", "```\n", "Itereeri, üle generaatori või vastavalt vajadusele üle iteraatori, kasutades `for`-tsüklit:\n", "1. Funktsiooni `next` kasutus keelatud;\n", "2. Kasuta funktsiooni `next`." ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7777\n", "777\n", "77\n", "7\n", "7777\n", "777\n", "77\n", "7\n" ] } ], "source": [ "# 1)\n", "def gen():\n", " yield 7777\n", " yield 777\n", " yield 77\n", " yield 7\n", "\n", "for i in gen(): # Itereerin üle generaatori. Operaator in loob iteraatori taustal\n", " print(i)\n", "\n", "iteraator = gen() # Loon iteraatori.\n", "\n", "for i in iteraator: # Itereerin üle iteratori.\n", " print(i)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7777\n", "777\n", "77\n", "7\n" ] } ], "source": [ "# 2) Kasutan funktsiooni next.\n", "def gen():\n", " yield 7777\n", " yield 777\n", " yield 77\n", " yield 7\n", "\n", "iteraator = gen() # Loon iteraatori.\n", "\n", "for _ in range(4): # 4 = len(list(gen()))\n", " print(next(iteraator))" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7777\n", "777\n", "77\n", "7\n" ] } ], "source": [ "# 2) Kasutan funktsiooni next. Rumal lahend.\n", "def gen():\n", " yield 7777\n", " yield 777\n", " yield 77\n", " yield 7\n", "\n", "iteraator = gen() # Loon iteraatori.\n", "\n", "for _ in 1,: # 1, on ühe elemendiga ennik.\n", " print(next(iteraator))\n", " print(next(iteraator))\n", " print(next(iteraator))\n", " print(next(iteraator))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 3:**\n", "\n", "Itereeri laisalt üle loendi:\n", "```python\n", "lst = [3, 4, 5, 6, 7]\n", "```\n", "Vihje: Laisa itereerimise mõiste." ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 4 5 6 7 " ] } ], "source": [ "# VASTUS: Muuda list iteraatoriks ja siis itereeri üle selle\n", "lst = [3, 4, 5, 6, 7]\n", "\n", "laisk = iter(lst) # Loon iteraatori.\n", "for i in laisk: # Itereerin üle iteraatori.\n", " print(i, end=' ')" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 4 5 6 7 " ] } ], "source": [ "lst = [3, 4, 5, 6, 7]\n", "\n", "for i in (i for i in lst): # Itereerin üle generaatori.\n", " print(i, end=' ')" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 4 5 6 7 " ] } ], "source": [ "lst = [3, 4, 5, 6, 7]\n", "laisk = (i for i in lst) # Defineerin iteraatori laisk.\n", "\n", "for i in laisk: # Itereerin üle iteraatori.\n", " print(i, end=' ')" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3 4 5 6 7\n" ] } ], "source": [ "lst = [3, 4, 5, 6, 7]\n", "print(*list(i for i in lst)) # Funktsioon list itereeris laisalt." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 4:**\n", "\n", "Defineeri generaator ja/või loo selle põhjal iteraator mis genereerib järgmised täisarve vahemukus $[10, 0]$:\n", "\n", "Oodatev tulemus:\n", "```\n", "10\n", "9\n", "8\n", "7\n", "6\n", "5\n", "4\n", "3\n", "2\n", "1\n", "0\n", "```\n", "või\n", "```\n", "10 9 8 7 6 5 4 3 2 1 0 \n", "```\n", "Vihje: Mõtle tavalisele funktsioonile ning asenda `return` lausendiga `yield`." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 9 8 7 6 5 4 3 2 1 0 " ] } ], "source": [ "def gen(a):\n", " for _ in range(0, 11):\n", " yield a\n", " a -= 1\n", " \n", "for i in gen(10): # Kontrollin.\n", " print(i, end=' ')" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 9 8 7 6 5 4 3 2 1 0 " ] } ], "source": [ "def gen():\n", " for i in range(10, -1, -1):\n", " yield print(i, end=' ') # Lausendiga return me nii ei teinud aga siin omab see mõtet.\n", " \n", "for i in gen(): # Kontrollin.\n", " i" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 9 8 7 6 5 4 3 2 1 0 " ] } ], "source": [ "def gen():\n", " for i in range(10, -1, -1):\n", " yield i\n", "\n", "num = gen() # Loon iteraatori.\n", "\n", "for i in num: # Kontrollin.\n", " print(i, end=' ')" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 9 8 7 6 5 4 3 2 1 0 " ] } ], "source": [ "def gen():\n", " for i in range(10, -1, -1):\n", " yield i\n", "\n", "num = gen() # Loon iteraatori.\n", "\n", "for i in range(11): # Kontrollin.\n", " print(next(num), end=' ') # Funktsioon next." ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 9 8 7 6 5 4 3 2 1 0 " ] } ], "source": [ "def gen():\n", " for i in range(10, -1, -1):\n", " yield i\n", " \n", "num = gen()\n", "\n", "for i in range(11): # kontrollin\n", " print(num.__next__(), end=' ') # Maagiline meetod." ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10 9 8 7 6 5 4 3 2 1 0 " ] } ], "source": [ "num = iter([i for i in range(10, -1, -1)])\n", "\n", "for i in num:\n", " print(i, end=' ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 5:**\n", "\n", "Defineeri generaator mis genereerib järgmised täisarve vahemikus $[10, 0]$. Kasuta generaatori defineerimise lühiesitust." ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "10\n", "9\n", "8\n", "7\n", "6\n", "5\n", "4\n", "3\n", "2\n", "1\n", "0\n" ] } ], "source": [ "num = (i for i in range(10, -1, -1)) # Generaatori lühiesitus.\n", "\n", "for i in num: # Kontrollin. Itereerin üle generaatori.\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 6:**\n", "\n", "Defineeri generaator või iteraator mis loob ja leiab arvude 15-dad astmed, kusjuures arvud võetakse vahemikust $[10, 0]$.\n", "\n", "Oodatav tulemus:\n", "```\n", "1000000000000000\n", "205891132094649\n", "35184372088832\n", "4747561509943\n", "470184984576\n", "30517578125\n", "1073741824\n", "14348907\n", "32768\n", "1\n", "0\n", "```" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1000000000000000\n", "205891132094649\n", "35184372088832\n", "4747561509943\n", "470184984576\n", "30517578125\n", "1073741824\n", "14348907\n", "32768\n", "1\n", "0\n" ] } ], "source": [ "def gen():\n", " for i in range(10, -1, -1):\n", " yield i**15\n", " \n", "for i in gen(): # Itereerin üle generaatori.\n", " print(i)" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1000000000000000\n", "205891132094649\n", "35184372088832\n", "4747561509943\n", "470184984576\n", "30517578125\n", "1073741824\n", "14348907\n", "32768\n", "1\n", "0\n" ] } ], "source": [ "def gen():\n", " for i in range(10, -1, -1):\n", " yield i**15\n", "\n", "item = gen() # Iteraatori loomine\n", "\n", "for i in item: # Itereerin üle iteraatorit.\n", " print(i)" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1000000000000000\n", "205891132094649\n", "35184372088832\n", "4747561509943\n", "470184984576\n", "30517578125\n", "1073741824\n", "14348907\n", "32768\n", "1\n", "0\n" ] } ], "source": [ "def gen():\n", " for i in range(10, -1, -1):\n", " yield i**15\n", "\n", "item = gen() # Iteraatori loomine\n", "\n", "for _ in range(11): # Kontrollin.\n", " print(next(item)) # Itereerin üle iteraatorit. Funktsioon next." ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1000000000000000\n", "205891132094649\n", "35184372088832\n", "4747561509943\n", "470184984576\n", "30517578125\n", "1073741824\n", "14348907\n", "32768\n", "1\n", "0\n" ] } ], "source": [ "nums = iter([i**15 for i in range(10, -1, -1)]) # List muudetakse iteraatoriks.\n", "\n", "for i in nums:\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 7:**\n", "\n", "Defineeri generaator mis loob ja leiab arvude 15-dad astmed. Arve vali vahemikust $[10, 0]$. Kasuta generaatori defineerimiseks generatori lühiesitust.\n", "\n", "Oodatav tulemus:\n", "```\n", "1000000000000000\n", "205891132094649\n", "35184372088832\n", "4747561509943\n", "470184984576\n", "30517578125\n", "1073741824\n", "14348907\n", "32768\n", "1\n", "0\n", "```" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1000000000000000\n", "205891132094649\n", "35184372088832\n", "4747561509943\n", "470184984576\n", "30517578125\n", "1073741824\n", "14348907\n", "32768\n", "1\n", "0\n" ] } ], "source": [ "nums = (i**15 for i in range(10, -1, -1)) # Generaatori lühiesitus.\n", "\n", "for i in nums: # Itereerin üle generaatori.\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 8:**\n", "\n", "Defineeri generaator või iteraator mis väljastab alltoodud loendis olevate riikide nimed.\n", "```python\n", "['Eesti', 'Kanada', 'USA', 'Läti']\n", "```" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Eesti\n", "Kanada\n", "USA\n", "Läti\n" ] } ], "source": [ "def riigid():\n", " for riik in ['Eesti', 'Kanada', 'USA', 'Läti']:\n", " yield riik\n", " \n", "for i in riigid(): # Itereerib üle generaatori.\n", " print(i)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Eesti\n", "Kanada\n", "USA\n", "Läti\n" ] } ], "source": [ "def riigid():\n", " for riik in ['Eesti', 'Kanada', 'USA', 'Läti']:\n", " yield print(riik)\n", " \n", "for i in riigid(): # Itereerib üle generaatori.\n", " i # Iteraat sisaldab funktsiooni print." ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Eesti\n", "Kanada\n", "USA\n", "Läti\n" ] } ], "source": [ "riigid = iter(['Eesti', 'Kanada', 'USA', 'Läti'])\n", "\n", "for i in riigid:\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 9:**\n", "\n", "Defineeri generaator, kasutades selle lühiesitust, mis väljastab alltoodud loendis olevate riikide nimed.\n", "```python\n", "['Eesti', 'Kanada', 'USA', 'Läti']\n", "```" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Eesti\n", "Kanada\n", "USA\n", "Läti\n" ] } ], "source": [ "riigid = (i for i in ['Eesti', 'Kanada', 'USA', 'Läti']) # Generaator.\n", "\n", "for i in riigid:\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 10:**\n", "\n", "Kasutades `for`-`in`-`if`-avaldist generaator lühiesituses teisenda loendis `numbrid` olevad arvud täisarvudeks (näiteks kasutades sisseehitatud funktsiooni `int`) ning elimineeri negatiivsed loendi elemendid.\n", "```python\n", "numbrid = [34.6, -203.4, 68.3, -12.2, 44.6, 12.7]\n", "```\n", "Oodatav tulemus:\n", "```\n", "34\n", "68\n", "44\n", "12\n", "```\n", "või\n", "```\n", "34 68 44 12\n", "```" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "34\n", "68\n", "44\n", "12\n" ] } ], "source": [ "numbrid = [34.6, -203.4, 68.3, -12.2, 44.6, 12.7]\n", "\n", "it = (int(x) for x in numbrid if x >= 0)\n", "\n", "for i in it:\n", " print(i)" ] }, { "cell_type": "code", "execution_count": 26, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "34 68 44 12 " ] } ], "source": [ "numbrid = [34.6, -203.4, 68.3, -12.2, 44.6, 12.7]\n", "\n", "it = (int(x) for x in numbrid if x >= 0)\n", "\n", "for i in it:\n", " print(i, end=' ')" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "34 68 44 12 " ] } ], "source": [ "# Kasutan midagi muud peale funktsiooni int\n", "import math\n", "numbrid = [34.6, -203.4, 68.3, -12.2, 44.6, 12.7]\n", "\n", "it = (math.floor(x) for x in numbrid if x >= 0)\n", "\n", "for i in it:\n", " print(i, end=' ')" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "34 68 44 12 " ] } ], "source": [ "# Kasutan midagi muud peale funktsiooni int\n", "numbrid = [34.6, -203.4, 68.3, -12.2, 44.6, 12.7]\n", "\n", "it = (int(x // 1) for x in numbrid if x >= 0)\n", "\n", "for i in it:\n", " print(i, end=' ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 11:**\n", "\n", "Kasutades `for`-`in`-`if`-avaldist generaator lühiesituses leia $50$-ne esimese mitte-negatiivse täisarvu 16-dad astmed. Filtreeri välja paarisarvulised tulemused.\n", "\n", "Oodatav tulemus:\n", "```\n", "1\n", "43046721\n", "152587890625\n", "33232930569601\n", "1853020188851841\n", "45949729863572161\n", "665416609183179841\n", "6568408355712890625\n", "48661191875666868481\n", "288441413567621167681\n", "1430568690241985328321\n", "6132610415680998648961\n", "23283064365386962890625\n", "79766443076872509863361\n", "250246473680347348787521\n", "727423121747185263828481\n", "1977985201462558877934081\n", "5070942774902496337890625\n", "12337511914217166362274241\n", "28644003124274380508351361\n", "63759030914653054346432641\n", "136614025729312093462315201\n", "282748441902441558837890625\n", "566977372488557307219621121\n", "1104427674243920646305299201\n", "```" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "43046721\n", "152587890625\n", "33232930569601\n", "1853020188851841\n", "45949729863572161\n", "665416609183179841\n", "6568408355712890625\n", "48661191875666868481\n", "288441413567621167681\n", "1430568690241985328321\n", "6132610415680998648961\n", "23283064365386962890625\n", "79766443076872509863361\n", "250246473680347348787521\n", "727423121747185263828481\n", "1977985201462558877934081\n", "5070942774902496337890625\n", "12337511914217166362274241\n", "28644003124274380508351361\n", "63759030914653054346432641\n", "136614025729312093462315201\n", "282748441902441558837890625\n", "566977372488557307219621121\n", "1104427674243920646305299201\n" ] } ], "source": [ "lahend = [i ** 16 for i in range(50) if (i**16) % 2 != 0]\n", "for i in lahend:\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 12:**\n", "\n", "1. Defineeri funktsioon mis väljastab listi mis sisaldab funktsioonile etteantud listis olevate arvude ruute.\n", "2. Defineeri generaator mis väljastab listi mis sisaldab generaatorile etteantud listis olevate arvude ruute.\n", "\n", "Sisendlist vali kujul:\n", "```python\n", "[1, 2, 3, 4]\n", "```\n", "Oodatav tulemus:\n", "```python\n", "[1, 4, 9, 16]\n", "```" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 4, 9, 16]" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 1 Funktsioon.\n", "def ruut(nums):\n", " tulem = []\n", " for i in nums:\n", " tulem.append(i * i)\n", " return tulem\n", "\n", "ruut([1, 2, 3, 4])" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 4, 9, 16]" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "def ruut(nums):\n", " t = [i ** 2 for i in nums]\n", " return t\n", "\n", "ruut([1, 2, 3, 4])" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[1, 4, 9, 16]" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# 2 Generaator.\n", "def gen_ruut(nums):\n", " tulem = []\n", " for i in nums:\n", " tulem.append(i * i)\n", " yield tulem\n", "\n", "n = gen_ruut([1, 2, 3, 4]) # Loome iteraatori.\n", "\n", "next(n) # NB! Järgmine funktsiooni next väljakutse ammendaks iteraatori." ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1, 4, 9, 16]\n" ] } ], "source": [ "# 2 Generaator, vale vastus võrdluseks.\n", "def gen_ruut(nums):\n", " for i in nums:\n", " yield i * i # Ei väljasta listi vaid ruudu.\n", "\n", "n = gen_ruut([1, 2, 3, 4])\n", "\n", "print(list(n)) # Laiskus. Funktsioon list itereeris üle iteraatori n." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 13:**\n", "\n", "Defineeri lõpmatu generaator mis genereerib mittenegatiivseid paarisarve. " ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "2\n", "4\n", "6\n", "8\n", "10\n" ] } ], "source": [ "# Lahend 1.\n", "def gen_inf():\n", " i = 0\n", " while True:\n", " yield 2 * i\n", " i += 1\n", " \n", "inf = gen_inf()\n", "\n", "for _ in range(5): # Prindin esimesed 5 iteraati.\n", " print(next(inf))\n", " \n", "print(next(inf)) # Veel üks, igaks juhuks." ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "2\n", "4\n", "6\n", "8\n" ] } ], "source": [ "# Lahend 2.\n", "def gen_inf2():\n", " i = 0\n", " while True:\n", " yield i\n", " i += 2\n", "\n", "inf = gen_inf2() \n", "\n", "for _ in range(5): # Prindin esimesed 5. Saad ka while loopi kasutada.\n", " print(next(inf))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 14:**\n", "\n", "Rakenda järjest kolme generaatorit. Generaatorid peavad töötama iseseisvalt ja ka üheskoos järjest rakendatuna. Generaatorid võtavad argumendina vasti järgmist listi:\n", "```python\n", "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "```\n", "Generaatorid peavad:\n", "- Filtreerima välja listi paaritud arvud.\n", "- Korrutama etteantud listi arve arvuga kolm.\n", "- Väljastama sõne kujul `Number on .`\n", "\n", "Küsitud operatsioone teosta esitatud järjekorras.\n", "\n", "Oodatav tulemus:\n", "```\n", "Number on 6.\n", "Number on 12.\n", "Number on 18.\n", "Number on 24.\n", "Number on 30.\n", "```" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number on 6.\n", "Number on 12.\n", "Number on 18.\n", "Number on 24.\n", "Number on 30.\n" ] } ], "source": [ "def paaris(nums):\n", " for num in nums:\n", " if num % 2 == 0:\n", " yield num\n", " \n", "def korda_kolm(nums):\n", " for num in nums:\n", " yield 3 * num\n", " \n", "def to_string(nums):\n", " for num in nums:\n", " yield f'Number on {num}.'\n", "\n", "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\n", "pipeline = to_string(korda_kolm(paaris(nums))) # Loome liititeraatori.\n", "\n", "for num in pipeline: # Itereerin üle iteraatorit.\n", " print(num)" ] }, { "cell_type": "code", "execution_count": 37, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Number on 6.\n", "Number on 12.\n", "Number on 18.\n", "Number on 24.\n", "Number on 30.\n" ] } ], "source": [ "def paaris(nums):\n", " for num in nums:\n", " if num % 2 == 0:\n", " yield num\n", " \n", "def korda_kolm(nums):\n", " for num in nums:\n", " yield 3 * num\n", " \n", "def to_string(nums):\n", " for num in nums:\n", " yield f'Number on {num}.'\n", "\n", "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\n", "for num in to_string(korda_kolm(paaris(nums))): # Itereerin generaatorit.\n", " print(num)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 15:**\n", "\n", "Rakenda järjest nelja generaatorit. Generaatorid peavad töötama iseseisvalt ja ka üheskoos järjest rakendatuna. Generaatorid võtavad argumendina vasti järgmist listi:\n", "```python\n", "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "```\n", "Generaatorid peavad:\n", "- Listist valima paarisarvud ja väljastama need.\n", "- Korrutama etteantud listi arve arvuga 7.31 ja väljastama saadud tulemused.\n", "- Leidma arvu juure ja väljastama selle.\n", "- Väljastama sõne kujul `Arv oli aga muutus arvuks .`\n", "\n", "Küsitud operatsioone teosta esitatud järjekorras.\n", "\n", "Oodatav tulemus:\n", "```\n", "Arv oli 2 aga muutus arvuks 3.823610858861032.\n", "Arv oli 4 aga muutus arvuks 5.407402333838309.\n", "Arv oli 6 aga muutus arvuks 6.622688275919379.\n", "Arv oli 8 aga muutus arvuks 7.647221717722064.\n", "Arv oli 10 aga muutus arvuks 8.549853799919621.\n", "```" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Arv oli 2 aga muutus arvuks 3.823610858861032.\n", "Arv oli 4 aga muutus arvuks 5.407402333838309.\n", "Arv oli 6 aga muutus arvuks 6.622688275919379.\n", "Arv oli 8 aga muutus arvuks 7.647221717722064.\n", "Arv oli 10 aga muutus arvuks 8.549853799919621.\n" ] } ], "source": [ "def even_filter(nums):\n", " for num in nums:\n", " if num % 2 == 0:\n", " yield num\n", "\n", "def multiply_by_num(nums):\n", " for num in nums:\n", " yield num, 7.31 * num # Sama moodi nagu lausendiga return.\n", "\n", "def sqrt(tpl_lst):\n", " for tpl in tpl_lst:\n", " yield tpl[0], tpl[1] ** 0.5\n", "\n", "def convert_to_string(tpl_lst):\n", " for tpl in tpl_lst:\n", " yield f'Arv oli {tpl[0]} aga muutus arvuks {tpl[1]}.'\n", "\n", "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\n", "pipeline = convert_to_string(sqrt(multiply_by_num(even_filter(nums)))) # Loome liititeraatori.\n", "\n", "for num in pipeline:\n", " print(num)" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Arv oli 2 aga muutus arvuks 3.823610858861032.\n", "Arv oli 4 aga muutus arvuks 5.407402333838309.\n", "Arv oli 6 aga muutus arvuks 6.622688275919379.\n", "Arv oli 8 aga muutus arvuks 7.647221717722064.\n", "Arv oli 10 aga muutus arvuks 8.549853799919621.\n" ] } ], "source": [ "def even_filter(nums):\n", " for num in nums:\n", " if num % 2 == 0:\n", " yield num\n", "\n", "def multiply_by_num(nums):\n", " for num in nums:\n", " yield num, 7.31 * num # Sama moodi nagu lausendiga return.\n", "\n", "def sqrt(tpl_lst):\n", " for tpl in tpl_lst:\n", " yield tpl[0], tpl[1]**0.5\n", "\n", "def convert_to_string(tpl_lst):\n", " for tpl in tpl_lst:\n", " yield f'Arv oli {tpl[0]} aga muutus arvuks {tpl[1]}.'\n", "\n", "nums = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]\n", "\n", "for num in convert_to_string(sqrt(multiply_by_num(even_filter(nums)))): # Itereerin otse üle generaatori\n", " print(num)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 16:**\n", "\n", "Telk kujutus on antud kujul:\n", "$$x_{n + 1} = \\mu \\min(x_n, 1 - x_n)$$\n", "või \n", "$$x_{n+1} =\\begin{cases}\n", " \\mu x_n, & \\text{kui}~~~ x_n < \\dfrac{1}{2},\\\\\n", " \\mu (1 - x_n), & \\text{kui}~~~ \\dfrac{1}{2} \\le x_n,\n", " \\end{cases}\n", "$$\n", "kus $\\mu$ on kontrollparameeter. Defineeri generaator mis leiab iteraatide $x_n$ väärtused $n > 0$ jaoks, etteantud algväärtuse $x_0 \\in [0, 1]$ ja parameetri $\\mu \\in [0, 2]$ jaoks.\n", "\n", "Vihje: Kasuta esimest definitsiooni ja sisseehitatud funktsiooni `min`.\n", "\n", "Viide: https://en.wikipedia.org/wiki/Tent_map" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.1\n", "0.2\n", "0.4\n", "0.8\n", "0.3999999999999999\n", "0.7999999999999998\n", "0.40000000000000036\n", "0.8000000000000007\n", "0.3999999999999986\n", "0.7999999999999972\n" ] } ], "source": [ "def tent_map(mu, x0):\n", " x = x0\n", " while True:\n", " yield x\n", " x = mu * min(x, 1 - x)\n", "\n", "t = tent_map(2.0, 0.1)\n", "\n", "for _ in range(10): # Prindin 10 iteraati.\n", " print(next(t))" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.1\n", "0.2\n", "0.4\n", "0.8\n", "0.3999999999999999\n", "0.7999999999999998\n", "0.40000000000000036\n", "0.8000000000000007\n", "0.3999999999999986\n", "0.7999999999999972\n" ] } ], "source": [ "def tent_map(mu, x0):\n", " x = x0\n", " while True:\n", " yield x\n", " x = mu * min(x, 1 - x)\n", "\n", "t = tent_map(2.0, 0.1)\n", "\n", "j = 0\n", "for i in t: # Prindin 10 iteraati.\n", " if j == 10:\n", " break\n", " print(i)\n", " j += 1 " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 17:**\n", "\n", "Loo uus generaator lisades eelmises ülesandes loodud generaatorile täisarvuline argument `n` mis tähistab väljastatud kujutuse iteraatide arvu. Teisisõnu muuda generaator lõplikuks. Leia esimese $55$-e telk kujutise jada liikme kuupjuurte maksimumi. Kasuta algtingimust $x_0 = 0.1$ ja parameetri $\\mu$ väärtuseks vali $2.0$. Kuupjuurte leidmiseks loo ja kasuta generaatorit. Maksimumi leidmiseks kasuta sisseehitatud funktsiooni `max`.\n", "\n", "Vihje: Kasuta generaatorite järjestikku rakendamist.\n", "\n", "Oodatav vastus: `0.933127789204312`" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.933127789204312\n" ] } ], "source": [ "def tent_finite(mu, x0, n):\n", " x = x0\n", " j = 0\n", " while j < n:\n", " yield x\n", " x = mu * min(x, 1 - x)\n", " j += 1\n", " \n", "def kjuur(nums):\n", " for num in nums:\n", " yield num ** (1/3)\n", "\n", "\n", "#vastus:\n", "print(max(kjuur(tent_finite(2.0, 0.1, 55)))) # Funktsioon max oskan itereerida iteraatoreid ja generaatoreid.\n", "\n", "# Kontroll.\n", "#mins = kjuur(tent_finite(2.0, 0.1, 55))\n", "#for i in mins:\n", "# print(' ', i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 18:**\n", "\n", "Rahetera numbrid või $3n + 1$ jada. Defineeri generaator mis genereerib numbreid järgmiselt:\n", "- Vali ühest suurem täisarv;\n", "- Juhul kui arv on paaris, jaga see kahega;\n", "- Juhul kui arv on paaritu, korruta see kolmega ja liida üks;\n", "- Kui leitud arv on üks lõpeta iteratsioon.\n", "\n", "Näide: Alustades viiega on oodatav tulemus järgmine:\n", "```\n", "5\n", "16\n", "8.0\n", "4.0\n", "2.0\n", "1.0\n", "```\n", "või\n", "```\n", "5 16 8.0 4.0 2.0 1.0\n", "```\n", "Viide: https://en.wikipedia.org/wiki/Collatz_conjecture" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "16\n", "8.0\n", "4.0\n", "2.0\n", "1.0\n" ] } ], "source": [ "def rnum(n): # n > 1\n", " yield n\n", " while n != 1:\n", " if n % 2 == 0:\n", " n = n / 2\n", " else:\n", " n = 3*n + 1\n", " yield n\n", " \n", "for i in rnum(5): # Itereerin üle generaatori.\n", " print(i)" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "16\n", "8.0\n", "4.0\n", "2.0\n", "1.0\n" ] } ], "source": [ "def rnum(n): # n > 1\n", " yield n\n", " while n != 1:\n", " if n % 2 == 0:\n", " n = n/2\n", " elif n % 2 == 1:\n", " n = 3*n + 1\n", " yield n\n", " \n", "for i in rnum(5): # Itereerin üle generaatori.\n", " print(i)" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5\n", "16\n", "8.0\n", "4.0\n", "2.0\n", "1.0\n" ] } ], "source": [ "def rnum(n): # n > 1\n", " yield n\n", " while n != 1:\n", " if n%2 == 0:\n", " n = n/2\n", " elif n%2 == 1:\n", " n = 3*n + 1\n", " yield n\n", "\n", "iter0 = rnum(5)\n", "\n", "for i in iter0: # Itereerin üle iteraatori.\n", " print(i)" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "5 16 8.0 4.0 2.0 1.0 " ] } ], "source": [ "def rnum(n): # n > 1\n", " yield n\n", " while n != 1:\n", " n = n / 2 if n % 2 == 0 else 3*n + 1 # if-else valikuavaldis.\n", " yield n\n", " \n", "for i in rnum(5): # Itereerin üle generaatori.\n", " print(i, end=' ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 19:**\n", "\n", "Loo generaatorit nimega `minu_range` mis käitub võimalikult sarnaselt Pythoni sisseehitatud vahemikufunktsiooniga `range`." ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "minu range 5\n", "minu range 4\n", "minu range 3\n", "minu range 2\n" ] } ], "source": [ "# Peaaegu nagu Python range. Pole päris õige, lubab 0 argumenti läbi.\n", "def minu_range(*args):\n", " samm = 1\n", " if len(args) == 1:\n", " start, stopp = 0, args[0]\n", " elif len(args) == 2:\n", " start, stopp = args[0], args[1]\n", " elif len(args) == 3:\n", " start, stopp, samm = args[0], args[1], args[2]\n", " i = start\n", " if stopp - start > 0 and samm > 0: # Selleks et toetada negatiivset sammu.\n", " while i < stopp:\n", " yield i\n", " i += samm\n", " elif stopp - start < 0 and samm < 0: \n", " while i > stopp:\n", " yield i\n", " i += samm\n", "\n", "\n", "for i in minu_range(5,1,-1): # Ei halda vigaseid sisendeid.\n", " print('minu range', i)" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "minu range 1\n", "minu range 3\n", "minu range 5\n", "minu range 7\n", "minu range 9\n" ] } ], "source": [ "# Peaaegu nagu Python range. Pole päris õige, vajab vähemalt kahte positsionaalset argumenti.\n", "def minu_range(start, stopp, samm=1):\n", " i = start\n", " if stopp - start > 0: # Selleks et toetada negatiivset sammu.\n", " while stopp - i > 0:\n", " yield i\n", " i += samm\n", " else:\n", " while stopp - i < 0:\n", " yield i\n", " i += samm\n", "\n", "for i in minu_range(1, 10, 2): # Pole päris õige, vajab vähemalt kahte positsionaalset argumenti.\n", " print('minu range', i)" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "minu range 1\n", "minu range 3\n", "minu range 5\n", "minu range 7\n", "minu range 9\n" ] } ], "source": [ "# Peaaegu nagu Python range. Pole päris õige, vajab vähemalt kahte positsionaalset argumenti.\n", "def minu_range(start, stopp, samm=1):\n", " for i in range(start, stopp, samm): # Alatu nahhaalsus.\n", " yield i\n", "\n", "for i in minu_range(1, 10, 2): # Pole päris õige, vajab vähemalt kahte positsionaalset argumenti.\n", " print('minu range', i)" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--> 1 --> 2 --> 3 --> 4 --> 5 --> 6 --> 7 --> 8 --> 9 " ] } ], "source": [ "# Peaaegu nagu Python range. Lubab 0 argumenti läbi, funktsioon range nii ei laseks.\n", "def minu_range(*args):\n", " samm = 1\n", " if len(args) == 1:\n", " start = 0\n", " stopp = args[0]\n", " elif len(args) == 2:\n", " start = args[0]\n", " stopp = args[1]\n", " elif len(args) == 3:\n", " start = args[0]\n", " stopp = args[1]\n", " samm = args[2]\n", " elif len(args) == 0:\n", " print('Midagi on valesti. Puuduvad argumendid.')\n", " start, stopp = 0, 0 # Selleks et vältida erisust.\n", " else:\n", " print('Midagi on valesti. Liiga palju argumente.')\n", " i = start\n", " if stopp - start > 0 and samm > 0: # Selleks et toetada negatiivset sammu.\n", " while i < stopp:\n", " yield i\n", " i += samm\n", " elif stopp - start < 0 and samm < 0: \n", " while i > stopp:\n", " yield i\n", " i += samm\n", " else:\n", " print('Vale sisend. Kas sisend puudub. Kas start, stopp või samm on valed.')\n", "\n", "for i in minu_range(1,10,1):\n", " print('-->', i, end=' ')" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "--> 10 --> 9 --> 8 --> 7 --> 6 --> 5 --> 4 --> 3 --> 2 " ] } ], "source": [ "# VÕIMALIK ÕIGE VASTUS\n", "# Täpselt nagu Pythoni range. Kui argumendid puuduvad tõstatub Pythoni erisus.\n", "def minu_range(stopp, *args): # Üks positsionaalne argument on kohustuslik, nagu funktsioonis range.\n", " samm = 1\n", " if len(args) == 0:\n", " start = 0\n", " elif len(args) == 1:\n", " start = stopp\n", " stopp = args[0]\n", " elif len(args) == 2:\n", " start = stopp\n", " stopp = args[0]\n", " samm = args[1] \n", " else:\n", " print('Vale sisend:', end=' ')\n", " start, stopp = 0, 0 # Selleks et vältida Pythoni enda erisust.\n", " i = start\n", " if stopp - start > 0 and samm > 0: # Selleks et toetada negatiivset sammu.\n", " while i < stopp:\n", " yield i\n", " i += samm\n", " elif stopp - start < 0 and samm < 0: \n", " while i > stopp:\n", " yield i\n", " i += samm\n", " else:\n", " print('Liiga palju argumente.')\n", "\n", "\n", "for i in minu_range(10,1,-1): \n", " print('-->', i, end=' ')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 20:**\n", "\n", "Loo generaator `minu_enumerate` mis käitub sarnaselt Pythoni sisseehitatud funktsiooniga `enumerate`. Loodud generaator peab töötama *ainult* järgmises tsüklis:\n", "```python\n", "for i, el in minu_enumerate([5, 4, 3, 2, 1]):\n", " print('Minu enumerate:', (i, el))\n", "```\n", "Koonsooli väljund peab olema *sarnane* alloleva tsükli väljundiga.\n", "```python\n", "for i, el in enumerate([5, 4, 3, 2, 1]):\n", " print('enumerate:', (i, el))\n", "```\n", "Oodatav tulemus:\n", "```\n", "Minu enumerate: (0, 5)\n", "Minu enumerate: (1, 4)\n", "Minu enumerate: (2, 3)\n", "Minu enumerate: (3, 2)\n", "Minu enumerate: (4, 1)\n", "```" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[(0, 5), (1, 4), (2, 3), (3, 2), (4, 1)]" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# meeldetuletuseks\n", "list(enumerate([5, 4, 3, 2, 1])) # Mida funktsioon teeb." ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Minu enumerate: (0, 5)\n", "Minu enumerate: (1, 4)\n", "Minu enumerate: (2, 3)\n", "Minu enumerate: (3, 2)\n", "Minu enumerate: (4, 1)\n", "enumerate: (0, 5)\n", "enumerate: (1, 4)\n", "enumerate: (2, 3)\n", "enumerate: (3, 2)\n", "enumerate: (4, 1)\n" ] } ], "source": [ "def minu_enumerate(lst):\n", " i = 0\n", " while i < len(lst):\n", " yield i, lst[i] # Võid sulge kasutada (i, lst[i])\n", " i += 1\n", "\n", "for i, el in minu_enumerate([5, 4, 3, 2, 1]):\n", " print('Minu enumerate:', (i, el))\n", " \n", "for i, el in enumerate([5, 4, 3, 2, 1]):\n", " print('enumerate:', (i, el))" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Minu enumerate: (0, 5)\n", "Minu enumerate: (1, 4)\n", "Minu enumerate: (2, 3)\n", "Minu enumerate: (3, 2)\n", "Minu enumerate: (4, 1)\n", "enumerate: (0, 5)\n", "enumerate: (1, 4)\n", "enumerate: (2, 3)\n", "enumerate: (3, 2)\n", "enumerate: (4, 1)\n" ] } ], "source": [ "# Nii saab ka loomulikult.\n", "def minu_enumerate(lst):\n", " for i, el in enumerate(lst): # Alatu nahhaalsus.\n", " yield (i, lst[i])\n", "\n", "for i, el in minu_enumerate([5, 4, 3, 2, 1]):\n", " print('Minu enumerate:', (i, el))\n", " \n", "for i, el in enumerate([5, 4, 3, 2, 1]):\n", " print('enumerate:', (i, el))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 21:**\n", "\n", "Defineeri generaator mis võtab argumendina vastu meelevaldse funksiooni ning leiab selle funktsiooni iteraadid meelevaldselt valitud reaalarvulise algtimgimuse jaoks.\n", "\n", "Generaatori kontrollimiseks kasuta Ülesandes 16 kasutatud kujutuse funktsiooni, mis on endiselt kujul:\n", "$$f(x) = \\mu \\min(x, 1 - x),$$\n", "kus $\\mu \\in [0, 2]$ on parameeter.\n", "\n", "Näidisvastus: Kui valida algtingimuseks $x_0 = 0.1$, parameetri $\\mu = 2$ ja teostada $10$ iteraatsiooni siis:\n", "```\n", "0.1\n", "0.2\n", "0.4\n", "0.8\n", "0.3999999999999999\n", "0.7999999999999998\n", "0.40000000000000036\n", "0.8000000000000007\n", "0.3999999999999986\n", "0.7999999999999972\n", "```" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.1\n", "0.2\n", "0.4\n", "0.8\n", "0.3999999999999999\n", "0.7999999999999998\n", "0.40000000000000036\n", "0.8000000000000007\n", "0.3999999999999986\n", "0.7999999999999972\n" ] } ], "source": [ "def iterate(func, x): # Matemaatilne itereerimine, itereerin üle etteantud funktsiooni.\n", " while True:\n", " yield x\n", " x = func(x)\n", " \n", "def tent_map(x):\n", " return mu * min(x, 1 - x)\n", "\n", "mu = 2\n", "x = iterate(tent_map, 0.1)\n", "\n", "for _ in range(10):\n", " print(next(x))" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.1\n", "0.2\n", "0.4\n", "0.8\n", "0.3999999999999999\n", "0.7999999999999998\n", "0.40000000000000036\n", "0.8000000000000007\n", "0.3999999999999986\n", "0.7999999999999972\n" ] } ], "source": [ "def iterate(func, x): # Matemaatilne itereerimine, itereerin üle etteantud funktsiooni.\n", " while True:\n", " yield x\n", " x = func(x)\n", " \n", "def tent_map(x):\n", " return mu * min(x, 1 - x)\n", "\n", "mu = 2\n", "x = iterate(tent_map, 0.1)\n", "\n", "j = 0\n", "for i in x: # Itereerin üle iteraatori.\n", " if j == 10:\n", " break\n", " print(i)\n", " j += 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Ülesanne 22:**\n", "\n", "Loo lõpmatu generaator mis genereerib Fibonacci jada liikmeid. Meeldetuletuseks: Funktsioon mis leiab `n`-da jada liikme ja kood mis väljastab konsooli kümme esimest liiget on kujul:\n", "```python\n", "def fib(n):\n", " '''Leian fibonacci n-da jada liikme.'''\n", " if n <= 2:\n", " return 1\n", " a = b = 1\n", " for i in range(n - 2):\n", " a, b = b, a + b\n", " return b\n", "\n", "for i in range(1, 11): # Esimesed 10 liiget.\n", " print(fib(i))\n", "```\n", "Oodatav tulemus:\n", "```\n", "1\n", "1\n", "2\n", "3\n", "5\n", "8\n", "13\n", "21\n", "34\n", "55\n", "```\n", "või\n", "```\n", "1 1 2 3 5 8 13 21 34 55 \n", "```" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 1 2 3 5 8 13 21 34 55 " ] } ], "source": [ "def fib():\n", " '''Genereerib Fibonacci jada liikmeid'''\n", " a, b = 0, 1\n", " while True:\n", " yield b\n", " a, b = b, a + b\n", "\n", "f = fib()\n", "\n", "for _ in range(10):\n", " print(next(f), end=' ')" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1 1 2 3 5 8 13 21 34 55 " ] } ], "source": [ "def fib():\n", " '''Genereerib Fibonacci jada liikmeid'''\n", " a, b = 0, 1\n", " while True:\n", " yield b\n", " a, b = b, a + b\n", "\n", "j = 0\n", "for i in fib(): # Itereerin üle generaatori.\n", " if j == 10:\n", " break\n", " print(i, end=' ')\n", " j += 1" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "1\n", "1\n", "2\n", "3\n", "5\n", "8\n", "13\n", "21\n", "34\n", "55\n" ] } ], "source": [ "def fib():\n", " '''Genereerib Fibonacci jada liikmeid'''\n", " a, b = 0, 1\n", " while True:\n", " yield b\n", " a, b = b, a + b\n", "\n", "f = fib()\n", "\n", "j = 0\n", "for i in f: # Itereerin üle iteraatori.\n", " if j == 10:\n", " break\n", " print(i)\n", " j += 1" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel)", "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.11.0" } }, "nbformat": 4, "nbformat_minor": 4 }