Praktikum 8¶

Allolevad ülesanded on kursuse "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.

Viimati uuendatud 20.10.2025.

Inimintellekti loodud ülesanded¶

Ülesanne 0:

Keegi kirjutas koodi:

def arvutus(a, b, c, d, operator='+'):
    y = (a, b, c, d) = str(a), str(b), str(c), str(d)
    operator = ' ' + operator + ' '
    tehe = ''
    for x in y:
        tehe += x + operator
    tehe = tehe[:-3]
    res = eval(tehe)
    print(tehe + '=', res)

arvutus(1, 2, 3, 4)

Kasuta lausendit assert. Veendu, et eelmainitud protseduur peatub kui:

argumendid a, b, c või d pole numbrid,
argument operator pole sõne,
argument operator pole üks järgmistest operatoritest: +, -, *, /, //, %, **.

Ülesanne 1:

Funktsiooni $f(x)$ väärtused on arvutatud sammuga $\Delta x$. Leitud väärtused on salvestatud listi:

[1, 2, 4, 6, 6, 4, 3, 1, 0, -1, -2, -1, 0, 2, 3, 4, 5, 5, 5, 4]

Teatavasti saab leida funktsiooni $f(x)$ tuletise $f'(x)$ kasutades lõplike vahede meetodit kujul:

$$ f'(x) = \lim_{\Delta x \to 0} \frac{f(x + \Delta x) - f(x)}{\Delta x} \quad \Rightarrow \quad f'(x) \approx \frac{f(x + \Delta x) - f(x)}{\Delta x}, $$

vali andmete sammuks $\Delta x = 0.1$.

Kirjuta funktsioon mis leiab listi andmete tuletise.
Kirjuta generaator mis leiab laisalt listi andmete tuletise.

Vastus: Tuletise andmed esitatuna listis

[10.0, 20.0, 20.0, 0.0, -20.0, -10.0, -20.0, -10.0, -10.0, -10.0, 10.0, 10.0, 20.0, 10.0, 10.0, 10.0, 0.0, 0.0, -10.0]

või

[10, 20, 20, 0, -20, -10, -20, -10, -10, -10, 10, 10, 20, 10, 10, 10, 0, 0, -10]

Ülesanne 2:

Kasuta eelmises ülesandes loodud generaatorit. Kasuta listi andmete (graafikute) kuvamiseks funktsiooni:

def ascii_plot(lst, height=20, x_spacing=2, point_char="o"):
    """
    ASCII vertical graph plotter using a customizable character for data points.
    Automatically scales to data range, shows a zero line, 
    and adds spacing between x-axis points.

    Args:
        lst (list[int|float]): data values
        height (int): vertical height of the graph
        x_spacing (int): spaces between data points horizontally
        point_char (str): character used for plotting data points
    """
    if not lst:
        print("(empty list)")
        return

    mn, mx = min(lst), max(lst)
    if mn == mx:
        mn -= 1
        mx += 1

    def value_to_row(v):
        ratio = (v - mn) / (mx - mn)
        return int(round((1 - ratio) * (height - 1)))

    cols = len(lst)
    rows = height
    width = cols * (x_spacing + 1)

    grid = [[" " for _ in range(width)] for _ in range(rows)]

    # place points
    for i, v in enumerate(lst):
        r = value_to_row(v)
        c = i * (x_spacing + 1)
        grid[r][c] = point_char

    # zero line (if 0 is within range)
    zero_line_row = value_to_row(0) if mn <= 0 <= mx else None
    label_w = max(len(str(mx)), len(str(mn)))

    # draw top to bottom
    for r in range(rows):
        if r == 0:
            label = str(mx).rjust(label_w)
        elif r == rows - 1:
            label = str(mn).rjust(label_w)
        elif zero_line_row is not None and r == zero_line_row:
            label = "0".rjust(label_w)
        else:
            label = " " * label_w

        line = []
        for c in range(width):
            ch = grid[r][c]
            if zero_line_row is not None and r == zero_line_row:
                line.append(point_char if ch == point_char else "-")
            else:
                line.append(ch)
        print(f"{label} ┤" + "".join(line))

    # x-axis labels
    x_axis = " " * (label_w + 2)
    for i in range(cols):
        x_axis += str(i % 10) + " " * x_spacing
    print(x_axis)

Kirjuta programm:

Kuva listi andmed, juhul kui

lst = [1, 2, 4, 6, 6, 4, 3, 1, 0, -1, -2, -1, 0, 2, 3, 4, 5, 5, 5, 4]

