Python atmintinė

Greita paieška

Spausk Ctrl + F (Mac – ⌘F). Visos sekcijos išskleistos; nėra puslapiavimo ar paslėptų atsakymų. Paieška randa pavadinimus, lietuviškus ir angliškus terminus bei patį kodą. Raktažodžiai pateikti ir be lietuviškų raidžių.

Reikia užduoties? Ieškok Programų šablonai. Reikia greito pasitikrinimo? Ieškok Ką atspausdins. Kopijavimo mygtukas kopijuoja tik kodą. Pavyzdžius vykdyk po vieną; failų pavyzdžiams perskaityk nurodytą įvesties formatą.

Greitas šablonų žemėlapis

• Reikia kaupti sumą? for, kaupiklis prieš ciklą.
• Reikia tik tinkamų narių? naujas sąrašas, if ir append.
• Reikia kartoti iki ribos? while ir būsenos atnaujinimas.
• Reikia suskaičiuoti kategorijas? dict, in, pradinis 1.
• Reikia nuskaityti skaičius? with open, split, float, try/except.
• Reikia išsaugoti rezultatus? write, f-eilutė ir \n.
• Reikia pakartotinai naudoti skaičiavimą? def, parametrai, return.
• Rezultatas None? tikrink return; po sort – keitimas vietoje.

Algoritmas ir programa

Paieška: algoritmas algorithm įvestis isvestis baigtinumas blokinė schema kompiliatorius interpretatorius

Algoritmas yra aiški veiksmų seka uždaviniui išspręsti: įvestis → apdorojimas → išvestis. Šiame kurse nagrinėjami baigtiniai algoritmai. Programa užrašo algoritmą pasirinkta kalba. Blokinėje schemoje rombas reiškia sąlygą, stačiakampis – veiksmą, rodyklė – vykdymo kryptį. Kompiliatorius parengia vykdomą kodą; interpretatorius vykdo programą per kalbos vykdymo aplinką. Procesorius tiesiogiai Python teksto nesupranta. Įprastas CPython pirmiausia kompiliuoja kodą į baitkodą, o jį vykdo virtualioji mašina.

a, b, c = 2, 4, 6
vidurkis = (a + b + c) / 3
print(vidurkis)  # 4.0

Dažna klaida. Veikianti programa gali turėti loginę klaidą. Tikrink su atsakymu, kurį gali suskaičiuoti pats.

Kintamieji ir priskyrimas

Paieška: kintamasis variable assignment priskyrimas sukeitimas swap komentaras snake_case

Priskyrimas = pirmiausia apskaičiuoja dešinę pusę ir tada susieja vardą su objektu. Vardas gali turėti raides, skaitmenis ir _, bet negali prasidėti skaitmeniu ar būti rezervuotas žodis. Didžiosios ir mažosios raidės skiriasi. Komentaras prasideda #. a, b = b, a sukeičia vertes; a = b; b = a seną a prarastų.

a = 3
b = a
a += 1
print(a, b)  # 4 3
a, b = b, a
print(a, b)  # 3 4

Dažna klaida. Neuždenk integruotų vardų: sum = 0 ar list = [] vėliau trukdys iškviesti sum(...) ir list(...).

Aritmetika ir vienetai

Paieška: operatoriai operators aritmetika laipsnis šaknis saknis dalyba liekana modulo floor division precedence

+ sudeda, - atima, * daugina, / dalija, // apvalina dalmenį žemyn, % grąžina liekaną, ** kelia laipsniu. Tvarka: skliaustai, laipsniai, daugyba ir dalyba, sudėtis ir atimtis. Kvadratinė šaknis: x ** 0.5. Mokslinis užrašas 1e-3 reiškia 0.001. Vienetų Python netikrina: s → min dalijame iš 60; m/s → km/h dauginame iš 3.6; dalį į procentus dauginame iš 100. Santykinis skirtumas neturi sekundžių vieneto.

