{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Praktikum 3, 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 16.09.2024.
\n",
"\n",
"---"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 1:**\n",
"\n",
"Teisenda list `lst = ['H', 'e', 'l', 'l', 'o', None]` ennikuks ja hulgaks. Kontrolli kas loodud andmetüübi esindajad sisaldavad tühimärki (`None`)."
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"('H', 'e', 'l', 'l', 'o', None)\n",
"True\n",
"{'e', None, 'H', 'l', 'o'}\n",
"True\n"
]
}
],
"source": [
"lst = ['H', 'e', 'l', 'l', 'o', None]\n",
"tpl = tuple(lst) # Ennikuks\n",
"print(tpl)\n",
"print(None in tpl)\n",
"\n",
"st = set(lst) # Hulgaks\n",
"print(st)\n",
"print(None in st)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 2:**\n",
"\n",
"Teisenda sõne `'Hello Python!'` listiks."
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n', '!']\n"
]
}
],
"source": [
"a = 'Hello Python!'\n",
"print(list(a))"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"['H', 'e', 'l', 'l', 'o', ' ', 'P', 'y', 't', 'h', 'o', 'n', '!']"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"list('Hello Python!')"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 3:**\n",
"\n",
"Defineeri lause: `\"Parim oma põllu uudseviljast vii Issanda, oma Jumala kotta! Ära keeda kitsetalle ta ema piimas!\"`. Leia mitmest erinevast tähemärgist koosneb eelmainitud lause.\n",
"\n",
"1) Ignoreeri tõstutundlikust (suur, väike täht).\n",
"2) Ära ignoreeri tõstutundlikust.\n",
"\n",
"Tähemärkide loendamiseks kasuta sisseehitatud funktsioone.\n",
"\n",
"Vastused:\n",
"1) 24 mitte 21 või 95.\n",
"2) 21 mitte 24 või 95."
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'P', 'j', 'J', 'l', ' ', 'e', 't', 'p', 'n', 'u', 'd', 'õ', 'o', ',', 'Ä', 'i', '!', 'm', 's', 'a', 'k', 'v', 'r', 'I'}\n",
"24\n",
"{'P', 'J', 'R', ' ', 'V', ',', 'E', 'Ä', 'O', 'K', 'Õ', '!', 'N', 'A', 'D', 'S', 'U', 'L', 'M', 'T', 'I'}\n",
"21\n"
]
}
],
"source": [
"# 1. Ignoreerib tõstutundlikust \n",
"sentence = \"Parim oma põllu uudseviljast vii Issanda, oma Jumala kotta! Ära keeda kitsetalle ta ema piimas!\"\n",
"tm = set(sentence)\n",
"print(tm)\n",
"print(len(tm))\n",
"\n",
"# 2. Ei ignoreeri tõstutundlikust.\n",
"sentence = \"Parim oma põllu uudseviljast vii Issanda, oma Jumala kotta! Ära keeda kitsetalle ta ema piimas!\"\n",
"tm = set(sentence.upper())\n",
"print(tm)\n",
"print(len(tm))"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"{'j', 'ä', 'l', ' ', 'e', 't', 'p', 'n', 'u', 'd', 'õ', 'o', ',', 'i', '!', 'm', 's', 'a', 'k', 'v', 'r'}\n",
"21\n"
]
}
],
"source": [
"# Lisaks eelmistele.\n",
"sentence = \"Parim oma põllu uudseviljast vii Issanda, oma Jumala kotta! Ära keeda kitsetalle ta ema piimas!\"\n",
"tm = set(sentence.lower())\n",
"print(tm)\n",
"print(len(tm))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 4:**\n",
"\n",
"Leia:\n",
"\n",
"1. $(-1 + 3{\\rm i})^2 = (-1 + 3{\\rm i}) \\cdot (-1 + 3{\\rm i})$\n",
"2. $\\sqrt{-1}$\n",
"3. ${\\rm i}^2$\n",
"4. ${\\rm i}^3$\n",
"5. $(2 {\\rm i})^2$\n",
"6. $(2 {\\rm i})^3$\n",
"7. ${\\rm Im}({\\rm i}^3)$\n",
"8. $(3 + 2{\\rm i}) + (1 + 7{\\rm i}) \\cdot (3 + 2{\\rm i})$\n",
"\n",
"Vastused ja oodatav väljund konsoolis:\n",
"\n",
"| | 1. | 2. | 3. | 4. | 5. | 6. | 7. | 8. |\n",
"|:-------:|:--:|:--:|:--:|:--:|:--:|:--:|:--:|:--:|\n",
"| Algebra |$-8-6{\\rm i}$| ${\\rm i}$ | $-1$ | $-{\\rm i}$ | $-4$ | $-8{\\rm i}$ | $-1$ | $-8+25{\\rm i}$ |\n",
"| Konsool | (-8-6j) | (6.123233995736766e-17+1j) | (-1+0j) | (-0-1j) | (-4+0j) | (-0-8j) | -1.0 | (-8+25j) |"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(-8-6j)\n",
"(-8-6j)\n",
"(-8-6j)\n",
"(-8-6j)\n"
]
}
],
"source": [
"# 1.\n",
"print(complex(-1, 3) ** 2)\n",
"print((-1+3j) ** 2)\n",
"print(complex(-1, 3) * complex(-1, 3))\n",
"print((-1+3j) * (-1+3j))"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(6.123233995736766e-17+1j)\n",
"(6.123233995736766e-17+1j)\n",
"(6.123233995736766e-17+1j)\n",
"(6.123233995736766e-17+1j)\n"
]
}
],
"source": [
"# 2.\n",
"print(complex(-1, 0) ** 0.5)\n",
"print(complex(-1) ** 0.5)\n",
"print((-1+0j) ** 0.5)\n",
"print((-1) ** 0.5) # NB! Sulud."
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(-1+0j)\n",
"(-1+0j)\n",
"(-1+0j)\n"
]
}
],
"source": [
"# 3.\n",
"print(complex(0, 1) ** 2)\n",
"print((0+1j) ** 2)\n",
"print(1j ** 2)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(-0-1j)\n",
"(-0-1j)\n",
"(-0-1j)\n"
]
}
],
"source": [
"# 4.\n",
"print(complex(0, 1) ** 3)\n",
"print((0+1j) ** 3)\n",
"print(1j ** 3)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(-4+0j)\n",
"(-4+0j)\n",
"(-4+0j)\n"
]
}
],
"source": [
"# 5.\n",
"print(complex(0, 2) ** 2)\n",
"print((0+2j) ** 2)\n",
"print(2j ** 2)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(-0-8j)\n",
"(-0-8j)\n",
"(-0-8j)\n"
]
}
],
"source": [
"# 6.\n",
"print(complex(0, 2) ** 3)\n",
"print((0+2j) ** 3)\n",
"print(2j ** 3)"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"-1.0\n",
"-1.0\n",
"-1.0\n"
]
}
],
"source": [
"# 7.\n",
"v1 = complex(0, 1) ** 3\n",
"print(v1.imag)\n",
"\n",
"v2 = (0+1j) ** 3\n",
"print(v2.imag)\n",
"\n",
"v3 = 1j ** 3\n",
"print(v3.imag)"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"(-8+25j)\n",
"(-8+25j)\n"
]
}
],
"source": [
"# 8.\n",
"print(complex(3, 2) + complex(1, 7) * complex(3, 2))\n",
"print((3 + 2j) + (1 + 7j) * (3 + 2j))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 5:**\n",
"\n",
"Leia:\n",
"\n",
"$$\\frac{11001000_2 \\cdot 310_8 + 5A3_{16}}{41443_{10}}$$\n",
"\n",
"Lisaks leia etteantud arvude väärtused kümnendsüsteemis ehk teisenda arvud kümnenedsüsteemi.\n",
"\n",
"Vastused: $1_{10}$ ja $11001000_2 = 200_{10}$, $310_8 = 200_{10}$, $5A3_{16} = 1443_{10}$."
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.0"
]
},
"execution_count": 14,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"(0b11001000 * 0o310 + 0x5A3) / 41443"
]
},
{
"cell_type": "code",
"execution_count": 15,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"200"
]
},
"execution_count": 15,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"0b11001000"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"200"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"0o310"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1443"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"0x5A3"
]
},
{
"cell_type": "code",
"execution_count": 18,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.0\n",
"200 200 1443 41443\n"
]
}
],
"source": [
"# Või teisenda algul ja teosta siis tehe\n",
"a1 = 0b11001000\n",
"a2 = 0o310\n",
"a3 = 0x5A3\n",
"a4 = 41443\n",
"\n",
"v = (a1 * a2 + a3) / a4\n",
"print(v)\n",
"\n",
"print(a1, a2, a3, a4)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.0\n",
"200 200 1443 41443\n"
]
}
],
"source": [
"# Nii saab ka\n",
"a1 = int(0b11001000)\n",
"a2 = int(0o310)\n",
"a3 = int(0x5A3)\n",
"a4 = 41443\n",
"\n",
"v = (a1 * a2 + a3) / a4\n",
"print(v)\n",
"\n",
"print(a1, a2, a3, a4)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.0\n",
"200 200 1443 41443\n"
]
}
],
"source": [
"# Nii saab ka 2\n",
"a1 = int('11001000', 2) # toetab baase 2-36\n",
"a2 = int('310', 8)\n",
"a3 = int('5A3', 16)\n",
"a4 = 41443\n",
"\n",
"v = (a1 * a2 + a3) / a4\n",
"print(v)\n",
"\n",
"print(a1, a2, a3, a4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 6:**\n",
"\n",
"Teisenda arv $111010110111100110100010101_{2}$ kaheksandsüsteemi, kümnendsüsteemi ja kuueteistkümnendiksüsteemi.\n",
"\n",
"Vastused ja oodatav tulemus konsoolis:\n",
"\n",
"| | Kaheksandsüsteem | Kümnendsüsteem | Kuueteistkümnendiksüsteem |\n",
"|:-----:|:-------------:|:----------------:|:--------------:|\n",
"|Number | $726746425_8$ | $123456789_{10}$ | $75BCD15_{16}$ |\n",
"|Konsool| 0o726746425 | 123456789 | 0x75bcd15 |"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"0o726746425\n",
"123456789\n",
"0x75bcd15\n"
]
}
],
"source": [
"print(oct(0b111010110111100110100010101))\n",
"print(0b111010110111100110100010101)\n",
"print(hex(0b111010110111100110100010101))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 7:**\n",
"\n",
"Kas võrratus $2B1_{16} < 777_{8}$ on tõene või väär?\n",
"\n",
"Vastus: Väär."
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"0x2B1 < 0o777"
]
},
{
"cell_type": "code",
"execution_count": 23,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"False\n"
]
}
],
"source": [
"print(0x2B1 < 0o777)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 8:**\n",
"\n",
"Kirjuta \"Hello World!\" programm, kasuta lausendit `def`."
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello World!\n"
]
}
],
"source": [
"def hello_world():\n",
" print('Hello World!')\n",
"\n",
"hello_world()"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 9:**\n",
"\n",
"Kirjuta programm mis leiab täisarvu $x$ vastavalt järgmisele funktsioonile:\n",
"$$y = f(x) = -x - 1.$$ \n",
"\n",
"Näide: Arvule `1` vastab `-2`."
]
},
{
"cell_type": "code",
"execution_count": 25,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-2"
]
},
"execution_count": 25,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def func(x):\n",
" y = -x - 1\n",
" return y\n",
"\n",
"func(1)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-2"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def func(x):\n",
" return -x - 1\n",
"\n",
"func(1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 10:**\n",
"\n",
"Lisa eelmises ülesandes loodud funktsioonile docstring (minimaalne näide)."
]
},
{
"cell_type": "code",
"execution_count": 27,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-2"
]
},
"execution_count": 27,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def func(x):\n",
" '''Function that finds something.'''\n",
" y = -x - 1\n",
" return y\n",
"\n",
"func(1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 11:**\n",
"\n",
"Kirjuta programm mis ei kasuta algebra operaatoreid (`+`, `-`, `*`, jne.). Programm peab leidma täisarvu vastavalt järgmisele valemile:\n",
"$$x_{\\rm tulem} = -x_{\\rm sisend} - 1,$$\n",
"kus $x_{\\rm tulem}$ ja $x_{\\rm sisend}$ on täisarvud. \n",
"\n",
"Näide: Arvule `1` vastab `-2`."
]
},
{
"cell_type": "code",
"execution_count": 28,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-2"
]
},
"execution_count": 28,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"~1 # Vastus põhineb täiendi kasutamisel."
]
},
{
"cell_type": "code",
"execution_count": 29,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-2"
]
},
"execution_count": 29,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def valem(arv):\n",
" return ~arv\n",
"\n",
"valem(1)"
]
},
{
"cell_type": "code",
"execution_count": 30,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"-2"
]
},
"execution_count": 30,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Peaaegu lahend. Lahendab kasutades ainult ühte miinust :)\n",
"def valem(arv):\n",
" tulem = -arv # Miinuse kasutus keelatud.\n",
" tulem -= 1 # -= pole algebra operaator.\n",
" return tulem\n",
"\n",
"valem(1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 12:**\n",
"\n",
"Kirjuta programm mis ei kasuta algebra operaatoreid (`+`, `-`, `*`, `**`, jne.). Programm peab leidma täisarvu vastavalt järgmisele funktsioonile:\n",
"$$f(x, n) = 2^n \\cdot x,$$\n",
"kus $x$ ja $n = 2$ on täisarvud. \n",
"\n",
"Näide: Arvule $x = 5$ vastab $20$."
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"20"
]
},
"execution_count": 31,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"5 << 2"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"20\n"
]
}
],
"source": [
"def valem(arv):\n",
" return arv << 2\n",
"\n",
"print(valem(5))"
]
},
{
"cell_type": "code",
"execution_count": 33,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"20"
]
},
"execution_count": 33,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def valem(arv, n):\n",
" return arv << n\n",
"\n",
"valem(5, 2)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 13:**\n",
"\n",
"Kirjuta funktsioon `to_decimal` mis leiab neljale etteantud biti väärtusele vastava positiivse kümnendsüsteemi täisarvu.\n",
"\n",
"Näide: Väljakutse `to_decimal(1, 0, 0, 1)` väljastab `9`."
]
},
{
"cell_type": "code",
"execution_count": 34,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"9\n"
]
}
],
"source": [
"def to_decimal(b4, b3, b2, b1):\n",
" arv = b4 * (2 ** 3) + b3 * (2 ** 2) + b2 * (2 ** 1) + b1 * (2 ** 0)\n",
" return arv\n",
"\n",
"print(to_decimal(1, 0, 0, 1))"
]
},
{
"cell_type": "code",
"execution_count": 35,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"9"
]
},
"execution_count": 35,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def to_decimal(b4, b3, b2, b1):\n",
" arv = b4*8 + b3*4 + b2*2 + b1\n",
" return arv\n",
"\n",
"to_decimal(1, 0, 0, 1)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 14:**\n",
"\n",
"Loo ja prindi konsooli list (loend) mis sisaldab kõiki positiivseid paarisarve 0 ja 500 (500 kaasa arvatud) vahel."
]
},
{
"cell_type": "code",
"execution_count": 36,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50, 52, 54, 56, 58, 60, 62, 64, 66, 68, 70, 72, 74, 76, 78, 80, 82, 84, 86, 88, 90, 92, 94, 96, 98, 100, 102, 104, 106, 108, 110, 112, 114, 116, 118, 120, 122, 124, 126, 128, 130, 132, 134, 136, 138, 140, 142, 144, 146, 148, 150, 152, 154, 156, 158, 160, 162, 164, 166, 168, 170, 172, 174, 176, 178, 180, 182, 184, 186, 188, 190, 192, 194, 196, 198, 200, 202, 204, 206, 208, 210, 212, 214, 216, 218, 220, 222, 224, 226, 228, 230, 232, 234, 236, 238, 240, 242, 244, 246, 248, 250, 252, 254, 256, 258, 260, 262, 264, 266, 268, 270, 272, 274, 276, 278, 280, 282, 284, 286, 288, 290, 292, 294, 296, 298, 300, 302, 304, 306, 308, 310, 312, 314, 316, 318, 320, 322, 324, 326, 328, 330, 332, 334, 336, 338, 340, 342, 344, 346, 348, 350, 352, 354, 356, 358, 360, 362, 364, 366, 368, 370, 372, 374, 376, 378, 380, 382, 384, 386, 388, 390, 392, 394, 396, 398, 400, 402, 404, 406, 408, 410, 412, 414, 416, 418, 420, 422, 424, 426, 428, 430, 432, 434, 436, 438, 440, 442, 444, 446, 448, 450, 452, 454, 456, 458, 460, 462, 464, 466, 468, 470, 472, 474, 476, 478, 480, 482, 484, 486, 488, 490, 492, 494, 496, 498, 500]\n"
]
}
],
"source": [
"print(list(range(0, 501, 2)))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 15:**\n",
"\n",
"Loo funktsioon mis juurib etteantud arvu."
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.23606797749979"
]
},
"execution_count": 37,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def juur(x):\n",
" return x**0.5\n",
"\n",
"juur(5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 16:**\n",
"\n",
"Defineeri funktsioon mis leiab kolme arvu ruutkeskväärtuse. Ruutkeskväärtus on defineeritud järgmiselt:\n",
"\n",
"$$ x_{\\rm rms} = \\sqrt{\\frac{x_1^2 + x_2^2 + x_3^2}{3}},$$\n",
"kus $x_1$, $x_2$ ja $x_3$ on reaalarvud."
]
},
{
"cell_type": "code",
"execution_count": 38,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4.83045891539648"
]
},
"execution_count": 38,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def rk(a, b, c):\n",
" return ((a**2 + b**2 + c**2)/3)**0.5\n",
"\n",
"rk(3, 5, 6)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 17:**\n",
"\n",
"Loo funktsioon mis leiab kolme etteantud arvu ruutkeskväärtuse ja ruutkeskväärtuse juure."
]
},
{
"cell_type": "code",
"execution_count": 39,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(4.08248290463863, 2.0205155046766237)"
]
},
"execution_count": 39,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def rk_juur0(a, b, c):\n",
" rkv = ((a**2 + b**2 + c**2)/3)**0.5\n",
" juurv = rkv**0.5\n",
" return rkv, juurv\n",
"\n",
"rk_juur0(3, 4, 5) # Vaikimisi väljastati tulemused ennikusse."
]
},
{
"cell_type": "code",
"execution_count": 40,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(4.08248290463863, 2.0205155046766237)"
]
},
"execution_count": 40,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Kasutan eelnevalt loodud funktsioone, vt. ül 15 ja 16.\n",
"def rk_juur(a, b, c):\n",
" rkv = rk(a, b, c) # Kasutan eelnevalt loodud funktsioone, vt. ül 15 ja 16.\n",
" juurv = juur(rkv) # Kasutan eelnevalt loodud funktsiooni.\n",
" return rkv, juurv\n",
"\n",
"rk_juur(3,4,5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 18:**\n",
"\n",
"Loo kaks funktsiooni mis leiavad kolme etteantud arvu ruutkeskväärtuse ja ruutkeskväärtuse juure: \n",
"1) Esimene funktsioon väljastab tulemused loendisse.\n",
"2) Teine funktsioon väljastab tulemused sõnaraamatusse mille võtmesõnad on `rkv` ja `juur`.\n",
"\n",
"Kasuta teisena loodud funktsiooni ja prindi konsooli võtmesõnale `juur` vastav väärtus (kolme arvu ruutkeskväärtuse juur)."
]
},
{
"cell_type": "code",
"execution_count": 41,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[4.08248290463863, 2.0205155046766237]\n",
"{'rkv': 4.08248290463863, 'juur': 2.0205155046766237}\n",
"2.0205155046766237\n"
]
}
],
"source": [
"def rk_juur_listi(a, b, c):\n",
" rkv = ((a**2 + b**2 + c**2)/3)**0.5\n",
" juurv = rkv**0.5\n",
" return [rkv, juurv]\n",
"\n",
"def rk_juur_dict(a, b, c):\n",
" rkv = ((a**2 + b**2 + c**2)/3)**0.5\n",
" juurv = rkv**0.5\n",
" return {'rkv':rkv, 'juur':juurv}\n",
"\n",
"print(rk_juur_listi(3, 4, 5))\n",
"print(rk_juur_dict(3, 4, 5))\n",
"print(rk_juur_dict(3, 4, 5)['juur'])"
]
},
{
"cell_type": "code",
"execution_count": 42,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[4.08248290463863, 2.0205155046766237]\n",
"{'rkv': 4.08248290463863, 'juur': 2.0205155046766237}\n",
"2.0205155046766237\n"
]
}
],
"source": [
"# Kasutan eelnevalt loodud funktsioone, vt. ül 15 ja 16.\n",
"def rk_juur_listi(a, b, c):\n",
" rkv = rk(a, b, c) # Kasutan eelnevalt loodud funktsiooni.\n",
" return [rkv, juur(rkv)] # Kasutan eelnevalt loodud funktsiooni.\n",
"\n",
"def rk_juur_dict(a, b, c):\n",
" rkv = rk(a, b, c) # Kasutan eelnevalt loodud funktsiooni.\n",
" return {'rkv':rkv, 'juur':juur(rkv)} # Kasutan eelnevalt loodud funktsiooni.\n",
"\n",
"print(rk_juur_listi(3, 4, 5))\n",
"print(rk_juur_dict(3, 4, 5))\n",
"print(rk_juur_dict(3, 4, 5)['juur'])"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 19:**\n",
"\n",
"Defineeri funktsioon/protseduur mis liidab, korrutab ja jagab kahte etteantud reaalarvu ning esitab tulemuse kujul:\n",
"\n",
"```\n",
"Tulemus on:\n",
" + = \n",
" * = \n",
" / = \n",
"```\n",
"\n",
"kus ``'ed on esitatud viie komakoha täpsusega."
]
},
{
"cell_type": "code",
"execution_count": 43,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tulemus on:\n",
"3 + 5 = 8.00000\n",
"3 * 5 = 15.00000\n",
"3 / 5 = 0.60000\n"
]
}
],
"source": [
"def tulemus(a, b):\n",
" summa = a + b\n",
" kor = a * b\n",
" jag = a / b\n",
" print('Tulemus on:')\n",
" print('{} + {} = {:.5f}'.format(a, b, summa))\n",
" print('{} * {} = {:.5f}'.format(a, b, kor))\n",
" print('{} / {} = {:.5f}'.format(a, b, jag))\n",
"\n",
"tulemus(3, 5)"
]
},
{
"cell_type": "code",
"execution_count": 44,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tulemus on:\n",
"3 + 5 = 8.00000\n",
"3 * 5 = 15.00000\n",
"3 / 5 = 0.60000\n"
]
}
],
"source": [
"def tulemus(a, b):\n",
" summa = a + b\n",
" kor = a * b\n",
" jag = a / b\n",
" print(f'''Tulemus on:\n",
"{a} + {b} = {summa:.5f}\n",
"{a} * {b} = {kor:.5f}\n",
"{a} / {b} = {jag:.5f}''')\n",
"\n",
"tulemus(3, 5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 20:**\n",
"\n",
"Näita, et arv `3` sisaldub listis `a`, kasuta `in` operaatorit.\n",
"\n",
"`a = [1, [2, [3, 4], 5, 6], 7, 8, 9]`"
]
},
{
"cell_type": "code",
"execution_count": 45,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"True"
]
},
"execution_count": 45,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = [1, [2, [3, 4], 5, 6], 7, 8, 9]\n",
"3 in a[1][1]"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 21:**\n",
"\n",
"Kirjuta Pythoni programm mis leiab ruutvõrrandi, mis on kujul:\n",
"\n",
"$$a x^2 + b x + c = 0,$$\n",
"\n",
"lahendid $x_\\pm$ etteantud koefitsentide $a \\ne 0$, $b$ ja $c$ korral. Kasuta ruutvõrrandi lahendit kujul:\n",
"\n",
"$$x_\\pm = \\frac{-b \\pm \\sqrt{b^2 - 4 a c}}{2 a}.$$"
]
},
{
"cell_type": "code",
"execution_count": 46,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(-1.0, -2.0)"
]
},
"execution_count": 46,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def rv_sol(a, b, c):\n",
" x1 = (-b + (b**2 - 4*a*c) ** 0.5) / (2 * a)\n",
" x2 = (-b - (b**2 - 4*a*c) ** 0.5) / (2 * a)\n",
" return (x1, x2)\n",
"\n",
"rv_sol(2, 6, 4)"
]
},
{
"cell_type": "code",
"execution_count": 47,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"(-1.0, -2.0)"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"def sol(a, b, c):\n",
" d = (b**2 - 4*a*c) ** 0.5\n",
" x1 = (-b+d) / (2*a)\n",
" x2 = (-b-d) / (2*a)\n",
" return (x1, x2)\n",
"\n",
"sol(2, 6, 4)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 22:**\n",
"\n",
"Loo funktsioon/protseduur mis leiab etteantud täisarvu paarsuse.\n",
"\n",
"Vihje: Täisarv $a$ on paaris kui selle arvu kahega jagamise jääk on null ning arv $a$ on paaritu kui selle kahega jagamise jääk pole null."
]
},
{
"cell_type": "code",
"execution_count": 48,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"87 on paaritu.\n"
]
}
],
"source": [
"def paarsus(a):\n",
" if a%2 == 0:\n",
" print(a, 'on paaris.')\n",
" else:\n",
" print(a, 'on paaritu.')\n",
" \n",
"paarsus(87)"
]
},
{
"cell_type": "code",
"execution_count": 49,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"87 on paaritu.\n"
]
}
],
"source": [
"def paarsus(a):\n",
" if a%2 == 0:\n",
" print(f'{a} on paaris.')\n",
" else:\n",
" print(f'{a} on paaritu.')\n",
" \n",
"paarsus(87)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 23:**\n",
"\n",
"Kuidas näeb välja eelmises ülesandes kasutatud algoritmi vooskeemi?"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [],
"source": [
"# Sarnane Joonisele 11 Naited_L3.html failist."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 24:**\n",
"\n",
"Loo muutuja `nimi` ja omista selle väärtuseks `Juulius`. Kirjuta programm mis tervitab Juuliust ja tema kolme sõpra nimepidi ja tundmatute nimede puhul teavitab: `Ma ei tea kes sa oled!`. Veendu, et su programm töötab.\n",
"\n",
"Juuliuse sõprade nimed on järgmised: `Fred`, `Mari` ja `Adolf`.\n",
"\n",
"Kasuta nii `if`-`elif`-`else` kui ka `if`-`else` konstruktsioone (kaks lahendust)."
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tere Juulius.\n"
]
}
],
"source": [
"nimi = 'Juulius'\n",
"\n",
"if nimi == 'Fred':\n",
" print('Tere Fred.')\n",
"elif nimi == 'Mari':\n",
" print('Tere Mari.')\n",
"elif nimi == 'Adolf':\n",
" print('Tere Adolf.')\n",
"elif nimi == nimi: # Siia ei jõua kui True ülal.\n",
" print('Tere Juulius.')\n",
"else:\n",
" print(\"Ma ei tea kes sa oled!\")"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tere Juulius.\n"
]
}
],
"source": [
"nimi = 'Juulius'\n",
"\n",
"nimed = ['Fred', 'Mari', 'Adolf', nimi]\n",
"if nimi in nimed:\n",
" print(f'Tere {nimi}.')\n",
"else:\n",
" print(\"Ma ei tea kes sa oled!\")"
]
},
{
"cell_type": "code",
"execution_count": 53,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Tere Juulius.\n"
]
}
],
"source": [
"nimi = 'Juulius'\n",
"\n",
"def teretaja(nim):\n",
" nimed = ['Fred', 'Mari', 'Adolf', nimi]\n",
" if nim in nimed:\n",
" print(f'Tere {nim}.')\n",
" else:\n",
" print(\"Ma ei tea kes sa oled!\")\n",
" \n",
"teretaja(nimi)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 25:**\n",
"\n",
"Kirjuta funktsioon/protseduur mis järjestab sellele etteantud listis olevad arvud kasvavas järjekorras. Kasuta listi `lst = [3, 2, 1]`. Kasuta listi meetodeid."
]
},
{
"cell_type": "code",
"execution_count": 54,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"[1, 2, 3]\n"
]
}
],
"source": [
"def my_sort(lst):\n",
" lst.sort() # IN PLACE meetod.\n",
" \n",
"lst = [3, 2, 1]\n",
"\n",
"my_sort(lst) # Järjestus tehtud.\n",
"\n",
"print(lst) # Kontroll."
]
},
{
"cell_type": "code",
"execution_count": 55,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"[1, 2, 3]"
]
},
"execution_count": 55,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# See ei kasuta meetodit aga võrdluseks ikka lisatud.\n",
"def my_sort(lst):\n",
" return sorted(lst) # sorted sisseehitatud funktsioon\n",
" \n",
"lst = [3, 2, 1]\n",
"\n",
"my_sort(lst)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"**Ülesanne 26:**\n",
"\n",
"Kontrolli kas Pythoni interpretaator toetab numbrite sisestamist kujul: \n",
"- `1_200_300.01` (arv $1\\,200\\,300.01$)\n",
"- `0.000_000_2` (arv $0.000\\,000\\,2 = 2 \\cdot 10^{-7}$)\n",
"- `1E5` (arvu standardkuju $1 \\cdot 10^5 = 100\\,000$)\n",
"- `1.23e-10` (arvu standardkuju $1.23 \\cdot 10^{-10} = 0.000\\,000\\,000\\,123$)"
]
},
{
"cell_type": "code",
"execution_count": 56,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1200300.01\n",
"\t True\n",
"2e-07\n",
"\t True\n",
"100000.0\n",
"\t True\n",
"1.23e-10\n",
"\t True\n"
]
}
],
"source": [
"x1 = 1_200_300.01 # Alakriipse saad lisada meelevaldselt, arvu väärtus ei muutu.\n",
"print(x1)\n",
"print('\\t', 1_200_300.01 == 1200300.01)\n",
"\n",
"x2 = 0.000_000_2\n",
"print(x2)\n",
"print('\\t', 0.000_000_2 == 0.0000002)\n",
"\n",
"x3 = 1E5\n",
"print(x3)\n",
"print('\\t', 1E5 == 100000)\n",
"\n",
"x4 = 1.23e-10\n",
"print(x4)\n",
"print('\\t', 1.23e-10 == 0.000000000123)"
]
},
{
"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
}