Leia andmete tuletis. Eelda, et $\Delta x = 0.1$. Kuva leitud listi andmed.
Leia andmete teine tuletis. Eelda, et $\Delta x = 0.1$. Kuva leitud listi andmed.

Oodatav tulemus:

1. [1, 2, 4, 6, 6, 4, 3, 1, 0, -1, -2, -1, 0, 2, 3, 4, 5, 5, 5, 4]

 6 ┤      * *                               
   ┤                                * * *   
   ┤    *     *                   *       * 
   ┤                                        
   ┤            *               *           
   ┤  *                       *             
   ┤*             *                         
   ┤                                        
 0 ┤----------------*-------*---------------
   ┤                  *   *                 
-2 ┤                    *                   
    0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 


2. [10.0, 20.0, 20.0, 0.0, -20.0, -10.0, -20.0, -10.0, -10.0, -10.0, 10.0, 10.0, 20.0, 10.0, 10.0, 10.0, 0.0, 0.0, -10.0]

 20.0 ┤  * *                   *             
      ┤                                      
      ┤*                   * *   * * *       
      ┤                                      
      ┤                                      
    0 ┤------*-------------------------*-*---
      ┤                                      
      ┤                                      
      ┤          *   * * *                 * 
      ┤                                      
-20.0 ┤        *   *                         
       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 


3. [100.0, 0.0, -200.0, -200.0, 100.0, -100.0, 100.0, 0.0, 0.0, 200.0, 0.0, 100.0, -100.0, 0.0, 0.0, -100.0, 0.0, -100.0]

 200.0 ┤                  *                 
       ┤                                    
       ┤*       *   *         *             
       ┤                                    
       ┤                                    
     0 ┤--*-----------*-*---*-----*-*---*---
       ┤                                    
       ┤                                    
       ┤          *             *     *   * 
       ┤                                    
-200.0 ┤    * *                             
        0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7

Ülesanne 3:

Kasuta funktsiooni filter. Eemalda listist

numbers = [1, 2, 3, 4, 5, 6]

paaritud arvud.

Vastus: [2, 4, 6]

Ülesanne 4:

Keegi kirjutas koodi kujul:

def is_even(x):
    if x % 2 == 0:
        return x

numbers = [0, 1, 2, 3, 4, 5, 6]

even_numbers = list(filter(is_even, numbers))
print(even_numbers)

Kas see programm töötab korrektselt? Kui ei siis paranda see.

Vastus: Ei.

Ülesanne 5:

List on antud kujul:

words = ["apple", "", "banana", "", "cherry"]

Eemalda tühjad sõned.

Vastus: ['apple', 'banana', 'cherry']

Ülesanne 6: *

Ülesandes 1 kirjutati numbriliselt tuletist leidev funktsioon. Kirjuta see funktsioon ümber. Kood peab kasutama sisseehitatud funktsiooni map tuletise väärtuste leidmiseks.

lst = [1, 2, 4, 6, 6, 4, 3, 1, 0, -1, -2, -1, 0, 2, 3, 4, 5, 5, 5, 4]

Vastus: Tuletise andmed esitatuna listis

[10.0, 20.0, 20.0, 0.0, -20.0, -10.0, -20.0, -10.0, -10.0, -10.0, 10.0, 10.0, 20.0, 10.0, 10.0, 10.0, 0.0, 0.0, -10.0]

või

[10, 20, 20, 0, -20, -10, -20, -10, -10, -10, 10, 10, 20, 10, 10, 10, 0, 0, -10]

Graafik kasutades Ülesande 2 funktsiooni ascii_plot:

 20.0 ┤  * *                   *             
      ┤                                      
      ┤*                   * *   * * *       
      ┤                                      
      ┤                                      
    0 ┤------*-------------------------*-*---
      ┤                                      
      ┤                                      
      ┤          *   * * *                 * 
      ┤                                      
-20.0 ┤        *   *                         
       0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8

Ülesanne 7:

Leia loendis

numbers = [1, 2, 3, 4, 5, 6]

olevate paaris arvude ruudud. Kasuta funktsioone filter ja map.

Vastus: [4, 16, 36].

Ülesanne 8:

Järjesta loend a tähestikulisse järjekorda. Esita loend b kahanevalt.

a = ['Mari', 'Mai', 'Kalle', 'Aune']
b = [23, 65, 77, 1, 34, 99, 854]

Vastused: ['Aune', 'Kalle', 'Mai', 'Mari'] ja [854, 99, 77, 65, 34, 23, 1].

