{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Cvičení č. 4 rozšířené o poznámky ze cvičení a řešení některých příkladů (ZS 2026/27)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### V minulém díle jste viděli..." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Způsob kódování dat v paměti počítače: znaky, celá čísla a \"reálná\" čísla.\n", "- Použití funkcí `bool`, `int`, `float` a konstant `None`, `True`, `False`.\n", "- Importování modulu `math` a použití matematických konstant a funkci:" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Číslo π je přibližně 3.141592653589793\n", "Hodnota cos(π) je -1.0\n" ] } ], "source": [ "import math\n", "\n", "print(\"Číslo π je přibližně\", math.pi)\n", "print(\"Hodnota cos(π) je \", math.cos(math.pi))" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Jak odevzdávat úkoly v rozhraní Nbgrader" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Typ `complex`" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Jazyk Python také umožňuje provádět výpočty s komplexními čísly, která jsou reprezentována pomocí typu `complex`.\n", "Komplexní číslo má reálnou a imaginární část, přičemž imaginární jednotka se značí _suffixem_ `j`:" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c2 = (1-2j)\n" ] } ], "source": [ "c2 = 1 - 2j\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "complex" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(c2)" ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c2 = (1.1+2.5j)\n" ] } ], "source": [ "c2 = 1.1 + 2.5j\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c2 = (1.1+0j)\n" ] } ], "source": [ "c2 = 1.1 + 0j\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c2 = 2.3j\n" ] } ], "source": [ "c2 = 2.3j\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c1 = (1+2j)\n" ] } ], "source": [ "c1 = complex(1, 2)\n", "print(\"c1 =\", c1)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c2 = (1.2+0j)\n" ] } ], "source": [ "c2 = complex(1.2)\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "float() argument must be a string or a real number, not 'complex'", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[31]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# přímý převod z complex na int/float nejde:\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m float(c2)\n", "\u001b[31mTypeError\u001b[39m: float() argument must be a string or a real number, not 'complex'" ] } ], "source": [ "# přímý převod z complex na int/float nejde:\n", "float(c2)" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid syntax (2351132776.py, line 2)", "output_type": "error", "traceback": [ " \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[10]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[31m \u001b[39m\u001b[31mc2 = 1 - 2 j\u001b[39m\n ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m invalid syntax\n" ] } ], "source": [ "# mezi číslem a znakem 'j' nesmí být mezera:\n", "c2 = 1 - 2 j\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c2 = -9\n", "c2 = (1-1j)\n" ] } ], "source": [ "# před znakem 'j' nesmíme vynechat číslo:\n", "j = 10\n", "\n", "c2 = 1 - j\n", "print(\"c2 =\", c2)\n", "\n", "c2 = 1 - 1j\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "c2 = 1j\n" ] } ], "source": [ "c2 = 1j\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "zadej komplexní cislo 1+3j\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "c2 = (1+3j)\n" ] } ], "source": [ "# při načítání pomocí input nesmí být \"kolem znaku '+'/'-' mezery: \n", "c2 = complex(input(\"zadej komplexní cislo\"))\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "zadej komplexní cislo 1 + 4j\n" ] }, { "ename": "ValueError", "evalue": "complex() arg is a malformed string", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mValueError\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[14]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# při načítání pomocí input nesmí být \"uvnitř\" čísla mezery:\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m c2 = complex(input(\u001b[33m\"zadej komplexní cislo\"\u001b[39m))\n\u001b[32m 3\u001b[39m print(\u001b[33m\"c2 =\"\u001b[39m, c2)\n", "\u001b[31mValueError\u001b[39m: complex() arg is a malformed string" ] } ], "source": [ "# při načítání pomocí input nesmí být \"kolem znaku '+'/'-' mezery: \n", "c2 = complex(input(\"zadej komplexní cislo\"))\n", "print(\"c2 =\", c2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__Pozor__ na to, že imaginární jednotka `j` musí vždy následovat bezprostředně za nějakou číslicí, jinak je `j` syntakticky interpretován jako identifikátor proměnné, který ani nemusí být komplexní číslo." ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3\n", "1j\n" ] } ], "source": [ "j = 3\n", "print(j)\n", "print(1j)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "S hodnotami typu `complex` můžeme provádět téměř všechny aritmetické operace stejně jako pro typ `int`, s výjimkou operátoru `%` (zbytek po celočíselném dělení).\n", "Viz tabulka v předchozím cvičení." ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(2+0j) 4j (5+0j) (-0.6+0.8j) (0.5+1j) (-3+4j)\n" ] } ], "source": [ "# s komplexními čísli mohu provádět většinu operací jako s celými čísli:\n", "print(c1 + c2, c1 - c2, c1 * c2, c1 / c2, c1 / 2, c1 ** 2)" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "unsupported operand type(s) for %: 'complex' and 'complex'", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[4]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# všechny aritmetické operátory s výjimkou //, %\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m print(c1 % c2)\n", "\u001b[31mTypeError\u001b[39m: unsupported operand type(s) for %: 'complex' and 'complex'" ] } ], "source": [ "# všechny aritmetické operátory s výjimkou //, %\n", "print(c1 % c2)" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "unsupported operand type(s) for //: 'complex' and 'complex'", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[7]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# všechny aritmetické operátory s výjimkou //, %\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m print(c1 // c2)\n", "\u001b[31mTypeError\u001b[39m: unsupported operand type(s) for //: 'complex' and 'complex'" ] } ], "source": [ "# všechny aritmetické operátory s výjimkou //, %\n", "print(c1 // c2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Typ `complex` představuje první _složený_ datový typ, se kterým jsme se setkali.\n", "Hodnoty typu `complex` jsou složené z reálné a imaginární části, které mají typ `float` a lze k nim přistoupit pomocí tzv. _atributů_ `.real` a `.imag`.\n", "Typ `complex` dále poskytuje tzv. _metodu_ `.conjugate()`, která provádí komplexní sdružení." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-2.0" ] }, "execution_count": 8, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c2 = 1 - 2j\n", "c2.imag" ] }, { "cell_type": "code", "execution_count": 28, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 28, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(c2.imag)" ] }, { "cell_type": "code", "execution_count": 25, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1.0" ] }, "execution_count": 25, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c2.real" ] }, { "cell_type": "code", "execution_count": 29, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "float" ] }, "execution_count": 29, "metadata": {}, "output_type": "execute_result" } ], "source": [ "type(c2.real)" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(1-2j) (1+2j)\n" ] } ], "source": [ "c3 = c2.conjugate()\n", "print(c2, c3)" ] }, { "cell_type": "code", "execution_count": 27, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "reálná část: 1.0\n", "imaginární část: 2.0\n", "komplexně sdružené číslo: (1-2j)\n" ] } ], "source": [ "c = 1 + 2j\n", "print(\"reálná část:\", c.real)\n", "print(\"imaginární část:\", c.imag)\n", "print(\"komplexně sdružené číslo:\", c.conjugate())" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(1.09868411346781-0.45508986056222733j)" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# modul cmath .. obdoba modulu math pro komplexní čísla\n", "import cmath\n", "cmath.sqrt(1-1j)" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1j" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "cmath.sqrt(-1)" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(6.123233995736766e-17+1j)" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "(-1) ** 0.5 # funguje, vrací typ complex\n", "# pozorujeme zaokrouhlovací chybu" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Příklady" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1a. *Kalkulačka pro komplexní čísla*\n", "\n", "Načtěte od uživatele 2 komplexní čísla a vypočtěte jejich součet, rozdíl, součin, podíl, velikost, komplexní soudružné číslo.\n", "\n", "Využijte operátory nebo funkce, které jsou pro komplexní čísla dostupné." ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdin", "output_type": "stream", "text": [ "zadej komplexni cislo 1-3j\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "(1-2j)\n" ] }, { "name": "stdin", "output_type": "stream", "text": [ "zadej komplexni cislo 2+0.5j\n" ] }, { "name": "stdout", "output_type": "stream", "text": [ "(3+0.5j)\n" ] } ], "source": [ "z1 = complex(input(\"zadej komplexni cislo\"))\n", "print(c1)\n", "z2 = complex(input(\"zadej komplexni cislo\"))\n", "print(c2)" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Součet: (3-2.5j)\n", "Rozdíl: (-1-3.5j)\n", "Součin: (3.5-5.5j)\n", "Podíl: (0.11764705882352941-1.5294117647058822j)\n", "Číslo sdružené k prvnímu číslu: (1+3j)\n", "Číslo sdružené k druhému číslu: (2-0.5j)\n" ] } ], "source": [ "# Výpočty\n", "soucet = z1 + z2\n", "rozdil = z1 - z2\n", "soucin = z1 * z2\n", "podil = z1 / z2\n", "\n", "# Komplexně sdružená čísla\n", "sdruzene1 = z1.conjugate()\n", "sdruzene2 = z2.conjugate()\n", "\n", "print(\"Součet: \", soucet)\n", "print(\"Rozdíl: \", rozdil)\n", "print(\"Součin: \", soucin)\n", "print(\"Podíl: \", podil)\n", "\n", "print(\"Číslo sdružené k prvnímu číslu:\", sdruzene1)\n", "print(\"Číslo sdružené k druhému číslu:\", sdruzene2)" ] }, { "cell_type": "code", "execution_count": 38, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Velikost prvního čísla: 3.1622776601683795\n" ] } ], "source": [ "# Velikost komplexního čísla\n", "# 1. výpočet pomocí atributů z.imag, z.real\n", "velikost = (z1.real **2 + z1.imag ** 2) ** 0.5\n", "print(\"Velikost prvního čísla:\", velikost)" ] }, { "cell_type": "code", "execution_count": 39, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Velikost prvního čísla: (3.1622776601683795+0j)\n", "Velikost prvního čísla: 3.1622776601683795\n" ] } ], "source": [ "# 2. výpočet pres pres násobení čísla s číslem komplexne sdruzenym, z.conjugate()\n", "velikost_c = (z1 * z1.conjugate()) ** 0.5\n", "print(\"Velikost prvního čísla:\", velikost_c)\n", "\n", "velikost = velikost_c.real\n", "print(\"Velikost prvního čísla:\", velikost)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Velikost prvního čísla: 3.1622776601683795\n" ] } ], "source": [ "# 3. výpočet pomocí funkce abs()\n", "velikost = abs(z1)\n", "print(\"Velikost prvního čísla:\", velikost)" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "velikost_prvniho = abs(z1)\n", "print(velikost_prvniho)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1b. *Kalkulačka pro komplexní čísla podruhé*\n", "\n", "Zadání je stejné jako v příkladu 1a, ale tentokrát operace implementujte sami (tj. například pro scítání sečtěte zvlášť reálnou složku a zvlášť imaginární složku a vytvoříte z výsledku nové komplexní číslo).\n", "\n", "Výsledky operací porovnejte s výsledky předchozího příkladu." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Načtení dvou komplexních čísel\n", "z1 = complex(input(\"Zadejte první komplexní číslo (např. 2+3j): \"))\n", "z2 = complex(input(\"Zadejte druhé komplexní číslo (např. 1-2j): \"))" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "(3+2.5j)\n" ] } ], "source": [ "# Reálné a imaginární části\n", "a1 = z1.real\n", "b1 = z1.imag\n", "a2 = z2.real\n", "b2 = z2.imag\n", "\n", "# Součet:\n", "a = a1 + a2\n", "b = b1 + b2\n", "soucet = complex(a, b)\n", "print(soucet)" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Součet: (3+2.5j)\n", "Rozdíl: (-1+3.5j)\n", "Součin: (3.5+5.5j)\n", "Podíl: (0.11764705882352941+1.5294117647058822j)\n", "Číslo sdružené k prvnímu číslu: (1-3j)\n", "Velikost prvního čísla: 3.1622776601683795\n" ] } ], "source": [ "a1 = z1.real\n", "a2 = z2.real\n", "b1 = z1.imag\n", "b2 = z2.imag\n", "\n", "soucet = complex(a1 + a2, b1 + b2)\n", "rozdil = complex(a1 - a2, b1 - b2)\n", "soucin = complex(a1 * a2 - b1 * b2, a1 * b2 + a2 * b1)\n", "podil = complex((a1 * a2 + b1 * b2) / (a2**2 + b2**2), (a2 * b1 - a1 * b2) / (a2**2 + b2**2))\n", "sdruzene = complex(a1, -b1)\n", "velikost_prvniho = (a1 ** 2 + b1 ** 2) ** 0.5\n", "\n", "print(\"Součet: \", soucet)\n", "print(\"Rozdíl: \", rozdil)\n", "print(\"Součin: \", soucin)\n", "print(\"Podíl: \", podil)\n", "\n", "print(\"Číslo sdružené k prvnímu číslu:\", sdruzene)\n", "print(\"Velikost prvního čísla:\", velikost_prvniho)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2. Napište program, který spočítá vzdálenost dvou komplexních čísel." ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.640054944640259\n" ] } ], "source": [ "# vzdalenost = abs(c - d)\n", "# abs(z=a+bi)= sqrt(a^2+b^2) = sqrt(z * komplexně sdružené číslo k z)\n", "vzdalenost = abs(z1 - z2)\n", "print(vzdalenost)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3. Použijte jazyk Python pro vyřešení kvadratické rovnice $\\pi x^2 + 2x + 1 = 0$. (Řešení tohoto příkladu nemusí být univerzální program, stačí posloupnost příkazů s výpočty, které byste prováděli \"na papíře\".)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "-8.566370614359172\n" ] } ], "source": [ "# 1. spočteme diskriminant\n", "import math\n", "a = math.pi\n", "b = 2\n", "c = 1\n", "\n", "D = b ** 2 - 4 * a * c\n", "print(D)" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "kořeny: (-0.3183098861837907+0.4658204617032757j) (-0.3183098861837907-0.4658204617032757j)\n" ] } ], "source": [ "# 2. spočteme kořeny\n", "# protože je diskriminant záporný, bude mít rovnice komplexní kořeny:\n", "a1 = - b / (2 * a)\n", "b1 = (-D) ** (1 / 2) / (2 * a)\n", "\n", "x1 = complex(a1, b1)\n", "x2 = complex(a1, -b1)\n", "print(\"kořeny:\", x1, x2)" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "kořeny: (-0.3183098861837907+0.4658204617032757j) (-0.3183098861837907-0.4658204617032757j)\n" ] } ], "source": [ "x1 = a1 + 1j * b1\n", "x2 = x1.conjugate()\n", "print(\"kořeny:\", x1, x2)" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "kořeny: (-0.3183098861837907+0.4658204617032757j) (-0.3183098861837907-0.4658204617032757j)\n", "kořeny: (-0.3183098861837907+0.4658204617032757j) (-0.3183098861837907-0.4658204617032757j)\n" ] } ], "source": [ "# tentokrát podle vzorce pro komplexní obor\n", "x1 = - b / (2 * a) + 1j * (-D) ** (1 / 2) / (2 * a)\n", "x2 = - b / (2 * a) - 1j * (-D) ** (1 / 2) / (2 * a)\n", "print(\"kořeny:\", x1, x2)\n" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "kořeny: (-0.31830988618379064+0.4658204617032757j) (-0.31830988618379064-0.4658204617032757j)\n" ] } ], "source": [ "# tentokrát podle vzorce pro reálný obor:\n", "x1 = (-b + D ** (1/2)) / (2 * a)\n", "x2 = x1.conjugate()\n", "print(\"kořeny:\", x1, x2)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "4. *Převod do polárních souřadnic a zpět*\n", "\n", "Napište program, který zadané komplexní číslo převede z kartézských souřadnic do polárních souřadnic.\n", "Dále napište i program pro konverzi z polárních souřadnic do kartézských.\n", "\n", "Pro kontrolu nakonec můžete využít funkce `cmath.polar()` a `cmath.rect()`." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# společně jsme nedělali" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Práce s proměnnými v Pythonu" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Pojem __proměnná__ (anglicky _variable_) představuje oblast v paměti počítače, která je vyhrazena pro uložení odkazu na nějakou hodnotu, kterou si chceme zapamatovat.\n", "Abychom mohli s proměnnými v programech pracovat, musíme je pojmenovat.\n", "Kdykoliv potom v kódu použijete název proměnné, interpret zařídí dosazení hodnoty, na kterou se daná proměnná odkazuje.\n", "\n", "Pojem __identifikátor__ představuje název proměnné, který vystupuje ve zdrojovém kódu.\n", "V Pythonu platí pro identifikátory následující pravidla:\n", "\n", "- Smějí obsahovat písmena, číslice a podtržítka.\n", "- Nesmějí začínat číslicí.\n", "- Rozlišuje se v nich velikost písmen. Identifikátory `ahoj`, `Ahoj` a `AHOJ` tedy představují různé proměnné.\n", "- Nesmějí být shodné s některým klíčovým slovem, což jsou slova, která mají v jazyce speciální význam.\n", " Zatím jsme potkali tato klíčová slova: `True`, `False`, `None` a k dalším se dostaneme později.\n", " Jejich seznam není potřeba se učit nazpaměť – v nových verzích jazyka se postupně rozšiřuje a pokud byste náhodou porušili toto pravidlo, interpret vám oznámí syntaktickou chybu.\n", "\n", "Nejdůležitější zásadou je volit názvy proměnných tak, aby co nejlépe naznačovaly jejich účel a aby se _při čtení kódu člověkem_ nepletly s ostatními názvy používanými v programu.\n", "Nejběžnější konvence pro pojmenování proměnných v Pythonu používá pouze malá písmena a znak `_` pro spojení více slov: `proměnná_s_dlouhým_názvem`." ] }, { "cell_type": "code", "execution_count": 1, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "7 \n", "abc \n" ] } ], "source": [ "# pokud do proměnné vložím novou hodnotu, může se změnit její typ:\n", "a = 7\n", "print(a, type(a))\n", "a = \"abc\"\n", "print(a, type(a))" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "6\n", "3.141592653589793\n", "ahoj\n" ] } ], "source": [ "x = 2 * 3\n", "print(x)\n", "x = math.pi\n", "print(x)\n", "x = print\n", "x(\"ahoj\")" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "ename": "SyntaxError", "evalue": "invalid decimal literal (841903365.py, line 1)", "output_type": "error", "traceback": [ " \u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[49]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[31m \u001b[39m\u001b[31m1a = 45\u001b[39m\n ^\n\u001b[31mSyntaxError\u001b[39m\u001b[31m:\u001b[39m invalid decimal literal\n" ] } ], "source": [ "1a = 45" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [], "source": [ "_t = 45" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [], "source": [ "print = (\"ahoj\")" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "ename": "TypeError", "evalue": "'str' object is not callable", "output_type": "error", "traceback": [ "\u001b[31m---------------------------------------------------------------------------\u001b[39m", "\u001b[31mTypeError\u001b[39m Traceback (most recent call last)", "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[57]\u001b[39m\u001b[32m, line 1\u001b[39m\n\u001b[32m----> \u001b[39m\u001b[32m1\u001b[39m print(\u001b[33m\"ahoj\"\u001b[39m)\n", "\u001b[31mTypeError\u001b[39m: 'str' object is not callable" ] } ], "source": [ "print(\"ahoj\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Inicializace a předefinování proměnných\n", "\n", "Novou proměnnou vytvoříme pomocí přiřazovacího operátoru `=`, kde na levé straně vystupuje nový identifikátor a na pravé straně výraz, který po vyhodnocení inicializuje danou proměnnou:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 1\n", "b = a + 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Proměnná se však odkazuje výslednou hodnotu inicializačního výrazu, nikoliv na celý výraz.\n", "Pokud bychom např. v předchozí buňce dále změnili hodnotu proměnné `a`, nemělo by to vliv na proměnnou `b`.\n", "\n", "Pokud již inicializovaná proměnná existuje, tedy název se již odkazuje na nějakou hodnotu, dojde jednoduše ke změně odkazu na novou hodnotu.\n", "Při tom může dojít ke změně typu, tedy proměnná není vázána na typ hodnoty použitý při inicializaci." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Jazyk Python pracuje s odkazy na hodnoty, tj. s proměnnými, stejně jako s odkazy na jiné objekty, se kterými se postupně seznámíme.\n", "Umožňuje tedy např. vytvářet nové odkazy na funkce a dokonce \"předefinovat\" existující odkaz na funkci jiným objektem:" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "ahoj\n", "ahoj\n" ] } ], "source": [ "b = print\n", "print = \"Hello, world!\"\n", "b(\"ahoj\")\n", "\n", "print = b\n", "print(\"ahoj\")" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = print\n", "print = \"Hello, world!\"\n", "a(print)\n", "print = a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Proměnné a buňky v Jupyter notebooku\n", "\n", "Seznam aktuálně definovaných proměnných můžeme zobrazit kliknutím na tlačítko\n", " (_Enable Debugger_) v horním panelu a následným zobrazením _debuggeru_ na pravé straně.\n", "V rozhraní JupyterLab je zde opět ikona brouka, v rozhraní Jupyter Notebook je tlačítko v menu _View → Right Sidebar → Show Debugger_.\n", "\n", "V prostředí Jupyter se notebooky obsahující buňky s kódem mohou chovat na první pohled nečekaným způsobem.\n", "Proměnné definované v jedné buňce totiž po jejím spuštění zůstanou definované v interpretu zpracovávajícího daný notebook a můžou ovlivnit chování při vyhodnocování kódu dále spouštěných buněk.\n", "Zkuste například opakovaně spouštět následující dvě buňky v různém pořadí a sledujte stav proměnných v _debuggeru_:" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = 0" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "a = a + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "__K zamyšlení:__ co se stane po restartování kernelu pro tento notebook a spuštění pouze druhé z těchto buněk?" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import cmath" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "cmath.pi" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "from math import pi, cos" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Příklady" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "Dokončete všechny příklady z minulého cvičení." ] } ], "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.14.7" } }, "nbformat": 4, "nbformat_minor": 4 }