print(7 + 3 * 2, (7 + 3) * 2)  # 13 20
print(7 / 2, 7 // 2, 7 % 2)  # 3.5 3 1
print(-7 // 2)  # -4, ne -3
print(16 ** 0.5, 27 ** (1/3))  # 4.0 3.0

Dažna klaida. ^ nėra kėlimas laipsniu. (2*h/g)**0.5 ir 2*h/g**0.5 yra skirtingos formulės.

Tipai ir konvertavimas

Paieška: type int float str bool None integer string conversion konvertavimas tipas kablelis

int – sveikasis skaičius, float – baigtinio tikslumo realusis skaičius, str – tekstas, bool – True arba False, None – rezultato nebuvimą žymintis objektas. int("7") veikia; int("7.5") sukelia ValueError. int(7.9) nukerta trupmeninę dalį link nulio. float priima dešimtainį tašką. Sąrašas list ir žodynas dict yra keičiami, tekstas str ir kortežas tuple – nekeičiami.

print(type(7), type(7.0), type("7"))
print(int("7"), float("7.5"), str(12))
print("7" * 2, 7 * 2)  # 77 14
print(float("7,5".replace(",", ".")))  # 7.5

Dažna klaida. "laikas: " + 7 sukelia TypeError. Naudok f-eilutę, str(7) arba print su kableliais.

Įvestis ir išvestis

Paieška: input print sep end įvestis ivestis isvestis output klaviatura

input() visada grąžina tekstą be galutinio Enter simbolio. Skaičiavimams konvertuok į int arba float. print(a, b) dalis atskiria tarpu ir pabaigoje prideda naują eilutę; sep keičia skirtuką, end – pabaigą. Colab kodo langelį vykdo Shift+Enter. Paleisk langelius iš eilės; patikrai naudinga paleisti viską iš naujos sesijos.

x = float(input("Skaičius: ").replace(",", "."))
print("Dvigubai:", 2 * x)
print("a", "b", sep=";", end="!\n")  # a;b!

Dažna klaida. print("x = 5") visada rodo tą patį tekstą. Kintamojo vertę rodo print(f"x = {x}").

Float tikslumas

Paieška: float tolerancija tolerance abs isclose apvalinimas round lygybe tikslumas

Dalis dešimtainių trupmenų dvejetaine forma netelpa tiksliai. Todėl 0.1 + 0.2 == 0.3 yra False. Apytikslius skaičiavimų rezultatus lygink su tolerancija: abs(a-b) <= eps. Tolerancija priklauso nuo uždavinio ir vienetų. round(x, n) grąžina skaičių, o f-eilutė su .nf – tekstą. Python round lygiųjų atveju taiko apvalinimą į artimiausią lyginį, tačiau float atvaizdavimas taip pat gali paveikti rezultatą.

a, b = 0.1 + 0.2, 0.3
print(a == b)  # False
print(abs(a - b) <= 1e-9)  # True
print(round(2.5), round(3.5))  # 2 4

Dažna klaida. Tolerancijos negalima mažinti be galo: iteracija gali nebeartėti dėl float tikslumo. Pridėk iteracijų ribą.

Indeksai ir pjūviai

Paieška: index slicing indeksavimas karpymas pjuvis pjūvis len reverse atbulai

Pirmas sekos indeksas 0, paskutinis -1. s[a:b:k] ima nuo a imtinai iki b neimtinai, žingsniu k. Praleista pradžia ar pabaiga parenkama pagal žingsnio kryptį. [::-1] apverčia seką; [::2] ima kas antrą. Vienas neegzistuojantis indeksas sukelia IndexError; per platus pjūvis saugiai apkarpomas. Žingsnis 0 negalimas.

s = "spektras"
print(s[0], s[-1], len(s))  # s s 8
print(s[2:6], s[:4], s[4:])  # ektr spek tras
print(s[::2], s[::-1], s[1:7:3])  # seta sartkeps pt
print(s[99:])  # tuščias tekstas

Dažna klaida. Narių n turinčios sekos paskutinis teigiamas indeksas yra n-1, ne n.

Teksto metodai

Paieška: string tekstas split strip replace upper lower join startswith find index isalpha

strip() pašalina tarpus ir eilučių pabaigas tik iš kraštų. split() skaido per bet kokius tarpinius tarpus ir praleidžia jų kartojimą; split(",") skaido būtent per kablelį ir gali palikti tuščias dalis. replace(a,b), upper(), lower() grąžina naują tekstą. skirtukas.join(tekstu_sarasas) sujungia tekstus. startswith tikrina pradžią; find grąžina -1, jei nerado; index tokiu atveju sukelia ValueError. isalpha atskiria raides nuo skyrybos.

s = "  2.05   1.98\n"
print(s.split())  # ['2.05', '1.98']
print("a,,b".split(","))  # ['a', '', 'b']
print("-".join(["a", "b"]))  # a-b
s = s.strip().replace("2.05", "2.00")
print(s)

Dažna klaida. s.upper() nepersieja s. Jei reikia išsaugoti rezultatą, rašyk s = s.upper(). Teksto simbolio priskyrimu s[0] pakeisti negalima.

F-eilutės ir formatavimas

Paieška: f-string fstring format f eilutes .2f .3e .4g procentai plotis reiksminiai skaitmenys

f"{x:.2f}" – dvi vietos po taško; f"{x:8.3f}" – bent 8 simbolių plotis, trys vietos po taško; .3e – mokslinis užrašas su trimis vietomis po taško; .4g – keturi reikšminiai skaitmenys; .1% – dalis paverčiama procentais. Formatuotas rezultatas yra tekstas. Dvigubi {{ ir }} išveda riestinius skliaustus.

t, paklaida = 2.0467, 0.0321
print(f"T = {t:.2f} ± {paklaida:.2f} s")  # T = 2.05 ± 0.03 s
print(f"{299792458:.3e}")  # 2.998e+08
print(f"{0.1819:.2%}")  # 18.19%
print(f"{3.5:8.3f}")

Dažna klaida. round(x, 3) neužtikrina trijų matomų vietų. .3f užtikrina ir galinius nulius.

Sąrašai ir operacijos

Paieška: list sarasas sąrašas append extend insert pop remove sort sorted reverse count index sum min max

Sąrašas saugo tvarkingą narių seką. append(x) prideda vieną narį, extend(kita_seka) – visus jos narius, insert(i,x) įterpia, pop(i) pašalina ir grąžina narį pagal indeksą (be argumento – paskutinį), remove(x) pašalina pirmą tokią vertę. count(x) suskaičiuoja pasikartojimus; index(x) randa pirmą indeksą. sort() ir reverse() keičia vietoje ir grąžina None; sorted() grąžina naują sąrašą. sum, min, max, len yra atskiros funkcijos.

m = [3, 1, 2]
m.append(4)
print(sorted(m))  # [1, 2, 3, 4]
print(m)  # [3, 1, 2, 4]
paskutinis = m.pop()
m.sort()
print(m, paskutinis)  # [1, 2, 3] 4

Dažna klaida. m = m.sort() paverčia m į None. sum([]) yra 0, bet min([]) ir max([]) sukelia ValueError; vidurkiui būtina patikrinti tuštumą.

Nuorodos ir kopijos

Paieška: alias reference copy shallow deepcopy kopija nuoroda mutable immutable tuple kortezas rinkinys

Visi Python vardai susiejami su objektais. b = a nekuria naujo objekto. Kai objektas yra keičiamas sąrašas, a.append(...) matosi ir per b. a.copy() arba a[:] sukuria seklią išorinio sąrašo kopiją; vidiniai sąrašai lieka bendri. Tuple – nekeičiamas kortežas: (1,2), vieno nario – (1,). Jo viduje gali būti keičiamų objektų. Tuple nėra set; set saugo unikalias vertes ir čia nėra pagrindinė tema.

a = [1, 2]
b = a
c = a.copy()
a.append(3)
print(b, c)  # [1, 2, 3] [1, 2]
lentele = [[1, 2], [3, 4]]
kopija = lentele.copy()
lentele[0][0] = 99
print(kopija)  # [[99, 2], [3, 4]]

Dažna klaida. Funkcijos parametras taip pat gali rodyti tą patį sąrašą. append funkcijos viduje pakeis perduotą objektą; paprastas vietinio vardo perpriskyrimas – ne.

Sąlygos ir loginės vertės

Paieška: if elif else bool True False and or not in is None salyga palyginimas

== tikrina lygybę, != nelygybę, < <= > >= tvarką. and reikalauja abiejų, or bent vienos, not apverčia loginę vertę. Pirmumas: palyginimai → not → and → or; skliaustai padaro ketinimą aiškų. and ir or trumpina vertinimą: antros dalies gali nevykdyti. if/elif/else vykdo tik pirmą teisingą šaką; atskiri if gali įvykdyti kelias. 0, tuščios sekos ir None yra klaidingos loginėje sąlygoje. is None tikrina rezultato nebuvimą.

x = 0
if x == 0:
    print("nulis")
elif x > 0:
    print("teigiamas")
else:
    print("neigiamas")
m = []
if m and max(m) > 5:
    print("yra didelis")  # max([]) nebus vykdomas

Dažna klaida. if x == 1 or 2 visada teisinga, nes 2 yra truthy. Rašyk x == 1 or x == 2 arba x in [1, 2]. else neturi papildomos sąlygos.

For ir range

Paieška: for range len enumerate zip ciklas iteracija skaitliukas kaupiklis off-by-one

for x in seka eina per narius. range(n) duoda 0…n-1; range(a,b,k) neįtraukia b, o k negali būti 0. range(len(m)) patogu, kai reikia indekso. enumerate(m, start=1) pateikia numerį ir vertę. zip(a,b) suporuoja lygiagrečius sąrašus ir sustoja ties trumpesniu. Kaupiklį ir rezultatų sąrašą paruošk prieš ciklą, pildyk viduje, rezultatą rodyk po ciklo. For gali iteruoti ir per failą, ne tik iš anksto žinomą sąrašą.

suma = 0
for x in [2, 4, 6]:
    suma += x
print(suma)  # 12
print(list(range(2, 7, 2)))  # [2, 4, 6]
for nr, x in enumerate([10, 20], start=1):
    print(nr, x)

Dažna klaida. Po netuščio ciklo kintamasis lieka su paskutine verte. Po tuščio ciklo jis gali būti visai neapibrėžtas. Iteruodamas nešalink narių iš to paties sąrašo: kurk naują.

While, break ir continue

Paieška: while break continue infinite loop amzinas begalinis ciklas iteraciju riba sustojimas

while tikrina sąlygą prieš kiekvieną praėjimą ir gali neįvykdyti nė vieno. Reikia pradinės būsenos, sąlygos, veiksmų ir būsenos atnaujinimo. break iškart baigia artimiausią ciklą; continue praleidžia likusius šio praėjimo veiksmus. while True dažniausiai baigiamas pasiekiamu break. Skaitiniam artėjimui pridėk iteracijų ribą ir patikrink, ar gautas pakankamai tikslus rezultatas. Užstrigusį vietinį procesą stabdo Ctrl+C.

i = 0
while i < 5:
    i += 1  # prieš continue!
    if i == 3:
        continue
    print(i)  # 1, 2, 4, 5 atskirose eilutėse

Dažna klaida. n = 10; while n != 0: n -= 3 nulio nepasieks. Jei i atnaujinamas po continue, ciklas gali užstrigti.

Žodynai ir skaitliukai

Paieška: dict dictionary zodynas žodynas key value keys values items get del clear zip

Žodynas saugo unikalių raktų ir verčių poras. d[k] nuskaito; d[k] = v prideda arba pakeičia; del d[k] ištrina. k in d tikrina raktus, ne vertes. d.get(k, numatyta) grąžina numatytą reikšmę, jei rakto nėra. for k in d eina per raktus; items() duoda poras, values() – vertes. Python žodynai išlaiko įterpimo tvarką. Raktas turi būti hashable: sąrašas netinka; tuple tinka tik kai visi jo nariai hashable. Vertės gali būti bet kokie objektai.

kiek = {}
for rusis in ["Fe", "Ca", "Fe"]:
    if rusis in kiek:
        kiek[rusis] += 1
    else:
        kiek[rusis] = 1
for raktas, verte in kiek.items():
    print(raktas, verte)
print(kiek.get("Au", 0))  # 0

Dažna klaida. "Fe" ir "fe" yra skirtingi raktai. d[k] neegzistuojančiam raktui sukelia KeyError. dict(zip(...)) pasikartojančius raktus perrašo.

Vidurkis, mediana ir sigma

Paieška: mean median std sigma standartinis nuokrypis vidurkis mediana dispersija N N-1

Vidurkis = suma / N. Mediana – surikiuotos sekos vidurys: nelyginiam N imk m[N//2], lyginiam – (m[N//2-1]+m[N//2])/2. Šio kurso σ = sqrt(sum((x-vid)**2)/N). Tai populiacijos standartinis nuokrypis; imties įvertyje naudojamas N-1. Sigma nėra vidurkio neapibrėžtis. Neįmanomas vertes pašalink prieš skaičiuodamas statistiką; išskirtis gali išpūsti ir vidurkį, ir sigma.

m = [1, 2, 3]
vid = sum(m) / len(m)
suma_kv = 0
for x in m:
    suma_kv += (x - vid) ** 2
sigma = (suma_kv / len(m)) ** 0.5
print(f"{vid:.3f} {sigma:.3f}")  # 2.000 0.816

Dažna klaida. Nekeisk N į N-1 automatiškai: vykdyk užduoties formulę. Tuščio sąrašo statistika neapibrėžta; vienam nariui ši σ lygi 0.

Filtravimas ir išskirtys

Paieška: filter outlier good impossible filtravimas isvalymas 3 sigma nuokrypis abs

Pirmiausia atskirk fiziškai neįmanomas reikšmes (pavyzdžiui, kritimo laiką <=0). Tada skaičiuok vidurkį ir σ iš galiojančių duomenų. Išskirtis šiame pratime: abs(x-vid) > 3*sigma. Tinkami duomenys: <=. Naują sąrašą pildyk append, o ne remove vykstant iteracijai. Po valymo statistiką skaičiuok iš naujo. Trijų sigmų taisyklė yra mokomasis kriterijus su prielaidomis; ji negarantuoja, kad visi blogi duomenys aptikti.

m = [1.9, 2.0, 2.1, 0.0]
svarus = []
atmesta = 0
for x in m:
    if x <= 0:
        atmesta += 1
    else:
        svarus.append(x)
print(svarus, atmesta)

Dažna klaida. Jei pirma tikrinsi outlier, nulis gali patekti į tą šaką ir nebebus suskaičiuotas kaip impossible. Šakų tvarka keičia klasifikaciją.

Failų skaitymas ir keliai

Paieška: file open with read readline readlines close encoding utf-8 FileNotFoundError header antraste kelias

with open(vardas, "r", encoding="utf-8") as f atidaro tekstą ir uždaro failą išeinant iš bloko. for eilute in f skaito po eilutę, read() – likusį tekstą, readline() – kitą vieną eilutę, readlines() – likusių eilučių sąrašą. Skaitymas stumia failo poziciją. Santykinis kelias skaičiuojamas nuo dabartinio darbo aplanko, kuris nebūtinai sutampa su .py vieta. Windows keliuose patogu / arba raw tekstas r"aplankas\failas.txt". Įkeltus Colab failus reikia išsaugoti prieš pasibaigiant sesijai.

with open("matavimai.txt", "r", encoding="utf-8") as f:
    antraste = f.readline()
    for eilute in f:
        tekstas = eilute.strip()
        if not tekstas or tekstas.startswith("#"):
            continue
        print(tekstas)

Dažna klaida. readline() visada praleidžia tik vieną eilutę. Jei yra dvi antraštės, reikia dviejų iškvietimų arba readlines()[2:]. print(eilute) gali pridėti antrą naujos eilutės simbolį.

Stulpeliai, CSV ir blogos eilutės

Paieška: CSV split separator stulpelis stulpeliai header ValueError IndexError try except continue

Prieš nuskaitydamas nustatyk antraščių skaičių, skirtuką, stulpelių indeksus ir vienetus. Septintas stulpelis turi indeksą 6. Tuščias eilutes ir komentarus praleisk. Pirma patikrink stulpelių kiekį, tada konvertuok VISAS reikiamas vertes, tik tada papildyk lygiagrečius sąrašus. Taip bloga eilutė jų ilgių neišderins. Paprastam CSV tinka split(","); jei laukai turi kablelius kabutėse, reikia csv modulio. Kabliataškiu atskirtam failui split(";") ir tik skaitiniame lauke replace(",", ".").

eilute = "10,22;8,55"
dalys = eilute.split(";")
t = float(dalys[0].replace(",", "."))
a = float(dalys[1].replace(",", "."))
print(t, a)  # 10.22 8.55

Dažna klaida. **** nėra skaičius. Vien except ValueError nepagaus per trumpos eilutės IndexError. Tūkstančių skirtuko "1,500" nereikia aklai versti į "1.500".

Failų rašymas

Paieška: write writelines w a r append output failo rasymas nauja eilute newline

"r" skaito esamą failą; "w" sukuria arba iškart ištuština esamą; "a" papildo galą arba sukuria failą. write() priima str ir neprideda \n. Iš readlines gautos eilutės dažniausiai jau turi \n – jo nedvigubink. Antraštę rašyk vieną kartą prieš ciklą. write grąžina įrašytų simbolių skaičių, ne naują failo objektą.

with open("rezultatai.txt", "w", encoding="utf-8") as f:
    f.write("# indeksas verte\n")
    for i, x in enumerate([2.05, 1.98], start=1):
        f.write(f"{i} {x:.3f}\n")
with open("rezultatai.txt", "a", encoding="utf-8") as f:
    f.write("# baigta\n")

Dažna klaida. with open(..., "w") ciklo viduje vis perrašo failą. Atidaryk prieš ciklą. Naudok tą patį vardo kintamąjį, kurį gavai iš input.

Klaidų žodynas ir try/except

Paieška: SyntaxError IndentationError NameError TypeError ValueError IndexError KeyError ZeroDivisionError traceback runtime logic try except raise

Sintaksės klaida: kodas negali būti išanalizuotas (SyntaxError, IndentationError). Vykdymo klaida: NameError – nėra vardo, TypeError – netinkamas tipas, ValueError – netinkama vertė, IndexError – indeksas už ribų, KeyError – nėra rakto, ZeroDivisionError – dalyba iš nulio, FileNotFoundError – nėra failo. Loginė klaida gali nesukelti jokios išimties. Traceback skaityk nuo apačios: klaidos tipas ir priežastis, tada eilutė ir iškvietimų kelias. try vykdo rizikingą bloką, atitinkamas except apdoroja klaidą. raise leidžia ją aiškiai sukelti.

try:
    a = float(input("a: "))
    b = float(input("b: "))
    print(a / b)
except ValueError:
    print("Įvesk skaičius")
except ZeroDivisionError:
    print("Dalyba iš nulio negalima")

Dažna klaida. Plikas except gali paslėpti programavimo klaidas. Gaudyk konkrečią išimtį ir pranešk, kas praleista. Sintaksės klaidos tame pačiame faile paprastas try neišgelbės.

Funkcijos, parametrai ir return

Paieška: def function funkcija parametras argumentas return print None docstring help default keyword positional

def sukuria funkciją; jos kūnas vykdomas tik iškvietus vardas(...). Parametrai yra vardai apraše, argumentai – perduotos reikšmės. Privalomi parametrai rašomi prieš turinčius numatytąsias vertes. Argumentus galima perduoti pagal vietą arba vardą. Docstring aprašo paskirtį ir vienetus; help(f) parodo aprašą. return grąžina reikšmę ir iškart baigia iškvietimą. Be return arba su return be išraiškos grąžinama None. return a,b grąžina tuple; jį gali išpakuoti į du vardus.

def atstumas(t, g=9.81):
    """Kritimo atstumas metrais; t sekundėmis."""
    return g * t**2 / 2

s = atstumas(g=10, t=2)
print(s)  # 20.0

Dažna klaida. print rezultato neišsaugo kaip funkcijos grąžinamos vertės. f ir f() skiriasi: pirmas yra funkcijos objektas, antras ją iškviečia.

Vietiniai vardai ir funkcijų derinimas

Paieška: scope local global vietinis mutable parametras early return is None funkciju kompozicija

Funkcijos parametrai ir joje priskirti vardai yra vietiniai. Išorinis x ir vietinis x gali turėti tą patį vardą ir skirtingas reikšmes. Duomenis perduok parametrais, rezultatus grąžink per return. Perduotas sąrašas lieka bendras objektas: jo keitimas vietoje matomas išorėje. Ankstyvas return ciklo viduje tinka pirmo atitikmens paieškai, bet nutrauktų viso sąrašo sumavimą. Patikrink tuščią įvestį ir nerastą rezultatą prieš jį formatuodamas.

def kvadratu(x):
    x = x ** 2
    return x

x = 9
z = kvadratu(x)
print(x, z)  # 9 81

def papildyk(m):
    m.append(3)

a = [1, 2]
papildyk(a)
print(a)  # [1, 2, 3]

Dažna klaida. Numatytojo parametro [] venk: tas pats sąrašas naudojamas per kelis iškvietimus. Naudok None ir sukurk naują sąrašą kūne.

Pirmas grafikas

Paieška: plot matplotlib pyplot plt xlabel ylabel legend savefig show grafikas

Papildomas pakartojimas: penktos–septintos temų grafiko receptas. x ir y sąrašai turi atitikti vienas kitą. "o-" rodo taškus ir liniją; label suteikia kreivės vardą, legend jį parodo. Ašių pavadinimuose nurodyk vienetus. savefig vykdyk prieš show. Tai nėra išplėstinė grafikų analizė.

import matplotlib.pyplot as plt
t = [0, 1, 2]
h = [2.0, 1.6, 1.28]
plt.plot(t, h, "o-", label="aukštis")
plt.xlabel("Laikas, s")
plt.ylabel("Aukštis, m")
plt.legend()
plt.savefig("grafikas.png")
plt.show()

Dažna klaida. savefig po show kai kuriose aplinkose išsaugo tuščią paveikslą. matplotlib nėra standartinės bibliotekos dalis.

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į.