19. hodina - Podprogram s parametrom¶

Vytvor nový program, v ktorom na začiatku priradíš do premennej cislo číslo od 0 po 999. Použi vetvenie na to, aby program rozhodol a správne vypísal hlásenie o tom, či je číslo jedno-, dvoj- alebo trojciferné. Napríklad, pre cislo = 128 program vypíše:
```
Číslo 128 je trojciferné.
```

Dokonči nasledujúce podprogramy, ktoré vypíšu správny vek:

def mam10():
    vek = 10
    print('Mám', vek, 'rokov')

def mam20():
    vek = ......
    print('Mám', vek, 'rokov')

def mam30():
    vek = 30
    print(....................................)

mam10()
mam20()
mam30()

Urob to tak, aby sa všetky 3 podprogramy navzájom čo najviac podobali.

Predchádzajúce riešenie sa dá zapísať pomocou jediného podprogramu:
```
def mam(vek):
    print('Mám', vek, 'rokov')

mam(10)
mam(20)
mam(30)
```
Vyskúšaj.

Ako program funguje?

v zátvorke v hlavičke podprogramu je meno parametra

def mam(vek):
    print('Mám', vek, 'rokov')       # tu sa parameter používa – parameter funguje ako premenná

mam(10)
mam(20)
mam(30)

hodnota v zátvorkách sa priradí do parametra vek:
- pri prvom zavolaní mam(10) bude mať parameter vek hodnotu 10
- pri druhom zavolaní mam(20) bude mať parameter vek hodnotu 20
- pri treťom zavolaní mam(30) bude mať parameter vek hodnotu 30

Dokonči podprogram vypis, ktorý používa parameter x na to, aby vypísal hodnotu parametra x a jeho druhú mocninu:

def vypis(x):
    print('Číslo', ...)
    print('Umocnené na druhú sa rovná', ............)

vypis(1)
vypis(2)
vypis(3)

Program by mal po spustení vypísať:

Číslo 1
Umocnené na druhú sa rovná 1
Číslo 2
Umocnené na druhú sa rovná 4
Číslo 3
Umocnené na druhú sa rovná 9

Doplň do predchádzajúceho podprogramu príkaz, ktorým sa vypíše aj prevrátená hodnota x:

Číslo 1
Umocnené na druhú sa rovná 1
Prevrátená hodnota sa rovná 1.0
Číslo 2
Umocnené na druhú sa rovná 4
Prevrátená hodnota sa rovná 0.5
Číslo 3
Umocnené na druhú sa rovná 9
Prevrátená hodnota sa rovná 0.3333333333333333

Dokonči podprogram kruh tak, aby kreslil kruhy so stredom 200, 150 a polomerom r, ktorý bude jeho parametrom:

import tkinter

canvas = tkinter.Canvas()
canvas.pack()

def kruh(r):
    canvas.create_oval(............, ............, ............, ............)

kruh(10)
kruh(100)
kruh(50)

Ak si postupoval správne, program by mal nakresliť:

Vytvor podprogram nahodny_kruh s parametrom r, ktorý nakreslí na náhodné pozície kruh s polomerom r červenej farby. Zavolaj tento podprogram pre rôzne hodnoty parametra. Výsledok môže vyzerať napríklad takto:

Vyskúšaj, čo program nakreslí, ak takto zavoláš podprogram nahodny_kruh:
```
for i in range(10):
    nahodny_kruh(i)
```

Polomer kruhu môžeme určiť aj takto:
```
for i in range(10):
    nahodny_kruh(i + 5)
```
Spusti program, aby si videl, čo urobí a vyplň nasledujúci tabuľku:

hodnota v premennej i

hodnota parametra r

0

1

2

3

4

5

6

7

8

9

hodnota v premennej `i`	hodnota parametra `r`
0
1
2
3
4
5
6
7
8
9

Zadefinuj podprogram oblubujem s parametrom cislo. Podprogram vypíše, či číslo obľubuje:
- ak je číslo menšie ako 7, vypíše Mám rád číslo ...
- inak vypíše Číslo ... sa mi nepáči
Podprogram zavolaj a over, že vypíše:
```
>>> oblubujem(1)
Mám rád číslo 1
>>> oblubujem(5)
Mám rád číslo 5
>>> oblubujem(10)
Číslo 10 sa mi nepáči
```

Použi cyklus a zavolaj podprogram oblubujem z predchádzajúcej úlohy pre čísla od 0 po 10:

Mám rád číslo 0
Mám rád číslo 1
...
Mám rád číslo 6
Číslo 7 sa mi nepáči
...
Číslo 10 sa mi nepáči

(*) Zadefinuj podprogram stvorec s parametrom a, ktorý udáva dĺžku strany štvorca. Podprogram by mal fungovať tak, že štvorec kreslí iba pre kladné hodnoty parametra a, ale pre záporné hodnoty vypíše správu Nedá sa. Ľavý horný roh štvorca bude 10, 10. Správu vypíš do stredu grafickej plochy. Otestuj, že podprogram správne pracuje.

pre stvorec(-50)

pre stvorec(100)


pre `stvorec(-50)`	pre `stvorec(100)`

(*) Uprav predchádzajúci podprogram stvorec tak, aby sa pre záporné hodnoty parametra a nič nikde nevypísalo. Stačí, ak zmažeš vetvu else: aj s príkazom pre výpis. Takýto príkaz sa nazýva if bez vetvy else:
```
if podmienka:
    príkaz       #
    príkaz       # vetva if
    ...          #
```

Poznáš hru Myslím si číslo, v ktorej treba uhádnuť neznáme číslo? Vytvor takú hru na počítači – počítač si vymyslí číslo od 1 po 5 a my ho musíme uhádnuť. Môže to fungovať takto:
- po spustení programu počítač priradí do premennej cislo náhodne vygenerované číslo,
- potom vypíše správu Myslím si číslo od 1 do 5. Skús ho uhádnuť...
- vo svojom programe budeš mať zadefinovaný podprogram skus s parametrom n, ktorý porovná cislo s hodnotu n a vypíše: buď Hurá, uhádol si!, alebo Nie, moje číslo je iné....
Hra môže prebiehať nasledovne – spustíme program a v príkazovom riadku odpovedáme tým, že voláme podprogram skus:
```
=========== RESTART ===========
Myslím si číslo od 1 do 5. Skús ho uhádnuť...
>>> skus(3)
Nie, moje číslo je iné...
>>> skus(2)
Nie, moje číslo je iné...
>>> skus(5)
Hurá, uhádol si!
>>>
```

(*) Vylepši predchádzajúci program tak, aby nám podprogram skus poradil:

=========== RESTART ===========
Myslím si číslo od 1 do 5. Skús ho uhádnuť...
>>> skus(3)
Nie, moje číslo je menšie...
>>> skus(1)
Nie, moje číslo je väčšie...
>>> skus(2)
Hurá, uhádol si!
>>>

Vytvor jednoduchý kvíz na sčítanie čísel. Počítač na začiatku vygeneruje dve náhodné čísla z rozsahu od 1 po 10, vypíše ich a my musíme odpovedať tým, že zavoláme podprogram over:
```
=========== RESTART ===========
Kolko je 10 + 7 ?
>>> over(5)
Nesprávne, malo to byt 17
>>>
=========== RESTART ===========
Kolko je 4 + 9 ?
>>> over(13)
Správne
>>>
```

(*) Treba preskúmať, ako často padne 6, keď veľakrát hádžeme kockou. Vytvor podprogram stastie s parametrom n, ktorý odsimuluje n hodov s bežnou hracou kockou. Podprogram n-krát vygeneruje náhodné číslo od 1 po 6, a ak padne šestka, zvýši počítadlo o 1. Podprogram na záver vypíše správu v tvare, napríklad:
```
Pravdepodobnosť výhry pri 10 hodoch: 0.2
```
Nechaj podprogram vypísať, aké budú pravdepodobnosti výhry pri 10, 100, 1000, 10000, 100000 hodoch.

(*) Dlaždič mal rovnomerne poukladať kocky do jedného radu. Mal však dobrú náladu a medzi kockami nechával náhodné medzery. Vytvor podprogram rad s parametrom y, ktorý nakreslí vedľa seba 20 kociek. Kocky kresli ako šedé štvorčeky veľkosti 10 x 10. Všetky ležia na y-ovej pozícii v grafickej ploche. Prvá kocka má x-ovú súradnicu 10 a každá ďalšia ju má väčšiu o náhodné číslo z rozsahu od 12 do 20.

Takýto obrázok dostaneme, ak podprogram zavoláme:
```
for i in range(15):
    rad(5 + i * 15)
```