{
"cells": [
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Cvičení č. 2 rozšířené o poznámky ze cvičení a řešení některých příkladů "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"#### V minulém díle jste viděli..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- __základní pojmy__ – počítač, program, algoritmus\n",
"- základní vlastnosti programovacích jazyků\n",
"- představení prostředí Python a Jupyter\n",
"\n",
"První programátorské prvky, které jsme si ukázali:"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"### Python jako kalkulačka\n",
"* matematické výrazy obsahující čísla, ( , ), operátory + , - , *, / , ** , // , % , proměnné \n",
" * pořadí vyhodnocení operátorů je celkem intuitivní (pokud nevím, mrknu se do dokumentace nebo použiji závorky)\n",
"* kód v buňce (nebo v konzoli) spustím např. pomocí `Shift enter`\n",
"* interpret Pythonu pracuje ve smyčce:\n",
" * načti vstup - vyhodnoť výraz - vypiš výsledek\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"11.4"
]
},
"execution_count": 1,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"4 + (5 - 6) * -7.4"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.4142135623730951"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"2 ** 0.5 # mocnina"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.6"
]
},
"execution_count": 13,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"13 / 5 # dělení"
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2"
]
},
"execution_count": 12,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"13 // 5 # celočíselné dělení"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"3"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"13 % 5 # zbytek po celočíselném dělení"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- v buňkách může být buď text (ve formátu Markdown) nebo zdojový kód (Python) \n",
"- pokud omylem nastavíme typ buňky jako Markdown, kód se po spuštění neprovede (ale bere se jako text ve formátu Markdown):"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"x = 8\n",
"x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- a teď správně:"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = 8\n",
"x"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Použití funkce `print` pro výpis textu, případně více hodnot:\n",
" - může mít více parametrů, pak vypíše výsledky za sebe na jeden řádek oddělené mezerou, na konci odřádkuje\n",
" - Volání funkce: `název_funkce (parametry oddělené čárkou)`, např. `print(x, y, z)`"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Hello, world!\n",
"Výsledek je 42\n",
"73 1.25 a\n",
"73_1.25_a\n"
]
}
],
"source": [
"print(\"Hello, world!\")\n",
"print(\"Výsledek je\", 42)\n",
"print(67 + 6, 5/4, \"a\") # každý z výrazů se vyhodnotí, vypíší se výsledky\n",
"\n",
"# pro pokročilé:\n",
"print(67 + 6, 5/4, \"a\", sep = \"_\") # oddělovač nebude mezera, ale \"_\""
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Zápis jednoduchých matematických výrazů:"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"6.2\n"
]
}
],
"source": [
"print(1 + 2 * 3 - 4 / 5)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Používání proměnných:"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [],
"source": [
"# proměnná umožňuje uchovat hodnotu pro další použití\n",
"a = 1\n",
"b = 2\n",
"c = 2 * (a + b)\n",
"d = \"ahoj\""
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1 2 6 ahoj\n"
]
}
],
"source": [
"print(a, b, c, d)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"4"
]
},
"execution_count": 10,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# hodnotu proměnné můžeme měnit:\n",
"b = 6\n",
"b = b + 3\n",
"b = b // 2\n",
"b"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"120"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# zkuste spustit opakovaně:\n",
"b = b * 2\n",
"b"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n"
]
},
{
"data": {
"text/plain": [
"15"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# operátory můžeme psát zkráceně:\n",
"b = 6\n",
"\n",
"# b = b - 3 \n",
"b -= 3\n",
"print(b)\n",
"\n",
"# b = b * (8 - 3)\n",
"b *= 8 - 3\n",
"b"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"15"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"b = 6 \n",
"b -= 3\n",
"b *= 8 - 3\n",
"b"
]
},
{
"cell_type": "code",
"execution_count": 22,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"2.0"
]
},
"execution_count": 22,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# příklad: zkuste si spočítat v hlavě:\n",
"a = 14\n",
"a += 1\n",
"a /= 3\n",
"a %= 3\n",
"a"
]
},
{
"cell_type": "code",
"execution_count": 50,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"7 7 7\n",
"3 3.5 a\n"
]
}
],
"source": [
"# vícenásobné přiřazení:\n",
"x = y = z = 7 \n",
"# x += 1\n",
"print(x, y, z)\n",
"\n",
"x, y, z = 3, 3.5, \"a\"\n",
"print(x, y, z)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- názvy proměnných : písmena, číslice, '_' , prvním znakem nesmí být číslice, v názvech proměnných nesmí být mezery"
]
},
{
"cell_type": "code",
"execution_count": 51,
"metadata": {
"scrolled": true
},
"outputs": [
{
"ename": "SyntaxError",
"evalue": "invalid decimal literal (1560275617.py, line 1)",
"output_type": "error",
"traceback": [
"\u001b[0;36m Cell \u001b[0;32mIn[51], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m 8x = 7\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid decimal literal\n"
]
}
],
"source": [
"8x = 7"
]
},
{
"cell_type": "code",
"execution_count": 52,
"metadata": {},
"outputs": [],
"source": [
"a1 = 8\n",
"d_min = 89\n"
]
},
{
"cell_type": "code",
"execution_count": 24,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"V Zoo máme 15 zvířat.\n"
]
}
],
"source": [
"# program je přehlednější, pokud proměnné mají smysluplné názvy\n",
"# pro psaní víceslovných názvů platí různé konvence:\n",
"žirafy = 8\n",
"hroši = 7\n",
"celkem_zvířat = žirafy + hroši\n",
"#celkemZvířat\n",
"#print(\"V Zoo máme\", celkem_zvířat, \"zvířat.\", sep = \"_\")\n",
"print(\"V Zoo máme\", celkem_zvířat, \"zvířat.\")\n",
"\n",
"# je pohodlnější používat angličtinu :-)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"- Použití funkce `input` pro přečtení uživatelského vstupu ve formě textu:"
]
},
{
"cell_type": "code",
"execution_count": 16,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"Zadej text: 67\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Zadal jsi 67\n"
]
},
{
"data": {
"text/plain": [
"'67'"
]
},
"execution_count": 16,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# pozor, funkce input vrací textový řetězec (str), pokud chci číslo, musím hodnotu tzv. přetypovat\n",
"\n",
"text = input(\"Zadej text:\")\n",
"print(\"Zadal jsi\", text)\n",
"text"
]
},
{
"cell_type": "code",
"execution_count": 17,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"str"
]
},
"execution_count": 17,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(text)"
]
},
{
"cell_type": "code",
"execution_count": 19,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"Zadej cislo: 5\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"5\n"
]
},
{
"data": {
"text/plain": [
"8"
]
},
"execution_count": 19,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Načtu celé číslo\n",
"s = input(\"Zadej cislo:\")\n",
"cislo = int(s)\n",
"print(cislo)\n",
"cislo + 3"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"int"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(cislo)"
]
},
{
"cell_type": "code",
"execution_count": 20,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"Zadej cislo: 6.7\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"6.7\n"
]
},
{
"data": {
"text/plain": [
"9.7"
]
},
"execution_count": 20,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Načtu \"reálné číslo\"\n",
"s = input(\"Zadej cislo:\")\n",
"cislo = float(s)\n",
"print(cislo)\n",
"cislo + 3"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"float"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"type(cislo)"
]
},
{
"cell_type": "code",
"execution_count": 21,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"Zadej cislo: 2.5\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"2.5\n"
]
},
{
"data": {
"text/plain": [
"str"
]
},
"execution_count": 21,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Načtu string\n",
"s = input(\"Zadej cislo:\")\n",
"print(s)\n",
"type(s)"
]
},
{
"cell_type": "code",
"execution_count": 9,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"str"
]
},
"execution_count": 9,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"a = \"ahoj\"\n",
"type(a)"
]
},
{
"cell_type": "code",
"execution_count": 32,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"1.Zadej číslo: 1\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"1\n"
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
"2. Zadej číslo: 2\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"2\n"
]
},
{
"name": "stdin",
"output_type": "stream",
"text": [
"3. Zadej číslo: 3\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"3\n"
]
}
],
"source": [
"# Zkrácený zápis:\n",
"x = input(\"1.Zadej číslo:\")\n",
"x = int(x)\n",
"print(x)\n",
"\n",
"x = int(input(\"2. Zadej číslo:\"))\n",
"print(x)\n",
"\n",
"# teoreticky by šlo i toto (ale není to pěkné):\n",
"print(int(input(\"3. Zadej číslo:\")))"
]
},