Ülesanne 9:

Järjesta loendis a olevate nimede tähemärgid tähestikulisse järjekorda. Kasuta:

Kasutades sisseehitatud funktsioone,
kasutades for-in avaldist (list comprehension).

Oodatavad tulemused:

[['M', 'a', 'i', 'r'],
 ['M', 'a', 'i'],
 ['K', 'a', 'e', 'l', 'l'],
 ['A', 'e', 'n', 'u']]

ja/või

[['M', 'a', 'i', 'r'], ['M', 'a', 'i'], ['K', 'a', 'e', 'l', 'l'], ['A', 'e', 'n', 'u']]

Ülesanne 10:

Järjesta loend a tähestikulisse järjekorda. Lisa iga nime ette sõne "Tipi-".

a = ['Mari', 'Bella', 'Kalle', 'Aune']

Kasuta:

sisseehitatud funktsioone ja
for-in avaldist (list comprehension).

Oodatav tulemus:

['Tipi-Aune', 'Tipi-Bella', 'Tipi-Kalle', 'Tipi-Mari']

Ülesanne 11:

Leia ja esita uues loendis loendi arvud arvud mis on keskmisest väiksemad. Tulemuse leidmiseks kasuta:

sisseehitatud funktsiooni filter ja
for-in avaldist.

Etteantud loend:

arvud = [1, 2, 3, 4, 5, 6, 7, 3.3, 6.6, 4.4, 8.9]

Vastus: [1, 2, 3, 4, 3.3, 4.4].

Ülesanne 12:

Kasutades ainult ühte rida koodi, kirjuta programm mis filtreerib järgmist listi:

nimed = ['juulia', 'juulius', 'silver', 'mare', 'juku', 'arno']

Jäta alles nimed mis algavad tähega "j". Muuda nime esimene täht suureks. Lisa nimedele perekonnanimi "Tipikas".

Oodatav tulemus:

['Juulia Tipikas', 'Juulius Tipikas', 'Juku Tipikas']

Ülesanne 13:

Andmed on esitatud listis kujul:

lst = ['', [], 'a', (1,), 0, False, True, 100]

Filtreeri välja mittetriviaalsed objektid. Funktsiooni bool kasutamine on keelatud.
Mis andmetüübiga on tegu, lst[3]?

Oodatav tulemus:

['a', (1,), True, 100]
Kxxxxxž.

Ülesanne 14:

Andmed on esitatud listis kujul:

data = ['x', -1, -2.5, 3, 4.5, 5, 6.7, [1, 2, 3], 'y', 'g']

Filtreeri välja sõned ja järjesta need uues listis tähestikulisse järjekorda, prindi loodud list konsooli.
Filtreeri välja numbrid mis jäävad negatiivseks peale seda kui neile on liidetud arv üks ja neid on ümardatud kasutades funktsiooni round. Salvesta leitud ja muudetud arvud uude listi.

Oodatav tulemus:

['g', 'x', 'y']
[-2.5]

Ülesanne 15:

Andmed on esitatud kujul:

lst = ['', [], 'a', (1,), 0, False, True, 100]

Tuvasta listis lst olev (tühi) list ja lisa sellele listi lst kõik muud elemendid.

Oodatav tulemus: ['', ['', 'a', (1,), 0, False, True, 100], 'a', (1,), 0, False, True, 100].

Ülesanne 16:

Leia ringi pindalad erinevate raadiuste jaoks kasuta funktsiooni map või for-in avaldist ja enda defineeritud funktsiooni pindala mis leiab ringi pindala. Ringi pindala valem on kujul:

$$ A = \pi r^{2}, $$

kus $r$ on raadius. Leia $\pi$ väärtus kasutades enda lemmikut $\pi$ aproksimatsioonivalemit, vt. nt. https://mathworld.wolfram.com/PiApproximations.html

Etteantud raadiused:

raadius = [1, 2, 3, 4, 5, 6, 7.5, 9, 23.3]

Ülesanne 17:

Kirjuta programm mis palub kasutajal sisestada tehte kujul: 1 + 8 * 8 * 9. Kui kasutaja sisestab tehte õigesti, tervita kasutajat sõnega kujul:

'Tubli!'

Kui kasutaja teeb vea tehte sisestamisel (eeldame, et suvalist teksti ei sisestata) siis vasta sõnega kujul:

'Ei oska trükkida vä?'

Korda protsessi kuni õige tehe on sisestatud või kuni kolm korda. Kui kasutaja on valemi kolm korda valesti sisestanud siis ja ainult siis teavita kasutajat järgmisest:

'Mäng läbi!'

Vihje: Kasuta sisseehitatud funktsiooni eval ja while-else tsükklit.

Ülesanne 18:

Keegi kirjutas Pythoni koodi:

code = '''
x = 'Juulius'
y = 'Tipikas'
z = ' '
nimi = x + z + y
for i in range(2, 5):
    print(f'{nimi} on {i}-kordne luuser.')
print('Keegi ei armasta mind!')
'''

Kes see võis küll olla? Hiljem keegi teine (ka luuser) kirjutas samasse skoopi koodi:

x, y, z = 1, 2, 3 
exec(code)  # Huvitav mida see teeb?
vastus = x + z + y
assert vastus == 6, 'Vastus peab olema: x + z + y = 6'

Miks tõstatub koodi interpreteerimisel erisus AssertionError?

Vihje: Koodi interpreteerimise järejekord.

Ülesanne 19:

Kontrolli kas listi

lst_1 = [None, False, 0, {}, [], '', 0j, 0+0j, 0.0, not True]

kõik elemendid omavad tõeväärtust False.

Vihje: Kõik elemendid on juhtumisi triviaalsed Pythoni andmetüüpide esindajad.

Ülesanne 20:

On antud list kujul:

lst = ['a', 'b', '', [], 1.1, 2.1, 3, 8, 3, 8, -8, 2+3j, 8+8j, None, False]

Veendu selles, et:

vähemalt üks listis lst olevatest täisarvudest on paaris;
kõik listis lst olevad paaris täisarvud on positiivsed.

Ülesanne 21:

Vasta ilma interpreteerimiseta, kas allolev kood teostab real 3 oleva funktsiooni print väljakutse.

nimi = 'Mary'
assert nimi == 'Mari', f'Nimi on {nimi} see peaks olema Mari.'
print(f'Minu nimi on {nimi}.')

Interpreteeri eelolev lähtekood. Seleta konsooli väljastatud tulemus.

Ülesanne 22:

Kasuta loengus tutvustatud dekoraatorit cacheit ning rakenda seda funktsioonile mis leiab arvu faktoriaali rekursiivselt. Rekursiivne faktoriaali eeskiri ja funktsioon on kujul:

def recursive_factorial(n):
    if n <= 1:
        return 1
    return recursive_factorial(n - 1) * n

Veendu, et dekoraator töötab.

Näidisvastus: Väljakutse recursive_factorial(500) tagastab

1220136825991110068701238785423046926253574342803192842192413588385845373153881997605
4964475022032818630136164771482035841633787220781772004807852051593292854779075719393
3060377296085908627042917454788242491272634430567017327076946106280231045264421887878
9465754777149863494367781037644274033827365397471386477878495438489595537537990423241
0612713269843277457155463099772027810145610811883737095310163563244329870295638966289
1165897476957208792692887128178007026517450776841071962439039432253642260523494585012
9918571501248706961568141625359056693423813008856249246891564126775654481886506593847
9517753608940057452389403357984763639449053130623237490664450488246650759467358620746
3792518420045936969298102226397195259719094521782333175693458150855233282076282002340
2626907898342451712006207714640979456116127629145951237229913340169552363850942885592
0187274337951730145863575708283557801587354327688886801203998823847021514676054454076
6353598417443048012893831389688163948746965881750450692636533817505547812864000000000
0000000000000000000000000000000000000000000000000000000000000000000000000000000000000
000000000000000000000000000000

Ülesanne 23:

Kontrolli allolevate funktsioonide fib ja rec_fib töökorrektsust kasutades lausendit assert ning tingimust:

fib(n) = rec_fib(n) = <tulem>

Teosta kontroll vähemalt kolme n väärtuse korral. Etteantud funktsioonid fib ja rec_fib on kujul:

def fib(n):
    '''Leian fibonacci n-da jada liikme.'''
    if n <= 2:
        return 1
    f1 = f2 = 1
    for i in range(n - 2):
        f1, f2 = f2, f1 + f2
    return f2


def rec_fib(n):
    '''Leiab n-da fibonacci jada liikme rekursiivselt.'''
    if n <= 2:
        return 1
    return rec_fib(n - 2) + rec_fib(n - 1)

Soovitus: Loo funktsioon.

Ülesanne 24:

Kasuta funktsiooni sulundi (function closure) konstruktsiooni. Loo funktsioon salasona kuhu on sulustatud parool: Parool123456.

Oodatav tulemus: Väljakutse salasona() peab printima konsooli parooli Parool123456.

Ülesanne 25:

Defineeri funktsioon mis leiab sellele etteantud kolme arvu summa. Loo dekoraator mis muudab äsjamainitud funktsioonile etteantud negatiivsed argumendid positiivseks. Mis tähendab, et dekoreeritud funktsioon leiab arvude absoluutväärtuste summa.

Ülesanne 26:

Defineeri funktsioon mis leiab sellele etteantud teadmata (meelevaldse) arvu arvude summa. Loo dekoraator mis muudab äsjamainitud funktsioonile etteantud negatiivsed argumendid positiivseks. Mis tähendab, et dekoreeritud funktsioon leiab etteantud arvude absoluutväärtuste summa.

Ülesanne 27: *

Kasutades funktsiooni sulundi (function closure) konstruktsiooni. Loo funktsioon korrutaja_arvuga(<number>) mis väljastab omakorda sellesse pesastatud arvuga arv korrutava funktsiooni ja sulustatud argumendi arv väärtuse.

Seo pesastatud funktsioon funktsiooninimedega korruta_neljaga ja korruta_viiega nii, te allolevad neli rida koodi töötaks nagu loodetud:

korruta_neljaga = korrutaja_arvuga(4)
korruta_viiega = korrutaja_arvuga(5)

print('4 * 9 =', korruta_neljaga(9))  # --> 4 * 9 = 36
print('5 * 9 =', korruta_viiega(9))   # --> 5 * 9 = 45

Seega viimased kaks rida peavad genereerima konsooli tulemuse kujul:

4 * 9 = 36
5 * 9 = 45

Programm peab teostama korrutustehted $4 \cdot 9$ ja $5 \cdot 9$ automaatselt.

Ülesanne 28:

Kasutades pesastatud for tsüklit ja eelmises ülesandes loodud funktsiooni korrutaja_arvuga genereeri uued korrutustehteid teostavad funktsioonid ning kasuta neid korrutustabeli trükkimiseks.

Oodatav tulemus:

jne.

Ülesanne 29:

Kasutades funktsiooni map teisenda loendis ilm kasutatud temperatuuriskaala ${}^\circ F \to {}^\circ C$. Esita loend samas vormingus. Teisenduse tegemiseks kasuta valemit:

$$ {}^\circ C = \frac{5 ({}^\circ F- 32)}{9}. $$

Andmed kus temperatuur on esitatud Fahrenheitides on kujul:

ilm = [('Tallinn', 47),
       ('Riiga', 41),
       ('Helsinki', 40),
       ('Stockholm', 39)]

Ülesanne 30: *

Järjesta kasvavalt loendis planeedid olevad ennikud kolmanda tulba järgi. Kasuta funktsiooni sorted nimega argumenti key.

Etteantud loend:

planeedid = [
    ('Mercury', 0.382,  0.06),
    ('Venus',   0.949,  0.82),
    ('Earth',   1.00,   1.00),
    ('Mars',    0.532,  0.11),
    ('Jupiter', 11.209, 317.8),
    ('Saturn',  9.449,  95.2),
    ('Uranus',  4.007,  14.6),
    ('Neptune', 3.883,  17.2)]

Teine tulp on planeedi diameeter mis on normeeritud planeedi Maa diameetrile ja kolmas tulp on planeedi mass mis on normeeritud planeedi Maa massile.

Ülesanne 31:

Defineeri funktsioon mis leiab sellele meelevaldse arvu etteantud numbrite summa. Loo dekoraator mis eemaldab äsjamainitud funktsioonile etteantud positiivsed arvud kui negatiivseid on rohkem ja vastupidi. Juhul kui positiivseid ja negatiivseid argumente on võrdne arv eemaldab dekoraator kõik argumendid. Arv null pole ei positiivne ega negatiivne.

Tehisintellekti loodud ülesanded¶

Järgnevad ülesanded on loodud 19.10.2025 juturoboti OpenAI ChatGPT (GPT-5) poolt.

Ülesanne TI-1:

Exercise: Power Function Factory

Goal Create a function factory that generates functions to raise a number to a fixed power.

Instructions

Write a function make_power(n) that:
- Accepts an integer n.
- Returns a new function power(x) that computes x ** n.
Add an assert inside power(x) to ensure x is numeric (int or float).
Test the returned functions with the examples below.

☻ ☻ ☻