Programavimo įvadas Python / 1 kontrolinis

Programų pavyzdžiai

Pasiruošimo užduotys su pilnu kodu ir rezultato patikra.

Programų šablonai

Tipiniai pirmų septynių temų įgūdžių deriniai. Pradėk nuo statistikos, duomenų valymo, while, failo analizės ir funkcijų. Sekos, teksto analizė ir pirminiai skaičiai – papildoma treniruotė. Kiekvienam pavyzdžiui pateikta užduotis, visas kodas ir patikra.

Priklausomybė: matavimų valymo pavyzdys naudoja šiame puslapyje esančią statistika funkciją; kiti pavyzdžiai pateikti atskirai. Įvesties failai, kurių reikia CSV ir failo analizės pavyzdžiams, neplatinami – paruošk juos pagal nurodytą formatą.

Laisvasis kritimas

Paieška: kritimas aukstis laikas greitis input formule

Iš aukščio h ir pagreičio g apskaičiuoti kritimo laiką bei greitį; patikrinti įvestį.

h = float(input("Aukštis, m: ").replace(",", "."))
g = 9.81
if h < 0:
    print("Aukštis negali būti neigiamas")
else:
    t = (2 * h / g) ** 0.5
    v = g * t
    print(f"t = {t:.3f} s; v = {v:.2f} m/s = {v*3.6:.1f} km/h")

Patikra: Kai h=100: t=4.515 s; v=44.29 m/s; 159.5 km/h. h=0 duoda nulį.

Statistika ciklais

Paieška: vidurkis mediana sigma sum be sum ciklas min max

Funkcija grąžina vidurkį, medianą ir σ. Vidurkį bei σ skaičiuoti ciklais.

def statistika(m):
    if not m:
        return None
    suma = 0
    for x in m:
        suma += x
    vid = suma / len(m)
    kv = 0
    for x in m:
        kv += (x - vid) ** 2
    sigma = (kv / len(m)) ** 0.5
    r = sorted(m)
    n = len(r)
    if n % 2 == 1:
        med = r[n // 2]
    else:
        med = (r[n // 2 - 1] + r[n // 2]) / 2
    return vid, med, sigma

rez = statistika([1, 2, 3, 4])
if rez is None:
    print("Nėra duomenų")
else:
    vid, med, sig = rez
    print(f"vid={vid:.3f}; med={med:.3f}; sigma={sig:.3f}")

Patikra: vid=2.500; med=2.500; sigma=1.118. [] → None; [5] → (5.0, 5, 0.0).

Matavimų valymas ir g

Paieška: outlier impossible good 3sigma filtravimas kritimas pagreitis

Pašalinti t<=0, apskaičiuoti statistiką, taikyti 3σ, perskaičiuoti g. Pirma kopijuok aukščiau esančią statistika funkciją.

laikai = [0.4951, 0.4941, 0.4952, 0.4938, 0.4944, 0.4955,
          0.4940, 0.4949, 0.0, 0.4943, 0.5412, 0.4948,
          0.4953, 0.4939, 0.4942, 0.4950]
tikri = []
for t in laikai:
    if t > 0:
        tikri.append(t)
rez = statistika(tikri)
if rez is None:
    print("Nėra galiojančių laikų")
else:
    vid, med, sig = rez
    kiek = {"good": 0, "outlier": 0, "impossible": 0}
    svarus = []
    for t in laikai:
        if t <= 0:
            kiek["impossible"] += 1
        elif abs(t - vid) > 3 * sig:
            kiek["outlier"] += 1
        else:
            kiek["good"] += 1
            svarus.append(t)
    print(kiek)
    rez2 = statistika(svarus)
    if rez2 is not None:
        vid2, med2, sig2 = rez2
        g = 2 * 1.2 / vid2**2
        print(f"vid={vid2:.4f} s; sigma={sig2:.5f} s; g={g:.2f} m/s²")

Patikra: good=14, outlier=1, impossible=1. Išvalytas vidurkis 0.4946 s; sigma 0.00055 s; g=9.81 m/s².

Minimumas ir maksimumas ciklu

Paieška: min max neigiami skaiciai indeksas atitinkanti verte

Nenaudojant min/max rasti kraštines vertes ir didžiausios indeksą.

m = [-12.4, -8.7, -15.1, -6.3, -18.2]
if not m:
    print("Nėra duomenų")
else:
    maz = did = m[0]
    i_did = 0
    for i in range(1, len(m)):
        if m[i] < maz:
            maz = m[i]
        if m[i] > did:
            did = m[i]
            i_did = i
    print(maz, did, i_did)

Patikra: -18.2 -6.3 3. Susietą vertę kitame sąraše gausi kitas[i_did].

Kamuoliuko atšokimai

Paieška: while kelias atsokimai kamuoliukas zodynas iteraciju riba

Kiekvienam aukščio daugikliui rasti atšokimų skaičių ir nueitą kelią iki aukštis <0.01 m.

def atsokimai(q, h=2.0, riba=0.01):
    if not (0 < q < 1) or h <= 0 or riba <= 0:
        return None
    kelias = h
    n = 0
    while h >= riba and n < 10000:
        h *= q
        n += 1
        kelias += 2 * h
    if h >= riba:
        return None
    return n, kelias

for rusis, q in {"teniso": 0.55, "krepsinio": 0.65,
                 "guminis": 0.8, "golfo": 0.7}.items():
    rez = atsokimai(q)
    if rez is not None:
        n, kelias = rez
        print(f"{rusis}: {n}; {kelias:.2f} m")

Patikra: Atšokimų: 9, 13, 24, 15. Guminio kelias 17.92 m. Įtrauktas paskutinis visas mažesnis už ribą atšokimas.

Kvadratinė šaknis iteracijomis

Paieška: sqrt babilonieciu Newton while tolerancija konvergencija

Babiloniečių metodu tikslinti teigiamo skaičiaus šaknį; riboti žingsnių skaičių.

def saknis(x, eps=1e-10):
    if x < 0 or eps <= 0:
        return None
    if x == 0:
        return 0.0, 0
    s = max(1.0, x)
    n = 0
    while abs(s*s - x) > eps and n < 1000:
        s = (s + x/s) / 2
        n += 1
    if abs(s*s - x) > eps:
        return None
    return s, n

rez = saknis(33)
if rez is not None:
    s, n = rez
    print(f"{s:.10f}; žingsnių {n}")

Patikra: Šaknis 5.7445626465; žingsnių skaičius priklauso nuo pradinio spėjimo. Neigiamam x grąžinama None.

Kategorijų ir žodžių skaičiavimas

Paieška: dictionary counter frequency dazniai elementai zodziai items get

Suskaičiuoti, kiek kartų kartojasi kiekviena kategorija, ir įrašyti į failą.

duomenys = ["Fe", "Ca", "Fe", "Ti", "Ca", "Fe"]
kiek = {}
for x in duomenys:
    if x in kiek:
        kiek[x] += 1
    else:
        kiek[x] = 1
with open("kategorijos.txt", "w", encoding="utf-8") as f:
    f.write("# kategorija kiekis\n")
    for x, n in kiek.items():
        f.write(f"{x} {n}\n")
print(kiek)

Patikra: {'Fe': 3, 'Ca': 2, 'Ti': 1}. Žodžiams naudok sakinys.lower().split(); skyrybą pašalink atskirai.

Failo analizė nuo pradžios iki galo

Paieška: failas antraste 2 keturi stulpeliai try except **** elementas spektras filtras

Pirmas dvi eilutes laikyti antrašte, skaitinius stulpelius konvertuoti saugiai, suskaičiuoti elementus. Šis pavyzdys tikisi 5 arba 7 stulpelių; elemento vardas yra septintas. Failo vardą įvesk pats.

def nuskaityk(vardas):
    stulpeliai = [[], [], [], []]
    identifikuotos = []
    blogos = 0
    with open(vardas, "r", encoding="utf-8") as f:
        antraste = f.readline() + f.readline()
        for eilute in f:
            tekstas = eilute.strip()
            if not tekstas or tekstas.startswith("#"):
                continue
            d = tekstas.split()
            if len(d) not in (5, 7):
                blogos += 1
                continue
            try:
                x1, x2 = float(d[0]), float(d[1])
                x3, x4 = float(d[2]), float(d[3])
                float(d[4])
                if len(d) == 7:
                    float(d[5])
            except ValueError:
                blogos += 1
                continue
            stulpeliai[0].append(x1)
            stulpeliai[1].append(x2)
            stulpeliai[2].append(x3)
            stulpeliai[3].append(x4)
            if len(d) == 7:
                identifikuotos.append(tekstas + "\n")
    return antraste, stulpeliai, identifikuotos, blogos

try:
    vardas = input("Įvesties failas: ")
    antraste, st, eilutes, blogos = nuskaityk(vardas)
    print("Galiojančių:", len(st[0]), "blogų:", blogos)
    if st[2]:
        i = st[2].index(max(st[2]))
        print("Didžiausia:", st[2][i], "atitinka:", st[1][i])
    kiek = {}
    for eilute in eilutes:
        elementas = eilute.split()[6]
        kiek[elementas] = kiek.get(elementas, 0) + 1
    print(kiek)
    ieskomas = input("Elemento raktas: ").strip()
    tinka = []
    for eilute in eilutes:
        if eilute.split()[6] == ieskomas:
            tinka.append(eilute)
    if not tinka:
        print("Tokio elemento nėra")
    else:
        with open("atrinktos-linijos.txt", "w", encoding="utf-8") as f:
            f.write(antraste)
            for eilute in tinka:
                f.write(eilute)
        print("Įrašyta duomenų eilučių:", len(tinka))
except FileNotFoundError:
    print("Patikrink įvesties failo vardą ir darbo aplanką")

Patikra: Patikra: bloga eilutė nepapildo nė vieno stulpelio; visų keturių sąrašų ilgiai sutampa. Rezultatų failo nekeisk į įvesties failą.

Dviejų stulpelių CSV

Paieška: csv kabliataskis kablelis decimal comma stulpeliai skaitymas

Nuskaityti du skaitinius stulpelius iš paprasto failo su antrašte ir kabliataškiu; dešimtainis skirtukas – kablelis.

def skaityk_csv(vardas):
    x, y = [], []
    blogos = 0
    with open(vardas, encoding="utf-8") as f:
        f.readline()
        for eilute in f:
            if not eilute.strip():
                continue
            d = eilute.strip().split(";")
            if len(d) != 2:
                blogos += 1
                continue
            try:
                a = float(d[0].replace(",", "."))
                b = float(d[1].replace(",", "."))
            except ValueError:
                blogos += 1
                continue
            x.append(a)
            y.append(b)
    return x, y, blogos

# Paruošk failą: pirma eilutė x;y, toliau 1,5;2,5 ir 2,0;3,0.
print(skaityk_csv("matavimai.csv"))

Patikra: Su aprašytu failu: ([1.5, 2.0], [2.5, 3.0], 0). Sudėtingam CSV su kabutėmis naudok csv.reader.

Skilimas ir fono atėmimas

Paieška: radioaktyvus skilimas liko fonas perpus puse None funkcijos laikas sekundes minutes

Pilnas pavyzdys su savarankiškai sukurtais trumpais duomenimis: nuskaityti, atimti foną, rasti pirmą pusę, įrašyti rezultatą. Laikas faile sekundėmis, funkcijose minutėmis.

def liko(N0, t, T=2.55):
    if N0 < 0 or t < 0 or T <= 0:
        return None
    return N0 * 2 ** (-t / T)

def skaityk(vardas):
    t, n = [], []
    with open(vardas, encoding="utf-8") as f:
        f.readline()
        for eilute in f:
            d = eilute.split()
            if len(d) != 2:
                continue
            try:
                sek, impulsai = float(d[0]), int(d[1])
            except ValueError:
                continue
            t.append(sek / 60)
            n.append(impulsai)
    return t, n

def be_fono(n, fonas=20):
    gryni = []
    for x in n:
        gryni.append(x - fonas)
    return gryni

def perpus(t, n):
    if not n or len(t) != len(n) or n[0] <= 0:
        return None, None
    for i in range(len(n)):
        if n[i] <= n[0] / 2:
            return t[i], n[i]
    return None, None

# Mokomieji duomenys: programa nepriklauso nuo papildomo failo.
with open("skilimo-pavyzdys.txt", "w", encoding="utf-8") as f:
    f.write("laikas_s impulsai\n0 1020\n60 800\n120 650\n180 450\n")
t, n = skaityk("skilimo-pavyzdys.txt")
g = be_fono(n)
t_pus, n_pus = perpus(t, g)
if t_pus is None:
    print("Pusė nepasiekta")
else:
    print(f"Pirmas matavimas: {t_pus:.1f} min; {n_pus} impulsų")
with open("grynuju-pavyzdys.txt", "w", encoding="utf-8") as f:
    f.write("# laikas_min grynieji\n")
    for i in range(len(t)):
        f.write(f"{t[i]:.1f} {g[i]}\n")
print(liko(800, 5, T=5))

Patikra: Pirmas matavimas: 3.0 min; 430 impulsų. liko(800,5,T=5) → 400.0. Tikslus pusės laikas nebūtinai sutampa su pirmu užfiksuotu tašku.

Teksto analizė

Paieška: zodziu skaicius balses priebalses isalpha lower split join

Suskaičiuoti žodžius, balses ir priebalses; skyrybos nelaikyti raidėmis.

s = "Programa skaito tekstą."
balses = "aąeęėiįyouųū"
b = p = 0
for raide in s.lower():
    if raide.isalpha():
        if raide in balses:
            b += 1
        else:
            p += 1
print("Žodžių:", len(s.split()))
print("Balsių:", b, "priebalsių:", p)

Patikra: 3 žodžiai, 8 balsės ir 12 priebalsių. split skaičiuoja tarpais atskirtas dalis, ne kalbinius žodžius visais atvejais.

Dalyba ir sekos

Paieška: range append modulo dalijasi Fibonacci fibonacio progresija suma

Surinkti skaičius, kurie dalijasi iš 3 ir 4; sugeneruoti geometrinę ir Fibonačio sekas.

dalus = []
for x in range(1, 51):
    if x % 3 == 0 and x % 4 == 0:
        dalus.append(x)
print(dalus)

geometrine = []
x, suma = 1, 0
for i in range(10):
    geometrine.append(x)
    suma += x
    x *= 2
print(geometrine, suma)

fib = []
a, b = 0, 1
for i in range(20):
    fib.append(a)
    a, b = b, a + b
print(fib)

Patikra: [12, 24, 36, 48]; geometrinės suma 1023; Fibonačio paskutiniai nariai 1597, 2584, 4181.

Pirminių skaičių atranka

Paieška: prime pirminis break nested ciklas daliklis

Papildoma treniruotė: atrinkti pirminius; 0 ir 1 nepriskirti pirminiams.

def pirminis(x):
    if x < 2:
        return False
    d = 2
    while d * d <= x:
        if x % d == 0:
            return False
        d += 1
    return True

rez = []
for x in [1, 2, 3, 4, 5, 6, 7, 97, 100]:
    if pirminis(x):
        rez.append(x)
print(rez)

Patikra: [2, 3, 5, 7, 97]. Pakanka daliklius tikrinti iki kvadratinės šaknies imtinai.

Kartoti įvestį iki teisingo skaičiaus

Paieška: while True break try except input ValueError pazymys

Klausti sveikojo pažymio 1–10, kol įvedama teisingai.

while True:
    try:
        pazymys = int(input("Pažymys 1–10: "))
    except ValueError:
        print("Įvesk sveikąjį skaičių")
        continue
    if 1 <= pazymys <= 10:
        break
    print("Pažymys turi būti nuo 1 iki 10")
print("Įvestas pažymys", pazymys)

Patikra: Įvesk devyni, tada 9.5, tada 11, tada 9: tik 9 priimamas.

Ką atspausdins?

Pirmiausia uždenk atsakymą ir atsek kiekvieną eilutę. Atsakymai palikti matomi, kad juos rastų Ctrl+F.

Priskyrimas

x = 5
x = x + 1
print(x)

Atsakymas: 6

Dešinė pusė naudoja seną x.

Tekstas ir skaičius

print("7" * 2)
print(7 * 2)

Atsakymas: 77
14

Tekstas kartojamas, skaičius dauginamas.

Pjūvis

print("spektras"[1:4])

Atsakymas: pek

Indeksas 4 neįtraukiamas.

Nuoroda

a = [1, 2]
b = a
a.append(3)
print(b)

Atsakymas: [1, 2, 3]

Abu vardai susieti su vienu sąrašu.

Rikiavimo rezultatas

a = [3, 1, 2]
b = a.sort()
print(a, b)

Atsakymas: [1, 2, 3] None

sort keičia vietoje, grąžina None.

Šakų tvarka

t = 2.87
if t > 2:
    print("A")
elif t > 2.5:
    print("B")

Atsakymas: A

Pirma teisinga šaka laimi.

Range

print(list(range(1, 8, 3)))

Atsakymas: [1, 4, 7]

8 neįtraukiamas.

Kaupiklis

s = 0
for x in [2, 4, 6]:
    s += x
print(s)

Atsakymas: 12

Kaupiklis paruoštas prieš ciklą.

While riba

k = 0
s = 0
while s < 10:
    k += 1
    s += k
print(k, s)

Atsakymas: 4 10

Po ketvirto praėjimo sąlyga klaidinga.

Return ir print

def f(x):
    print(x*x)
y = f(3)
print(y)

Atsakymas: 9
None

Pirmas spausdinimas funkcijoje, antroji vertė None.

Vietinis vardas

def f(x):
    return x*x
x = 9
print(x, f(x))

Atsakymas: 9 81

Išorinis x nepakeistas.

Numatytasis argumentas

def galia(darbas, laikas=1.0):
    return darbas/laikas
print(galia(10, 4), galia(10), galia(laikas=5, darbas=10))

Atsakymas: 2.5 10.0 2.0

Argumentus galima perduoti pagal vardą.

Žodyno raktai

d = {"A": 1}
d["a"] = 2
print(len(d))

Atsakymas: 2

Raidžių dydis svarbus.

Loginė klaida

a, b, c = 2, 2, 2
print(a + b + c/3)

Atsakymas: 4.666666666666667

Veikia, bet ne vidurkis. Reikia (a+b+c)/3.

Užpildyk spragą

suma_kv = 0
for x in m:
    # Įrašyk kaupimo eilutę

Atsakymas: suma_kv += (x - vid) ** 2

Kaupti visų nuokrypių kvadratus, ne tik paskutinį.

Rask klaidą

i = 0
while i < 5:
    if i == 2:
        continue
    print(i)
    i += 1

Atsakymas: Spausdina 0 ir 1, tada užstringa ties i=2.

i atnaujinimą perkelk prieš continue arba kitaip užtikrink būsenos pokytį.