
{
"cell_type": "code",
"execution_count": 31,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"4545 454545\n",
"90 135\n"
]
}
],
"source": [
"# operátory dělají různé věci pro různé datové typy:\n",
"x = \"45\" # str\n",
"print(x + x, 3 * x)\n",
"\n",
"x = 45 # int\n",
"print(x + x, 3 * x)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Příklady na procvičení"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"1. Napiš program, který uživateli nabídne zadat jeho jméno a následně ho přivítá."
]
},
{
"cell_type": "code",
"execution_count": 11,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"zadej jmeno: zuzka\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"ahoj zuzka , vítám tě!\n"
]
}
],
"source": [
"jmeno = input(\"zadej jmeno:\")\n",
"print(\"ahoj\", jmeno, \", vítám tě!\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"1. Napište program, který spočítá a vypíše počet sekund v roce."
]
},
{
"cell_type": "code",
"execution_count": 12,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Rok ma 31536000 vterin.\n"
]
}
],
"source": [
"vysledek = 365 * 24 * 60 * 60\n",
"print(\"Rok má\", vysledek, \"vteřin.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"2. Napište program, který spočítá cenu nafty potřebné na cestu osobním autem z Prahy do Ostravy a zpět. Vzdálenost po dálnici D1 je $380~km$, auto má průměrnou spotřebu $5.1~l/100~km$ a aktuální cena nafty je $35.90~Kč/l$. Pro jaký minimální počet cestujících je cesta autem výhodnější než cesta vlakem?"
]
},
{
"cell_type": "code",
"execution_count": 13,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Cena nafty je 1934.1239999999998 .\n"
]
}
],
"source": [
"# druhý příklad\n",
"vzdalenost = 380\n",
"spotřeba_l_za_100_km = 5.1\n",
"cena_za_litr = 49.9\n",
"\n",
"# celkova cena = celkova spotreba (v litrech) * cena (za litr)\n",
"# celkova spotreba = celkova vzdalenost v km * spotřeba za km\n",
"\n",
"celková_spotřeba = (vzdalenost * 2) * (spotřeba_l_za_100_km / 100)\n",
"celková_cena = celková_spotřeba * cena_za_litr\n",
"\n",
"print(\"Cena nafty je\", celková_cena, \".\")\n",
"\n"
]
},
{
"cell_type": "code",
"execution_count": 14,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"3.8682479999999995\n",
"Jízda autem se vyplatí 4 lidem.\n"
]
}
],
"source": [
"# druhy podpriklad\n",
"\n",
"cena_jízdenky = 500\n",
"# cena_jízdenky = input(\"Jaka je cena zpáteční jizdenky z Prahy do Ostravy?\")\n",
"print(celková_cena / cena_jízdenky)\n",
"\n",
"autem_lépe = celková_cena // cena_jízdenky + 1\n",
"\n",
"autem_lépe = int(autem_lépe)\n",
"print(\"Jízda autem se vyplatí\", autem_lépe, \"lidem.\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Efektivní používání klávesnice"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Ačkoliv programátoři tráví více času čtením existujícího kódu než psaním nového kódu, je potřeba naučit se používat klávesnici efektivním způsobem.\n",
"Není totiž nic trapnějšího, než když přijdete za kolegou diskutovat svůj kód a při první úpravě nemůžete na klávesnici najít středník, složenou závorku nebo libovolný jiný znak...\n",
"Proto zde uvádíme přehled užitečných klávesových zkratek a dalších triků.\n",
"\n",
"Také __velmi doporučujeme__ procvičit si [psaní všemi deseti](https://www.psani-deseti.cz/), bude se vám to hodit nejen při programování.\n",
"\n",
"Používání klávesnice závisí na [rozložení kláves](https://cs.wikipedia.org/wiki/Rozlo%C5%BEen%C3%AD_kl%C3%A1ves).\n",
"V ČR jsou populární rozložení __CZ QWERTZ__, __US__ a __Česká programátorská klávesnice__.\n",
"Každé rozložení kláves navíc umožňuje psát speciální znaky pomocí různých kombinací kláves – tyto kombinace se ale liší v závislosti na operačním systému a samozřejmě na zvoleném rozložení kláves.\n",
"\n",
"V případě používání české klávesnice (rozložení __CZ__) doporučujeme pro usnadnění programování a zrychlení psaní používat následující klávesové zkratky využívající klávesu [AltGr](https://en.wikipedia.org/wiki/AltGr_key):\n",
"\n",
"- `AltGr`+`x` → `#`\n",
"- `AltGr`+`v` → `@`\n",
"- `AltGr`+`b` → `{`\n",
"- `AltGr`+`n` → `}`\n",
"- `AltGr`+`,` → `<`\n",
"- `AltGr`+`.` → `>`\n",
"- `AltGr`+`f` → `[`\n",
"- `AltGr`+`g` → `]`\n",
"\n",
"V systému Linux navíc fungují následující zkratky využívající horní řadu znaků s diakritikou (speciální znaky jsou na těchto klávesách spolu s číslicemi nakresleny pro snazší zapamatování):\n",
"\n",
"- `AltGr`+`ě` → `@`\n",
"- `AltGr`+`š` → `#`\n",
"- `AltGr`+`č` → `$`\n",
"- `AltGr`+`ř` → `%`\n",
"- `AltGr`+`ž` → `^`\n",
"- `AltGr`+`ý` → `&`\n",
"- `AltGr`+`á` → `*`\n",
"- `AltGr`+`í` → `{`\n",
"- `AltGr`+`é` → `}`\n",
"\n",
"Pod ostatními klávesami se skrývají další, i když méně užitečné speciální znaky.\n",
"\n",
"\n",
"Znáte další užitečné klávesové zkratky, např. pro macOS? Dejte nám vědět! 😉🙏\n",
"
"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Data v paměti počítače"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Každý program pracuje s daty: čte vstupní data, produkuje výstupní data a v průběhu zpracování používá paměť počítače pro uchování přechodných dat.\n",
"Ačkoliv uživateli jsou data většinou zobrazena v takovém formátu, se kterým dokáže člověk snadno pracovat, __počítač pracuje pouze s daty zakódovanými ve dvojkové (binární) soustavě__.\n",
"Dále je nutné si uvědomit, že __záleží na tom, které kódování je pro danou hodnotu použito__, protože různé hodnoty s použitím různých kódování můžou mít stejnou binární reprezentaci (viz příklady níže).\n",
"\n",
"Bez ohledu na způsob kódování je binární kód charakterizován tím, že v něm vystupují pouze číslice 0 a 1.\n",
"Nejmenší jednotka informace je __bit__ (zkratka z anglického _binary digit_) a skupina 8 bitů představuje 1 __bajt__ (anglicky _byte_).\n",
"\n",
"\n",
"\n",
"Paměť počítače je fyzicky uzpůsobena tak, že umožňuje adresovat jednotlivé bajty a procesor počítače používá instrukce, které zpracovávají celé skupiny bajtů.\n",
"V dnešní době jsou nejčastější procesory, které využívají 64-bitové instrukce.\n",
"\n",
"## Kódování celých čísel\n",
"\n",
"Přirozená čísla zapisujeme ve dvojkové soustavě, která funguje podobně jako desítková soustava – je to poziční číselná soustava o základu 2 s číslicemi 0 a 1.\n",
"Pro převod ze dvojkové soustavy do desítkové se používá [substituční metoda](https://cs.wikipedia.org/wiki/Substitu%C4%8Dn%C3%AD_metoda_(%C4%8D%C3%ADseln%C3%A9_soustavy))\n",
"a převod z desítkové soustavy do dvojkové se používá [metoda dělení základem](https://cs.wikipedia.org/wiki/Metoda_d%C4%9Blen%C3%AD_z%C3%A1kladem).\n",
"Pro kódování záporných čísel se nejčastěji používá [dvojkový doplněk](https://cs.wikipedia.org/wiki/Dvojkov%C3%BD_dopln%C4%9Bk).\n",
"\n",
"## Kódování znaků\n",
"\n",
"Základní metoda pro binární reprezentaci textu jakožto posloupnosti znaků využívá tzv. [ASCII tabulku](https://cs.wikipedia.org/wiki/ASCII), která každému znaku vystupujícímu v tabulce přiřazuje unikátní binární kód.\n",
"Je to původně 7-bitový kód obsahující 128 platných znaků, ale pro praktické účely se každý zakódovaný znak doplňuje jedním nevyužitým bitem, aby v posloupnosti každému znaku odpovídal jeden bajt.\n",
"\n",
"V současné době je nejčastější kódování [UTF-8](https://cs.wikipedia.org/wiki/UTF-8), které je zpětně kompatibilní (každý ASCII kód je platný UTF-8 kód) a umožňuje kódovat $2^{31}$ znaků, čili pokrývá celou znakovou sadu Unicode.\n",
"\n",
"## Kódování \"reálných\" čísel\n",
"\n",
"Výše uvedené způsoby kódování celých čísel a znaků jsou _bezeztrátové_, čili opakovaným převodem hodnoty do binární soustavy a zpět dostaneme přesně původní hodnotu.\n",
"Je ale problém najít prakticky užitečné kódování reálných čísel do binární soustavy, které by bylo bezeztrátové.\n",
"Problém spočívá v tom, že např. číslo 0.3 má konečný rozvoj v desítkové soustavě, ale nekonečný rozvoj ve dvojkové soustavě.\n",
"Při převodu se tedy musíme uchýlit k _aproximaci_ – musíme provést zaokrouhlení tak, aby výsledná hodnota obsahovala daný počet bitů.\n",
"\n",
"K dalším problémům dochází při vyhodnocování aritmetických operací.\n",
"Pokud např. při součtu dvou \"reálných\" čísel ve dvojkové soustavě obsahuje správný výsledek větší počet bitů než je povoleno pro dané kódování, musíme opět provést zaokrouhlení a výsledek je špatně.\n",
"Lze tedy říci, že většina výpočtů s \"reálnými\" čísly v počítači probíhá nepřesně.\n",
"Problémům s přesností počítačové aritmetiky se nebudeme dále věnovat, podrobnosti můžete najít např. na stránce [Floating Point Arithmetic: Issues and Limitations](https://docs.python.org/3/tutorial/floatingpoint.html).\n",
"\n",
"## Příklady\n",
"\n",
"- desítková reprezentace binárního čísla 11: `3`\n",
"- binární reprezentace čísla 11: `1011`\n",
"- binární reprezentace textového řetězce \"11\" podle ASCII kódování: `0011000100110001`\n",
"- desítková reprezentace binárního čísla 0011000100110001: `12593`\n",
"- 64-bitová binární reprezentace hodnoty `1.0` podle standardu [IEEE 754](https://cs.wikipedia.org/wiki/IEEE_754): `11111111110000000000000000000000000000000000000000000000000000`"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Datové typy a zadávání hodnot v Pythonu"
]
},
{
"cell_type": "code",
"execution_count": 61,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"1.0"
]
},
"execution_count": 61,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1/3 * 3"
]
},
{
"cell_type": "code",
"execution_count": 62,
"metadata": {},
"outputs": [
{
"data": {
"text/plain": [
"0.9999999999999999"
]
},
"execution_count": 62,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"1/6 + 1/6 + 1/6 + 1/6+ 1/6 + 1/6"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Zatím jsme viděli tyto typy objektů v Pythonu:\n",
"\n",
"- text (např. `\"Hello, world!\"`)\n",
"- číslo\n",
" - celé číslo (např. `0`, `1`, atd.)\n",
" - \"reálné\" číslo (např. `1.5`)\n",
"\n",
"Pokud použijeme funkci `input`, výsledek je _vždy textový objekt_, i když uživatel zadá číslo.\n",
"Pokud chceme získat _číselný objekt_, musíme použít příslušnou funkci, která získá číselnou hodnotu z textu:\n",
"\n",
"- funkce `int` vrátí celé číslo:\n",
" ```python\n",
" a = int(input(\"Zadej číslo:\"))\n",
" print(a * 2)\n",
" ```\n",
"- funkce `float` vrátí \"reálné\" číslo:\n",
" ```python\n",
" a = float(input(\"Zadej číslo:\"))\n",
" print(a * 2)\n",
" ```\n",
"\n",
"__K zamyšlení a vyzkoušení:__ Co se stane, když uživatel nezadá číslo, ale něco jiného? Co se stane, když zadá několik čísel oddělených mezerou nebo čárkou?"
]
},
{
"cell_type": "code",
"execution_count": 72,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"zadej číslo: 9\n"
]
}
],
"source": [
"x = input(\"zadej číslo: \")\n",
"x = int(x) \n"
]
},
{
"cell_type": "code",
"execution_count": 74,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"zadej číslo: 78\n"
]
},
{
"data": {
"text/plain": [
"78.0"
]
},
"execution_count": 74,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"x = float(input(\"zadej číslo: \"))\n",
"x"
]
},
{
"cell_type": "code",
"execution_count": 68,
"metadata": {},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"6 6 6.0\n",
" \n"
]
}
],
"source": [
"y = int(x)\n",
"z = float(x)\n",
"print(x, y, z)\n",
"print(type(x), type(y), type(z))"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"Nyní si procvičíme programování na několika příkladech.\n",
"K datovým hodnotám a zadávání čísel se vrátíme ještě podrobněji na příštím cvičení..."
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"# Příklady"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"1. Napište program, který se zeptá uživatele na kladné číslo a spočítá obvod a obsah čtverce, který má délku strany rovnou zadané hodnotě. "
]
},
{
"cell_type": "code",
"execution_count": 37,
"metadata": {},
"outputs": [
{
"name": "stdin",
"output_type": "stream",
"text": [
"Zadej délku strany: 4\n"
]
},
{
"name": "stdout",
"output_type": "stream",
"text": [
"Obvod čtverce o délce strany 4.0 je 16.0 a jeho obsah je 16.0 .\n",
"Obvod čtverce o délce strany 4.0 je 16.0 a jeho obsah je 16.0.\n"
]
}
],
"source": [
"# je dobré si to rozdělit na 3 části: načst zadání, spočítat výsledek, vypsat výsledek\n",
"a = input(\"Zadej délku strany:\")\n",
"a = float(a) \n",
"# mohu zkratit na jeden řádek:\n",
"# a = float(input(\"Zadej délku strany:\"))\n",
"\n",
"o = 4 * a\n",
"s = a * a\n",
"\n",
"print(\"Obvod čtverce o délce strany\", a, \"je\", o,\"a jeho obsah je\", s,\".\")\n",
"\n",
"# pro pokročilé:\n",
"print(f\"Obvod čtverce o délce strany {a} je {o} a jeho obsah je {s}.\")\n"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"2. Napište program, který se zeptá uživatele na kladné číslo a spočítá obvod a obsah pravidelného pětiúhelníku, který má délku strany rovnou zadané hodnotě.\n",
"\n",
"Nápověda: odmocnina se dá spočítat pomocí obecné mocniny."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# Obvod pětiúhelníku o délce strany 4.0 je 20.0 a jeho obsah je 27.53.\n",
"a = input(\"Zadej delku strany\")\n",
"a = float(a)\n",
"o = 5 * a\n",
"S = (25 + 10 * 5 ** (1 / 2)) ** 0.5 / 4 * a ** 2 \n",
"print(\"Obvod petiuhelniku o strane delky\", a, \"je\", o, \", obsah je\", S, \".\")"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"3. Napište program, který se uživatele zeptá na jeho rok narození a spočítá, kolik mu je let."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# už jsme dělali minule :-)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"4a. Napište program, který se zeptá uživatele na jeho výšku a hmotnost. Následně spočítá a vypíše příslušnou hodnotu [BMI indexu](https://cs.wikipedia.org/wiki/Index_t%C4%9Blesn%C3%A9_hmotnosti)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# pozor na správné jednotky, zkontrolujte si výsledek "
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"4b. Rozšiřte předchozí program tak, aby vypsal, jaké je rozmezí optimální (normální) hmotnosti uživatele při jeho výšce."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# jde to i bez podmínek (ty ještě neumíme)"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"4c. *(těžší, pro rychlíky)* Upravte předchozí program tak, aby podle spočítaného BMI uživatele klasifikuje jeho hodnotu na základě standardních kategorií: podváha, normální váha, nadváha a obezita."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": [
"# zde již jsou potřeba podmínky, jen pro pokročilejší"
]
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"5. Napište program, který převede teplotu z Celsiů na Fahrenheity a opačně."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"6. Spočítej energii na základě slavné rovnice `E = mc²`, kde `m` je hmotnost objektu a `c` je rychlost světla ve vakuu (`c = 3 x 10^8 m/s`)."
]
},
{
"cell_type": "code",
"execution_count": null,
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"metadata": {},
"source": [
"7. Napiš program, který převede rychlost zadanou v kilometrech za hodinu (km/h) na metry za sekundu (m/s) a vypíše výsledek."
]
},
{
"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.14.7"
}
},
"nbformat": 4,
"nbformat_minor": 4
}