Pitonas - Naudotojo indėlis [lt]

Vadovėlis/Duomenų tyryba ir informacija

2023-07-27T11:21:29Z

Monika: /* Viešai prieinami duomenys */

{{navigation |previous=Pažangios funkcijos|next=Pabaiga}}
==Dirbtinis intelektas==

Dirbtinis intelektas (sutrumpintai DI) - tai tam tikros rūšies kompiuterio programa, galinti atlikti užduotis, kurioms paprastai reikia žmogaus intelekto, pavyzdžiui, mokytis, spręsti problemas ir priimti sprendimus. Šios programos skirtos analizuoti duomenis, atpažinti modelius ir daryti prognozes remiantis gauta informacija.

Vienas tau pažįstamų dirbtinio intelekto pavyzdžių yra "Siri" arba "Alexa" - balso asistentai, kurie gali suprasti tavo komandas ir atsakyti į tavo klausimus. Kitas pavyzdys - savaeigiai automobiliai, kurie, naudodami jutiklius ir algoritmus, orientuojasi keliuose ir išvengia kliūčių.

Dirbtinis intelektas yra sparčiai auganti sritis, kuri keičia daugelį mūsų gyvenimo aspektų - nuo sveikatos priežiūros ir švietimo iki finansų ir transporto. Būdamas vidurinės mokyklos moksleivis gali susidurti su įvairiais AI pavidalais, todėl mokymasis apie jį gali padėti suprasti mūsų pasaulį formuojančią technologiją.

Nors dirbtinis intelektas gali būti labai naudingas, yra ir tam tikrų su šia technologija susijusių pavojų ir rizikos.

Vienas iš didžiausių su dirbtiniu intelektu susijusių rūpesčių - galimybė, kad jis gali pakeisti žmonių darbo vietas. Tobulėjant dirbtiniam intelektui, jis gali atlikti daug užduočių, kurias anksčiau atlikdavo žmonės, o tai gali lemti darbo vietų perkėlimą ir potencialiai didelį nedarbo lygį.
[[Vaizdas:AI padeda zmonems su kasdieniais darbais.png|miniatiūra|332x332px|AI padeda su kasdieniais darbais]]

Kitas su dirbtiniu intelektu susijęs pavojus - galimybė jį panaudoti piktavališkais tikslais, pavyzdžiui, kibernetinėms atakoms arba autonominių ginklų kūrimui. Taip pat kyla pavojus, kad dirbtinio intelekto sistemos gali priimti neobjektyvius ar diskriminacinius sprendimus, jei jos bus apmokytos pagal neobjektyvius duomenis.

Kitas susirūpinimą keliantis dalykas - galimybė, kad dirbtinis intelektas taps pernelyg galingas ir priims žmonėms žalingus sprendimus. Pavyzdžiui, jei dirbtinio intelekto sistemai būtų perduota valdyti ypatingos svarbos infrastruktūrą, pavyzdžiui, elektros tinklus ar transporto sistemas, dėl gedimo ar įsilaužimo galėtų būti padaryta didelė žala žmonėms ir aplinkai.

Galiausiai kyla pavojus, kad dirbtinis intelektas gali būti naudojamas dezinformacijai skleisti arba viešajai nuomonei manipuliuoti, o tai gali turėti rimtų pasekmių demokratijai ir socialiniam stabilumui.

Siekiant pašalinti šią riziką, svarbu, kad būtų sukurta etiška ir atsakinga praktika, susijusi su dirbtinio intelekto kūrimu ir naudojimu, įskaitant reglamentavimą, skaidrumą ir atskaitomybę.

==Kriptografinės sistemos==

Kriptografija - tai informacijos apsaugos praktika, kai informacija paverčiama į neįskaitomą formatą, vadinamą šifruotuoju tekstu, kad ją perskaityti galėtų tik tie, kurie turi raktą, leidžiantį ją iššifruoti atgal į pradinę formą. Kriptografijos sistemos naudojamos daugelyje programų, siekiant užtikrinti saugų ryšį ir apsaugoti slaptą informaciją. 

Yra keletas kriptografijos sistemų tipų, tačiau čia pateikiamos kelios dažniausiai pasitaikančios, su kuriomis galite susidurti:

* '''Simetrinio rakto kriptografija''': Šio tipo kriptografijoje vienas slaptas raktas naudojamas ir šifruojant, ir iššifruojant pranešimą. Kad būtų užtikrintas saugus ryšys, komunikuojančios šalys raktą turi laikyti paslaptyje. Vienas iš paprastesnių simetrinio kodavimo pavyzdžių - "Atbash" kodavimas, kurio esmė yra pakeisti abėcėlės raides vietomis, t.y. pirmoji raidė tampa paskutine, antroji - priešpaskutine, ir taip toliau. Pvz., žinutė "LABAS" užšifruota "OZYZH". Atkoduojant, tiesiog reikia pakeisti raidžių vietomis atgal, ir gautume pradinę žinutę "LABAS".

* '''Asimetrinio rakto kriptografija''': Šis kriptografijos tipas taip pat žinomas kaip viešojo rakto kriptografija, kai pranešimams šifruoti ir dešifruoti naudojama raktų pora - viešasis ir privatusis raktas. Viešuoju raktu galima dalytis viešai, o privatusis raktas turi būti laikomas paslaptyje. Ši sistema dažniausiai naudojama saugioms internetinėms operacijoms, tokioms kaip internetinė bankininkystė ir apsipirkimas. Pavyzdžiui, norint užšifruoti pranešimą "LABAS", reikia naudoti gavėjo viešąjį raktą, kuris gali būti naudojamas tik užšifruoti pranešimus, bet ne dekoduoti juos atgal į pradinę formą. Atkoduojant, naudojamas privatus raktas. Asimetrinis kodavimas yra sudėtingas procesas, reikalaujantis specialių žinių ir įrangos.

* '''''Hash'' šifravimo funkcijos''': Tai matematinės funkcijos, kurios priima pranešimą ir sukuria fiksuoto dydžio simbolių eilutę, vadinamą šifravimo reikšmė (hash value). Šifravimo funkcijos dažniausiai naudojamos pranešimo vientisumui patikrinti, nes bet koks pradinio pranešimo pakeitimas lemia kitokią šifravimo reikšmę.

* '''Skaitmeniniai parašai''': Tai elektroniniai parašai, naudojami siuntėjo tapatybei patvirtinti ir pranešimo vientisumui užtikrinti. Skaitmeniniai parašai naudoja viešojo rakto kriptografiją, kad būtų sukurtas unikalus skaitmeninis parašas, kurį gavėjas gali patikrinti naudodamas siuntėjo viešąjį raktą.

Kriptografija yra įdomi ir svarbi sritis, kuri naudojama daugelyje sričių, siekiant užtikrinti saugų bendravimą ir apsaugoti slaptą informaciją. Tikiuosi, kad tai leido tau gerai apžvelgti skirtingus kriptografijos sistemų tipus!

==Viešai prieinami duomenys==

Viešai prieinami duomenys yra informacija, kurią galima lengvai rasti ir naudoti be jokių apribojimų ar mokesčio. Tai yra duomenys, kurie yra viešai prieinami internete arba kitose viešose duomenų bazėse, valdžios institucijų tinklalapiuose ir kituose lengvai pasiekiamuose šaltiniuose. Pavyzdžiui, tai gali būti statistiniai duomenys apie gyventojų skaičių, mokyklų rezultatus, oro temperatūrą, populiarią muziką ir t.t.

Automatizuotai renkami duomenys yra informacija, kuri yra surinkta naudojant kompiuterines programas ar įrankius, kad būtų galima greitai ir efektyviai gauti didelius duomenų kiekius. Tai gali būti padaryta naudojant specialias kompiuterines programas, kurios lanko internetinius tinklalapius ir išgrynina duomenis, arba pasitelkus API (programavimo sąsajas), kurios leidžia gauti tam tikrus duomenis iš kitų interneto platformų ar paslaugų.

Pavyzdžiui, jei norėtum sužinoti, kiek daugiausiai balų buvo gauta egzaminuojantis matematiką pastaraisiais metais, galėtum tai padaryti naudodamas viešai prieinamus statistinius duomenis, pateiktus švietimo ministerijos tinklalapyje. Tačiau, jei norėtum surinkti duomenis apie populiariausius dainų atlikėjus iš skirtingų interneto tinklalapių, tai gali būti atlikta naudojant automatizuotą duomenų surinkimo įrankį ar programą.

Viešai prieinami ir automatizuotai renkami duomenys yra naudingi moksliniams tyrimams, rašant mokyklos projektus ar atliekant statistines analizes. Svarbu prisiminti, kad naudojant duomenis, visada reikia atsižvelgti į duomenų šaltinio patikimumą ir pateikti tinkamas šaltinio nuorodas ar citatas, kad būtų galima patikrinti duomenų teisingumą ir atsekamumą.

{{navigation |previous=Pažangios funkcijos|next=Pabaiga}}
[[Category:Python Vadovėlis]]

Vadovėlis/Testavimas

2023-06-30T12:50:53Z

Monika: Naujas puslapis: === Testavimas === Programų testavimas – tai dar vienas svarbus programavimo žingsnis. Ankstesniame skyriuje apie derinimą kalbėjome kaip ieškoti klaidų, kai programa neveikia taip, kaip turėtų. Šiame skyriuje pakalbėsime apie testavimą arba, kaip įvertinti, ar programa veikia tinkamai, ar ne. === Unit testai === Nors egzistuoja įvairių testų kategorijų, unit testai yra viena dažniausiai naudojamų tarp programuotojų. Unit – išvertus iš anglų ka...

=== Testavimas ===

Programų testavimas – tai dar vienas svarbus programavimo žingsnis. Ankstesniame skyriuje apie derinimą kalbėjome kaip ieškoti klaidų, kai programa neveikia taip, kaip turėtų. Šiame skyriuje pakalbėsime apie testavimą arba, kaip įvertinti, ar programa veikia tinkamai, ar ne.

=== Unit testai ===

Nors egzistuoja įvairių testų kategorijų, unit testai yra viena dažniausiai naudojamų tarp programuotojų. Unit – išvertus iš anglų kalbos – tai vienetas. Unit testai – tai tokie testai, kurių metu izoliuotai yra tikrinamos individualios programos dalys (funkcijos, metodai, klasės). Tad pagrindinis unit testų tikslas – patikrinti, kad kiekvienas individualus komponentas veikia taip, kaip turėtų.

Unit testų rašymas dažnai yra pirmasis žingsnis programų testavimo procese. Tai užtikrina kodo kokybę ir leidžia atrasti klaidas kodui dar nepasiekus galutinių vartotojų.

Programuojant unit testus galima rinktis skirtingas strategijas. Testams naudojant įprastus duomenis galima patikrinti dažniausiai pasitaikančius scenarijus ir įsitikinti, kad individualios programos dalys veikia tinkamai. Kita vertus, testams galima naudoti ir ekstremalius duomenis. Tai reiškia, kad intensyviai tikriname visus galimus komponento limitus norėdami apsisaugoti nuo bet kokių įmanomų netikėtumų.

Geriausia testavimo strategija – naudoti abu testavimo metodus kartu. Patikrinti tiek programos veikimą su įprastais duomenimis, kurių tikimės, tiek su įvairiausiais ekstremaliais scenarijais. Tokiu atveju galime jaustis saugesni, kad programa veiks tinkamai. Be to, pakeitus tam tikrus programos aspektus, galima daug greičiau patikrinti, ar tai nepakenkė jau anksčiau egzistavusiam funkcionalumui.

Šiame vadovėlyje nesimokysime, kaip rašyti unit testus. Tačiau manau, kad jau dabar svarbu žinoti apie jų reikšmę ir svarbą programuotojo kelyje.

Vadovėlis/Paieška ir Rikiavimas

2023-06-28T13:08:29Z

Monika: /* Suliejimo rikiavimas (Merge sort) */

Atlikęs praeito skyriaus uždavinius, jau daug žinai apie sąrašo sukūrimą ir visus bazinius sąrašo metodus. Dabar pasinaudosime įgytomis žiniomis ir susipažinsime su labai dažnai sutinkamais uždaviniais: paieška ir rikiavimas.

= Paieška =

Paieškos algoritmai naudojami norint rasti konkretų elementą sąraše ar duomenų masyve. Yra keletas paieškos algoritmų, tačiau parodysiu du dažniausiai naudojamus - tiesinę paiešką ir dvejetainę paiešką.

== Tiesinė paieška ==
Tiesinė paieška - tai paprastas paieškos algoritmas, kuris, ieškodamas tikslinės reikšmės, peržiūri kiekvieną sąrašo elementą. Pažiūrėk į tiesinės paieškos funkcijos pavyzdį "Python" kalba:

<syntaxhighlight lang="python">
def tiesinė_paieška(sąrašas, ieškomas_žodis):
for i in range(len(sąrašas)):
if sąrašas[i] == ieškomas_žodis:
return i
return -1 # ieškomas_žodis nerastas
</syntaxhighlight>

Ši funkcija priima masyvą <code>sąrašas</code> ir tikslinę reikšmę <code>ieškomas_žodis</code> ir grąžina tikslinės reikšmės indeksą masyve. Jei tikslinė vertė nerandama masyve, funkcija grąžina -1. Labai praprasta ir aišku.

== Dvejetainė paieška ==
Kita vertus, dvejetainė paieška yra efektyvesnis paieškos algoritmas, kuris veikia tik surikiuotose masyvuose (sąrašuose). Jis veikia pakartotinai dalydamas paieškos intervalą per pusę, kol randama tikslinė reikšmė. Painu? Daug aiškiau bus pažiūrėjus šį pavyzdį:

<syntaxhighlight lang="python">
def dvejetainė_paieška(sąrašas, tikslas):
# išsisaugome sąrašo pirmą ir paskutinį indeksą
apačia = 0
viršus = len(sąrašas) - 1

while apačia <= viršus:
# atrandame vidurį pagal formulę: (pradžios indeksas + pabaigos indeksas) padalintas per pusę, be liekanos
viduriukas = (apačia + viršus) // 2
# patikriname, ar `viduriukas` indekse yra mūsų ieškomas tikslas, ir jį atradus grąžiname indeksą.
if sąrašas[viduriukas] == tikslas:
return viduriukas
# jeigu ne, tai pagal tai, kurioje pusėje yra ieškomas elementas pakeičiame viršutinį arba apatinį indeksą
elif sąrašas[viduriukas] < tikslas:
apačia = viduriukas + 1
else:
viršus = viduriukas - 1
# ir kartojame iš naujo, bet jau su nauju, per pus mažesniu rėžiu

return -1 # tikslas nerastas

sąrašas = [1,2,3,4,5,6,7,8,9,10]
print(dvejetainė_paieška(sąrašas, 7)) # 6
</syntaxhighlight>

Panagrinėkim detaliai, kaip vyksta procesas. Ieškome, kur yra skaičius 7, sąraše [1,2,3,4,5,6,7,8,9,10]. Funkcijos pradžios kintamieji:
<syntaxhighlight lang="python">
apačia = 0
viršus = 9 # (ilgis 10 - 1 )
</syntaxhighlight>
Pirmas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 4 # (0 + 9) // 2
# sąrašas[4] saugo reikšmę 5. Ne mūsų ieškomas skaičius.
# kadangi tikslas yra surasti 7, tai mūsų kito ciklo metu ieškosime viršutinėje sąrašo dalyje, todėl nusistatome naują apačios reikšmę, viduriukas + 1.
apačia = 5 # (4 + 1)
</syntaxhighlight>
Antras `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 7 # (5 + 9) // 2
# sąrašas[7] saugo reikšmę 8. Jau arčiau, bet ne dar vis ne mūsų ieškoma reikšmė 7. Nustatome šįkartą naują viršutinę reikšmę, viduriukas - 1
viršus = 6 # (7 - 1)
</syntaxhighlight>
Trečias `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 5 # (5 + 6) // 2
# sąrašas[5] saugo reikmę 6. Vėl pro šalį. Nustatome naują apatinę reikšmę:
apačia = 6 # (5 + 1)
</syntaxhighlight>
Ketvirtas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 6 # (6 + 6) // 2
sąrašas[6] saugo reikšmę 7. Valio! Radom. Grąžinam indeksą 7.
</syntaxhighlight>

Atkreipk dėmesį, kad dvejetainės paieškos algoritmas atrado reikšmę per 4 ciklus. Kaip manai, kiek ciklų prireiktų tiesinės paieškos algoritmui? Pasufleruosiu... Daugiau :)

= Rikiavimas =

Rikiavimo algoritmai naudojami duomenų sąrašui išdėstyti tam tikra tvarka. Rikiavimo algoritmų yra daug ir įvairių, bet papasakosiu tik kelis naudingiausius. Pateiktus algoritmus tu gelėsi nesunkiai pritaikyti ir kitokiems duomenų tipams, ne tik žodžiams. Bet apie tai vėliau.

== Įterpimo rikiavimas (Insertion Sort) ==

Įterpimo rikiavimas yra paprastas rikiavimo algoritmas, kuris veikia padalydamas sąrašą į dvi dalis: surikiuotą ir nesurikiuotą. Tada iteratyviai paimamas elementas iš nerikiuotos dalies ir įterpiamas į reikiamą vietą surikiuotoje dalyje, kol visas sąrašas surikiuojamas.
Pažiūrėkim, kaip tai atrodo:

<syntaxhighlight lang="python">
def įterpimo_rikiavimas(sąrašas):
for i in range(1, len(sąrašas)):
raktas = sąrašas[i]
j = i - 1
while j >= 0 and sąrašas[j] > raktas:
sąrašas[j+1] = sąrašas[j]
j -= 1
sąrašas[j+1] = raktas
</syntaxhighlight>

Ši funkcija paima sąrašą <code>sąrašas</code> ir sutikiuoja jį didėjimo tvarka, naudodama įterpimo rikiavimą. Ji pradeda iteruoti per sąrašą nuo antrojo elemento (indeksas 1) iki galo. Kiekvieno elemento reikšmė išsaugoma kaip <code>raktas</code>, o jo indeksas - kaip <code>i</code>, tada einama atgal per surikiuotą sąrašo dalį (nuo indekso <code>i-1</code> iki 0) ir ieškoma tinkamos vietos rakto reikšmei įterpti. Tai daroma lyginant rakto vertę su kiekvienu išrikiuotos sąrašo dalies elementu ir perstumiant didesnius elementus viena pozicija į dešinę, kol randama tinkama pozicija. Suradęs tinkamą poziciją, į ją įterpia rakto reikšmę.

Įterpimo rikiavimo laiko sudėtingumas blogiausiu atveju yra O(n2), o tai reiškia, kad didelių įvesties sąrašų atveju jis gali būti lėtas. Tačiau jis turi mažesnes pridėtines išlaidas nei kai kurie kiti rikiavivmo algoritmai ir gali būti efektyvesnis už juos mažiems įvesties sąrašams arba iš dalies surikiuotiems įvesties sąrašams.

== Burbulinis rikiavimas (Bubble sort) ==
Burbulinis rikiavimas - tai paprastas rikiavimo algoritmas, kuris pakartotinai pereina per sąrašą, palygina gretimus elementus ir sukeičia juos vietomis, jei jų eiliškumas netinkamas. Pažiūrėkime į burbulinio rikiavimo funkcijos pavyzdį:

<syntaxhighlight lang="python">
def burbulinis_rikiavimas(sąrašas):
sąrašo_ilgis = len(sąrašas)

for i in range(sąrašo_ilgis):
for j in range(0, sąrašo_ilgis-i-1):
if sąrašas[j] > sąrašas[j+1]:
sąrašas[j], sąrašas[j+1] = sąrašas[j+1], sąrašas[j]
</syntaxhighlight>
Ši funkcija paima sąrašą <code>sąrašas</code> ir surikiuoja jį didėjančia tvarka, naudodama burbulinį rikiavimą.

== Greitasis rikiavimas (Quicksort) ==
Greitasis rikiavimas yra plačiai naudojamas rikiavimo algoritmas, kuriame taikomas "skaldyk ir valdyk" metodas. Jis veikia iš masyvo (arba sąrašo) išrenkant ašinį elementą ir kitus elementus suskirstant į du papildomus masyvus pagal tai, ar jie mažesni, ar didesni už ašinį elementą. Tada šis procesas rekursiškai kartojamas kiekviename pogrupyje.

Štai greitojo rikiavimo funkcijos pavyzdys "Python" kalba:

<syntaxhighlight lang="python">
def greitasis_rikiavimas(masyvas):
mažiau = []
lygus = []
daugiau = []
if len(masyvas) > 1:
ašis = masyvas[0]
for x in masyvas:
if x < ašis:
mažiau.append(x)
elif x == ašis:
lygus.append(x)
elif x > ašis:
daugiau.append(x)
# neužmiršk grąžinti rezultato!
return greitasis_rikiavimas(mažiau) + lygus + greitasis_rikiavimas(daugiau)
# Atkreipk dėmesį, kad naudojame `lygus`, o ne `ašis`
else:
return masyvas
</syntaxhighlight>

Funkcijos parametras <code>masyvas</code> yra sąrašas, kurį norime surikiuoti.

Pagrindinė funkcijos dalis yra sąlyga <code>if len(masyvas) > 1:</code>, kuri tikrina, ar sąraše yra daugiau nei vienas elementas. Jei sąraše yra tik vienas arba nulis elementų, tai jis jau yra surikiuotas, todėl tiesiog grąžinamas toks pat sąrašas.

Jei sąraše yra daugiau nei vienas elementas, algoritmas tęsiasi. Pirma, parenkamas elementas <code>ašis</code>, šiuo atveju tai yra pirmas sąrašo elementas <code>masyvas[0]</code>. Tuomet algoritmas eina per visus sąrašo elementus ir prideda juos į tris skirtingus sąrašus (<code>mažiau</code>, <code>lygus</code>, <code>daugiau</code>), priklausomai nuo to, kaip jie lyginami su <code>ašis</code>.

* Jei elementas '''x''' yra mažesnis už '''ašis''', jis pridedamas į '''mažiau''' sąrašą.
* Jei elementas '''x''' yra lygus '''ašis''', jis pridedamas į '''lygus''' sąrašą.
* Jei elementas '''x''' yra didesnis už '''ašis''', jis pridedamas į '''daugiau''' sąrašą.

Tai vadinama ''dalijimo procesu''. Po šio proceso turime tris naujus sąrašus: '''mažiau''', '''lygus''' ir '''daugiau''', kurie yra dalinai surikiuoti (mažesni už '''ašis''', lygūs '''ašis''' ir didesni už '''ašis''').

Toliau funkcija naudoja rekursiją ir kviečia save su <code>mažiau</code> ir <code>daugiau</code> sąrašais, taip pritaikydama dalijimo ir surikiavimo procesą šiems dviejams sąrašams atskirai. Rekursyviai kviečiant save, galiausiai bus pasiektas atvejis, kai sąrašai <code>mažiau</code> ir <code>daugiau</code> bus sudaryti iš nulio arba vieno elemento, o tai reiškia, kad jie jau surikiuoti. Tada funkcija grąžina sudėtą sąrašą: <code>greitasis_rikiavimas(mažiau) + lygus + greitasis_rikiavimas(daugiau)</code>, kuris sudarys pilnai surikiuotą sąrašą.

Galutinis rezultatas yra surikiuotas sąrašas, kuris yra grąžinamas iš pradinių sąrašų iškvietimo vietos.

Pvz. jei iškviečiame funkciją <code>greitasis_rikiavimas([3, 1, 4, 1, 5, 9, 2, 6, 5])</code>, tai gražins <code>[1, 1, 2, 3, 4, 5, 5, 6, 9]</code>, kuris yra pradinis sąrašas surikiuotas didėjimo tvarka.

== Suliejimo rikiavimas (Merge sort) ==
Suliejimo rikiavimas - tai rikiavimo algoritmas, kuris veikia pagal dalinimo ir sujungimo principą. Tai efektyvus algoritmas, kuris naudoja rekursiją.

Šis algoritmas veikia taip:
* Jei sąraše yra nulis arba vienas elementas, tai jis jau yra surikiuotas. Grąžinamas tas pats sąrašas.
* Jei sąraše yra daugiau nei vienas elementas, sąrašas yra padalinamas į dvi lygias dalis.
* Kiekviena dalis yra rekursyviai rikiuojama naudojant '''merge sort''' algoritmą.
* Surikiuotos dvi dalys yra sujungiamos į vieną sąrašą. Sujungimo metu elementai yra palyginami ir sudedami į naują sąrašą didėjimo tvarka.

Šis procesas yra pakartojamas tol, kol visi sąrašai yra padalinti iki vieno elemento ir tada sujungti į vieną galutinį surikiuotą sąrašą.

Suliejimo rikiavimo algoritmas yra efektyvus, nes dalijimo ir sujungimo žingsniai yra vykdomi daug kartų, o kiekviename žingsnyje sąrašas yra padalintas į dvi lygias dalis. Tai leidžia efektyviai rikiuoti didelius sąrašus.

<syntaxhighlight lang="python">
def suliejimo_rikiavimas(sąrašas):
# sąraše yra nulis arba vienas elementas
if len(sąrašas) <= 1:
return sąrašas

# Dalinimo žingsnis: padaliname sąrašą į dvi lygias dalis
vidurys = len(sąrašas) // 2
kairė = sąrašas[:vidurys]
dešinė = sąrašas[vidurys:]

# Rekursyviai rikiuojame kiekvieną dalį
kairė = suliejimo_rikiavimas(kairė)
dešinė = suliejimo_rikiavimas(dešinė)

# Sujungimo žingsnis: sujungiame surikiuotas dalis į vieną sąrašą
return suliejimas(kairė, dešinė)

def suliejimas(kairė, dešinė):
rezultatas = []
i = 0 # indeksas kairėje dalyje
j = 0 # indeksas dešinėje dalyje

# Lyginame ir sujungiame elementus
while i < len(kairė) and j < len(dešinė):
if kairė[i] <= dešinė[j]:
rezultatas.append(kairė[i])
i += 1
else:
rezultatas.append(dešinė[j])
j += 1

# Jei viena dalis baigiasi anksčiau, pridedame likusius elementus
while i < len(kairė):
rezultatas.append(kairė[i])
i += 1
while j < len(dešinė):
rezultatas.append(dešinė[j])
j += 1

return rezultatas

# Pavyzdys naudojant suliejimo_rikiavimas funkciją
sąrašas = [3, 1, 4, 1, 5, 9, 2, 6, 5]
surikiuotas_sąrašas = suliejimo_rikiavimas(sąrašas)
print(surikiuotas_sąrašas)
</syntaxhighlight>

Šis pavyzdys naudoja dvi funkcijas: <code>suliejimo_rikiavimas</code> ir <code>suliejimas</code>. <code>suliejimo_rikiavimas</code> funkcija atlieka dalinimo ir rekursyvaus rikiavimo žingsnius, o <code>suliejimas</code> funkcija atlieka surikiuotų dalių sujungimą.

Šio pavyzdžio rezultatas:
[1, 1, 2, 3, 4, 5, 5, 6, 9]

Vadovėlis/Paieška ir Rikiavimas

2023-06-28T13:07:42Z

Monika: /* Greitasis rikiavimas (Quicksort) */

Atlikęs praeito skyriaus uždavinius, jau daug žinai apie sąrašo sukūrimą ir visus bazinius sąrašo metodus. Dabar pasinaudosime įgytomis žiniomis ir susipažinsime su labai dažnai sutinkamais uždaviniais: paieška ir rikiavimas.

= Paieška =

Paieškos algoritmai naudojami norint rasti konkretų elementą sąraše ar duomenų masyve. Yra keletas paieškos algoritmų, tačiau parodysiu du dažniausiai naudojamus - tiesinę paiešką ir dvejetainę paiešką.

== Tiesinė paieška ==
Tiesinė paieška - tai paprastas paieškos algoritmas, kuris, ieškodamas tikslinės reikšmės, peržiūri kiekvieną sąrašo elementą. Pažiūrėk į tiesinės paieškos funkcijos pavyzdį "Python" kalba:

<syntaxhighlight lang="python">
def tiesinė_paieška(sąrašas, ieškomas_žodis):
for i in range(len(sąrašas)):
if sąrašas[i] == ieškomas_žodis:
return i
return -1 # ieškomas_žodis nerastas
</syntaxhighlight>

Ši funkcija priima masyvą <code>sąrašas</code> ir tikslinę reikšmę <code>ieškomas_žodis</code> ir grąžina tikslinės reikšmės indeksą masyve. Jei tikslinė vertė nerandama masyve, funkcija grąžina -1. Labai praprasta ir aišku.

== Dvejetainė paieška ==
Kita vertus, dvejetainė paieška yra efektyvesnis paieškos algoritmas, kuris veikia tik surikiuotose masyvuose (sąrašuose). Jis veikia pakartotinai dalydamas paieškos intervalą per pusę, kol randama tikslinė reikšmė. Painu? Daug aiškiau bus pažiūrėjus šį pavyzdį:

<syntaxhighlight lang="python">
def dvejetainė_paieška(sąrašas, tikslas):
# išsisaugome sąrašo pirmą ir paskutinį indeksą
apačia = 0
viršus = len(sąrašas) - 1

while apačia <= viršus:
# atrandame vidurį pagal formulę: (pradžios indeksas + pabaigos indeksas) padalintas per pusę, be liekanos
viduriukas = (apačia + viršus) // 2
# patikriname, ar `viduriukas` indekse yra mūsų ieškomas tikslas, ir jį atradus grąžiname indeksą.
if sąrašas[viduriukas] == tikslas:
return viduriukas
# jeigu ne, tai pagal tai, kurioje pusėje yra ieškomas elementas pakeičiame viršutinį arba apatinį indeksą
elif sąrašas[viduriukas] < tikslas:
apačia = viduriukas + 1
else:
viršus = viduriukas - 1
# ir kartojame iš naujo, bet jau su nauju, per pus mažesniu rėžiu

return -1 # tikslas nerastas

sąrašas = [1,2,3,4,5,6,7,8,9,10]
print(dvejetainė_paieška(sąrašas, 7)) # 6
</syntaxhighlight>

Panagrinėkim detaliai, kaip vyksta procesas. Ieškome, kur yra skaičius 7, sąraše [1,2,3,4,5,6,7,8,9,10]. Funkcijos pradžios kintamieji:
<syntaxhighlight lang="python">
apačia = 0
viršus = 9 # (ilgis 10 - 1 )
</syntaxhighlight>
Pirmas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 4 # (0 + 9) // 2
# sąrašas[4] saugo reikšmę 5. Ne mūsų ieškomas skaičius.
# kadangi tikslas yra surasti 7, tai mūsų kito ciklo metu ieškosime viršutinėje sąrašo dalyje, todėl nusistatome naują apačios reikšmę, viduriukas + 1.
apačia = 5 # (4 + 1)
</syntaxhighlight>
Antras `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 7 # (5 + 9) // 2
# sąrašas[7] saugo reikšmę 8. Jau arčiau, bet ne dar vis ne mūsų ieškoma reikšmė 7. Nustatome šįkartą naują viršutinę reikšmę, viduriukas - 1
viršus = 6 # (7 - 1)
</syntaxhighlight>
Trečias `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 5 # (5 + 6) // 2
# sąrašas[5] saugo reikmę 6. Vėl pro šalį. Nustatome naują apatinę reikšmę:
apačia = 6 # (5 + 1)
</syntaxhighlight>
Ketvirtas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 6 # (6 + 6) // 2
sąrašas[6] saugo reikšmę 7. Valio! Radom. Grąžinam indeksą 7.
</syntaxhighlight>

Atkreipk dėmesį, kad dvejetainės paieškos algoritmas atrado reikšmę per 4 ciklus. Kaip manai, kiek ciklų prireiktų tiesinės paieškos algoritmui? Pasufleruosiu... Daugiau :)

= Rikiavimas =

Rikiavimo algoritmai naudojami duomenų sąrašui išdėstyti tam tikra tvarka. Rikiavimo algoritmų yra daug ir įvairių, bet papasakosiu tik kelis naudingiausius. Pateiktus algoritmus tu gelėsi nesunkiai pritaikyti ir kitokiems duomenų tipams, ne tik žodžiams. Bet apie tai vėliau.

== Įterpimo rikiavimas (Insertion Sort) ==

Įterpimo rikiavimas yra paprastas rikiavimo algoritmas, kuris veikia padalydamas sąrašą į dvi dalis: surikiuotą ir nesurikiuotą. Tada iteratyviai paimamas elementas iš nerikiuotos dalies ir įterpiamas į reikiamą vietą surikiuotoje dalyje, kol visas sąrašas surikiuojamas.
Pažiūrėkim, kaip tai atrodo:

<syntaxhighlight lang="python">
def įterpimo_rikiavimas(sąrašas):
for i in range(1, len(sąrašas)):
raktas = sąrašas[i]
j = i - 1
while j >= 0 and sąrašas[j] > raktas:
sąrašas[j+1] = sąrašas[j]
j -= 1
sąrašas[j+1] = raktas
</syntaxhighlight>

Ši funkcija paima sąrašą <code>sąrašas</code> ir sutikiuoja jį didėjimo tvarka, naudodama įterpimo rikiavimą. Ji pradeda iteruoti per sąrašą nuo antrojo elemento (indeksas 1) iki galo. Kiekvieno elemento reikšmė išsaugoma kaip <code>raktas</code>, o jo indeksas - kaip <code>i</code>, tada einama atgal per surikiuotą sąrašo dalį (nuo indekso <code>i-1</code> iki 0) ir ieškoma tinkamos vietos rakto reikšmei įterpti. Tai daroma lyginant rakto vertę su kiekvienu išrikiuotos sąrašo dalies elementu ir perstumiant didesnius elementus viena pozicija į dešinę, kol randama tinkama pozicija. Suradęs tinkamą poziciją, į ją įterpia rakto reikšmę.

Įterpimo rikiavimo laiko sudėtingumas blogiausiu atveju yra O(n2), o tai reiškia, kad didelių įvesties sąrašų atveju jis gali būti lėtas. Tačiau jis turi mažesnes pridėtines išlaidas nei kai kurie kiti rikiavivmo algoritmai ir gali būti efektyvesnis už juos mažiems įvesties sąrašams arba iš dalies surikiuotiems įvesties sąrašams.

== Burbulinis rikiavimas (Bubble sort) ==
Burbulinis rikiavimas - tai paprastas rikiavimo algoritmas, kuris pakartotinai pereina per sąrašą, palygina gretimus elementus ir sukeičia juos vietomis, jei jų eiliškumas netinkamas. Pažiūrėkime į burbulinio rikiavimo funkcijos pavyzdį:

<syntaxhighlight lang="python">
def burbulinis_rikiavimas(sąrašas):
sąrašo_ilgis = len(sąrašas)

for i in range(sąrašo_ilgis):
for j in range(0, sąrašo_ilgis-i-1):
if sąrašas[j] > sąrašas[j+1]:
sąrašas[j], sąrašas[j+1] = sąrašas[j+1], sąrašas[j]
</syntaxhighlight>
Ši funkcija paima sąrašą <code>sąrašas</code> ir surikiuoja jį didėjančia tvarka, naudodama burbulinį rikiavimą.

== Greitasis rikiavimas (Quicksort) ==
Greitasis rikiavimas yra plačiai naudojamas rikiavimo algoritmas, kuriame taikomas "skaldyk ir valdyk" metodas. Jis veikia iš masyvo (arba sąrašo) išrenkant ašinį elementą ir kitus elementus suskirstant į du papildomus masyvus pagal tai, ar jie mažesni, ar didesni už ašinį elementą. Tada šis procesas rekursiškai kartojamas kiekviename pogrupyje.

Štai greitojo rikiavimo funkcijos pavyzdys "Python" kalba:

<syntaxhighlight lang="python">
def greitasis_rikiavimas(masyvas):
mažiau = []
lygus = []
daugiau = []
if len(masyvas) > 1:
ašis = masyvas[0]
for x in masyvas:
if x < ašis:
mažiau.append(x)
elif x == ašis:
lygus.append(x)
elif x > ašis:
daugiau.append(x)
# neužmiršk grąžinti rezultato!
return greitasis_rikiavimas(mažiau) + lygus + greitasis_rikiavimas(daugiau)
# Atkreipk dėmesį, kad naudojame `lygus`, o ne `ašis`
else:
return masyvas
</syntaxhighlight>

Funkcijos parametras <code>masyvas</code> yra sąrašas, kurį norime surikiuoti.

Pagrindinė funkcijos dalis yra sąlyga <code>if len(masyvas) > 1:</code>, kuri tikrina, ar sąraše yra daugiau nei vienas elementas. Jei sąraše yra tik vienas arba nulis elementų, tai jis jau yra surikiuotas, todėl tiesiog grąžinamas toks pat sąrašas.

Jei sąraše yra daugiau nei vienas elementas, algoritmas tęsiasi. Pirma, parenkamas elementas <code>ašis</code>, šiuo atveju tai yra pirmas sąrašo elementas <code>masyvas[0]</code>. Tuomet algoritmas eina per visus sąrašo elementus ir prideda juos į tris skirtingus sąrašus (<code>mažiau</code>, <code>lygus</code>, <code>daugiau</code>), priklausomai nuo to, kaip jie lyginami su <code>ašis</code>.

* Jei elementas '''x''' yra mažesnis už '''ašis''', jis pridedamas į '''mažiau''' sąrašą.
* Jei elementas '''x''' yra lygus '''ašis''', jis pridedamas į '''lygus''' sąrašą.
* Jei elementas '''x''' yra didesnis už '''ašis''', jis pridedamas į '''daugiau''' sąrašą.

Tai vadinama ''dalijimo procesu''. Po šio proceso turime tris naujus sąrašus: '''mažiau''', '''lygus''' ir '''daugiau''', kurie yra dalinai surikiuoti (mažesni už '''ašis''', lygūs '''ašis''' ir didesni už '''ašis''').

Toliau funkcija naudoja rekursiją ir kviečia save su <code>mažiau</code> ir <code>daugiau</code> sąrašais, taip pritaikydama dalijimo ir surikiavimo procesą šiems dviejams sąrašams atskirai. Rekursyviai kviečiant save, galiausiai bus pasiektas atvejis, kai sąrašai <code>mažiau</code> ir <code>daugiau</code> bus sudaryti iš nulio arba vieno elemento, o tai reiškia, kad jie jau surikiuoti. Tada funkcija grąžina sudėtą sąrašą: <code>greitasis_rikiavimas(mažiau) + lygus + greitasis_rikiavimas(daugiau)</code>, kuris sudarys pilnai surikiuotą sąrašą.

Galutinis rezultatas yra surikiuotas sąrašas, kuris yra grąžinamas iš pradinių sąrašų iškvietimo vietos.

Pvz. jei iškviečiame funkciją <code>greitasis_rikiavimas([3, 1, 4, 1, 5, 9, 2, 6, 5])</code>, tai gražins <code>[1, 1, 2, 3, 4, 5, 5, 6, 9]</code>, kuris yra pradinis sąrašas surikiuotas didėjimo tvarka.

== Suliejimo rikiavimas (Merge sort) ==
Suliejimo rikiavimas - tai rikiavimo algoritmas, kuris veikia pagal dalinimo ir sujungimo principą. Tai efektyvus algoritmas, kuris naudoja rekursiją.

Šis algoritmas veikia taip:
* Jei sąraše yra nulis arba vienas elementas, tai jis jau yra surikiuotas. Grąžinamas tas pats sąrašas.
* Jei sąraše yra daugiau nei vienas elementas, sąrašas yra padalinamas į dvi lygias dalis.
* Kiekviena dalis yra rekursyviai rikiuojama naudojant '''merge sort''' algoritmą.
* Surikiuotos dvi dalys yra sujungiamos į vieną sąrašą. Sujungimo metu elementai yra palyginami ir sudedami į naują sąrašą didėjimo tvarka.

Šis procesas yra pakartojamas tol, kol visi sąrašai yra padalinti iki vieno elemento ir tada sujungti į vieną galutinį surikiuotą sąrašą.

Suliejimo rikiavimo algoritmas yra efektyvus, nes dalijimo ir sujungimo žingsniai yra vykdomi daug kartų, o kiekviename žingsnyje sąrašas yra padalintas į dvi lygias dalis. Tai leidžia efektyviai rikiuoti didelius sąrašus.

<syntaxhighlight lang="python">
def suliejimo_rikiavimas(sąrašas):
# sąraše yra nulis arba vienas elementas
if len(sąrašas) <= 1:
return sąrašas

# Dalinimo žingsnis: padaliname sąrašą į dvi lygias dalis
vidurys = len(sąrašas) // 2
kairė = sąrašas[:vidurys]
dešinė = sąrašas[vidurys:]

# Rekursyviai rikiuojame kiekvieną dalį
kairė = suliejimo_rikiavimas(kairė)
dešinė = suliejimo_rikiavimas(dešinė)

# Sujungimo žingsnis: sujungiame surikiuotas dalis į vieną sąrašą
return suliejimas(kairė, dešinė)

def suliejimas(kairė, dešinė):
rezultatas = []
i = 0 # indeksas kairėje dalyje
j = 0 # indeksas dešinėje dalyje

# Lyginame ir sujungiame elementus
while i < len(kairė) and j < len(dešinė):
if kairė[i] <= dešinė[j]:
rezultatas.append(kairė[i])
i += 1
else:
rezultatas.append(dešinė[j])
j += 1

# Jei viena dalis baigiasi anksčiau, pridedame likusius elementus
while i < len(kairė):
rezultatas.append(kairė[i])
i += 1
while j < len(dešinė):
rezultatas.append(dešinė[j])
j += 1

return rezultatas

# Pavyzdys naudojant suliejimo_rikiavimas funkciją
sąrašas = [3, 1, 4, 1, 5, 9, 2, 6, 5]
surikiuotas_sąrašas = suliejimo_rikiavimas(sąrašas)
print(surikiuotas_sąrašas)
</syntaxhighlight>

Šis pavyzdys naudoja dvi funkcijas: <code>suliejimo_rikiavimas</code> ir <code>suliejimas</code>. <code>suliejimo_rikiavimas</code> funkcija atlieka dalinimo ir rekursyvaus rikiavimo žingsnius, o <code>suliejimas</code> funkcija atlieka surikiuotų dalių sujungimą.

Rezultatas šio pavyzdžio bus:
[1, 1, 2, 3, 4, 5, 5, 6, 9]

Vadovėlis/Paieška ir Rikiavimas

2023-06-28T13:06:59Z

Monika: /* Suliejimo rikiavimas (Merge sort) */

Atlikęs praeito skyriaus uždavinius, jau daug žinai apie sąrašo sukūrimą ir visus bazinius sąrašo metodus. Dabar pasinaudosime įgytomis žiniomis ir susipažinsime su labai dažnai sutinkamais uždaviniais: paieška ir rikiavimas.

= Paieška =

Paieškos algoritmai naudojami norint rasti konkretų elementą sąraše ar duomenų masyve. Yra keletas paieškos algoritmų, tačiau parodysiu du dažniausiai naudojamus - tiesinę paiešką ir dvejetainę paiešką.

== Tiesinė paieška ==
Tiesinė paieška - tai paprastas paieškos algoritmas, kuris, ieškodamas tikslinės reikšmės, peržiūri kiekvieną sąrašo elementą. Pažiūrėk į tiesinės paieškos funkcijos pavyzdį "Python" kalba:

<syntaxhighlight lang="python">
def tiesinė_paieška(sąrašas, ieškomas_žodis):
for i in range(len(sąrašas)):
if sąrašas[i] == ieškomas_žodis:
return i
return -1 # ieškomas_žodis nerastas
</syntaxhighlight>

Ši funkcija priima masyvą <code>sąrašas</code> ir tikslinę reikšmę <code>ieškomas_žodis</code> ir grąžina tikslinės reikšmės indeksą masyve. Jei tikslinė vertė nerandama masyve, funkcija grąžina -1. Labai praprasta ir aišku.

== Dvejetainė paieška ==
Kita vertus, dvejetainė paieška yra efektyvesnis paieškos algoritmas, kuris veikia tik surikiuotose masyvuose (sąrašuose). Jis veikia pakartotinai dalydamas paieškos intervalą per pusę, kol randama tikslinė reikšmė. Painu? Daug aiškiau bus pažiūrėjus šį pavyzdį:

<syntaxhighlight lang="python">
def dvejetainė_paieška(sąrašas, tikslas):
# išsisaugome sąrašo pirmą ir paskutinį indeksą
apačia = 0
viršus = len(sąrašas) - 1

while apačia <= viršus:
# atrandame vidurį pagal formulę: (pradžios indeksas + pabaigos indeksas) padalintas per pusę, be liekanos
viduriukas = (apačia + viršus) // 2
# patikriname, ar `viduriukas` indekse yra mūsų ieškomas tikslas, ir jį atradus grąžiname indeksą.
if sąrašas[viduriukas] == tikslas:
return viduriukas
# jeigu ne, tai pagal tai, kurioje pusėje yra ieškomas elementas pakeičiame viršutinį arba apatinį indeksą
elif sąrašas[viduriukas] < tikslas:
apačia = viduriukas + 1
else:
viršus = viduriukas - 1
# ir kartojame iš naujo, bet jau su nauju, per pus mažesniu rėžiu

return -1 # tikslas nerastas

sąrašas = [1,2,3,4,5,6,7,8,9,10]
print(dvejetainė_paieška(sąrašas, 7)) # 6
</syntaxhighlight>

Panagrinėkim detaliai, kaip vyksta procesas. Ieškome, kur yra skaičius 7, sąraše [1,2,3,4,5,6,7,8,9,10]. Funkcijos pradžios kintamieji:
<syntaxhighlight lang="python">
apačia = 0
viršus = 9 # (ilgis 10 - 1 )
</syntaxhighlight>
Pirmas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 4 # (0 + 9) // 2
# sąrašas[4] saugo reikšmę 5. Ne mūsų ieškomas skaičius.
# kadangi tikslas yra surasti 7, tai mūsų kito ciklo metu ieškosime viršutinėje sąrašo dalyje, todėl nusistatome naują apačios reikšmę, viduriukas + 1.
apačia = 5 # (4 + 1)
</syntaxhighlight>
Antras `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 7 # (5 + 9) // 2
# sąrašas[7] saugo reikšmę 8. Jau arčiau, bet ne dar vis ne mūsų ieškoma reikšmė 7. Nustatome šįkartą naują viršutinę reikšmę, viduriukas - 1
viršus = 6 # (7 - 1)
</syntaxhighlight>
Trečias `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 5 # (5 + 6) // 2
# sąrašas[5] saugo reikmę 6. Vėl pro šalį. Nustatome naują apatinę reikšmę:
apačia = 6 # (5 + 1)
</syntaxhighlight>
Ketvirtas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 6 # (6 + 6) // 2
sąrašas[6] saugo reikšmę 7. Valio! Radom. Grąžinam indeksą 7.
</syntaxhighlight>

Atkreipk dėmesį, kad dvejetainės paieškos algoritmas atrado reikšmę per 4 ciklus. Kaip manai, kiek ciklų prireiktų tiesinės paieškos algoritmui? Pasufleruosiu... Daugiau :)

= Rikiavimas =

Rikiavimo algoritmai naudojami duomenų sąrašui išdėstyti tam tikra tvarka. Rikiavimo algoritmų yra daug ir įvairių, bet papasakosiu tik kelis naudingiausius. Pateiktus algoritmus tu gelėsi nesunkiai pritaikyti ir kitokiems duomenų tipams, ne tik žodžiams. Bet apie tai vėliau.

== Įterpimo rikiavimas (Insertion Sort) ==

Įterpimo rikiavimas yra paprastas rikiavimo algoritmas, kuris veikia padalydamas sąrašą į dvi dalis: surikiuotą ir nesurikiuotą. Tada iteratyviai paimamas elementas iš nerikiuotos dalies ir įterpiamas į reikiamą vietą surikiuotoje dalyje, kol visas sąrašas surikiuojamas.
Pažiūrėkim, kaip tai atrodo:

<syntaxhighlight lang="python">
def įterpimo_rikiavimas(sąrašas):
for i in range(1, len(sąrašas)):
raktas = sąrašas[i]
j = i - 1
while j >= 0 and sąrašas[j] > raktas:
sąrašas[j+1] = sąrašas[j]
j -= 1
sąrašas[j+1] = raktas
</syntaxhighlight>

Ši funkcija paima sąrašą <code>sąrašas</code> ir sutikiuoja jį didėjimo tvarka, naudodama įterpimo rikiavimą. Ji pradeda iteruoti per sąrašą nuo antrojo elemento (indeksas 1) iki galo. Kiekvieno elemento reikšmė išsaugoma kaip <code>raktas</code>, o jo indeksas - kaip <code>i</code>, tada einama atgal per surikiuotą sąrašo dalį (nuo indekso <code>i-1</code> iki 0) ir ieškoma tinkamos vietos rakto reikšmei įterpti. Tai daroma lyginant rakto vertę su kiekvienu išrikiuotos sąrašo dalies elementu ir perstumiant didesnius elementus viena pozicija į dešinę, kol randama tinkama pozicija. Suradęs tinkamą poziciją, į ją įterpia rakto reikšmę.

Įterpimo rikiavimo laiko sudėtingumas blogiausiu atveju yra O(n2), o tai reiškia, kad didelių įvesties sąrašų atveju jis gali būti lėtas. Tačiau jis turi mažesnes pridėtines išlaidas nei kai kurie kiti rikiavivmo algoritmai ir gali būti efektyvesnis už juos mažiems įvesties sąrašams arba iš dalies surikiuotiems įvesties sąrašams.

== Burbulinis rikiavimas (Bubble sort) ==
Burbulinis rikiavimas - tai paprastas rikiavimo algoritmas, kuris pakartotinai pereina per sąrašą, palygina gretimus elementus ir sukeičia juos vietomis, jei jų eiliškumas netinkamas. Pažiūrėkime į burbulinio rikiavimo funkcijos pavyzdį:

<syntaxhighlight lang="python">
def burbulinis_rikiavimas(sąrašas):
sąrašo_ilgis = len(sąrašas)

for i in range(sąrašo_ilgis):
for j in range(0, sąrašo_ilgis-i-1):
if sąrašas[j] > sąrašas[j+1]:
sąrašas[j], sąrašas[j+1] = sąrašas[j+1], sąrašas[j]
</syntaxhighlight>
Ši funkcija paima sąrašą <code>sąrašas</code> ir surikiuoja jį didėjančia tvarka, naudodama burbulinį rikiavimą.

== Greitasis rikiavimas (Quicksort) ==
Greitasis rikiavimas yra plačiai naudojamas rikiavimo algoritmas, kuriame taikomas "skaldyk ir valdyk" metodas. Jis veikia iš masyvo (arba sąrašo) išrenkant ašinį elementą ir kitus elementus suskirstant į du papildomus masyvus pagal tai, ar jie mažesni, ar didesni už ašinį elementą. Tada šis procesas rekursiškai kartojamas kiekviename pogrupyje.

Štai "Quicksort" funkcijos pavyzdys "Python" kalba:

<syntaxhighlight lang="python">
def quicksort(masyvas):
mažiau = []
lygus = []
daugiau = []
if len(masyvas) > 1:
ašis = masyvas[0]
for x in masyvas:
if x < ašis:
mažiau.append(x)
elif x == ašis:
lygus.append(x)
elif x > ašis:
daugiau.append(x)
# neužmiršk grąžinti rezultato!
return quicksort(mažiau) + lygus + quicksort(daugiau)
# Atkreipk dėmesį, kad naudojame `lygus`, o ne `ašis`
else:
return masyvas
</syntaxhighlight>

Funkcijos parametras <code>masyvas</code> yra sąrašas, kurį norime surikiuoti.

Pagrindinė funkcijos dalis yra sąlyga <code>if len(masyvas) > 1:</code>, kuri tikrina, ar sąraše yra daugiau nei vienas elementas. Jei sąraše yra tik vienas arba nulis elementų, tai jis jau yra surikiuotas, todėl tiesiog grąžinamas toks pat sąrašas.

Jei sąraše yra daugiau nei vienas elementas, algoritmas tęsiasi. Pirma, parenkamas elementas <code>ašis</code>, šiuo atveju tai yra pirmas sąrašo elementas <code>masyvas[0]</code>. Tuomet algoritmas eina per visus sąrašo elementus ir prideda juos į tris skirtingus sąrašus (<code>mažiau</code>, <code>lygus</code>, <code>daugiau</code>), priklausomai nuo to, kaip jie lyginami su <code>ašis</code>.

* Jei elementas '''x''' yra mažesnis už '''ašis''', jis pridedamas į '''mažiau''' sąrašą.
* Jei elementas '''x''' yra lygus '''ašis''', jis pridedamas į '''lygus''' sąrašą.
* Jei elementas '''x''' yra didesnis už '''ašis''', jis pridedamas į '''daugiau''' sąrašą.

Tai vadinama ''dalijimo procesu''. Po šio proceso turime tris naujus sąrašus: '''mažiau''', '''lygus''' ir '''daugiau''', kurie yra dalinai surikiuoti (mažesni už '''ašis''', lygūs '''ašis''' ir didesni už '''ašis''').

Toliau funkcija naudoja rekursiją ir kviečia save su <code>mažiau</code> ir <code>daugiau</code> sąrašais, taip pritaikydama dalijimo ir surikiavimo procesą šiems dviejams sąrašams atskirai. Rekursyviai kviečiant save, galiausiai bus pasiektas atvejis, kai sąrašai <code>mažiau</code> ir <code>daugiau</code> bus sudaryti iš nulio arba vieno elemento, o tai reiškia, kad jie jau surikiuoti. Tada funkcija grąžina sudėtą sąrašą: <code>quicksort(mažiau) + lygus + quicksort(daugiau)</code>, kuris sudarys pilnai surikiuotą sąrašą.

Galutinis rezultatas yra surikiuotas sąrašas, kuris yra grąžinamas iš pradinių sąrašų iškvietimo vietos.

Pvz. jei iškviečiame funkciją <code>quicksort([3, 1, 4, 1, 5, 9, 2, 6, 5])</code>, tai gražins <code>[1, 1, 2, 3, 4, 5, 5, 6, 9]</code>, kuris yra pradinis sąrašas surikiuotas didėjimo tvarka.

== Suliejimo rikiavimas (Merge sort) ==
Suliejimo rikiavimas - tai rikiavimo algoritmas, kuris veikia pagal dalinimo ir sujungimo principą. Tai efektyvus algoritmas, kuris naudoja rekursiją.

Šis algoritmas veikia taip:
* Jei sąraše yra nulis arba vienas elementas, tai jis jau yra surikiuotas. Grąžinamas tas pats sąrašas.
* Jei sąraše yra daugiau nei vienas elementas, sąrašas yra padalinamas į dvi lygias dalis.
* Kiekviena dalis yra rekursyviai rikiuojama naudojant '''merge sort''' algoritmą.
* Surikiuotos dvi dalys yra sujungiamos į vieną sąrašą. Sujungimo metu elementai yra palyginami ir sudedami į naują sąrašą didėjimo tvarka.

Šis procesas yra pakartojamas tol, kol visi sąrašai yra padalinti iki vieno elemento ir tada sujungti į vieną galutinį surikiuotą sąrašą.

Suliejimo rikiavimo algoritmas yra efektyvus, nes dalijimo ir sujungimo žingsniai yra vykdomi daug kartų, o kiekviename žingsnyje sąrašas yra padalintas į dvi lygias dalis. Tai leidžia efektyviai rikiuoti didelius sąrašus.

<syntaxhighlight lang="python">
def suliejimo_rikiavimas(sąrašas):
# sąraše yra nulis arba vienas elementas
if len(sąrašas) <= 1:
return sąrašas

# Dalinimo žingsnis: padaliname sąrašą į dvi lygias dalis
vidurys = len(sąrašas) // 2
kairė = sąrašas[:vidurys]
dešinė = sąrašas[vidurys:]

# Rekursyviai rikiuojame kiekvieną dalį
kairė = suliejimo_rikiavimas(kairė)
dešinė = suliejimo_rikiavimas(dešinė)

# Sujungimo žingsnis: sujungiame surikiuotas dalis į vieną sąrašą
return suliejimas(kairė, dešinė)

def suliejimas(kairė, dešinė):
rezultatas = []
i = 0 # indeksas kairėje dalyje
j = 0 # indeksas dešinėje dalyje

# Lyginame ir sujungiame elementus
while i < len(kairė) and j < len(dešinė):
if kairė[i] <= dešinė[j]:
rezultatas.append(kairė[i])
i += 1
else:
rezultatas.append(dešinė[j])
j += 1

# Jei viena dalis baigiasi anksčiau, pridedame likusius elementus
while i < len(kairė):
rezultatas.append(kairė[i])
i += 1
while j < len(dešinė):
rezultatas.append(dešinė[j])
j += 1

return rezultatas

# Pavyzdys naudojant suliejimo_rikiavimas funkciją
sąrašas = [3, 1, 4, 1, 5, 9, 2, 6, 5]
surikiuotas_sąrašas = suliejimo_rikiavimas(sąrašas)
print(surikiuotas_sąrašas)
</syntaxhighlight>

Šis pavyzdys naudoja dvi funkcijas: <code>suliejimo_rikiavimas</code> ir <code>suliejimas</code>. <code>suliejimo_rikiavimas</code> funkcija atlieka dalinimo ir rekursyvaus rikiavimo žingsnius, o <code>suliejimas</code> funkcija atlieka surikiuotų dalių sujungimą.

Rezultatas šio pavyzdžio bus:
[1, 1, 2, 3, 4, 5, 5, 6, 9]

Vadovėlis/Paieška ir Rikiavimas

2023-06-28T13:03:41Z

Monika: /* Greitasis rikiavimas (Quicksort) */

Atlikęs praeito skyriaus uždavinius, jau daug žinai apie sąrašo sukūrimą ir visus bazinius sąrašo metodus. Dabar pasinaudosime įgytomis žiniomis ir susipažinsime su labai dažnai sutinkamais uždaviniais: paieška ir rikiavimas.

= Paieška =

Paieškos algoritmai naudojami norint rasti konkretų elementą sąraše ar duomenų masyve. Yra keletas paieškos algoritmų, tačiau parodysiu du dažniausiai naudojamus - tiesinę paiešką ir dvejetainę paiešką.

== Tiesinė paieška ==
Tiesinė paieška - tai paprastas paieškos algoritmas, kuris, ieškodamas tikslinės reikšmės, peržiūri kiekvieną sąrašo elementą. Pažiūrėk į tiesinės paieškos funkcijos pavyzdį "Python" kalba:

<syntaxhighlight lang="python">
def tiesinė_paieška(sąrašas, ieškomas_žodis):
for i in range(len(sąrašas)):
if sąrašas[i] == ieškomas_žodis:
return i
return -1 # ieškomas_žodis nerastas
</syntaxhighlight>

Ši funkcija priima masyvą <code>sąrašas</code> ir tikslinę reikšmę <code>ieškomas_žodis</code> ir grąžina tikslinės reikšmės indeksą masyve. Jei tikslinė vertė nerandama masyve, funkcija grąžina -1. Labai praprasta ir aišku.

== Dvejetainė paieška ==
Kita vertus, dvejetainė paieška yra efektyvesnis paieškos algoritmas, kuris veikia tik surikiuotose masyvuose (sąrašuose). Jis veikia pakartotinai dalydamas paieškos intervalą per pusę, kol randama tikslinė reikšmė. Painu? Daug aiškiau bus pažiūrėjus šį pavyzdį:

<syntaxhighlight lang="python">
def dvejetainė_paieška(sąrašas, tikslas):
# išsisaugome sąrašo pirmą ir paskutinį indeksą
apačia = 0
viršus = len(sąrašas) - 1

while apačia <= viršus:
# atrandame vidurį pagal formulę: (pradžios indeksas + pabaigos indeksas) padalintas per pusę, be liekanos
viduriukas = (apačia + viršus) // 2
# patikriname, ar `viduriukas` indekse yra mūsų ieškomas tikslas, ir jį atradus grąžiname indeksą.
if sąrašas[viduriukas] == tikslas:
return viduriukas
# jeigu ne, tai pagal tai, kurioje pusėje yra ieškomas elementas pakeičiame viršutinį arba apatinį indeksą
elif sąrašas[viduriukas] < tikslas:
apačia = viduriukas + 1
else:
viršus = viduriukas - 1
# ir kartojame iš naujo, bet jau su nauju, per pus mažesniu rėžiu

return -1 # tikslas nerastas

sąrašas = [1,2,3,4,5,6,7,8,9,10]
print(dvejetainė_paieška(sąrašas, 7)) # 6
</syntaxhighlight>

Panagrinėkim detaliai, kaip vyksta procesas. Ieškome, kur yra skaičius 7, sąraše [1,2,3,4,5,6,7,8,9,10]. Funkcijos pradžios kintamieji:
<syntaxhighlight lang="python">
apačia = 0
viršus = 9 # (ilgis 10 - 1 )
</syntaxhighlight>
Pirmas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 4 # (0 + 9) // 2
# sąrašas[4] saugo reikšmę 5. Ne mūsų ieškomas skaičius.
# kadangi tikslas yra surasti 7, tai mūsų kito ciklo metu ieškosime viršutinėje sąrašo dalyje, todėl nusistatome naują apačios reikšmę, viduriukas + 1.
apačia = 5 # (4 + 1)
</syntaxhighlight>
Antras `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 7 # (5 + 9) // 2
# sąrašas[7] saugo reikšmę 8. Jau arčiau, bet ne dar vis ne mūsų ieškoma reikšmė 7. Nustatome šįkartą naują viršutinę reikšmę, viduriukas - 1
viršus = 6 # (7 - 1)
</syntaxhighlight>
Trečias `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 5 # (5 + 6) // 2
# sąrašas[5] saugo reikmę 6. Vėl pro šalį. Nustatome naują apatinę reikšmę:
apačia = 6 # (5 + 1)
</syntaxhighlight>
Ketvirtas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 6 # (6 + 6) // 2
sąrašas[6] saugo reikšmę 7. Valio! Radom. Grąžinam indeksą 7.
</syntaxhighlight>

Atkreipk dėmesį, kad dvejetainės paieškos algoritmas atrado reikšmę per 4 ciklus. Kaip manai, kiek ciklų prireiktų tiesinės paieškos algoritmui? Pasufleruosiu... Daugiau :)

= Rikiavimas =

Rikiavimo algoritmai naudojami duomenų sąrašui išdėstyti tam tikra tvarka. Rikiavimo algoritmų yra daug ir įvairių, bet papasakosiu tik kelis naudingiausius. Pateiktus algoritmus tu gelėsi nesunkiai pritaikyti ir kitokiems duomenų tipams, ne tik žodžiams. Bet apie tai vėliau.

== Įterpimo rikiavimas (Insertion Sort) ==

Įterpimo rikiavimas yra paprastas rikiavimo algoritmas, kuris veikia padalydamas sąrašą į dvi dalis: surikiuotą ir nesurikiuotą. Tada iteratyviai paimamas elementas iš nerikiuotos dalies ir įterpiamas į reikiamą vietą surikiuotoje dalyje, kol visas sąrašas surikiuojamas.
Pažiūrėkim, kaip tai atrodo:

<syntaxhighlight lang="python">
def įterpimo_rikiavimas(sąrašas):
for i in range(1, len(sąrašas)):
raktas = sąrašas[i]
j = i - 1
while j >= 0 and sąrašas[j] > raktas:
sąrašas[j+1] = sąrašas[j]
j -= 1
sąrašas[j+1] = raktas
</syntaxhighlight>

Ši funkcija paima sąrašą <code>sąrašas</code> ir sutikiuoja jį didėjimo tvarka, naudodama įterpimo rikiavimą. Ji pradeda iteruoti per sąrašą nuo antrojo elemento (indeksas 1) iki galo. Kiekvieno elemento reikšmė išsaugoma kaip <code>raktas</code>, o jo indeksas - kaip <code>i</code>, tada einama atgal per surikiuotą sąrašo dalį (nuo indekso <code>i-1</code> iki 0) ir ieškoma tinkamos vietos rakto reikšmei įterpti. Tai daroma lyginant rakto vertę su kiekvienu išrikiuotos sąrašo dalies elementu ir perstumiant didesnius elementus viena pozicija į dešinę, kol randama tinkama pozicija. Suradęs tinkamą poziciją, į ją įterpia rakto reikšmę.

Įterpimo rikiavimo laiko sudėtingumas blogiausiu atveju yra O(n2), o tai reiškia, kad didelių įvesties sąrašų atveju jis gali būti lėtas. Tačiau jis turi mažesnes pridėtines išlaidas nei kai kurie kiti rikiavivmo algoritmai ir gali būti efektyvesnis už juos mažiems įvesties sąrašams arba iš dalies surikiuotiems įvesties sąrašams.

== Burbulinis rikiavimas (Bubble sort) ==
Burbulinis rikiavimas - tai paprastas rikiavimo algoritmas, kuris pakartotinai pereina per sąrašą, palygina gretimus elementus ir sukeičia juos vietomis, jei jų eiliškumas netinkamas. Pažiūrėkime į burbulinio rikiavimo funkcijos pavyzdį:

<syntaxhighlight lang="python">
def burbulinis_rikiavimas(sąrašas):
sąrašo_ilgis = len(sąrašas)

for i in range(sąrašo_ilgis):
for j in range(0, sąrašo_ilgis-i-1):
if sąrašas[j] > sąrašas[j+1]:
sąrašas[j], sąrašas[j+1] = sąrašas[j+1], sąrašas[j]
</syntaxhighlight>
Ši funkcija paima sąrašą <code>sąrašas</code> ir surikiuoja jį didėjančia tvarka, naudodama burbulinį rikiavimą.

== Greitasis rikiavimas (Quicksort) ==
Greitasis rikiavimas yra plačiai naudojamas rikiavimo algoritmas, kuriame taikomas "skaldyk ir valdyk" metodas. Jis veikia iš masyvo (arba sąrašo) išrenkant ašinį elementą ir kitus elementus suskirstant į du papildomus masyvus pagal tai, ar jie mažesni, ar didesni už ašinį elementą. Tada šis procesas rekursiškai kartojamas kiekviename pogrupyje.

Štai "Quicksort" funkcijos pavyzdys "Python" kalba:

<syntaxhighlight lang="python">
def quicksort(masyvas):
mažiau = []
lygus = []
daugiau = []
if len(masyvas) > 1:
ašis = masyvas[0]
for x in masyvas:
if x < ašis:
mažiau.append(x)
elif x == ašis:
lygus.append(x)
elif x > ašis:
daugiau.append(x)
# neužmiršk grąžinti rezultato!
return quicksort(mažiau) + lygus + quicksort(daugiau)
# Atkreipk dėmesį, kad naudojame `lygus`, o ne `ašis`
else:
return masyvas
</syntaxhighlight>

Funkcijos parametras <code>masyvas</code> yra sąrašas, kurį norime surikiuoti.

Pagrindinė funkcijos dalis yra sąlyga <code>if len(masyvas) > 1:</code>, kuri tikrina, ar sąraše yra daugiau nei vienas elementas. Jei sąraše yra tik vienas arba nulis elementų, tai jis jau yra surikiuotas, todėl tiesiog grąžinamas toks pat sąrašas.

Jei sąraše yra daugiau nei vienas elementas, algoritmas tęsiasi. Pirma, parenkamas elementas <code>ašis</code>, šiuo atveju tai yra pirmas sąrašo elementas <code>masyvas[0]</code>. Tuomet algoritmas eina per visus sąrašo elementus ir prideda juos į tris skirtingus sąrašus (<code>mažiau</code>, <code>lygus</code>, <code>daugiau</code>), priklausomai nuo to, kaip jie lyginami su <code>ašis</code>.

* Jei elementas '''x''' yra mažesnis už '''ašis''', jis pridedamas į '''mažiau''' sąrašą.
* Jei elementas '''x''' yra lygus '''ašis''', jis pridedamas į '''lygus''' sąrašą.
* Jei elementas '''x''' yra didesnis už '''ašis''', jis pridedamas į '''daugiau''' sąrašą.

Tai vadinama ''dalijimo procesu''. Po šio proceso turime tris naujus sąrašus: '''mažiau''', '''lygus''' ir '''daugiau''', kurie yra dalinai surikiuoti (mažesni už '''ašis''', lygūs '''ašis''' ir didesni už '''ašis''').

Toliau funkcija naudoja rekursiją ir kviečia save su <code>mažiau</code> ir <code>daugiau</code> sąrašais, taip pritaikydama dalijimo ir surikiavimo procesą šiems dviejams sąrašams atskirai. Rekursyviai kviečiant save, galiausiai bus pasiektas atvejis, kai sąrašai <code>mažiau</code> ir <code>daugiau</code> bus sudaryti iš nulio arba vieno elemento, o tai reiškia, kad jie jau surikiuoti. Tada funkcija grąžina sudėtą sąrašą: <code>quicksort(mažiau) + lygus + quicksort(daugiau)</code>, kuris sudarys pilnai surikiuotą sąrašą.

Galutinis rezultatas yra surikiuotas sąrašas, kuris yra grąžinamas iš pradinių sąrašų iškvietimo vietos.

Pvz. jei iškviečiame funkciją <code>quicksort([3, 1, 4, 1, 5, 9, 2, 6, 5])</code>, tai gražins <code>[1, 1, 2, 3, 4, 5, 5, 6, 9]</code>, kuris yra pradinis sąrašas surikiuotas didėjimo tvarka.

== Suliejimo rikiavimas (Merge sort) ==
"Merge sort" yra rikiavimo algoritmas, kuris veikia pagal dalinimo ir sujungimo principą. Tai efektyvus algoritmas, kuris naudoja rekursiją.

Merge sort algoritmas veikia taip:
* Jei sąraše yra nulis arba vienas elementas, tai jis jau yra surikiuotas. Grąžinamas tas pats sąrašas.
* Jei sąraše yra daugiau nei vienas elementas, sąrašas yra padalinamas į dvi lygias dalis.
* Kiekviena dalis yra rekursyviai rikiuojama naudojant '''merge sort''' algoritmą.
* Surikiuotos dvi dalys yra sujungiamos į vieną sąrašą. Sujungimo metu elementai yra palyginami ir sudedami į naują sąrašą didėjimo tvarka.

Šis procesas yra pakartojamas tol, kol visi sąrašai yra padalinti iki vieno elemento ir tada sujungti į vieną galutinį surikiuotą sąrašą.

Merge sort algoritmas yra efektyvus, nes dalijimo ir sujungimo žingsniai yra vykdomi daug kartų, o kiekviename žingsnyje sąrašas yra padalintas į dvi lygias dalis. Tai leidžia efektyviai rikiuoti didelius sąrašus.

<syntaxhighlight lang="python">
def merge_sort(sąrašas):
# sąraše yra nulis arba vienas elementas
if len(sąrašas) <= 1:
return sąrašas

# Dalinimo žingsnis: padaliname sąrašą į dvi lygias dalis
vidurys = len(sąrašas) // 2
kairė = sąrašas[:vidurys]
dešinė = sąrašas[vidurys:]

# Rekursyviai rikiuojame kiekvieną dalį
kairė = merge_sort(kairė)
dešinė = merge_sort(dešinė)

# Sujungimo žingsnis: sujungiame surikiuotas dalis į vieną sąrašą
return merge(kairė, dešinė)

def merge(kairė, dešinė):
rezultatas = []
i = 0 # indeksas kairėje dalyje
j = 0 # indeksas dešinėje dalyje

# Lyginame ir sujungiame elementus
while i < len(kairė) and j < len(dešinė):
if kairė[i] <= dešinė[j]:
rezultatas.append(kairė[i])
i += 1
else:
rezultatas.append(dešinė[j])
j += 1

# Jei viena dalis baigiasi anksčiau, pridedame likusius elementus
while i < len(kairė):
rezultatas.append(kairė[i])
i += 1
while j < len(dešinė):
rezultatas.append(dešinė[j])
j += 1

return rezultatas

# Pavyzdys naudojant merge_sort funkciją
sąrašas = [3, 1, 4, 1, 5, 9, 2, 6, 5]
surikiuotas_sąrašas = merge_sort(sąrašas)
print(surikiuotas_sąrašas)
</syntaxhighlight>

Šis pavyzdys naudoja dvi funkcijas: <code>merge_sort</code> ir <code>merge</code>. <code>merge_sort</code> funkcija atlieka dalinimo ir rekursyvaus rikiavimo žingsnius, o <code>merge</code> funkcija atlieka surikiuotų dalių sujungimą.

Rezultatas šio pavyzdžio bus:
[1, 1, 2, 3, 4, 5, 5, 6, 9]

Vadovėlis/Paieška ir Rikiavimas

2023-06-28T13:01:51Z

Monika: /* Burbulinis rikiavimas (Bubble sort) */

Atlikęs praeito skyriaus uždavinius, jau daug žinai apie sąrašo sukūrimą ir visus bazinius sąrašo metodus. Dabar pasinaudosime įgytomis žiniomis ir susipažinsime su labai dažnai sutinkamais uždaviniais: paieška ir rikiavimas.

= Paieška =

Paieškos algoritmai naudojami norint rasti konkretų elementą sąraše ar duomenų masyve. Yra keletas paieškos algoritmų, tačiau parodysiu du dažniausiai naudojamus - tiesinę paiešką ir dvejetainę paiešką.

== Tiesinė paieška ==
Tiesinė paieška - tai paprastas paieškos algoritmas, kuris, ieškodamas tikslinės reikšmės, peržiūri kiekvieną sąrašo elementą. Pažiūrėk į tiesinės paieškos funkcijos pavyzdį "Python" kalba:

<syntaxhighlight lang="python">
def tiesinė_paieška(sąrašas, ieškomas_žodis):
for i in range(len(sąrašas)):
if sąrašas[i] == ieškomas_žodis:
return i
return -1 # ieškomas_žodis nerastas
</syntaxhighlight>

Ši funkcija priima masyvą <code>sąrašas</code> ir tikslinę reikšmę <code>ieškomas_žodis</code> ir grąžina tikslinės reikšmės indeksą masyve. Jei tikslinė vertė nerandama masyve, funkcija grąžina -1. Labai praprasta ir aišku.

== Dvejetainė paieška ==
Kita vertus, dvejetainė paieška yra efektyvesnis paieškos algoritmas, kuris veikia tik surikiuotose masyvuose (sąrašuose). Jis veikia pakartotinai dalydamas paieškos intervalą per pusę, kol randama tikslinė reikšmė. Painu? Daug aiškiau bus pažiūrėjus šį pavyzdį:

<syntaxhighlight lang="python">
def dvejetainė_paieška(sąrašas, tikslas):
# išsisaugome sąrašo pirmą ir paskutinį indeksą
apačia = 0
viršus = len(sąrašas) - 1

while apačia <= viršus:
# atrandame vidurį pagal formulę: (pradžios indeksas + pabaigos indeksas) padalintas per pusę, be liekanos
viduriukas = (apačia + viršus) // 2
# patikriname, ar `viduriukas` indekse yra mūsų ieškomas tikslas, ir jį atradus grąžiname indeksą.
if sąrašas[viduriukas] == tikslas:
return viduriukas
# jeigu ne, tai pagal tai, kurioje pusėje yra ieškomas elementas pakeičiame viršutinį arba apatinį indeksą
elif sąrašas[viduriukas] < tikslas:
apačia = viduriukas + 1
else:
viršus = viduriukas - 1
# ir kartojame iš naujo, bet jau su nauju, per pus mažesniu rėžiu

return -1 # tikslas nerastas

sąrašas = [1,2,3,4,5,6,7,8,9,10]
print(dvejetainė_paieška(sąrašas, 7)) # 6
</syntaxhighlight>

Panagrinėkim detaliai, kaip vyksta procesas. Ieškome, kur yra skaičius 7, sąraše [1,2,3,4,5,6,7,8,9,10]. Funkcijos pradžios kintamieji:
<syntaxhighlight lang="python">
apačia = 0
viršus = 9 # (ilgis 10 - 1 )
</syntaxhighlight>
Pirmas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 4 # (0 + 9) // 2
# sąrašas[4] saugo reikšmę 5. Ne mūsų ieškomas skaičius.
# kadangi tikslas yra surasti 7, tai mūsų kito ciklo metu ieškosime viršutinėje sąrašo dalyje, todėl nusistatome naują apačios reikšmę, viduriukas + 1.
apačia = 5 # (4 + 1)
</syntaxhighlight>
Antras `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 7 # (5 + 9) // 2
# sąrašas[7] saugo reikšmę 8. Jau arčiau, bet ne dar vis ne mūsų ieškoma reikšmė 7. Nustatome šįkartą naują viršutinę reikšmę, viduriukas - 1
viršus = 6 # (7 - 1)
</syntaxhighlight>
Trečias `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 5 # (5 + 6) // 2
# sąrašas[5] saugo reikmę 6. Vėl pro šalį. Nustatome naują apatinę reikšmę:
apačia = 6 # (5 + 1)
</syntaxhighlight>
Ketvirtas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 6 # (6 + 6) // 2
sąrašas[6] saugo reikšmę 7. Valio! Radom. Grąžinam indeksą 7.
</syntaxhighlight>

Atkreipk dėmesį, kad dvejetainės paieškos algoritmas atrado reikšmę per 4 ciklus. Kaip manai, kiek ciklų prireiktų tiesinės paieškos algoritmui? Pasufleruosiu... Daugiau :)

= Rikiavimas =

Rikiavimo algoritmai naudojami duomenų sąrašui išdėstyti tam tikra tvarka. Rikiavimo algoritmų yra daug ir įvairių, bet papasakosiu tik kelis naudingiausius. Pateiktus algoritmus tu gelėsi nesunkiai pritaikyti ir kitokiems duomenų tipams, ne tik žodžiams. Bet apie tai vėliau.

== Įterpimo rikiavimas (Insertion Sort) ==

Įterpimo rikiavimas yra paprastas rikiavimo algoritmas, kuris veikia padalydamas sąrašą į dvi dalis: surikiuotą ir nesurikiuotą. Tada iteratyviai paimamas elementas iš nerikiuotos dalies ir įterpiamas į reikiamą vietą surikiuotoje dalyje, kol visas sąrašas surikiuojamas.
Pažiūrėkim, kaip tai atrodo:

<syntaxhighlight lang="python">
def įterpimo_rikiavimas(sąrašas):
for i in range(1, len(sąrašas)):
raktas = sąrašas[i]
j = i - 1
while j >= 0 and sąrašas[j] > raktas:
sąrašas[j+1] = sąrašas[j]
j -= 1
sąrašas[j+1] = raktas
</syntaxhighlight>

Ši funkcija paima sąrašą <code>sąrašas</code> ir sutikiuoja jį didėjimo tvarka, naudodama įterpimo rikiavimą. Ji pradeda iteruoti per sąrašą nuo antrojo elemento (indeksas 1) iki galo. Kiekvieno elemento reikšmė išsaugoma kaip <code>raktas</code>, o jo indeksas - kaip <code>i</code>, tada einama atgal per surikiuotą sąrašo dalį (nuo indekso <code>i-1</code> iki 0) ir ieškoma tinkamos vietos rakto reikšmei įterpti. Tai daroma lyginant rakto vertę su kiekvienu išrikiuotos sąrašo dalies elementu ir perstumiant didesnius elementus viena pozicija į dešinę, kol randama tinkama pozicija. Suradęs tinkamą poziciją, į ją įterpia rakto reikšmę.

Įterpimo rikiavimo laiko sudėtingumas blogiausiu atveju yra O(n2), o tai reiškia, kad didelių įvesties sąrašų atveju jis gali būti lėtas. Tačiau jis turi mažesnes pridėtines išlaidas nei kai kurie kiti rikiavivmo algoritmai ir gali būti efektyvesnis už juos mažiems įvesties sąrašams arba iš dalies surikiuotiems įvesties sąrašams.

== Burbulinis rikiavimas (Bubble sort) ==
Burbulinis rikiavimas - tai paprastas rikiavimo algoritmas, kuris pakartotinai pereina per sąrašą, palygina gretimus elementus ir sukeičia juos vietomis, jei jų eiliškumas netinkamas. Pažiūrėkime į burbulinio rikiavimo funkcijos pavyzdį:

<syntaxhighlight lang="python">
def burbulinis_rikiavimas(sąrašas):
sąrašo_ilgis = len(sąrašas)

for i in range(sąrašo_ilgis):
for j in range(0, sąrašo_ilgis-i-1):
if sąrašas[j] > sąrašas[j+1]:
sąrašas[j], sąrašas[j+1] = sąrašas[j+1], sąrašas[j]
</syntaxhighlight>
Ši funkcija paima sąrašą <code>sąrašas</code> ir surikiuoja jį didėjančia tvarka, naudodama burbulinį rikiavimą.

== Greitasis rikiavimas (Quicksort) ==
"Quicksort" yra plačiai naudojamas rikiavimo algoritmas, kuriame taikomas "skaldyk ir valdyk" metodas. Jis veikia iš masyvo (arba sąrašo) išrenkant ašinį elementą ir kitus elementus suskirstant į du papildomus masyvus pagal tai, ar jie mažesni, ar didesni už ašinį elementą. Tada šis procesas rekursiškai kartojamas kiekviename pogrupyje.

Štai "Quicksort" funkcijos pavyzdys "Python" kalba:

<syntaxhighlight lang="python">
def quicksort(masyvas):
mažiau = []
lygus = []
daugiau = []
if len(masyvas) > 1:
ašis = masyvas[0]
for x in masyvas:
if x < ašis:
mažiau.append(x)
elif x == ašis:
lygus.append(x)
elif x > ašis:
daugiau.append(x)
# neužmiršk grąžinti rezultato!
return quicksort(mažiau)+lygus+quicksort(daugiau)
# Atkreipk dėmesį, kad naudojame `lygus`, o ne `ašis`
else:
return masyvas
</syntaxhighlight>

Funkcijos parametras <code>masyvas</code> yra sąrašas, kurį norime surikiuoti.

Pagrindinė funkcijos dalis yra sąlyga <code>if len(masyvas) > 1:</code>, kuri tikrina, ar sąraše yra daugiau nei vienas elementas. Jei sąraše yra tik vienas arba nulis elementų, tai jis jau yra surikiuotas, todėl tiesiog grąžinamas toks pat sąrašas.

Jei sąraše yra daugiau nei vienas elementas, algoritmas tęsiasi. Pirma, parenkamas elementas <code>ašis</code>, šiuo atveju tai yra pirmas sąrašo elementas <code>masyvas[0]</code>. Tuomet algoritmas eina per visus sąrašo elementus ir prideda juos į tris skirtingus sąrašus (<code>mažiau</code>, <code>lygus</code>, <code>daugiau</code>), priklausomai nuo to, kaip jie lyginami su <code>ašis</code>.

* Jei elementas '''x''' yra mažesnis už '''ašis''', jis pridedamas į '''mažiau''' sąrašą.
* Jei elementas '''x''' yra lygus '''ašis''', jis pridedamas į '''lygus''' sąrašą.
* Jei elementas '''x''' yra didesnis už '''ašis''', jis pridedamas į '''daugiau''' sąrašą.

Tai vadinama ''dalijimo procesu''. Po šio proceso turime tris naujus sąrašus: '''mažiau''', '''lygus''' ir '''daugiau''', kurie yra dalinai surikiuoti (mažesni už '''ašis''', lygūs '''ašis''' ir didesni už '''ašis''').

Toliau funkcija naudoja rekursiją ir kviečia save su <code>mažiau</code> ir <code>daugiau</code> sąrašais, taip pritaikydama dalijimo ir surikiavimo procesą šiems dviejams sąrašams atskirai. Rekursyviai kviečiant save, galiausiai bus pasiektas atvejis, kai sąrašai <code>mažiau</code> ir <code>daugiau</code> bus sudaryti iš nulio arba vieno elemento, o tai reiškia, kad jie jau surikiuoti. Tada funkcija grąžina sudėtą sąrašą: <code>quicksort(mažiau) + lygus + quicksort(daugiau)</code>, kuris sudarys pilnai surikiuotą sąrašą.

Galutinis rezultatas yra surikiuotas sąrašas, kuris yra grąžinamas iš pradinių sąrašų iškvietimo vietos.

Pvz. jei iškviečiame funkciją <code>quicksort([3, 1, 4, 1, 5, 9, 2, 6, 5])</code>, tai gražins <code>[1, 1, 2, 3, 4, 5, 5, 6, 9]</code>, kuris yra pradinis sąrašas surikiuotas didėjimo tvarka.

== Suliejimo rikiavimas (Merge sort) ==
"Merge sort" yra rikiavimo algoritmas, kuris veikia pagal dalinimo ir sujungimo principą. Tai efektyvus algoritmas, kuris naudoja rekursiją.

Merge sort algoritmas veikia taip:
* Jei sąraše yra nulis arba vienas elementas, tai jis jau yra surikiuotas. Grąžinamas tas pats sąrašas.
* Jei sąraše yra daugiau nei vienas elementas, sąrašas yra padalinamas į dvi lygias dalis.
* Kiekviena dalis yra rekursyviai rikiuojama naudojant '''merge sort''' algoritmą.
* Surikiuotos dvi dalys yra sujungiamos į vieną sąrašą. Sujungimo metu elementai yra palyginami ir sudedami į naują sąrašą didėjimo tvarka.

Šis procesas yra pakartojamas tol, kol visi sąrašai yra padalinti iki vieno elemento ir tada sujungti į vieną galutinį surikiuotą sąrašą.

Merge sort algoritmas yra efektyvus, nes dalijimo ir sujungimo žingsniai yra vykdomi daug kartų, o kiekviename žingsnyje sąrašas yra padalintas į dvi lygias dalis. Tai leidžia efektyviai rikiuoti didelius sąrašus.

<syntaxhighlight lang="python">
def merge_sort(sąrašas):
# sąraše yra nulis arba vienas elementas
if len(sąrašas) <= 1:
return sąrašas

# Dalinimo žingsnis: padaliname sąrašą į dvi lygias dalis
vidurys = len(sąrašas) // 2
kairė = sąrašas[:vidurys]
dešinė = sąrašas[vidurys:]

# Rekursyviai rikiuojame kiekvieną dalį
kairė = merge_sort(kairė)
dešinė = merge_sort(dešinė)

# Sujungimo žingsnis: sujungiame surikiuotas dalis į vieną sąrašą
return merge(kairė, dešinė)

def merge(kairė, dešinė):
rezultatas = []
i = 0 # indeksas kairėje dalyje
j = 0 # indeksas dešinėje dalyje

# Lyginame ir sujungiame elementus
while i < len(kairė) and j < len(dešinė):
if kairė[i] <= dešinė[j]:
rezultatas.append(kairė[i])
i += 1
else:
rezultatas.append(dešinė[j])
j += 1

# Jei viena dalis baigiasi anksčiau, pridedame likusius elementus
while i < len(kairė):
rezultatas.append(kairė[i])
i += 1
while j < len(dešinė):
rezultatas.append(dešinė[j])
j += 1

return rezultatas

# Pavyzdys naudojant merge_sort funkciją
sąrašas = [3, 1, 4, 1, 5, 9, 2, 6, 5]
surikiuotas_sąrašas = merge_sort(sąrašas)
print(surikiuotas_sąrašas)
</syntaxhighlight>

Šis pavyzdys naudoja dvi funkcijas: <code>merge_sort</code> ir <code>merge</code>. <code>merge_sort</code> funkcija atlieka dalinimo ir rekursyvaus rikiavimo žingsnius, o <code>merge</code> funkcija atlieka surikiuotų dalių sujungimą.

Rezultatas šio pavyzdžio bus:
[1, 1, 2, 3, 4, 5, 5, 6, 9]

Vadovėlis/Paieška ir Rikiavimas

2023-06-28T13:01:19Z

Monika: /* Burbulinis rikiavimas */

Atlikęs praeito skyriaus uždavinius, jau daug žinai apie sąrašo sukūrimą ir visus bazinius sąrašo metodus. Dabar pasinaudosime įgytomis žiniomis ir susipažinsime su labai dažnai sutinkamais uždaviniais: paieška ir rikiavimas.

= Paieška =

Paieškos algoritmai naudojami norint rasti konkretų elementą sąraše ar duomenų masyve. Yra keletas paieškos algoritmų, tačiau parodysiu du dažniausiai naudojamus - tiesinę paiešką ir dvejetainę paiešką.

== Tiesinė paieška ==
Tiesinė paieška - tai paprastas paieškos algoritmas, kuris, ieškodamas tikslinės reikšmės, peržiūri kiekvieną sąrašo elementą. Pažiūrėk į tiesinės paieškos funkcijos pavyzdį "Python" kalba:

<syntaxhighlight lang="python">
def tiesinė_paieška(sąrašas, ieškomas_žodis):
for i in range(len(sąrašas)):
if sąrašas[i] == ieškomas_žodis:
return i
return -1 # ieškomas_žodis nerastas
</syntaxhighlight>

Ši funkcija priima masyvą <code>sąrašas</code> ir tikslinę reikšmę <code>ieškomas_žodis</code> ir grąžina tikslinės reikšmės indeksą masyve. Jei tikslinė vertė nerandama masyve, funkcija grąžina -1. Labai praprasta ir aišku.

== Dvejetainė paieška ==
Kita vertus, dvejetainė paieška yra efektyvesnis paieškos algoritmas, kuris veikia tik surikiuotose masyvuose (sąrašuose). Jis veikia pakartotinai dalydamas paieškos intervalą per pusę, kol randama tikslinė reikšmė. Painu? Daug aiškiau bus pažiūrėjus šį pavyzdį:

<syntaxhighlight lang="python">
def dvejetainė_paieška(sąrašas, tikslas):
# išsisaugome sąrašo pirmą ir paskutinį indeksą
apačia = 0
viršus = len(sąrašas) - 1

while apačia <= viršus:
# atrandame vidurį pagal formulę: (pradžios indeksas + pabaigos indeksas) padalintas per pusę, be liekanos
viduriukas = (apačia + viršus) // 2
# patikriname, ar `viduriukas` indekse yra mūsų ieškomas tikslas, ir jį atradus grąžiname indeksą.
if sąrašas[viduriukas] == tikslas:
return viduriukas
# jeigu ne, tai pagal tai, kurioje pusėje yra ieškomas elementas pakeičiame viršutinį arba apatinį indeksą
elif sąrašas[viduriukas] < tikslas:
apačia = viduriukas + 1
else:
viršus = viduriukas - 1
# ir kartojame iš naujo, bet jau su nauju, per pus mažesniu rėžiu

return -1 # tikslas nerastas

sąrašas = [1,2,3,4,5,6,7,8,9,10]
print(dvejetainė_paieška(sąrašas, 7)) # 6
</syntaxhighlight>

Panagrinėkim detaliai, kaip vyksta procesas. Ieškome, kur yra skaičius 7, sąraše [1,2,3,4,5,6,7,8,9,10]. Funkcijos pradžios kintamieji:
<syntaxhighlight lang="python">
apačia = 0
viršus = 9 # (ilgis 10 - 1 )
</syntaxhighlight>
Pirmas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 4 # (0 + 9) // 2
# sąrašas[4] saugo reikšmę 5. Ne mūsų ieškomas skaičius.
# kadangi tikslas yra surasti 7, tai mūsų kito ciklo metu ieškosime viršutinėje sąrašo dalyje, todėl nusistatome naują apačios reikšmę, viduriukas + 1.
apačia = 5 # (4 + 1)
</syntaxhighlight>
Antras `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 7 # (5 + 9) // 2
# sąrašas[7] saugo reikšmę 8. Jau arčiau, bet ne dar vis ne mūsų ieškoma reikšmė 7. Nustatome šįkartą naują viršutinę reikšmę, viduriukas - 1
viršus = 6 # (7 - 1)
</syntaxhighlight>
Trečias `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 5 # (5 + 6) // 2
# sąrašas[5] saugo reikmę 6. Vėl pro šalį. Nustatome naują apatinę reikšmę:
apačia = 6 # (5 + 1)
</syntaxhighlight>
Ketvirtas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 6 # (6 + 6) // 2
sąrašas[6] saugo reikšmę 7. Valio! Radom. Grąžinam indeksą 7.
</syntaxhighlight>

Atkreipk dėmesį, kad dvejetainės paieškos algoritmas atrado reikšmę per 4 ciklus. Kaip manai, kiek ciklų prireiktų tiesinės paieškos algoritmui? Pasufleruosiu... Daugiau :)

= Rikiavimas =

Rikiavimo algoritmai naudojami duomenų sąrašui išdėstyti tam tikra tvarka. Rikiavimo algoritmų yra daug ir įvairių, bet papasakosiu tik kelis naudingiausius. Pateiktus algoritmus tu gelėsi nesunkiai pritaikyti ir kitokiems duomenų tipams, ne tik žodžiams. Bet apie tai vėliau.

== Įterpimo rikiavimas (Insertion Sort) ==

Įterpimo rikiavimas yra paprastas rikiavimo algoritmas, kuris veikia padalydamas sąrašą į dvi dalis: surikiuotą ir nesurikiuotą. Tada iteratyviai paimamas elementas iš nerikiuotos dalies ir įterpiamas į reikiamą vietą surikiuotoje dalyje, kol visas sąrašas surikiuojamas.
Pažiūrėkim, kaip tai atrodo:

<syntaxhighlight lang="python">
def įterpimo_rikiavimas(sąrašas):
for i in range(1, len(sąrašas)):
raktas = sąrašas[i]
j = i - 1
while j >= 0 and sąrašas[j] > raktas:
sąrašas[j+1] = sąrašas[j]
j -= 1
sąrašas[j+1] = raktas
</syntaxhighlight>

Ši funkcija paima sąrašą <code>sąrašas</code> ir sutikiuoja jį didėjimo tvarka, naudodama įterpimo rikiavimą. Ji pradeda iteruoti per sąrašą nuo antrojo elemento (indeksas 1) iki galo. Kiekvieno elemento reikšmė išsaugoma kaip <code>raktas</code>, o jo indeksas - kaip <code>i</code>, tada einama atgal per surikiuotą sąrašo dalį (nuo indekso <code>i-1</code> iki 0) ir ieškoma tinkamos vietos rakto reikšmei įterpti. Tai daroma lyginant rakto vertę su kiekvienu išrikiuotos sąrašo dalies elementu ir perstumiant didesnius elementus viena pozicija į dešinę, kol randama tinkama pozicija. Suradęs tinkamą poziciją, į ją įterpia rakto reikšmę.

Įterpimo rikiavimo laiko sudėtingumas blogiausiu atveju yra O(n2), o tai reiškia, kad didelių įvesties sąrašų atveju jis gali būti lėtas. Tačiau jis turi mažesnes pridėtines išlaidas nei kai kurie kiti rikiavivmo algoritmai ir gali būti efektyvesnis už juos mažiems įvesties sąrašams arba iš dalies surikiuotiems įvesties sąrašams.

== Burbulinis rikiavimas (Bubble sort) ==
Burbulinis rikiavimas - tai paprastas rikiavimo algoritmas, kuris pakartotinai pereina per sąrašą, palygina gretimus elementus ir sukeičia juos vietomis, jei jų eiliškumas netinkamas. Pažiūrėkim burbulinio rikiavimo funkcijos pavyzdį:

<syntaxhighlight lang="python">
def burbulinis_rikiavimas(sąrašas):
sąrašo_ilgis = len(sąrašas)

for i in range(sąrašo_ilgis):
for j in range(0, sąrašo_ilgis-i-1):
if sąrašas[j] > sąrašas[j+1]:
sąrašas[j], sąrašas[j+1] = sąrašas[j+1], sąrašas[j]
</syntaxhighlight>
Ši funkcija paima sąrašą <code>sąrašas</code> ir surikiuoja jį didėjančia tvarka, naudodama burbulinį rikiavimą.

== Greitasis rikiavimas (Quicksort) ==
"Quicksort" yra plačiai naudojamas rikiavimo algoritmas, kuriame taikomas "skaldyk ir valdyk" metodas. Jis veikia iš masyvo (arba sąrašo) išrenkant ašinį elementą ir kitus elementus suskirstant į du papildomus masyvus pagal tai, ar jie mažesni, ar didesni už ašinį elementą. Tada šis procesas rekursiškai kartojamas kiekviename pogrupyje.

Štai "Quicksort" funkcijos pavyzdys "Python" kalba:

<syntaxhighlight lang="python">
def quicksort(masyvas):
mažiau = []
lygus = []
daugiau = []
if len(masyvas) > 1:
ašis = masyvas[0]
for x in masyvas:
if x < ašis:
mažiau.append(x)
elif x == ašis:
lygus.append(x)
elif x > ašis:
daugiau.append(x)
# neužmiršk grąžinti rezultato!
return quicksort(mažiau)+lygus+quicksort(daugiau)
# Atkreipk dėmesį, kad naudojame `lygus`, o ne `ašis`
else:
return masyvas
</syntaxhighlight>

Funkcijos parametras <code>masyvas</code> yra sąrašas, kurį norime surikiuoti.

Pagrindinė funkcijos dalis yra sąlyga <code>if len(masyvas) > 1:</code>, kuri tikrina, ar sąraše yra daugiau nei vienas elementas. Jei sąraše yra tik vienas arba nulis elementų, tai jis jau yra surikiuotas, todėl tiesiog grąžinamas toks pat sąrašas.

Jei sąraše yra daugiau nei vienas elementas, algoritmas tęsiasi. Pirma, parenkamas elementas <code>ašis</code>, šiuo atveju tai yra pirmas sąrašo elementas <code>masyvas[0]</code>. Tuomet algoritmas eina per visus sąrašo elementus ir prideda juos į tris skirtingus sąrašus (<code>mažiau</code>, <code>lygus</code>, <code>daugiau</code>), priklausomai nuo to, kaip jie lyginami su <code>ašis</code>.

* Jei elementas '''x''' yra mažesnis už '''ašis''', jis pridedamas į '''mažiau''' sąrašą.
* Jei elementas '''x''' yra lygus '''ašis''', jis pridedamas į '''lygus''' sąrašą.
* Jei elementas '''x''' yra didesnis už '''ašis''', jis pridedamas į '''daugiau''' sąrašą.

Tai vadinama ''dalijimo procesu''. Po šio proceso turime tris naujus sąrašus: '''mažiau''', '''lygus''' ir '''daugiau''', kurie yra dalinai surikiuoti (mažesni už '''ašis''', lygūs '''ašis''' ir didesni už '''ašis''').

Toliau funkcija naudoja rekursiją ir kviečia save su <code>mažiau</code> ir <code>daugiau</code> sąrašais, taip pritaikydama dalijimo ir surikiavimo procesą šiems dviejams sąrašams atskirai. Rekursyviai kviečiant save, galiausiai bus pasiektas atvejis, kai sąrašai <code>mažiau</code> ir <code>daugiau</code> bus sudaryti iš nulio arba vieno elemento, o tai reiškia, kad jie jau surikiuoti. Tada funkcija grąžina sudėtą sąrašą: <code>quicksort(mažiau) + lygus + quicksort(daugiau)</code>, kuris sudarys pilnai surikiuotą sąrašą.

Galutinis rezultatas yra surikiuotas sąrašas, kuris yra grąžinamas iš pradinių sąrašų iškvietimo vietos.

Pvz. jei iškviečiame funkciją <code>quicksort([3, 1, 4, 1, 5, 9, 2, 6, 5])</code>, tai gražins <code>[1, 1, 2, 3, 4, 5, 5, 6, 9]</code>, kuris yra pradinis sąrašas surikiuotas didėjimo tvarka.

== Suliejimo rikiavimas (Merge sort) ==
"Merge sort" yra rikiavimo algoritmas, kuris veikia pagal dalinimo ir sujungimo principą. Tai efektyvus algoritmas, kuris naudoja rekursiją.

Merge sort algoritmas veikia taip:
* Jei sąraše yra nulis arba vienas elementas, tai jis jau yra surikiuotas. Grąžinamas tas pats sąrašas.
* Jei sąraše yra daugiau nei vienas elementas, sąrašas yra padalinamas į dvi lygias dalis.
* Kiekviena dalis yra rekursyviai rikiuojama naudojant '''merge sort''' algoritmą.
* Surikiuotos dvi dalys yra sujungiamos į vieną sąrašą. Sujungimo metu elementai yra palyginami ir sudedami į naują sąrašą didėjimo tvarka.

Šis procesas yra pakartojamas tol, kol visi sąrašai yra padalinti iki vieno elemento ir tada sujungti į vieną galutinį surikiuotą sąrašą.

Merge sort algoritmas yra efektyvus, nes dalijimo ir sujungimo žingsniai yra vykdomi daug kartų, o kiekviename žingsnyje sąrašas yra padalintas į dvi lygias dalis. Tai leidžia efektyviai rikiuoti didelius sąrašus.

<syntaxhighlight lang="python">
def merge_sort(sąrašas):
# sąraše yra nulis arba vienas elementas
if len(sąrašas) <= 1:
return sąrašas

# Dalinimo žingsnis: padaliname sąrašą į dvi lygias dalis
vidurys = len(sąrašas) // 2
kairė = sąrašas[:vidurys]
dešinė = sąrašas[vidurys:]

# Rekursyviai rikiuojame kiekvieną dalį
kairė = merge_sort(kairė)
dešinė = merge_sort(dešinė)

# Sujungimo žingsnis: sujungiame surikiuotas dalis į vieną sąrašą
return merge(kairė, dešinė)

def merge(kairė, dešinė):
rezultatas = []
i = 0 # indeksas kairėje dalyje
j = 0 # indeksas dešinėje dalyje

# Lyginame ir sujungiame elementus
while i < len(kairė) and j < len(dešinė):
if kairė[i] <= dešinė[j]:
rezultatas.append(kairė[i])
i += 1
else:
rezultatas.append(dešinė[j])
j += 1

# Jei viena dalis baigiasi anksčiau, pridedame likusius elementus
while i < len(kairė):
rezultatas.append(kairė[i])
i += 1
while j < len(dešinė):
rezultatas.append(dešinė[j])
j += 1

return rezultatas

# Pavyzdys naudojant merge_sort funkciją
sąrašas = [3, 1, 4, 1, 5, 9, 2, 6, 5]
surikiuotas_sąrašas = merge_sort(sąrašas)
print(surikiuotas_sąrašas)
</syntaxhighlight>

Šis pavyzdys naudoja dvi funkcijas: <code>merge_sort</code> ir <code>merge</code>. <code>merge_sort</code> funkcija atlieka dalinimo ir rekursyvaus rikiavimo žingsnius, o <code>merge</code> funkcija atlieka surikiuotų dalių sujungimą.

Rezultatas šio pavyzdžio bus:
[1, 1, 2, 3, 4, 5, 5, 6, 9]

Vadovėlis/Paieška ir Rikiavimas

2023-06-28T12:59:17Z

Monika: /* Dvejetainė paieška */

Atlikęs praeito skyriaus uždavinius, jau daug žinai apie sąrašo sukūrimą ir visus bazinius sąrašo metodus. Dabar pasinaudosime įgytomis žiniomis ir susipažinsime su labai dažnai sutinkamais uždaviniais: paieška ir rikiavimas.

= Paieška =

Paieškos algoritmai naudojami norint rasti konkretų elementą sąraše ar duomenų masyve. Yra keletas paieškos algoritmų, tačiau parodysiu du dažniausiai naudojamus - tiesinę paiešką ir dvejetainę paiešką.

== Tiesinė paieška ==
Tiesinė paieška - tai paprastas paieškos algoritmas, kuris, ieškodamas tikslinės reikšmės, peržiūri kiekvieną sąrašo elementą. Pažiūrėk į tiesinės paieškos funkcijos pavyzdį "Python" kalba:

<syntaxhighlight lang="python">
def tiesinė_paieška(sąrašas, ieškomas_žodis):
for i in range(len(sąrašas)):
if sąrašas[i] == ieškomas_žodis:
return i
return -1 # ieškomas_žodis nerastas
</syntaxhighlight>

Ši funkcija priima masyvą <code>sąrašas</code> ir tikslinę reikšmę <code>ieškomas_žodis</code> ir grąžina tikslinės reikšmės indeksą masyve. Jei tikslinė vertė nerandama masyve, funkcija grąžina -1. Labai praprasta ir aišku.

== Dvejetainė paieška ==
Kita vertus, dvejetainė paieška yra efektyvesnis paieškos algoritmas, kuris veikia tik surikiuotose masyvuose (sąrašuose). Jis veikia pakartotinai dalydamas paieškos intervalą per pusę, kol randama tikslinė reikšmė. Painu? Daug aiškiau bus pažiūrėjus šį pavyzdį:

<syntaxhighlight lang="python">
def dvejetainė_paieška(sąrašas, tikslas):
# išsisaugome sąrašo pirmą ir paskutinį indeksą
apačia = 0
viršus = len(sąrašas) - 1

while apačia <= viršus:
# atrandame vidurį pagal formulę: (pradžios indeksas + pabaigos indeksas) padalintas per pusę, be liekanos
viduriukas = (apačia + viršus) // 2
# patikriname, ar `viduriukas` indekse yra mūsų ieškomas tikslas, ir jį atradus grąžiname indeksą.
if sąrašas[viduriukas] == tikslas:
return viduriukas
# jeigu ne, tai pagal tai, kurioje pusėje yra ieškomas elementas pakeičiame viršutinį arba apatinį indeksą
elif sąrašas[viduriukas] < tikslas:
apačia = viduriukas + 1
else:
viršus = viduriukas - 1
# ir kartojame iš naujo, bet jau su nauju, per pus mažesniu rėžiu

return -1 # tikslas nerastas

sąrašas = [1,2,3,4,5,6,7,8,9,10]
print(dvejetainė_paieška(sąrašas, 7)) # 6
</syntaxhighlight>

Panagrinėkim detaliai, kaip vyksta procesas. Ieškome, kur yra skaičius 7, sąraše [1,2,3,4,5,6,7,8,9,10]. Funkcijos pradžios kintamieji:
<syntaxhighlight lang="python">
apačia = 0
viršus = 9 # (ilgis 10 - 1 )
</syntaxhighlight>
Pirmas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 4 # (0 + 9) // 2
# sąrašas[4] saugo reikšmę 5. Ne mūsų ieškomas skaičius.
# kadangi tikslas yra surasti 7, tai mūsų kito ciklo metu ieškosime viršutinėje sąrašo dalyje, todėl nusistatome naują apačios reikšmę, viduriukas + 1.
apačia = 5 # (4 + 1)
</syntaxhighlight>
Antras `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 7 # (5 + 9) // 2
# sąrašas[7] saugo reikšmę 8. Jau arčiau, bet ne dar vis ne mūsų ieškoma reikšmė 7. Nustatome šįkartą naują viršutinę reikšmę, viduriukas - 1
viršus = 6 # (7 - 1)
</syntaxhighlight>
Trečias `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 5 # (5 + 6) // 2
# sąrašas[5] saugo reikmę 6. Vėl pro šalį. Nustatome naują apatinę reikšmę:
apačia = 6 # (5 + 1)
</syntaxhighlight>
Ketvirtas `while` ciklas:
<syntaxhighlight lang="python">
viduriukas = 6 # (6 + 6) // 2
sąrašas[6] saugo reikšmę 7. Valio! Radom. Grąžinam indeksą 7.
</syntaxhighlight>

Atkreipk dėmesį, kad dvejetainės paieškos algoritmas atrado reikšmę per 4 ciklus. Kaip manai, kiek ciklų prireiktų tiesinės paieškos algoritmui? Pasufleruosiu... Daugiau :)

= Rikiavimas =

Rikiavimo algoritmai naudojami duomenų sąrašui išdėstyti tam tikra tvarka. Rikiavimo algoritmų yra daug ir įvairių, bet papasakosiu tik kelis naudingiausius. Pateiktus algoritmus tu gelėsi nesunkiai pritaikyti ir kitokiems duomenų tipams, ne tik žodžiams. Bet apie tai vėliau.

== Įterpimo rikiavimas (Insertion Sort) ==

Įterpimo rikiavimas yra paprastas rikiavimo algoritmas, kuris veikia padalydamas sąrašą į dvi dalis: surikiuotą ir nesurikiuotą. Tada iteratyviai paimamas elementas iš nerikiuotos dalies ir įterpiamas į reikiamą vietą surikiuotoje dalyje, kol visas sąrašas surikiuojamas.
Pažiūrėkim, kaip tai atrodo:

<syntaxhighlight lang="python">
def įterpimo_rikiavimas(sąrašas):
for i in range(1, len(sąrašas)):
raktas = sąrašas[i]
j = i - 1
while j >= 0 and sąrašas[j] > raktas:
sąrašas[j+1] = sąrašas[j]
j -= 1
sąrašas[j+1] = raktas
</syntaxhighlight>

Ši funkcija paima sąrašą <code>sąrašas</code> ir sutikiuoja jį didėjimo tvarka, naudodama įterpimo rikiavimą. Ji pradeda iteruoti per sąrašą nuo antrojo elemento (indeksas 1) iki galo. Kiekvieno elemento reikšmė išsaugoma kaip <code>raktas</code>, o jo indeksas - kaip <code>i</code>, tada einama atgal per surikiuotą sąrašo dalį (nuo indekso <code>i-1</code> iki 0) ir ieškoma tinkamos vietos rakto reikšmei įterpti. Tai daroma lyginant rakto vertę su kiekvienu išrikiuotos sąrašo dalies elementu ir perstumiant didesnius elementus viena pozicija į dešinę, kol randama tinkama pozicija. Suradęs tinkamą poziciją, į ją įterpia rakto reikšmę.

Įterpimo rikiavimo laiko sudėtingumas blogiausiu atveju yra O(n2), o tai reiškia, kad didelių įvesties sąrašų atveju jis gali būti lėtas. Tačiau jis turi mažesnes pridėtines išlaidas nei kai kurie kiti rikiavivmo algoritmai ir gali būti efektyvesnis už juos mažiems įvesties sąrašams arba iš dalies surikiuotiems įvesties sąrašams.

== Burbulinis rikiavimas ==
Burbulinis rikiavimas ( angliškai "Bubble sort" ) - tai paprastas rikiavimo algoritmas, kuris pakartotinai pereina per sąrašą, palygina gretimus elementus ir sukeičia juos vietomis, jei jų eiliškumas netinkamas. Pažiūrėkim burbulinio rikiavimo funkcijos pavyzdį:

<syntaxhighlight lang="python">
def burbulinis_rikiavimas(sąrašas):
sąrašo_ilgis = len(sąrašas)

for i in range(sąrašo_ilgis):
for j in range(0, sąrašo_ilgis-i-1):
if sąrašas[j] > sąrašas[j+1]:
sąrašas[j], sąrašas[j+1] = sąrašas[j+1], sąrašas[j]
</syntaxhighlight>
Ši funkcija paima sąrašą <code>sąrašas</code> ir surikiuoja jį didėjančia tvarka, naudodama burbulinį rikiavimą.

== Greitasis rikiavimas (Quicksort) ==
"Quicksort" yra plačiai naudojamas rikiavimo algoritmas, kuriame taikomas "skaldyk ir valdyk" metodas. Jis veikia iš masyvo (arba sąrašo) išrenkant ašinį elementą ir kitus elementus suskirstant į du papildomus masyvus pagal tai, ar jie mažesni, ar didesni už ašinį elementą. Tada šis procesas rekursiškai kartojamas kiekviename pogrupyje.

Štai "Quicksort" funkcijos pavyzdys "Python" kalba:

<syntaxhighlight lang="python">
def quicksort(masyvas):
mažiau = []
lygus = []
daugiau = []
if len(masyvas) > 1:
ašis = masyvas[0]
for x in masyvas:
if x < ašis:
mažiau.append(x)
elif x == ašis:
lygus.append(x)
elif x > ašis:
daugiau.append(x)
# neužmiršk grąžinti rezultato!
return quicksort(mažiau)+lygus+quicksort(daugiau)
# Atkreipk dėmesį, kad naudojame `lygus`, o ne `ašis`
else:
return masyvas
</syntaxhighlight>

Funkcijos parametras <code>masyvas</code> yra sąrašas, kurį norime surikiuoti.

Pagrindinė funkcijos dalis yra sąlyga <code>if len(masyvas) > 1:</code>, kuri tikrina, ar sąraše yra daugiau nei vienas elementas. Jei sąraše yra tik vienas arba nulis elementų, tai jis jau yra surikiuotas, todėl tiesiog grąžinamas toks pat sąrašas.

Jei sąraše yra daugiau nei vienas elementas, algoritmas tęsiasi. Pirma, parenkamas elementas <code>ašis</code>, šiuo atveju tai yra pirmas sąrašo elementas <code>masyvas[0]</code>. Tuomet algoritmas eina per visus sąrašo elementus ir prideda juos į tris skirtingus sąrašus (<code>mažiau</code>, <code>lygus</code>, <code>daugiau</code>), priklausomai nuo to, kaip jie lyginami su <code>ašis</code>.

* Jei elementas '''x''' yra mažesnis už '''ašis''', jis pridedamas į '''mažiau''' sąrašą.
* Jei elementas '''x''' yra lygus '''ašis''', jis pridedamas į '''lygus''' sąrašą.
* Jei elementas '''x''' yra didesnis už '''ašis''', jis pridedamas į '''daugiau''' sąrašą.

Tai vadinama ''dalijimo procesu''. Po šio proceso turime tris naujus sąrašus: '''mažiau''', '''lygus''' ir '''daugiau''', kurie yra dalinai surikiuoti (mažesni už '''ašis''', lygūs '''ašis''' ir didesni už '''ašis''').

Toliau funkcija naudoja rekursiją ir kviečia save su <code>mažiau</code> ir <code>daugiau</code> sąrašais, taip pritaikydama dalijimo ir surikiavimo procesą šiems dviejams sąrašams atskirai. Rekursyviai kviečiant save, galiausiai bus pasiektas atvejis, kai sąrašai <code>mažiau</code> ir <code>daugiau</code> bus sudaryti iš nulio arba vieno elemento, o tai reiškia, kad jie jau surikiuoti. Tada funkcija grąžina sudėtą sąrašą: <code>quicksort(mažiau) + lygus + quicksort(daugiau)</code>, kuris sudarys pilnai surikiuotą sąrašą.

Galutinis rezultatas yra surikiuotas sąrašas, kuris yra grąžinamas iš pradinių sąrašų iškvietimo vietos.

Pvz. jei iškviečiame funkciją <code>quicksort([3, 1, 4, 1, 5, 9, 2, 6, 5])</code>, tai gražins <code>[1, 1, 2, 3, 4, 5, 5, 6, 9]</code>, kuris yra pradinis sąrašas surikiuotas didėjimo tvarka.

== Suliejimo rikiavimas (Merge sort) ==
"Merge sort" yra rikiavimo algoritmas, kuris veikia pagal dalinimo ir sujungimo principą. Tai efektyvus algoritmas, kuris naudoja rekursiją.

Merge sort algoritmas veikia taip:
* Jei sąraše yra nulis arba vienas elementas, tai jis jau yra surikiuotas. Grąžinamas tas pats sąrašas.
* Jei sąraše yra daugiau nei vienas elementas, sąrašas yra padalinamas į dvi lygias dalis.
* Kiekviena dalis yra rekursyviai rikiuojama naudojant '''merge sort''' algoritmą.
* Surikiuotos dvi dalys yra sujungiamos į vieną sąrašą. Sujungimo metu elementai yra palyginami ir sudedami į naują sąrašą didėjimo tvarka.

Šis procesas yra pakartojamas tol, kol visi sąrašai yra padalinti iki vieno elemento ir tada sujungti į vieną galutinį surikiuotą sąrašą.

Merge sort algoritmas yra efektyvus, nes dalijimo ir sujungimo žingsniai yra vykdomi daug kartų, o kiekviename žingsnyje sąrašas yra padalintas į dvi lygias dalis. Tai leidžia efektyviai rikiuoti didelius sąrašus.

<syntaxhighlight lang="python">
def merge_sort(sąrašas):
# sąraše yra nulis arba vienas elementas
if len(sąrašas) <= 1:
return sąrašas

# Dalinimo žingsnis: padaliname sąrašą į dvi lygias dalis
vidurys = len(sąrašas) // 2
kairė = sąrašas[:vidurys]
dešinė = sąrašas[vidurys:]

# Rekursyviai rikiuojame kiekvieną dalį
kairė = merge_sort(kairė)
dešinė = merge_sort(dešinė)

# Sujungimo žingsnis: sujungiame surikiuotas dalis į vieną sąrašą
return merge(kairė, dešinė)

def merge(kairė, dešinė):
rezultatas = []
i = 0 # indeksas kairėje dalyje
j = 0 # indeksas dešinėje dalyje

# Lyginame ir sujungiame elementus
while i < len(kairė) and j < len(dešinė):
if kairė[i] <= dešinė[j]:
rezultatas.append(kairė[i])
i += 1
else:
rezultatas.append(dešinė[j])
j += 1

# Jei viena dalis baigiasi anksčiau, pridedame likusius elementus
while i < len(kairė):
rezultatas.append(kairė[i])
i += 1
while j < len(dešinė):
rezultatas.append(dešinė[j])
j += 1

return rezultatas

# Pavyzdys naudojant merge_sort funkciją
sąrašas = [3, 1, 4, 1, 5, 9, 2, 6, 5]
surikiuotas_sąrašas = merge_sort(sąrašas)
print(surikiuotas_sąrašas)
</syntaxhighlight>

Šis pavyzdys naudoja dvi funkcijas: <code>merge_sort</code> ir <code>merge</code>. <code>merge_sort</code> funkcija atlieka dalinimo ir rekursyvaus rikiavimo žingsnius, o <code>merge</code> funkcija atlieka surikiuotų dalių sujungimą.

Rezultatas šio pavyzdžio bus:
[1, 1, 2, 3, 4, 5, 5, 6, 9]

Vadovėlis/Paieška ir Rikiavimas

2023-06-28T12:54:30Z

Monika:

Atlikęs praeito skyriaus uždavinius, jau daug žinai apie sąrašo sukūrimą ir visus bazinius sąrašo metodus. Dabar pasinaudosime įgytomis žiniomis ir susipažinsime su labai dažnai sutinkamais uždaviniais: paieška ir rikiavimas.

= Paieška =

Paieškos algoritmai naudojami norint rasti konkretų elementą sąraše ar duomenų masyve. Yra keletas paieškos algoritmų, tačiau parodysiu du dažniausiai naudojamus - tiesinę paiešką ir dvejetainę paiešką.

== Tiesinė paieška ==
Tiesinė paieška - tai paprastas paieškos algoritmas, kuris, ieškodamas tikslinės reikšmės, peržiūri kiekvieną sąrašo elementą. Pažiūrėk į tiesinės paieškos funkcijos pavyzdį "Python" kalba:

<syntaxhighlight lang="python">
def tiesinė_paieška(sąrašas, ieškomas_žodis):
for i in range(len(sąrašas)):
if sąrašas[i] == ieškomas_žodis:
return i
return -1 # ieškomas_žodis nerastas
</syntaxhighlight>

Ši funkcija priima masyvą <code>sąrašas</code> ir tikslinę reikšmę <code>ieškomas_žodis</code> ir grąžina tikslinės reikšmės indeksą masyve. Jei tikslinė vertė nerandama masyve, funkcija grąžina -1. Labai praprasta ir aišku.

== Dvejetainė paieška ==
Kita vertus, dvejetainė paieška yra efektyvesnis paieškos algoritmas, kuris veikia tik surikiuotose masyvuose (sąrašuose). Jis veikia pakartotinai dalydamas paieškos intervalą per pusę, kol randama tikslinė reikšmė. Painu? Daug aiškiau bus pažiūrėjus šį pavyzdį:

<syntaxhighlight lang="python">
def dvejetainė_paieška(sąrašas, tikslas):
# išsisaugome sąrašo pirmą ir paskutinį indeksą
apačia = 0
viršus = len(sąrašas) - 1

while apačia <= viršus:
# atrandame vidurį pagal formulę: (pradžios indeksas + pabaigos indeksas) padalintas per pusę, be liekanos
viduriukas = (apačia + viršus) // 2
# patikriname, ar `viduriukas` indekse yra mūsų ieškomas tikslas, ir jį atradus grąžiname indeksą.
if sąrašas[viduriukas] == tikslas:
return viduriukas
# jeigu ne, tai pagal tai, kurioje pusėje yra ieškomas elementas pakeičiame viršutinį arba apatinį indeksą
elif sąrašas[viduriukas] < tikslas:
apačia = viduriukas + 1
else:
viršus = viduriukas - 1
# ir kartojame iš naujo, bet jau su nauju, per pus mažesniu rėžiu

return -1 # tikslas nerastas

sąrašas = [1,2,3,4,5,6,7,8,9,10]
print(dvejetainė_paieška(sąrašas, 7)) # 6
</syntaxhighlight>

Panagrinėkim detaliai, kaip vyksta procesas. Ieškome, kur yra skaičius 7, sąraše [1,2,3,4,5,6,7,8,9,10]. Funkcijos pradžios kintamieji:
apačia = 0
viršus = 9 (ilgis 10 - 1 )
Pirmas `while` ciklas:
viduriukas = 4 # (0 + 9) // 2
sąrašas[4] saugo reikšmę 5. Ne mūsų ieškomas skaičius.
kadangi tikslas yra surasti 7, tai mūsų kito ciklo metu ieškosime viršutinėje sąrašo dalyje, todėl nusistatome naują apačios reikšmę, viduriukas + 1.
apačia = 4 + 1 = 5.
Antras `while` ciklas:
viduriukas = 7 # (5 + 9) // 2
sąrašas[7] saugo reikšmę 8. Jau arčiau, bet ne dar vis ne mūsų ieškoma reikšmė 7. Nustatome šįkartą naują viršutinę reikšmę, viduriukas - 1
viršus = 7 - 1 = 6
Trečias `while` ciklas:
viduriukas = 5 # (5 + 6) // 2
sąrašas[5] saugo reikmę 6. Vėl pro šalį. Nustatome naują apatinę reikšmę:
apačia = 5 + 1 = 6
Ketvirtas `while` ciklas:
viduriukas = 6 # (6 + 6) // 2
sąrašas[6] saugo reikšmę 7. Valio! Radom. Grąžinam indeksą 7.

Atkreipk dėmesį, kad dvejetainės paieškos algoritmas atrado reikšmę per 4 ciklus. Kaip manai, kiek ciklų prireiktų tiesinės paieškos algoritmui? Pasufleruosiu... Daugiau :)

= Rikiavimas =

Rikiavimo algoritmai naudojami duomenų sąrašui išdėstyti tam tikra tvarka. Rikiavimo algoritmų yra daug ir įvairių, bet papasakosiu tik kelis naudingiausius. Pateiktus algoritmus tu gelėsi nesunkiai pritaikyti ir kitokiems duomenų tipams, ne tik žodžiams. Bet apie tai vėliau.

== Įterpimo rikiavimas (Insertion Sort) ==

Įterpimo rikiavimas yra paprastas rikiavimo algoritmas, kuris veikia padalydamas sąrašą į dvi dalis: surikiuotą ir nesurikiuotą. Tada iteratyviai paimamas elementas iš nerikiuotos dalies ir įterpiamas į reikiamą vietą surikiuotoje dalyje, kol visas sąrašas surikiuojamas.
Pažiūrėkim, kaip tai atrodo:

<syntaxhighlight lang="python">
def įterpimo_rikiavimas(sąrašas):
for i in range(1, len(sąrašas)):
raktas = sąrašas[i]
j = i - 1
while j >= 0 and sąrašas[j] > raktas:
sąrašas[j+1] = sąrašas[j]
j -= 1
sąrašas[j+1] = raktas
</syntaxhighlight>

Ši funkcija paima sąrašą <code>sąrašas</code> ir sutikiuoja jį didėjimo tvarka, naudodama įterpimo rikiavimą. Ji pradeda iteruoti per sąrašą nuo antrojo elemento (indeksas 1) iki galo. Kiekvieno elemento reikšmė išsaugoma kaip <code>raktas</code>, o jo indeksas - kaip <code>i</code>, tada einama atgal per surikiuotą sąrašo dalį (nuo indekso <code>i-1</code> iki 0) ir ieškoma tinkamos vietos rakto reikšmei įterpti. Tai daroma lyginant rakto vertę su kiekvienu išrikiuotos sąrašo dalies elementu ir perstumiant didesnius elementus viena pozicija į dešinę, kol randama tinkama pozicija. Suradęs tinkamą poziciją, į ją įterpia rakto reikšmę.

Įterpimo rikiavimo laiko sudėtingumas blogiausiu atveju yra O(n2), o tai reiškia, kad didelių įvesties sąrašų atveju jis gali būti lėtas. Tačiau jis turi mažesnes pridėtines išlaidas nei kai kurie kiti rikiavivmo algoritmai ir gali būti efektyvesnis už juos mažiems įvesties sąrašams arba iš dalies surikiuotiems įvesties sąrašams.

== Burbulinis rikiavimas ==
Burbulinis rikiavimas ( angliškai "Bubble sort" ) - tai paprastas rikiavimo algoritmas, kuris pakartotinai pereina per sąrašą, palygina gretimus elementus ir sukeičia juos vietomis, jei jų eiliškumas netinkamas. Pažiūrėkim burbulinio rikiavimo funkcijos pavyzdį:

<syntaxhighlight lang="python">
def burbulinis_rikiavimas(sąrašas):
sąrašo_ilgis = len(sąrašas)

for i in range(sąrašo_ilgis):
for j in range(0, sąrašo_ilgis-i-1):
if sąrašas[j] > sąrašas[j+1]:
sąrašas[j], sąrašas[j+1] = sąrašas[j+1], sąrašas[j]
</syntaxhighlight>
Ši funkcija paima sąrašą <code>sąrašas</code> ir surikiuoja jį didėjančia tvarka, naudodama burbulinį rikiavimą.

== Greitasis rikiavimas (Quicksort) ==
"Quicksort" yra plačiai naudojamas rikiavimo algoritmas, kuriame taikomas "skaldyk ir valdyk" metodas. Jis veikia iš masyvo (arba sąrašo) išrenkant ašinį elementą ir kitus elementus suskirstant į du papildomus masyvus pagal tai, ar jie mažesni, ar didesni už ašinį elementą. Tada šis procesas rekursiškai kartojamas kiekviename pogrupyje.

Štai "Quicksort" funkcijos pavyzdys "Python" kalba:

<syntaxhighlight lang="python">
def quicksort(masyvas):
mažiau = []
lygus = []
daugiau = []
if len(masyvas) > 1:
ašis = masyvas[0]
for x in masyvas:
if x < ašis:
mažiau.append(x)
elif x == ašis:
lygus.append(x)
elif x > ašis:
daugiau.append(x)
# neužmiršk grąžinti rezultato!
return quicksort(mažiau)+lygus+quicksort(daugiau)
# Atkreipk dėmesį, kad naudojame `lygus`, o ne `ašis`
else:
return masyvas
</syntaxhighlight>

Funkcijos parametras <code>masyvas</code> yra sąrašas, kurį norime surikiuoti.

Pagrindinė funkcijos dalis yra sąlyga <code>if len(masyvas) > 1:</code>, kuri tikrina, ar sąraše yra daugiau nei vienas elementas. Jei sąraše yra tik vienas arba nulis elementų, tai jis jau yra surikiuotas, todėl tiesiog grąžinamas toks pat sąrašas.

Jei sąraše yra daugiau nei vienas elementas, algoritmas tęsiasi. Pirma, parenkamas elementas <code>ašis</code>, šiuo atveju tai yra pirmas sąrašo elementas <code>masyvas[0]</code>. Tuomet algoritmas eina per visus sąrašo elementus ir prideda juos į tris skirtingus sąrašus (<code>mažiau</code>, <code>lygus</code>, <code>daugiau</code>), priklausomai nuo to, kaip jie lyginami su <code>ašis</code>.

* Jei elementas '''x''' yra mažesnis už '''ašis''', jis pridedamas į '''mažiau''' sąrašą.
* Jei elementas '''x''' yra lygus '''ašis''', jis pridedamas į '''lygus''' sąrašą.
* Jei elementas '''x''' yra didesnis už '''ašis''', jis pridedamas į '''daugiau''' sąrašą.

Tai vadinama ''dalijimo procesu''. Po šio proceso turime tris naujus sąrašus: '''mažiau''', '''lygus''' ir '''daugiau''', kurie yra dalinai surikiuoti (mažesni už '''ašis''', lygūs '''ašis''' ir didesni už '''ašis''').

Toliau funkcija naudoja rekursiją ir kviečia save su <code>mažiau</code> ir <code>daugiau</code> sąrašais, taip pritaikydama dalijimo ir surikiavimo procesą šiems dviejams sąrašams atskirai. Rekursyviai kviečiant save, galiausiai bus pasiektas atvejis, kai sąrašai <code>mažiau</code> ir <code>daugiau</code> bus sudaryti iš nulio arba vieno elemento, o tai reiškia, kad jie jau surikiuoti. Tada funkcija grąžina sudėtą sąrašą: <code>quicksort(mažiau) + lygus + quicksort(daugiau)</code>, kuris sudarys pilnai surikiuotą sąrašą.

Galutinis rezultatas yra surikiuotas sąrašas, kuris yra grąžinamas iš pradinių sąrašų iškvietimo vietos.

Pvz. jei iškviečiame funkciją <code>quicksort([3, 1, 4, 1, 5, 9, 2, 6, 5])</code>, tai gražins <code>[1, 1, 2, 3, 4, 5, 5, 6, 9]</code>, kuris yra pradinis sąrašas surikiuotas didėjimo tvarka.

== Suliejimo rikiavimas (Merge sort) ==
"Merge sort" yra rikiavimo algoritmas, kuris veikia pagal dalinimo ir sujungimo principą. Tai efektyvus algoritmas, kuris naudoja rekursiją.

Merge sort algoritmas veikia taip:
* Jei sąraše yra nulis arba vienas elementas, tai jis jau yra surikiuotas. Grąžinamas tas pats sąrašas.
* Jei sąraše yra daugiau nei vienas elementas, sąrašas yra padalinamas į dvi lygias dalis.
* Kiekviena dalis yra rekursyviai rikiuojama naudojant '''merge sort''' algoritmą.
* Surikiuotos dvi dalys yra sujungiamos į vieną sąrašą. Sujungimo metu elementai yra palyginami ir sudedami į naują sąrašą didėjimo tvarka.

Šis procesas yra pakartojamas tol, kol visi sąrašai yra padalinti iki vieno elemento ir tada sujungti į vieną galutinį surikiuotą sąrašą.

Merge sort algoritmas yra efektyvus, nes dalijimo ir sujungimo žingsniai yra vykdomi daug kartų, o kiekviename žingsnyje sąrašas yra padalintas į dvi lygias dalis. Tai leidžia efektyviai rikiuoti didelius sąrašus.

<syntaxhighlight lang="python">
def merge_sort(sąrašas):
# sąraše yra nulis arba vienas elementas
if len(sąrašas) <= 1:
return sąrašas

# Dalinimo žingsnis: padaliname sąrašą į dvi lygias dalis
vidurys = len(sąrašas) // 2
kairė = sąrašas[:vidurys]
dešinė = sąrašas[vidurys:]

# Rekursyviai rikiuojame kiekvieną dalį
kairė = merge_sort(kairė)
dešinė = merge_sort(dešinė)

# Sujungimo žingsnis: sujungiame surikiuotas dalis į vieną sąrašą
return merge(kairė, dešinė)

def merge(kairė, dešinė):
rezultatas = []
i = 0 # indeksas kairėje dalyje
j = 0 # indeksas dešinėje dalyje

# Lyginame ir sujungiame elementus
while i < len(kairė) and j < len(dešinė):
if kairė[i] <= dešinė[j]:
rezultatas.append(kairė[i])
i += 1
else:
rezultatas.append(dešinė[j])
j += 1

# Jei viena dalis baigiasi anksčiau, pridedame likusius elementus
while i < len(kairė):
rezultatas.append(kairė[i])
i += 1
while j < len(dešinė):
rezultatas.append(dešinė[j])
j += 1

return rezultatas

# Pavyzdys naudojant merge_sort funkciją
sąrašas = [3, 1, 4, 1, 5, 9, 2, 6, 5]
surikiuotas_sąrašas = merge_sort(sąrašas)
print(surikiuotas_sąrašas)
</syntaxhighlight>

Šis pavyzdys naudoja dvi funkcijas: <code>merge_sort</code> ir <code>merge</code>. <code>merge_sort</code> funkcija atlieka dalinimo ir rekursyvaus rikiavimo žingsnius, o <code>merge</code> funkcija atlieka surikiuotų dalių sujungimą.

Rezultatas šio pavyzdžio bus:
[1, 1, 2, 3, 4, 5, 5, 6, 9]

Vadovėlis/Daugiau apie funkcijas

2023-06-24T10:57:58Z

Monika: /* Skaldyk ir valdyk */

{{navigation |previous=Daugiau apie tekstines eilutes |next=Failų tvarkymas}}

=== Funkcijų parametrai ===
Python kalboje parametrų perdavimo būdas priklauso nuo to, kaip jie deklaruojami funkcijos apibrėžime. Perduodant parametrą į funkciją Python naudoja nuorodų perdavimo mechanizmą, tačiau priklausomai nuo to, kaip parametras perduodamas, galime stebėti skirtingą elgesį.

Kai parametras yra perduodamas kaip reikšmė, funkcija sukuria savo kopiją, ir kai ji yra modifikuojama funkcijoje, originali reikšmė nepasikeičia. Čia yra pavyzdys:

<syntaxhighlight lang="python">
def keisti_reikšmę(x):
x += 5
print("Funkcijos viduje x=", x)

# pagrindinė programa
a = 10
keisti_reikšmę(a)
print("Po funkcijos a=", a)
</syntaxhighlight>

Funkcijoje keisti_reikšmę() sukuriame naują kintamajį x, kuris yra lygus a reikšmei, ir prie jo pridedame 5. Tačiau, kai funkcija yra baigta, a reikšmė nepasikeičia, nes funkcija veikia su x reikšme, kuri yra jos kopija.

Kai parametras yra perduodamas kaip kintamojo adresas, funkcija gali modifikuoti kintamąjį tiesiogiai. Tai reiškia, kad, kai funkcija yra baigta, originalus kintamasis taip pat bus modifikuotas. Čia yra pavyzdys:

<syntaxhighlight lang="python">
def keisti_adresą(x):
x.append(5)
print("Funkcijos viduje x=", x)

# pagrindinė programa
a = [1, 2, 3, 4]
keisti_adresą(a)
print("Po funkcijos a=", a)
</syntaxhighlight>

Funkcijoje keisti_adresą() mes paduodame a adresą, o ne jo kopiją, todėl funkcija gali tiesiogiai modifikuoti originalų kintamąjį. Šiuo atveju a yra papildoma nauja reikšme, ir kai funkcija yra baigta, a reikšmė pasikeičia, nes ji tiesiogiai buvo modifikuota funkcijos.

Tai yra svarbus skirtumas tarp reikšmių ir adreso perdavimo mechanizmų Python kalboje. Pasirinkęs tinkamą perdavimo mechanizmą, gali užtikrinti, kad tavo funkcijos veikia taip, kaip tikiesi.

=== Skaldyk ir valdyk ===
Kai norėsi spręsti didelę ir sudėtingą užduotį - visų pirma išskaidyk ją į mažesnes dalis (funkcijas). Toks programavimo metodas vadinamas “Skaldyk ir valdyk”.

Taikant "skaldyk ir valdyk" metodą, sprendžiama užduotį mes padaliname į mažesnius uždavinius ir kiekvienas uždavinys sprendžiamas atskirai. Toliau dalijant uždavinius į dar mažesnius uždavinius, galiausiai galime pasiekti etapą, kai padalyti uždavinių nebebus įmanoma. Tuomet yra sprendžiamos šios mažiausios įmanomos mini užduotėlės (frakcijos). Galiausiai visų dalinių uždavinių sprendiniai sujungiami, kad būtų gautas pradinio uždavinio sprendinys.

[[Vaizdas:Skaldyk_ir_valdyk.jpg|alt=Skaldyk ir valdyk.|frameless|401x401px]]

Programos skaldymas į mažesnes dalis dar vadinamas “''smulkinamasis programavimas''”. Tuo tarpu priešingas veiksmas - sujungimas funkcijų į vis stambesnes funkcijas, kol galiausiai į vieną didelę programą vadinamas “''stambinamasis programavimas''”

{{navigation |previous=Daugiau apie tekstines eilutes |next=Failų tvarkymas}}
[[Category:Python Vadovėlis]]

Vadovėlis/Daugiau apie funkcijas

2023-06-24T10:56:19Z

Monika: /* Funckijų parametrai */

{{navigation |previous=Daugiau apie tekstines eilutes |next=Failų tvarkymas}}

=== Funkcijų parametrai ===
Python kalboje parametrų perdavimo būdas priklauso nuo to, kaip jie deklaruojami funkcijos apibrėžime. Perduodant parametrą į funkciją Python naudoja nuorodų perdavimo mechanizmą, tačiau priklausomai nuo to, kaip parametras perduodamas, galime stebėti skirtingą elgesį.

Kai parametras yra perduodamas kaip reikšmė, funkcija sukuria savo kopiją, ir kai ji yra modifikuojama funkcijoje, originali reikšmė nepasikeičia. Čia yra pavyzdys:

<syntaxhighlight lang="python">
def keisti_reikšmę(x):
x += 5
print("Funkcijos viduje x=", x)

# pagrindinė programa
a = 10
keisti_reikšmę(a)
print("Po funkcijos a=", a)
</syntaxhighlight>

Funkcijoje keisti_reikšmę() sukuriame naują kintamajį x, kuris yra lygus a reikšmei, ir prie jo pridedame 5. Tačiau, kai funkcija yra baigta, a reikšmė nepasikeičia, nes funkcija veikia su x reikšme, kuri yra jos kopija.

Kai parametras yra perduodamas kaip kintamojo adresas, funkcija gali modifikuoti kintamąjį tiesiogiai. Tai reiškia, kad, kai funkcija yra baigta, originalus kintamasis taip pat bus modifikuotas. Čia yra pavyzdys:

<syntaxhighlight lang="python">
def keisti_adresą(x):
x.append(5)
print("Funkcijos viduje x=", x)

# pagrindinė programa
a = [1, 2, 3, 4]
keisti_adresą(a)
print("Po funkcijos a=", a)
</syntaxhighlight>

Funkcijoje keisti_adresą() mes paduodame a adresą, o ne jo kopiją, todėl funkcija gali tiesiogiai modifikuoti originalų kintamąjį. Šiuo atveju a yra papildoma nauja reikšme, ir kai funkcija yra baigta, a reikšmė pasikeičia, nes ji tiesiogiai buvo modifikuota funkcijos.

Tai yra svarbus skirtumas tarp reikšmių ir adreso perdavimo mechanizmų Python kalboje. Pasirinkęs tinkamą perdavimo mechanizmą, gali užtikrinti, kad tavo funkcijos veikia taip, kaip tikiesi.

=== Skaldyk ir valdyk ===
Kai norėsi spręsti didelę ir sudėtingą užduotį - visų pirma išskaidyk ją į mažesnes dalis (funkcijas). Toks programavimo metodas vadinamas “Skaldyk ir valdyk”.

Taikant "skaldyk ir valdyk" metodą, sprendžiama užduotį mes padaliname į mažesnius uždavinius ir kiekvienas uždavinys sprendžiamas atskirai. Toliau dalijant uždavinius į dar mažesnius uždavinius, galiausiai galime pasiekti etapą, kai padalyti uždavinių nebebus įmanoma. Sprendžiamos tos mažiausios įmanomos mini užduotėlės (frakcijos). Galiausiai visų dalinių uždavinių sprendiniai sujungiami, kad būtų gautas pradinio uždavinio sprendinys.

[[Vaizdas:Skaldyk_ir_valdyk.jpg|alt=Skaldyk ir valdyk.|frameless|401x401px]]

Programos skaldymas į mažesnes dalis dar vadinamas “''smulkinamasis programavimas''”. Tuo tarpu priešingas veiksmas - sujungimas funkcijų į vis stambesnes funkcijas, kol galiausiai į vieną didelę programą vadinamas “''stambinamasis programavimas''”

{{navigation |previous=Daugiau apie tekstines eilutes |next=Failų tvarkymas}}
[[Category:Python Vadovėlis]]

Vadovėlis/Failų tvarkymas

2023-06-23T07:57:17Z

Monika: /* Paketinis ir interaktyvus failų apdorojimas */

{{navigation |previous=Daugiau apie funkcijas |next=Siekiant tobulumo}}

=== Failų įvestis/išvestis ===

Štai paprastas failo įvesties ir išvesties (I/O, ang. Input/Output) pavyzdys:
<syntaxhighlight lang="python">
# Rašyti į failą
with open("testas.txt", "wt") as rašomas_failas:
rašomas_failas.write("Šis tekstas bus išsiųstas į failą\nPažiūrėk ir pamatysi!")

# Skaityti failą
with open("testas.txt", "rt") as skaitomas_failas:
tekstas = skaitomas_failas.read()

print(tekstas)
</syntaxhighlight>

Failo <code>testas.txt</code> išvestis ir turinys yra:

Šis tekstas bus išsiųstas į failą
Pažiūrėk ir pamatysi!

Atkreipk dėmesį, kad programa sukūrė failą pavadinimu <code>testas.txt</code> kataloge, iš kurio paleidai programą. Eilutėje esantis <code>\n</code> nurodo Python'ui toje vietoje peršokti į naują eilutę.

Apžvelkime visus veiksmus su failais:
* Gauk failo objektą su funkcija <code>open</code>
* Skaityk iš arba rašyk į failo objektą (priklausomai nuo to, kokiu režimu jis buvo atidarytas)
* Jeigu failui atidaryti nenaudojai funkcijos <code>with</code>, turėsi jį uždaryti rankiniu būdu

Pirmas žingsnis yra gauti failo objektą. Tai galima padaryti naudojant funkciją <code>open</code>. Formatas yra <code>failo_objektas = open(failo_pavadinimas, režimas)</code>, kur <code>failo_objektas</code> yra kintamasis, į kurį reikia įdėti failo objektą, <code>failo_pavadinimas</code> yra eilutė su failo pavadinimu, o <code>režimas</code> yra <code>"rt"</code>, kad (ang. ''r''ead) skaityti failą kaip ''t''ekstą arba <code>"wt"</code> (''w''rite) rašytį į failą kaip ''t''ekstą (ir keletą kitų režimų, kuriuos čia praleisime). Toliau galima iškviesti failų objektų funkcijas. Dvi dažniausiai naudojamos funkcijos yra <code>read</code> (skaityti) ir <code>write</code> (rašyti). Funkcija <code>write</code> prideda eilutę prie failo pabaigos. Funkcija <code>read</code> nuskaito failo turinį ir grąžina jį kaip eilutę (kaip padaryta pavyzdyje).

O dabar čia yra nauja telefono numerių programos versija, kurią jau sukūrei anksčiau:

<syntaxhighlight lang="python">
def spausdink_numerius(numeriai):
print("Telefono numeriai:")
for k, v in numeriai.items():
print("Vardas:", k, "\tTelefono numeris:", v)
print()

def pridėk_numerį(numeriai, vardas, numeris):
numeriai[vardas] = numeris

def surask_numerį(numeriai, vardas):
if vardas in numeriai:
return "Telefono numeris yra " + numeriai[vardas]
else:
return vardas + " nebuvo rastas"

def pašalink_numerį(numeriai, vardas):
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas," nebuvo rastas")

def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()

def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Įkelk telefono numerius')
print('6. Išsaugok telefono numerius')
print('7. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu()
while True:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-7): "))
if meniu_pasirinkimas == 1:
spausdink_numerius(numeriai)
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
pridėk_numerį(numeriai, vardas, numeris)
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
pašalink_numerį(numeriai, vardas)
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
print(surask_numerį(numeriai, vardas))
elif meniu_pasirinkimas == 5:
failo_pavadinimas = input("Failo pavadinimas, kurį nori įkelti: ")
įkelti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 6:
failo_pavadinimas = input("Failo pavadinimas išsaugojimui: ")
išsaugoti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 7:
break
else:
spausdink_meniu()

print("Viso!")
</syntaxhighlight>

Gali pastebėti, kad dabar kodas papildomai išsaugo ir perskaito failus. Štai dviejų programos vykdymų išvestis:

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Liepa'''
Telefono numeris: '''1234'''
Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Benas'''
Telefono numeris: '''4321'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''6'''
Failo pavadinimas išsaugojimui: '''numeriai.txt'''
Įvesk skaičių (1-7): '''7'''
Viso!

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''5'''
Failo pavadinimas, kurį nori įkelti: '''numeriai.txt'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''7'''
Viso!

Naujos šios programos dalys yra:
<syntaxhighlight lang="python">
def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()
</syntaxhighlight>

Pirmiausia pažiūrėk į programos išsaugojimo dalį. Visų pirma, sukuriamas failo objektas su komanda <code>open(failo_pavadinimas, "wt")</code>. Toliau sukuriama eilutė kiekvienam telefono numeriui su komanda <code>išvesties_failas.write(k + "," + v + "\n")</code>. Tai išrašo eilutę, kurioje yra vardas, kablelis, telefono numeris, o po jos rašoma nauja eilutė.

Failo skaitymo dalis yra šiek tiek sudėtingesnė. Ji prasideda failo objekto gavimu. Tada ji naudoja <code>while True:</code> ciklą, kad tęstųsi ciklas tol, kol bus aptikta komanda <code>break</code>. Komanda <code>skaitoma_eilutė = skaitymo_failas.readline()</code> perskaito pirmą eilutę ir priskiria kintamajam <code>skaitome_eilutė</code>. Pasiekus failo pabaigą, funkcija <code>readline</code> grąžins tuščią eilutę. Sąlyginis sakinys <code>if</code> tai patikrina ir panaudojant komandą <code>break</code> nutraukia <code>while</code> ciklą. Funkcija <code>readline</code> perskaito ir grąžina vieną eilutę kartu su jos pabaigos simboliu. Tai yra tam, kad būtų galima spręsti ar tai yra tik tuščia eilutė, ar jau failo pabaiga. Taigi turime atsikratyti to paskutinio eilutės pabaigos simbolio. Komanda <code>skaitoma_eilutė = skaitoma_eilutė[:-1]</code> tai padaro už mus, išmesdama paskutinį simbolį. Toliau eilutė <code>vardas, numeris = skaitoma_eilutė.split(",")</code> padalija eilutę ties kableliu į vardą ir telefono numerį ir visa tai įtraukiama į <code>numeriai</code> žodyną.

=== Darbo su failais rėžimai ===
Be <code>"rt"</code> ir <code>"wt"</code> yra ir kitų darbo su failais rėžimų. Lentelėje rasi visų rėžimų sąrašą:
{| class="wikitable"
|+
!Rėžimas
!Paaiškinimas
|-
|"rt"
|Tekstinio failo nuskatymas
|-
|"wt"
|Teksto rašymas į failą
|-
|"xt"
|Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"at"
|Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r"
|Sinonimas "rt" rėžimui. Tekstinio failo nuskatymas
|-
|"w"
|Sinonimas "w" rėžimui. Teksto rašymas į failą
|-
|"x"
|Sinonimas "x" rėžimui. Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"a"
|Sinonimas "a" rėžimui. Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"rb"
|Dvejetainio duomenų failo nuskatymas
|-
|"wb"
|Dvejetainės informacijos rašymas į failą
|-
|"xb"
|Naujo dvejetainio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"ab"
|Dvejetainio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|-
|"r+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|}
Dvvejetainiai rėžimai šiame vadovėlyje plačiau nagrinėjami nėra

=== Pagrindinės darbo su tekstiniais failais operacijos ===
{| class="wikitable"
|+
!Operacija
!Paaiškinimas
|-
|failas.read()
|Nuskaitomas visas failo turinys
|-
|failas.read(kiek)
|Nuskaitomas nuordytas simbolių kiekis iš failo. Pvz naudojant failas.read(3) bus nuskaitomi 3 sekantys simboliai
|-
|failas.readline()
|Nuskaitoma sekanti failo eilutė
|-
|failas.readlines()
|Nuskaitomos visos failo eilutės. Gražinamas sąrašas sudarytas iš teksto eilučių
|-
|failas.close()
|Failo uždarymas. Uždarius failą veiksmai su juo negalimi. Atidarant failą naudojant with funkciją, jis bus uždarytas automatiškai, tad close() naudoti nebereikia
|-
|failas.write(rašomas_tesktas)
|Įrašo nurodytą tekstą į failą.
|-
|failas.writelines(rašomo_teksto_eilučių_sąrašas)
|Sąrašas sudarytas iš teskto eilučių yra įrašomas į failą. Kiekvienas sąrašo elementas bus įrašomas naujoje eilutėje
|}

=== Paketinis ir interaktyvus failų apdorojimas ===

Failai gali būti apdorojami įvairiais būdais. Vieni iš dažniausiai naudojamų ir naudingiausių būdų - tai paketinis duomenų apdorojimas ir interaktyvus duomenų apdorojimas.

Skaitymas iš failo yra vadinamas paketiniu duomenų apdorojimu, nes visi duomenys iš failo yra nuskaitomi ir apdorojami kaip vienas paketas. Tai reiškia, kad visi duomenys yra nuskaitomi iš failo į kompiuterio atmintį vienu metu ir toliau apdorojami kompiuterio procesorių, o ne tiesiogiai iš failo.

Pavyzdžiui, jei turi didelio dydžio tekstinį failą ir nori jį apdoroti programoje, failas bus nuskaitomas į atmintį ir tada apdorotas kaip vienas paketas, o ne kaip atskiri duomenų elementai.

Interaktyvus duomenų apdorojimas – tai būdas dirbti su duomenimis, kai vartotojas gali manipuliuoti įvairiais nustatymais, o ne laikytis iš anksto užprogramuotų algoritmų. Tai leidžia geriau valdyti rezultatus ir geriau suprasti duomenis.

=== Pažangesnis .txt failų naudojimas ===

Galbūt tau kyla toks klausimas: „Aš žinau, kaip skaityti ir rašyti tekstinį failą, bet ką daryti, jei noriu atspausdinti failą spausdintuvu?"

Yra keletas skirtingų būdų, kaip tai padaryti. Iš tikrųjų, pats lengviausias būdas yra atidaryti kitą programą, tada leisti viskuo pasirūpinti Python'o kodui, kad tau nereikėtų pačiam failo atidarinėti ir spausdinti. Šis metodas apima kitos programos subproceso (arba antrinis procesas; biblioteka 'subprocess') iškvietimą.

Prisimeni failą, į kurį įrašėme išvestį aukščiau esančioje programoje? Panaudokime tą failą.
Turėk omenyje, kad norint išvengti klaidų, ši programa naudoja sąvokas iš kito skyriaus. Nedvejodamas gali dar kartą peržiūrėti šį pavyzdį po kito skyriaus.

<syntaxhighlight lang="Python">
import subprocess
def pagrindinis():
try:
print("Ši maža programa iškviečia spausdinimo funkciją Notepad programoje")
#Atspausdinkime failą, kurį sukūrėme aukščiau esančioje programoje
subprocess.call(['notepad','/p','numeriai.txt'])
except WindowsError:
print("Pakviesto subproceso nėra arba jo negalima iškviesti.")

pagrindinis()
</syntaxhighlight>

<code>subprocess.call</code> turi tris argumentus. Pirmasis argumentas šio pavyzdžio kontekste turėtų būti programos pavadinimas, iš kurios nori iškviesti spausdinimo subprocesą. Antrasis argumentas turėtų būti konkretus tos programos subprocesas. Kad būtų paprasčiau, tiesiog suprask, kad šioje programoje <code>'/p'</code> yra subprocesas, naudojamas norint pasiekti spausdintuvą per nurodytą programą. Paskutinis argumentas turėtų būti failo pavadinimas, kurį norite siųsti į spausdinimo subprocesą. Šiuo atveju tai yra tas pats failas, naudotas anksčiau šiame skyriuje.

=== Pratimai ===
1. Parašyk programą, kuri suskaičiuotų, kiek faile yra eilučių.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
failas = input("Kokio failo eilutes skaičiuoti? ")
įvesties_failas = open(failas, "r")
eilutės = įvesties_failas.readlines()
įvesties_failas.close()

print("Failas", failas, "turi", len(eilutės), " eilutes")
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri nukopijuotų vieno failo lygines eilutes į kitą failą.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
įvesties_failo_pavadinimas = input("Kokio failo eilutes kopijuoti? ")
įvesties_failas = open(įvesties_failo_pavadinimas, "r")

išvesties_failo_pavadinimas = input("Į kokį failą išsaugoti lygines eilutes? ")
išvesties_failas = open(išvesties_failo_pavadinimas, "w")

eilutės_numeris = 0

while True:
eilutė = įvesties_failas.readline()
eilutės_numeris = eilutės_numeris + 1
if not eilutė:
break
else:
if (eilutės_numeris % 2) == 0:
išvesties_failas.write(eilutė)

įvesties_failas.close()
išvesties_failas.close()
</syntaxhighlight>
|-
|}

3. Dabar pakeisk pažymių programą iš skyriaus [[Vadovėlis/Žodynai|Žodynai]], kad ji naudotų failus mokinių pažymiams saugoti.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = { }

def įkelti_pažymius(pažymių_failas):
įvesties_failas = open(pažymių_failas, "r")
pažymiai = [ ]
while True:
mokinys_ir_pažymys = įvesties_failas.readline()
mokinys_ir_pažymys = mokinys_ir_pažymys[:-1]
if not mokinys_ir_pažymys:
break
else:
mokinio_vardas, mokinio_pažymiai = mokinys_ir_pažymys.split(",")
mokinio_pažymiai = mokinio_pažymiai.split(" ")
mokiniai[mokinio_vardas] = mokinio_pažymiai
įvesties_failas.close()
print("Pažymiai įkelti.")

def išsaugoti_pažymius(pažymių_failas):
išvesties_failas = open(pažymių_failas, "w")
for k, v in mokiniai.items():
išvesties_failas.write(k + ",")
for x in v:
išvesties_failas.write(str(x) + " ")
išvesties_failas.write("\n")
išvesties_failas.close()
print("Pažymiai išsaugoti.")

def spausdink_meniu():
print("1. Pridėk mokinį")
print("2. Pašalink mokinį")
print("3. Įkrauti pažymius")
print("4. Įrašyk pažymį")
print("5. Spausdink pažymius")
print("6. Įšsaugoti pažymius")
print("7. Spausdink meniu")
print("9. Išeik")

def spausdink_visus_pažymius():
if mokiniai:
raktai = sorted(mokiniai.keys())
print('\t', end=' ')
for x in užduotys:
print(x, '\t', end=' ')
print()
for x in raktai:
print(x, '\t', end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
else:
print("Neradau pažymių spausdinimui.")

def spausdink_pažymius(pažymiai):
for x in pažymiai:
print(x, '\t', end=' ')
print()

spausdink_meniu()
meniu_pasirinkimas = 0
while meniu_pasirinkimas != 9:
print()
meniu_pasirinkimas = int(input("Meniu pasirinkimas: "))
if meniu_pasirinkimas == 1:
vardas = input("Pridėk mokinį: ")
mokiniai[vardas] = [0] * len(užduotys)
elif meniu_pasirinkimas == 2:
vardas = input("Pašalink mokinį: ")
if vardas in mokiniai:
del mokiniai[vardas]
else:
print("Mokinys vardu:", vardas, " nerastas.")
elif meniu_pasirinkimas == 3:
pažymių_failas = input("Įkrauti pažymius iš kokio failo? ")
įkelti_pažymius(pažymių_failas)
elif meniu_pasirinkimas == 4:
print("Įrašyk pažymį")
vardas = input("Mokinys: ")
if vardas in mokiniai:
pažymiai = mokiniai[vardas]
print("Įrašyk mokinio pažymį")
print("Įrašyk 0 (nulį), kad išeitum")
for i,x in enumerate(užduotys):
print(i + 1, x, '\t', end=' ')
print()
spausdink_pažymius(pažymiai)
kuris = 1234
while kuris != -1:
kuris = int(input("Pažymys, kurį nori pakeisti: "))
kuris -= 1
if 0 <= kuris < len(pažymiai):
pažymys = int(input("Pažymys: "))
pažymiai[kuris] = pažymys
elif kuris != -1:
print("Klaidingas pažymys")
else:
print("Mokinys nerastas")
elif meniu_pasirinkimas == 5:
spausdink_visus_pažymius()
elif meniu_pasirinkimas == 6:
pažymių_failas = input("Į kokį failą išsaugoti pažymius? ")
išsaugoti_pažymius(pažymių_failas)
elif meniu_pasirinkimas != 9:
spausdink_meniu()

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie funkcijas |next=Siekiant tobulumo}}
[[Category:Python Vadovėlis]]

Vadovėlis/Failų tvarkymas

2023-06-23T07:56:17Z

Monika: /* Paketinis ir interaktyvus failų apdorojimas */

{{navigation |previous=Daugiau apie funkcijas |next=Siekiant tobulumo}}

=== Failų įvestis/išvestis ===

Štai paprastas failo įvesties ir išvesties (I/O, ang. Input/Output) pavyzdys:
<syntaxhighlight lang="python">
# Rašyti į failą
with open("testas.txt", "wt") as rašomas_failas:
rašomas_failas.write("Šis tekstas bus išsiųstas į failą\nPažiūrėk ir pamatysi!")

# Skaityti failą
with open("testas.txt", "rt") as skaitomas_failas:
tekstas = skaitomas_failas.read()

print(tekstas)
</syntaxhighlight>

Failo <code>testas.txt</code> išvestis ir turinys yra:

Šis tekstas bus išsiųstas į failą
Pažiūrėk ir pamatysi!

Atkreipk dėmesį, kad programa sukūrė failą pavadinimu <code>testas.txt</code> kataloge, iš kurio paleidai programą. Eilutėje esantis <code>\n</code> nurodo Python'ui toje vietoje peršokti į naują eilutę.

Apžvelkime visus veiksmus su failais:
* Gauk failo objektą su funkcija <code>open</code>
* Skaityk iš arba rašyk į failo objektą (priklausomai nuo to, kokiu režimu jis buvo atidarytas)
* Jeigu failui atidaryti nenaudojai funkcijos <code>with</code>, turėsi jį uždaryti rankiniu būdu

Pirmas žingsnis yra gauti failo objektą. Tai galima padaryti naudojant funkciją <code>open</code>. Formatas yra <code>failo_objektas = open(failo_pavadinimas, režimas)</code>, kur <code>failo_objektas</code> yra kintamasis, į kurį reikia įdėti failo objektą, <code>failo_pavadinimas</code> yra eilutė su failo pavadinimu, o <code>režimas</code> yra <code>"rt"</code>, kad (ang. ''r''ead) skaityti failą kaip ''t''ekstą arba <code>"wt"</code> (''w''rite) rašytį į failą kaip ''t''ekstą (ir keletą kitų režimų, kuriuos čia praleisime). Toliau galima iškviesti failų objektų funkcijas. Dvi dažniausiai naudojamos funkcijos yra <code>read</code> (skaityti) ir <code>write</code> (rašyti). Funkcija <code>write</code> prideda eilutę prie failo pabaigos. Funkcija <code>read</code> nuskaito failo turinį ir grąžina jį kaip eilutę (kaip padaryta pavyzdyje).

O dabar čia yra nauja telefono numerių programos versija, kurią jau sukūrei anksčiau:

<syntaxhighlight lang="python">
def spausdink_numerius(numeriai):
print("Telefono numeriai:")
for k, v in numeriai.items():
print("Vardas:", k, "\tTelefono numeris:", v)
print()

def pridėk_numerį(numeriai, vardas, numeris):
numeriai[vardas] = numeris

def surask_numerį(numeriai, vardas):
if vardas in numeriai:
return "Telefono numeris yra " + numeriai[vardas]
else:
return vardas + " nebuvo rastas"

def pašalink_numerį(numeriai, vardas):
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas," nebuvo rastas")

def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()

def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Įkelk telefono numerius')
print('6. Išsaugok telefono numerius')
print('7. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu()
while True:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-7): "))
if meniu_pasirinkimas == 1:
spausdink_numerius(numeriai)
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
pridėk_numerį(numeriai, vardas, numeris)
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
pašalink_numerį(numeriai, vardas)
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
print(surask_numerį(numeriai, vardas))
elif meniu_pasirinkimas == 5:
failo_pavadinimas = input("Failo pavadinimas, kurį nori įkelti: ")
įkelti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 6:
failo_pavadinimas = input("Failo pavadinimas išsaugojimui: ")
išsaugoti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 7:
break
else:
spausdink_meniu()

print("Viso!")
</syntaxhighlight>

Gali pastebėti, kad dabar kodas papildomai išsaugo ir perskaito failus. Štai dviejų programos vykdymų išvestis:

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Liepa'''
Telefono numeris: '''1234'''
Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Benas'''
Telefono numeris: '''4321'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''6'''
Failo pavadinimas išsaugojimui: '''numeriai.txt'''
Įvesk skaičių (1-7): '''7'''
Viso!

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''5'''
Failo pavadinimas, kurį nori įkelti: '''numeriai.txt'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''7'''
Viso!

Naujos šios programos dalys yra:
<syntaxhighlight lang="python">
def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()
</syntaxhighlight>

Pirmiausia pažiūrėk į programos išsaugojimo dalį. Visų pirma, sukuriamas failo objektas su komanda <code>open(failo_pavadinimas, "wt")</code>. Toliau sukuriama eilutė kiekvienam telefono numeriui su komanda <code>išvesties_failas.write(k + "," + v + "\n")</code>. Tai išrašo eilutę, kurioje yra vardas, kablelis, telefono numeris, o po jos rašoma nauja eilutė.

Failo skaitymo dalis yra šiek tiek sudėtingesnė. Ji prasideda failo objekto gavimu. Tada ji naudoja <code>while True:</code> ciklą, kad tęstųsi ciklas tol, kol bus aptikta komanda <code>break</code>. Komanda <code>skaitoma_eilutė = skaitymo_failas.readline()</code> perskaito pirmą eilutę ir priskiria kintamajam <code>skaitome_eilutė</code>. Pasiekus failo pabaigą, funkcija <code>readline</code> grąžins tuščią eilutę. Sąlyginis sakinys <code>if</code> tai patikrina ir panaudojant komandą <code>break</code> nutraukia <code>while</code> ciklą. Funkcija <code>readline</code> perskaito ir grąžina vieną eilutę kartu su jos pabaigos simboliu. Tai yra tam, kad būtų galima spręsti ar tai yra tik tuščia eilutė, ar jau failo pabaiga. Taigi turime atsikratyti to paskutinio eilutės pabaigos simbolio. Komanda <code>skaitoma_eilutė = skaitoma_eilutė[:-1]</code> tai padaro už mus, išmesdama paskutinį simbolį. Toliau eilutė <code>vardas, numeris = skaitoma_eilutė.split(",")</code> padalija eilutę ties kableliu į vardą ir telefono numerį ir visa tai įtraukiama į <code>numeriai</code> žodyną.

=== Darbo su failais rėžimai ===
Be <code>"rt"</code> ir <code>"wt"</code> yra ir kitų darbo su failais rėžimų. Lentelėje rasi visų rėžimų sąrašą:
{| class="wikitable"
|+
!Rėžimas
!Paaiškinimas
|-
|"rt"
|Tekstinio failo nuskatymas
|-
|"wt"
|Teksto rašymas į failą
|-
|"xt"
|Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"at"
|Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r"
|Sinonimas "rt" rėžimui. Tekstinio failo nuskatymas
|-
|"w"
|Sinonimas "w" rėžimui. Teksto rašymas į failą
|-
|"x"
|Sinonimas "x" rėžimui. Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"a"
|Sinonimas "a" rėžimui. Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"rb"
|Dvejetainio duomenų failo nuskatymas
|-
|"wb"
|Dvejetainės informacijos rašymas į failą
|-
|"xb"
|Naujo dvejetainio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"ab"
|Dvejetainio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|-
|"r+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|}
Dvvejetainiai rėžimai šiame vadovėlyje plačiau nagrinėjami nėra

=== Pagrindinės darbo su tekstiniais failais operacijos ===
{| class="wikitable"
|+
!Operacija
!Paaiškinimas
|-
|failas.read()
|Nuskaitomas visas failo turinys
|-
|failas.read(kiek)
|Nuskaitomas nuordytas simbolių kiekis iš failo. Pvz naudojant failas.read(3) bus nuskaitomi 3 sekantys simboliai
|-
|failas.readline()
|Nuskaitoma sekanti failo eilutė
|-
|failas.readlines()
|Nuskaitomos visos failo eilutės. Gražinamas sąrašas sudarytas iš teksto eilučių
|-
|failas.close()
|Failo uždarymas. Uždarius failą veiksmai su juo negalimi. Atidarant failą naudojant with funkciją, jis bus uždarytas automatiškai, tad close() naudoti nebereikia
|-
|failas.write(rašomas_tesktas)
|Įrašo nurodytą tekstą į failą.
|-
|failas.writelines(rašomo_teksto_eilučių_sąrašas)
|Sąrašas sudarytas iš teskto eilučių yra įrašomas į failą. Kiekvienas sąrašo elementas bus įrašomas naujoje eilutėje
|}

=== Paketinis ir interaktyvus failų apdorojimas ===

Failai gali būti apdorojami įvairiais būdais. Vieni naudingiausių būdų, tai paketinis duomenų apdorojimas ir interaktyvus duomenų apdorojimas.

Skaitymas iš failo yra vadinamas paketiniu duomenų apdorojimu, nes visi duomenys iš failo yra nuskaitomi ir apdorojami kaip vienas paketas. Tai reiškia, kad visi duomenys yra nuskaitomi iš failo į kompiuterio atmintį vienu metu ir toliau apdorojami kompiuterio procesorių, o ne tiesiogiai iš failo.

Pavyzdžiui, jei turi didelio dydžio tekstinį failą ir nori jį apdoroti programoje, failas bus nuskaitomas į atmintį ir tada apdorotas kaip vienas paketas, o ne kaip atskiri duomenų elementai.

Interaktyvus duomenų apdorojimas – tai būdas dirbti su duomenimis, kai vartotojas gali manipuliuoti įvairiais nustatymais, o ne laikytis iš anksto užprogramuotų algoritmų. Tai leidžia geriau valdyti rezultatus ir geriau suprasti duomenis.

=== Pažangesnis .txt failų naudojimas ===

Galbūt tau kyla toks klausimas: „Aš žinau, kaip skaityti ir rašyti tekstinį failą, bet ką daryti, jei noriu atspausdinti failą spausdintuvu?"

Yra keletas skirtingų būdų, kaip tai padaryti. Iš tikrųjų, pats lengviausias būdas yra atidaryti kitą programą, tada leisti viskuo pasirūpinti Python'o kodui, kad tau nereikėtų pačiam failo atidarinėti ir spausdinti. Šis metodas apima kitos programos subproceso (arba antrinis procesas; biblioteka 'subprocess') iškvietimą.

Prisimeni failą, į kurį įrašėme išvestį aukščiau esančioje programoje? Panaudokime tą failą.
Turėk omenyje, kad norint išvengti klaidų, ši programa naudoja sąvokas iš kito skyriaus. Nedvejodamas gali dar kartą peržiūrėti šį pavyzdį po kito skyriaus.

<syntaxhighlight lang="Python">
import subprocess
def pagrindinis():
try:
print("Ši maža programa iškviečia spausdinimo funkciją Notepad programoje")
#Atspausdinkime failą, kurį sukūrėme aukščiau esančioje programoje
subprocess.call(['notepad','/p','numeriai.txt'])
except WindowsError:
print("Pakviesto subproceso nėra arba jo negalima iškviesti.")

pagrindinis()
</syntaxhighlight>

<code>subprocess.call</code> turi tris argumentus. Pirmasis argumentas šio pavyzdžio kontekste turėtų būti programos pavadinimas, iš kurios nori iškviesti spausdinimo subprocesą. Antrasis argumentas turėtų būti konkretus tos programos subprocesas. Kad būtų paprasčiau, tiesiog suprask, kad šioje programoje <code>'/p'</code> yra subprocesas, naudojamas norint pasiekti spausdintuvą per nurodytą programą. Paskutinis argumentas turėtų būti failo pavadinimas, kurį norite siųsti į spausdinimo subprocesą. Šiuo atveju tai yra tas pats failas, naudotas anksčiau šiame skyriuje.

=== Pratimai ===
1. Parašyk programą, kuri suskaičiuotų, kiek faile yra eilučių.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
failas = input("Kokio failo eilutes skaičiuoti? ")
įvesties_failas = open(failas, "r")
eilutės = įvesties_failas.readlines()
įvesties_failas.close()

print("Failas", failas, "turi", len(eilutės), " eilutes")
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri nukopijuotų vieno failo lygines eilutes į kitą failą.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
įvesties_failo_pavadinimas = input("Kokio failo eilutes kopijuoti? ")
įvesties_failas = open(įvesties_failo_pavadinimas, "r")

išvesties_failo_pavadinimas = input("Į kokį failą išsaugoti lygines eilutes? ")
išvesties_failas = open(išvesties_failo_pavadinimas, "w")

eilutės_numeris = 0

while True:
eilutė = įvesties_failas.readline()
eilutės_numeris = eilutės_numeris + 1
if not eilutė:
break
else:
if (eilutės_numeris % 2) == 0:
išvesties_failas.write(eilutė)

įvesties_failas.close()
išvesties_failas.close()
</syntaxhighlight>
|-
|}

3. Dabar pakeisk pažymių programą iš skyriaus [[Vadovėlis/Žodynai|Žodynai]], kad ji naudotų failus mokinių pažymiams saugoti.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = { }

def įkelti_pažymius(pažymių_failas):
įvesties_failas = open(pažymių_failas, "r")
pažymiai = [ ]
while True:
mokinys_ir_pažymys = įvesties_failas.readline()
mokinys_ir_pažymys = mokinys_ir_pažymys[:-1]
if not mokinys_ir_pažymys:
break
else:
mokinio_vardas, mokinio_pažymiai = mokinys_ir_pažymys.split(",")
mokinio_pažymiai = mokinio_pažymiai.split(" ")
mokiniai[mokinio_vardas] = mokinio_pažymiai
įvesties_failas.close()
print("Pažymiai įkelti.")

def išsaugoti_pažymius(pažymių_failas):
išvesties_failas = open(pažymių_failas, "w")
for k, v in mokiniai.items():
išvesties_failas.write(k + ",")
for x in v:
išvesties_failas.write(str(x) + " ")
išvesties_failas.write("\n")
išvesties_failas.close()
print("Pažymiai išsaugoti.")

def spausdink_meniu():
print("1. Pridėk mokinį")
print("2. Pašalink mokinį")
print("3. Įkrauti pažymius")
print("4. Įrašyk pažymį")
print("5. Spausdink pažymius")
print("6. Įšsaugoti pažymius")
print("7. Spausdink meniu")
print("9. Išeik")

def spausdink_visus_pažymius():
if mokiniai:
raktai = sorted(mokiniai.keys())
print('\t', end=' ')
for x in užduotys:
print(x, '\t', end=' ')
print()
for x in raktai:
print(x, '\t', end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
else:
print("Neradau pažymių spausdinimui.")

def spausdink_pažymius(pažymiai):
for x in pažymiai:
print(x, '\t', end=' ')
print()

spausdink_meniu()
meniu_pasirinkimas = 0
while meniu_pasirinkimas != 9:
print()
meniu_pasirinkimas = int(input("Meniu pasirinkimas: "))
if meniu_pasirinkimas == 1:
vardas = input("Pridėk mokinį: ")
mokiniai[vardas] = [0] * len(užduotys)
elif meniu_pasirinkimas == 2:
vardas = input("Pašalink mokinį: ")
if vardas in mokiniai:
del mokiniai[vardas]
else:
print("Mokinys vardu:", vardas, " nerastas.")
elif meniu_pasirinkimas == 3:
pažymių_failas = input("Įkrauti pažymius iš kokio failo? ")
įkelti_pažymius(pažymių_failas)
elif meniu_pasirinkimas == 4:
print("Įrašyk pažymį")
vardas = input("Mokinys: ")
if vardas in mokiniai:
pažymiai = mokiniai[vardas]
print("Įrašyk mokinio pažymį")
print("Įrašyk 0 (nulį), kad išeitum")
for i,x in enumerate(užduotys):
print(i + 1, x, '\t', end=' ')
print()
spausdink_pažymius(pažymiai)
kuris = 1234
while kuris != -1:
kuris = int(input("Pažymys, kurį nori pakeisti: "))
kuris -= 1
if 0 <= kuris < len(pažymiai):
pažymys = int(input("Pažymys: "))
pažymiai[kuris] = pažymys
elif kuris != -1:
print("Klaidingas pažymys")
else:
print("Mokinys nerastas")
elif meniu_pasirinkimas == 5:
spausdink_visus_pažymius()
elif meniu_pasirinkimas == 6:
pažymių_failas = input("Į kokį failą išsaugoti pažymius? ")
išsaugoti_pažymius(pažymių_failas)
elif meniu_pasirinkimas != 9:
spausdink_meniu()

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie funkcijas |next=Siekiant tobulumo}}
[[Category:Python Vadovėlis]]

Vadovėlis/Failų tvarkymas

2023-06-23T07:55:47Z

Monika: /* Paketinis ir interaktyvus failų apdorojimas */

{{navigation |previous=Daugiau apie funkcijas |next=Siekiant tobulumo}}

=== Failų įvestis/išvestis ===

Štai paprastas failo įvesties ir išvesties (I/O, ang. Input/Output) pavyzdys:
<syntaxhighlight lang="python">
# Rašyti į failą
with open("testas.txt", "wt") as rašomas_failas:
rašomas_failas.write("Šis tekstas bus išsiųstas į failą\nPažiūrėk ir pamatysi!")

# Skaityti failą
with open("testas.txt", "rt") as skaitomas_failas:
tekstas = skaitomas_failas.read()

print(tekstas)
</syntaxhighlight>

Failo <code>testas.txt</code> išvestis ir turinys yra:

Šis tekstas bus išsiųstas į failą
Pažiūrėk ir pamatysi!

Atkreipk dėmesį, kad programa sukūrė failą pavadinimu <code>testas.txt</code> kataloge, iš kurio paleidai programą. Eilutėje esantis <code>\n</code> nurodo Python'ui toje vietoje peršokti į naują eilutę.

Apžvelkime visus veiksmus su failais:
* Gauk failo objektą su funkcija <code>open</code>
* Skaityk iš arba rašyk į failo objektą (priklausomai nuo to, kokiu režimu jis buvo atidarytas)
* Jeigu failui atidaryti nenaudojai funkcijos <code>with</code>, turėsi jį uždaryti rankiniu būdu

Pirmas žingsnis yra gauti failo objektą. Tai galima padaryti naudojant funkciją <code>open</code>. Formatas yra <code>failo_objektas = open(failo_pavadinimas, režimas)</code>, kur <code>failo_objektas</code> yra kintamasis, į kurį reikia įdėti failo objektą, <code>failo_pavadinimas</code> yra eilutė su failo pavadinimu, o <code>režimas</code> yra <code>"rt"</code>, kad (ang. ''r''ead) skaityti failą kaip ''t''ekstą arba <code>"wt"</code> (''w''rite) rašytį į failą kaip ''t''ekstą (ir keletą kitų režimų, kuriuos čia praleisime). Toliau galima iškviesti failų objektų funkcijas. Dvi dažniausiai naudojamos funkcijos yra <code>read</code> (skaityti) ir <code>write</code> (rašyti). Funkcija <code>write</code> prideda eilutę prie failo pabaigos. Funkcija <code>read</code> nuskaito failo turinį ir grąžina jį kaip eilutę (kaip padaryta pavyzdyje).

O dabar čia yra nauja telefono numerių programos versija, kurią jau sukūrei anksčiau:

<syntaxhighlight lang="python">
def spausdink_numerius(numeriai):
print("Telefono numeriai:")
for k, v in numeriai.items():
print("Vardas:", k, "\tTelefono numeris:", v)
print()

def pridėk_numerį(numeriai, vardas, numeris):
numeriai[vardas] = numeris

def surask_numerį(numeriai, vardas):
if vardas in numeriai:
return "Telefono numeris yra " + numeriai[vardas]
else:
return vardas + " nebuvo rastas"

def pašalink_numerį(numeriai, vardas):
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas," nebuvo rastas")

def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()

def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Įkelk telefono numerius')
print('6. Išsaugok telefono numerius')
print('7. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu()
while True:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-7): "))
if meniu_pasirinkimas == 1:
spausdink_numerius(numeriai)
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
pridėk_numerį(numeriai, vardas, numeris)
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
pašalink_numerį(numeriai, vardas)
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
print(surask_numerį(numeriai, vardas))
elif meniu_pasirinkimas == 5:
failo_pavadinimas = input("Failo pavadinimas, kurį nori įkelti: ")
įkelti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 6:
failo_pavadinimas = input("Failo pavadinimas išsaugojimui: ")
išsaugoti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 7:
break
else:
spausdink_meniu()

print("Viso!")
</syntaxhighlight>

Gali pastebėti, kad dabar kodas papildomai išsaugo ir perskaito failus. Štai dviejų programos vykdymų išvestis:

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Liepa'''
Telefono numeris: '''1234'''
Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Benas'''
Telefono numeris: '''4321'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''6'''
Failo pavadinimas išsaugojimui: '''numeriai.txt'''
Įvesk skaičių (1-7): '''7'''
Viso!

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''5'''
Failo pavadinimas, kurį nori įkelti: '''numeriai.txt'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''7'''
Viso!

Naujos šios programos dalys yra:
<syntaxhighlight lang="python">
def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()
</syntaxhighlight>

Pirmiausia pažiūrėk į programos išsaugojimo dalį. Visų pirma, sukuriamas failo objektas su komanda <code>open(failo_pavadinimas, "wt")</code>. Toliau sukuriama eilutė kiekvienam telefono numeriui su komanda <code>išvesties_failas.write(k + "," + v + "\n")</code>. Tai išrašo eilutę, kurioje yra vardas, kablelis, telefono numeris, o po jos rašoma nauja eilutė.

Failo skaitymo dalis yra šiek tiek sudėtingesnė. Ji prasideda failo objekto gavimu. Tada ji naudoja <code>while True:</code> ciklą, kad tęstųsi ciklas tol, kol bus aptikta komanda <code>break</code>. Komanda <code>skaitoma_eilutė = skaitymo_failas.readline()</code> perskaito pirmą eilutę ir priskiria kintamajam <code>skaitome_eilutė</code>. Pasiekus failo pabaigą, funkcija <code>readline</code> grąžins tuščią eilutę. Sąlyginis sakinys <code>if</code> tai patikrina ir panaudojant komandą <code>break</code> nutraukia <code>while</code> ciklą. Funkcija <code>readline</code> perskaito ir grąžina vieną eilutę kartu su jos pabaigos simboliu. Tai yra tam, kad būtų galima spręsti ar tai yra tik tuščia eilutė, ar jau failo pabaiga. Taigi turime atsikratyti to paskutinio eilutės pabaigos simbolio. Komanda <code>skaitoma_eilutė = skaitoma_eilutė[:-1]</code> tai padaro už mus, išmesdama paskutinį simbolį. Toliau eilutė <code>vardas, numeris = skaitoma_eilutė.split(",")</code> padalija eilutę ties kableliu į vardą ir telefono numerį ir visa tai įtraukiama į <code>numeriai</code> žodyną.

=== Darbo su failais rėžimai ===
Be <code>"rt"</code> ir <code>"wt"</code> yra ir kitų darbo su failais rėžimų. Lentelėje rasi visų rėžimų sąrašą:
{| class="wikitable"
|+
!Rėžimas
!Paaiškinimas
|-
|"rt"
|Tekstinio failo nuskatymas
|-
|"wt"
|Teksto rašymas į failą
|-
|"xt"
|Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"at"
|Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r"
|Sinonimas "rt" rėžimui. Tekstinio failo nuskatymas
|-
|"w"
|Sinonimas "w" rėžimui. Teksto rašymas į failą
|-
|"x"
|Sinonimas "x" rėžimui. Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"a"
|Sinonimas "a" rėžimui. Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"rb"
|Dvejetainio duomenų failo nuskatymas
|-
|"wb"
|Dvejetainės informacijos rašymas į failą
|-
|"xb"
|Naujo dvejetainio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"ab"
|Dvejetainio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|-
|"r+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|}
Dvvejetainiai rėžimai šiame vadovėlyje plačiau nagrinėjami nėra

=== Pagrindinės darbo su tekstiniais failais operacijos ===
{| class="wikitable"
|+
!Operacija
!Paaiškinimas
|-
|failas.read()
|Nuskaitomas visas failo turinys
|-
|failas.read(kiek)
|Nuskaitomas nuordytas simbolių kiekis iš failo. Pvz naudojant failas.read(3) bus nuskaitomi 3 sekantys simboliai
|-
|failas.readline()
|Nuskaitoma sekanti failo eilutė
|-
|failas.readlines()
|Nuskaitomos visos failo eilutės. Gražinamas sąrašas sudarytas iš teksto eilučių
|-
|failas.close()
|Failo uždarymas. Uždarius failą veiksmai su juo negalimi. Atidarant failą naudojant with funkciją, jis bus uždarytas automatiškai, tad close() naudoti nebereikia
|-
|failas.write(rašomas_tesktas)
|Įrašo nurodytą tekstą į failą.
|-
|failas.writelines(rašomo_teksto_eilučių_sąrašas)
|Sąrašas sudarytas iš teskto eilučių yra įrašomas į failą. Kiekvienas sąrašo elementas bus įrašomas naujoje eilutėje
|}

=== Paketinis ir interaktyvus failų apdorojimas ===

Failai gali būti apdorojami įvairiais būdais. Vieni dažniausiai naudojamų naudingų būdų, tai paketinis duomenų apdorojimas ir interaktyvus duomenų apdorojimas.

Skaitymas iš failo yra vadinamas paketiniu duomenų apdorojimu, nes visi duomenys iš failo yra nuskaitomi ir apdorojami kaip vienas paketas. Tai reiškia, kad visi duomenys yra nuskaitomi iš failo į kompiuterio atmintį vienu metu ir toliau apdorojami kompiuterio procesorių, o ne tiesiogiai iš failo.

Pavyzdžiui, jei turi didelio dydžio tekstinį failą ir nori jį apdoroti programoje, failas bus nuskaitomas į atmintį ir tada apdorotas kaip vienas paketas, o ne kaip atskiri duomenų elementai.

Interaktyvus duomenų apdorojimas – tai būdas dirbti su duomenimis, kai vartotojas gali manipuliuoti įvairiais nustatymais, o ne laikytis iš anksto užprogramuotų algoritmų. Tai leidžia geriau valdyti rezultatus ir geriau suprasti duomenis.

=== Pažangesnis .txt failų naudojimas ===

Galbūt tau kyla toks klausimas: „Aš žinau, kaip skaityti ir rašyti tekstinį failą, bet ką daryti, jei noriu atspausdinti failą spausdintuvu?"

Yra keletas skirtingų būdų, kaip tai padaryti. Iš tikrųjų, pats lengviausias būdas yra atidaryti kitą programą, tada leisti viskuo pasirūpinti Python'o kodui, kad tau nereikėtų pačiam failo atidarinėti ir spausdinti. Šis metodas apima kitos programos subproceso (arba antrinis procesas; biblioteka 'subprocess') iškvietimą.

Prisimeni failą, į kurį įrašėme išvestį aukščiau esančioje programoje? Panaudokime tą failą.
Turėk omenyje, kad norint išvengti klaidų, ši programa naudoja sąvokas iš kito skyriaus. Nedvejodamas gali dar kartą peržiūrėti šį pavyzdį po kito skyriaus.

<syntaxhighlight lang="Python">
import subprocess
def pagrindinis():
try:
print("Ši maža programa iškviečia spausdinimo funkciją Notepad programoje")
#Atspausdinkime failą, kurį sukūrėme aukščiau esančioje programoje
subprocess.call(['notepad','/p','numeriai.txt'])
except WindowsError:
print("Pakviesto subproceso nėra arba jo negalima iškviesti.")

pagrindinis()
</syntaxhighlight>

<code>subprocess.call</code> turi tris argumentus. Pirmasis argumentas šio pavyzdžio kontekste turėtų būti programos pavadinimas, iš kurios nori iškviesti spausdinimo subprocesą. Antrasis argumentas turėtų būti konkretus tos programos subprocesas. Kad būtų paprasčiau, tiesiog suprask, kad šioje programoje <code>'/p'</code> yra subprocesas, naudojamas norint pasiekti spausdintuvą per nurodytą programą. Paskutinis argumentas turėtų būti failo pavadinimas, kurį norite siųsti į spausdinimo subprocesą. Šiuo atveju tai yra tas pats failas, naudotas anksčiau šiame skyriuje.

=== Pratimai ===
1. Parašyk programą, kuri suskaičiuotų, kiek faile yra eilučių.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
failas = input("Kokio failo eilutes skaičiuoti? ")
įvesties_failas = open(failas, "r")
eilutės = įvesties_failas.readlines()
įvesties_failas.close()

print("Failas", failas, "turi", len(eilutės), " eilutes")
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri nukopijuotų vieno failo lygines eilutes į kitą failą.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
įvesties_failo_pavadinimas = input("Kokio failo eilutes kopijuoti? ")
įvesties_failas = open(įvesties_failo_pavadinimas, "r")

išvesties_failo_pavadinimas = input("Į kokį failą išsaugoti lygines eilutes? ")
išvesties_failas = open(išvesties_failo_pavadinimas, "w")

eilutės_numeris = 0

while True:
eilutė = įvesties_failas.readline()
eilutės_numeris = eilutės_numeris + 1
if not eilutė:
break
else:
if (eilutės_numeris % 2) == 0:
išvesties_failas.write(eilutė)

įvesties_failas.close()
išvesties_failas.close()
</syntaxhighlight>
|-
|}

3. Dabar pakeisk pažymių programą iš skyriaus [[Vadovėlis/Žodynai|Žodynai]], kad ji naudotų failus mokinių pažymiams saugoti.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = { }

def įkelti_pažymius(pažymių_failas):
įvesties_failas = open(pažymių_failas, "r")
pažymiai = [ ]
while True:
mokinys_ir_pažymys = įvesties_failas.readline()
mokinys_ir_pažymys = mokinys_ir_pažymys[:-1]
if not mokinys_ir_pažymys:
break
else:
mokinio_vardas, mokinio_pažymiai = mokinys_ir_pažymys.split(",")
mokinio_pažymiai = mokinio_pažymiai.split(" ")
mokiniai[mokinio_vardas] = mokinio_pažymiai
įvesties_failas.close()
print("Pažymiai įkelti.")

def išsaugoti_pažymius(pažymių_failas):
išvesties_failas = open(pažymių_failas, "w")
for k, v in mokiniai.items():
išvesties_failas.write(k + ",")
for x in v:
išvesties_failas.write(str(x) + " ")
išvesties_failas.write("\n")
išvesties_failas.close()
print("Pažymiai išsaugoti.")

def spausdink_meniu():
print("1. Pridėk mokinį")
print("2. Pašalink mokinį")
print("3. Įkrauti pažymius")
print("4. Įrašyk pažymį")
print("5. Spausdink pažymius")
print("6. Įšsaugoti pažymius")
print("7. Spausdink meniu")
print("9. Išeik")

def spausdink_visus_pažymius():
if mokiniai:
raktai = sorted(mokiniai.keys())
print('\t', end=' ')
for x in užduotys:
print(x, '\t', end=' ')
print()
for x in raktai:
print(x, '\t', end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
else:
print("Neradau pažymių spausdinimui.")

def spausdink_pažymius(pažymiai):
for x in pažymiai:
print(x, '\t', end=' ')
print()

spausdink_meniu()
meniu_pasirinkimas = 0
while meniu_pasirinkimas != 9:
print()
meniu_pasirinkimas = int(input("Meniu pasirinkimas: "))
if meniu_pasirinkimas == 1:
vardas = input("Pridėk mokinį: ")
mokiniai[vardas] = [0] * len(užduotys)
elif meniu_pasirinkimas == 2:
vardas = input("Pašalink mokinį: ")
if vardas in mokiniai:
del mokiniai[vardas]
else:
print("Mokinys vardu:", vardas, " nerastas.")
elif meniu_pasirinkimas == 3:
pažymių_failas = input("Įkrauti pažymius iš kokio failo? ")
įkelti_pažymius(pažymių_failas)
elif meniu_pasirinkimas == 4:
print("Įrašyk pažymį")
vardas = input("Mokinys: ")
if vardas in mokiniai:
pažymiai = mokiniai[vardas]
print("Įrašyk mokinio pažymį")
print("Įrašyk 0 (nulį), kad išeitum")
for i,x in enumerate(užduotys):
print(i + 1, x, '\t', end=' ')
print()
spausdink_pažymius(pažymiai)
kuris = 1234
while kuris != -1:
kuris = int(input("Pažymys, kurį nori pakeisti: "))
kuris -= 1
if 0 <= kuris < len(pažymiai):
pažymys = int(input("Pažymys: "))
pažymiai[kuris] = pažymys
elif kuris != -1:
print("Klaidingas pažymys")
else:
print("Mokinys nerastas")
elif meniu_pasirinkimas == 5:
spausdink_visus_pažymius()
elif meniu_pasirinkimas == 6:
pažymių_failas = input("Į kokį failą išsaugoti pažymius? ")
išsaugoti_pažymius(pažymių_failas)
elif meniu_pasirinkimas != 9:
spausdink_meniu()

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie funkcijas |next=Siekiant tobulumo}}
[[Category:Python Vadovėlis]]

Vadovėlis/Failų tvarkymas

2023-06-23T07:54:41Z

Monika: /* Paketinis ir interaktyvus failų apdorojimas */

{{navigation |previous=Daugiau apie funkcijas |next=Siekiant tobulumo}}

=== Failų įvestis/išvestis ===

Štai paprastas failo įvesties ir išvesties (I/O, ang. Input/Output) pavyzdys:
<syntaxhighlight lang="python">
# Rašyti į failą
with open("testas.txt", "wt") as rašomas_failas:
rašomas_failas.write("Šis tekstas bus išsiųstas į failą\nPažiūrėk ir pamatysi!")

# Skaityti failą
with open("testas.txt", "rt") as skaitomas_failas:
tekstas = skaitomas_failas.read()

print(tekstas)
</syntaxhighlight>

Failo <code>testas.txt</code> išvestis ir turinys yra:

Šis tekstas bus išsiųstas į failą
Pažiūrėk ir pamatysi!

Atkreipk dėmesį, kad programa sukūrė failą pavadinimu <code>testas.txt</code> kataloge, iš kurio paleidai programą. Eilutėje esantis <code>\n</code> nurodo Python'ui toje vietoje peršokti į naują eilutę.

Apžvelkime visus veiksmus su failais:
* Gauk failo objektą su funkcija <code>open</code>
* Skaityk iš arba rašyk į failo objektą (priklausomai nuo to, kokiu režimu jis buvo atidarytas)
* Jeigu failui atidaryti nenaudojai funkcijos <code>with</code>, turėsi jį uždaryti rankiniu būdu

Pirmas žingsnis yra gauti failo objektą. Tai galima padaryti naudojant funkciją <code>open</code>. Formatas yra <code>failo_objektas = open(failo_pavadinimas, režimas)</code>, kur <code>failo_objektas</code> yra kintamasis, į kurį reikia įdėti failo objektą, <code>failo_pavadinimas</code> yra eilutė su failo pavadinimu, o <code>režimas</code> yra <code>"rt"</code>, kad (ang. ''r''ead) skaityti failą kaip ''t''ekstą arba <code>"wt"</code> (''w''rite) rašytį į failą kaip ''t''ekstą (ir keletą kitų režimų, kuriuos čia praleisime). Toliau galima iškviesti failų objektų funkcijas. Dvi dažniausiai naudojamos funkcijos yra <code>read</code> (skaityti) ir <code>write</code> (rašyti). Funkcija <code>write</code> prideda eilutę prie failo pabaigos. Funkcija <code>read</code> nuskaito failo turinį ir grąžina jį kaip eilutę (kaip padaryta pavyzdyje).

O dabar čia yra nauja telefono numerių programos versija, kurią jau sukūrei anksčiau:

<syntaxhighlight lang="python">
def spausdink_numerius(numeriai):
print("Telefono numeriai:")
for k, v in numeriai.items():
print("Vardas:", k, "\tTelefono numeris:", v)
print()

def pridėk_numerį(numeriai, vardas, numeris):
numeriai[vardas] = numeris

def surask_numerį(numeriai, vardas):
if vardas in numeriai:
return "Telefono numeris yra " + numeriai[vardas]
else:
return vardas + " nebuvo rastas"

def pašalink_numerį(numeriai, vardas):
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas," nebuvo rastas")

def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()

def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Įkelk telefono numerius')
print('6. Išsaugok telefono numerius')
print('7. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu()
while True:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-7): "))
if meniu_pasirinkimas == 1:
spausdink_numerius(numeriai)
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
pridėk_numerį(numeriai, vardas, numeris)
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
pašalink_numerį(numeriai, vardas)
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
print(surask_numerį(numeriai, vardas))
elif meniu_pasirinkimas == 5:
failo_pavadinimas = input("Failo pavadinimas, kurį nori įkelti: ")
įkelti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 6:
failo_pavadinimas = input("Failo pavadinimas išsaugojimui: ")
išsaugoti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 7:
break
else:
spausdink_meniu()

print("Viso!")
</syntaxhighlight>

Gali pastebėti, kad dabar kodas papildomai išsaugo ir perskaito failus. Štai dviejų programos vykdymų išvestis:

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Liepa'''
Telefono numeris: '''1234'''
Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Benas'''
Telefono numeris: '''4321'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''6'''
Failo pavadinimas išsaugojimui: '''numeriai.txt'''
Įvesk skaičių (1-7): '''7'''
Viso!

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''5'''
Failo pavadinimas, kurį nori įkelti: '''numeriai.txt'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''7'''
Viso!

Naujos šios programos dalys yra:
<syntaxhighlight lang="python">
def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()
</syntaxhighlight>

Pirmiausia pažiūrėk į programos išsaugojimo dalį. Visų pirma, sukuriamas failo objektas su komanda <code>open(failo_pavadinimas, "wt")</code>. Toliau sukuriama eilutė kiekvienam telefono numeriui su komanda <code>išvesties_failas.write(k + "," + v + "\n")</code>. Tai išrašo eilutę, kurioje yra vardas, kablelis, telefono numeris, o po jos rašoma nauja eilutė.

Failo skaitymo dalis yra šiek tiek sudėtingesnė. Ji prasideda failo objekto gavimu. Tada ji naudoja <code>while True:</code> ciklą, kad tęstųsi ciklas tol, kol bus aptikta komanda <code>break</code>. Komanda <code>skaitoma_eilutė = skaitymo_failas.readline()</code> perskaito pirmą eilutę ir priskiria kintamajam <code>skaitome_eilutė</code>. Pasiekus failo pabaigą, funkcija <code>readline</code> grąžins tuščią eilutę. Sąlyginis sakinys <code>if</code> tai patikrina ir panaudojant komandą <code>break</code> nutraukia <code>while</code> ciklą. Funkcija <code>readline</code> perskaito ir grąžina vieną eilutę kartu su jos pabaigos simboliu. Tai yra tam, kad būtų galima spręsti ar tai yra tik tuščia eilutė, ar jau failo pabaiga. Taigi turime atsikratyti to paskutinio eilutės pabaigos simbolio. Komanda <code>skaitoma_eilutė = skaitoma_eilutė[:-1]</code> tai padaro už mus, išmesdama paskutinį simbolį. Toliau eilutė <code>vardas, numeris = skaitoma_eilutė.split(",")</code> padalija eilutę ties kableliu į vardą ir telefono numerį ir visa tai įtraukiama į <code>numeriai</code> žodyną.

=== Darbo su failais rėžimai ===
Be <code>"rt"</code> ir <code>"wt"</code> yra ir kitų darbo su failais rėžimų. Lentelėje rasi visų rėžimų sąrašą:
{| class="wikitable"
|+
!Rėžimas
!Paaiškinimas
|-
|"rt"
|Tekstinio failo nuskatymas
|-
|"wt"
|Teksto rašymas į failą
|-
|"xt"
|Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"at"
|Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r"
|Sinonimas "rt" rėžimui. Tekstinio failo nuskatymas
|-
|"w"
|Sinonimas "w" rėžimui. Teksto rašymas į failą
|-
|"x"
|Sinonimas "x" rėžimui. Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"a"
|Sinonimas "a" rėžimui. Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"rb"
|Dvejetainio duomenų failo nuskatymas
|-
|"wb"
|Dvejetainės informacijos rašymas į failą
|-
|"xb"
|Naujo dvejetainio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"ab"
|Dvejetainio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|-
|"r+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|}
Dvvejetainiai rėžimai šiame vadovėlyje plačiau nagrinėjami nėra

=== Pagrindinės darbo su tekstiniais failais operacijos ===
{| class="wikitable"
|+
!Operacija
!Paaiškinimas
|-
|failas.read()
|Nuskaitomas visas failo turinys
|-
|failas.read(kiek)
|Nuskaitomas nuordytas simbolių kiekis iš failo. Pvz naudojant failas.read(3) bus nuskaitomi 3 sekantys simboliai
|-
|failas.readline()
|Nuskaitoma sekanti failo eilutė
|-
|failas.readlines()
|Nuskaitomos visos failo eilutės. Gražinamas sąrašas sudarytas iš teksto eilučių
|-
|failas.close()
|Failo uždarymas. Uždarius failą veiksmai su juo negalimi. Atidarant failą naudojant with funkciją, jis bus uždarytas automatiškai, tad close() naudoti nebereikia
|-
|failas.write(rašomas_tesktas)
|Įrašo nurodytą tekstą į failą.
|-
|failas.writelines(rašomo_teksto_eilučių_sąrašas)
|Sąrašas sudarytas iš teskto eilučių yra įrašomas į failą. Kiekvienas sąrašo elementas bus įrašomas naujoje eilutėje
|}

=== Paketinis ir interaktyvus failų apdorojimas ===

Paketinis duomenų apdorojimas ir interaktyvus duomenų apdorojimas yra naudingi duomenų tvarkymo metodai.

Skaitymas iš failo yra vadinamas paketiniu duomenų apdorojimu, nes visi duomenys iš failo yra nuskaitomi ir apdorojami kaip vienas paketas. Tai reiškia, kad visi duomenys yra nuskaitomi iš failo į kompiuterio atmintį vienu metu ir toliau apdorojami kompiuterio procesorių, o ne tiesiogiai iš failo.

Pavyzdžiui, jei turi didelio dydžio tekstinį failą ir nori jį apdoroti programoje, failas bus nuskaitomas į atmintį ir tada apdorotas kaip vienas paketas, o ne kaip atskiri duomenų elementai.

Interaktyvus duomenų apdorojimas – tai būdas dirbti su duomenimis, kai vartotojas gali manipuliuoti įvairiais nustatymais, o ne laikytis iš anksto užprogramuotų algoritmų. Tai leidžia geriau valdyti rezultatus ir geriau suprasti duomenis.

=== Pažangesnis .txt failų naudojimas ===

Galbūt tau kyla toks klausimas: „Aš žinau, kaip skaityti ir rašyti tekstinį failą, bet ką daryti, jei noriu atspausdinti failą spausdintuvu?"

Yra keletas skirtingų būdų, kaip tai padaryti. Iš tikrųjų, pats lengviausias būdas yra atidaryti kitą programą, tada leisti viskuo pasirūpinti Python'o kodui, kad tau nereikėtų pačiam failo atidarinėti ir spausdinti. Šis metodas apima kitos programos subproceso (arba antrinis procesas; biblioteka 'subprocess') iškvietimą.

Prisimeni failą, į kurį įrašėme išvestį aukščiau esančioje programoje? Panaudokime tą failą.
Turėk omenyje, kad norint išvengti klaidų, ši programa naudoja sąvokas iš kito skyriaus. Nedvejodamas gali dar kartą peržiūrėti šį pavyzdį po kito skyriaus.

<syntaxhighlight lang="Python">
import subprocess
def pagrindinis():
try:
print("Ši maža programa iškviečia spausdinimo funkciją Notepad programoje")
#Atspausdinkime failą, kurį sukūrėme aukščiau esančioje programoje
subprocess.call(['notepad','/p','numeriai.txt'])
except WindowsError:
print("Pakviesto subproceso nėra arba jo negalima iškviesti.")

pagrindinis()
</syntaxhighlight>

<code>subprocess.call</code> turi tris argumentus. Pirmasis argumentas šio pavyzdžio kontekste turėtų būti programos pavadinimas, iš kurios nori iškviesti spausdinimo subprocesą. Antrasis argumentas turėtų būti konkretus tos programos subprocesas. Kad būtų paprasčiau, tiesiog suprask, kad šioje programoje <code>'/p'</code> yra subprocesas, naudojamas norint pasiekti spausdintuvą per nurodytą programą. Paskutinis argumentas turėtų būti failo pavadinimas, kurį norite siųsti į spausdinimo subprocesą. Šiuo atveju tai yra tas pats failas, naudotas anksčiau šiame skyriuje.

=== Pratimai ===
1. Parašyk programą, kuri suskaičiuotų, kiek faile yra eilučių.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
failas = input("Kokio failo eilutes skaičiuoti? ")
įvesties_failas = open(failas, "r")
eilutės = įvesties_failas.readlines()
įvesties_failas.close()

print("Failas", failas, "turi", len(eilutės), " eilutes")
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri nukopijuotų vieno failo lygines eilutes į kitą failą.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
įvesties_failo_pavadinimas = input("Kokio failo eilutes kopijuoti? ")
įvesties_failas = open(įvesties_failo_pavadinimas, "r")

išvesties_failo_pavadinimas = input("Į kokį failą išsaugoti lygines eilutes? ")
išvesties_failas = open(išvesties_failo_pavadinimas, "w")

eilutės_numeris = 0

while True:
eilutė = įvesties_failas.readline()
eilutės_numeris = eilutės_numeris + 1
if not eilutė:
break
else:
if (eilutės_numeris % 2) == 0:
išvesties_failas.write(eilutė)

įvesties_failas.close()
išvesties_failas.close()
</syntaxhighlight>
|-
|}

3. Dabar pakeisk pažymių programą iš skyriaus [[Vadovėlis/Žodynai|Žodynai]], kad ji naudotų failus mokinių pažymiams saugoti.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = { }

def įkelti_pažymius(pažymių_failas):
įvesties_failas = open(pažymių_failas, "r")
pažymiai = [ ]
while True:
mokinys_ir_pažymys = įvesties_failas.readline()
mokinys_ir_pažymys = mokinys_ir_pažymys[:-1]
if not mokinys_ir_pažymys:
break
else:
mokinio_vardas, mokinio_pažymiai = mokinys_ir_pažymys.split(",")
mokinio_pažymiai = mokinio_pažymiai.split(" ")
mokiniai[mokinio_vardas] = mokinio_pažymiai
įvesties_failas.close()
print("Pažymiai įkelti.")

def išsaugoti_pažymius(pažymių_failas):
išvesties_failas = open(pažymių_failas, "w")
for k, v in mokiniai.items():
išvesties_failas.write(k + ",")
for x in v:
išvesties_failas.write(str(x) + " ")
išvesties_failas.write("\n")
išvesties_failas.close()
print("Pažymiai išsaugoti.")

def spausdink_meniu():
print("1. Pridėk mokinį")
print("2. Pašalink mokinį")
print("3. Įkrauti pažymius")
print("4. Įrašyk pažymį")
print("5. Spausdink pažymius")
print("6. Įšsaugoti pažymius")
print("7. Spausdink meniu")
print("9. Išeik")

def spausdink_visus_pažymius():
if mokiniai:
raktai = sorted(mokiniai.keys())
print('\t', end=' ')
for x in užduotys:
print(x, '\t', end=' ')
print()
for x in raktai:
print(x, '\t', end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
else:
print("Neradau pažymių spausdinimui.")

def spausdink_pažymius(pažymiai):
for x in pažymiai:
print(x, '\t', end=' ')
print()

spausdink_meniu()
meniu_pasirinkimas = 0
while meniu_pasirinkimas != 9:
print()
meniu_pasirinkimas = int(input("Meniu pasirinkimas: "))
if meniu_pasirinkimas == 1:
vardas = input("Pridėk mokinį: ")
mokiniai[vardas] = [0] * len(užduotys)
elif meniu_pasirinkimas == 2:
vardas = input("Pašalink mokinį: ")
if vardas in mokiniai:
del mokiniai[vardas]
else:
print("Mokinys vardu:", vardas, " nerastas.")
elif meniu_pasirinkimas == 3:
pažymių_failas = input("Įkrauti pažymius iš kokio failo? ")
įkelti_pažymius(pažymių_failas)
elif meniu_pasirinkimas == 4:
print("Įrašyk pažymį")
vardas = input("Mokinys: ")
if vardas in mokiniai:
pažymiai = mokiniai[vardas]
print("Įrašyk mokinio pažymį")
print("Įrašyk 0 (nulį), kad išeitum")
for i,x in enumerate(užduotys):
print(i + 1, x, '\t', end=' ')
print()
spausdink_pažymius(pažymiai)
kuris = 1234
while kuris != -1:
kuris = int(input("Pažymys, kurį nori pakeisti: "))
kuris -= 1
if 0 <= kuris < len(pažymiai):
pažymys = int(input("Pažymys: "))
pažymiai[kuris] = pažymys
elif kuris != -1:
print("Klaidingas pažymys")
else:
print("Mokinys nerastas")
elif meniu_pasirinkimas == 5:
spausdink_visus_pažymius()
elif meniu_pasirinkimas == 6:
pažymių_failas = input("Į kokį failą išsaugoti pažymius? ")
išsaugoti_pažymius(pažymių_failas)
elif meniu_pasirinkimas != 9:
spausdink_meniu()

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie funkcijas |next=Siekiant tobulumo}}
[[Category:Python Vadovėlis]]

Vadovėlis/Pažangios funkcijos

2023-06-23T07:47:28Z

Monika: /* Pagalbininkė map() */

=== Pažangesnės funkcijos ===
Papasakosiu tau apie keletą neįtikėtinų funkcijų ir gudrybių, kurios padės supaprastinti užduočių atlikimą.
''Pradėkime'' :)

=== Lambda funkcija ===

Jau žinai kaip apsirašyti funkciją su žodeliu ‘’def’’. Lambda funkcija yra tokia pati funkcija, tik labai trumpa ir anoniminė - ji neturi jokio vardo. Kai reikia apibrėžti labai trumpą ir paprastą funkciją, kurią naudosime tik vieną kartą ir kuri nereikalauja sudėtingos logikos, galime naudoti lambda funkciją. Tai gali būti ypač naudinga, kai turime sudėtingą funkciją, kurią norime išskaidyti į smulkesnes dalis, arba kai norime panaudoti funkciją kaip argumentą kitai funkcijai. Lambda funkcijos sintaksė yra paprasta, rašome žodį lambda, po to tarp skliaustų nurodome argumentų sąrašą ir funkcijos išraišką. Tai viskas, ko mums reikia, kad apibrėžtume lambda funkciją.

Lambda funkcijos yra naudojamos daugeliui Python standartinių funkcijų, pavyzdžiui, <code>filter()</code>, <code>map()</code>, <code>sorted()</code>, kad būtų paprastesnis kodas. Apie jas daugiau papasakosiu šiame skyriuje, o dabar pažiūrėkime, kaip galime panaudoti lambda funkciją:

<syntaxhighlight lang="python">
# lambda funkcija apskaičiuojanti kvadratą
kvadratas = lambda x: x**2

print(kvadratas(5)) # 25

# lambda funkcija filtruojanti nelyginius skaičius
skaičiai = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
nelyginiai = list(filter(lambda x: x % 2 != 0, skaičiai))

print(nelyginiai) # [1, 3, 5, 7, 9]
</syntaxhighlight>

Lambda funkcija taip pat gali būti naudinga, kai reikia perduoti funkciją kaip argumentą į kitą funkciją. Tai leidžia sukurti trumpą, paprastą ir lengvai suprantamą kodą.

=== Rikiavimas su ''sorted()'' ===
Anksčiau rodžiau rikiavimo funkciją su sąrašais. Sąrašo funkcija <code>sąrašas.sort()</code> modifikuoja savo elementus juos surikiuodamas. Taip kintamasis pakeičia savo reikšmę. Python taip pat turi funkciją <code>sorted()</code> kuri grąžina naują surikiuotą rezultatą, nepakeisdama originalaus kintamojo.
Pažiūrėkim, kaip tai veikia:

<syntaxhighlight lang="python">
# susikuriame sąrašą su atsitiktiniais skaičiais
sąrašas = [3,1,5,23,0]
# sorted grąžina surikiuotą sąrašą, kuri priskiriame naujajam kintamajam.
surikiuotas_sąrašas = sorted(sąrašas)

# atsispausdiname rezultatą. Matysi, kad kintamasis sąrašas nepakeitė reikšmės, o surikiuotas_sąrašas reikšmė yra surikiuota.
print(surikiuotas_sąrašas, sąrašas)

# pažiūrėkim, ką padarys funkcija sort()
sąrašas.sort()
# rezultate matysi du surikiuotus identiškus sąrašus.
print(surikiuotas_sąrašas, sąrašas)

# kaip surikiuoti mažėjančia tvarka? Tiesiog pridėkime prie funkcijos reverse=True
atbulas_sąrašas = sorted(surikiuotas_sąrašas, reverse=True)
print(atbulas_sąrašas, surikiuotas_sąrašas, sąrašas)
</syntaxhighlight>

Rezultatus turėtum matyti tokius:

[0, 1, 3, 5, 23] [3, 1, 5, 23, 0]
[0, 1, 3, 5, 23] [0, 1, 3, 5, 23]
[23, 5, 3, 1, 0] [0, 1, 3, 5, 23] [0, 1, 3, 5, 23]

Akylus skaitytojas pamatys, kad pavyzdyje parodžiau papildomą sorted funkcionalumą atbuliniam sąrašo rikiavimui: <code>sorted(sąrašas, reverse=True)</code>. '''reverse''' anglų kalboje reiškia ''atbulinis'', todėl tai pasako funkcijai, kad mums reikia grąžint sąrašą atbuline tvarka.

Dar vienas labai svarbus skirtumas tarp sąrašas.sort() ir sorted() - ‘’sorted’’ naudojamas visiems iteruojamiems objektams. Pavyzdžiui anksčiau skyriuje minėtiems žodynams.

<syntaxhighlight lang="python">
# pasirašom funkciją sąrašo atvaizdavimui
def spausdink(sąrašas):
for elementas in sąrašas:
print(elementas)
print('')

# apsirašom sąrašą žodynų, kuriuos rikiuosime.
žodynai = [
{"vardas": "Darius", "metai": 15, "pomėgis": "bėgimas"},
{"vardas": "Marius", "metai": 14, "pomėgis": "krepšinis"},
{"vardas": "Karolis", "metai": 16, "pomėgis": "krepšinis"},
{"vardas": "Gileta", "metai": 13, "pomėgis": "tinklinis"},
{"vardas": "Eglė", "metai": 17, "pomėgis": "bėgimas"},
]

print('surikiuojam pagal metus mažėjančia tvarka')
spausdink(sorted(žodynai, key=lambda x: -x['metai']))

print('rikiuojame pagal dvi reikšmes: pradžioje pagal pomėgį, o vėliau pagal metus didėjančia tvarka.')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], x['metai'])) )
print('nurodome atbuline tvarka')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], x['metai']), reverse=True) )

print('rikiuojame pagal pomėgį didėjančia tvarka, o vėliau pagal metus mažėjančia')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], -x['metai'])) )
print('nurodome atbuline tvarka')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], -x['metai']), reverse=True) )

</syntaxhighlight>

Rezultatas bus toks:

surikiuojam pagal metus mažėjančia tvarka
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

rikiuojame pagal dvi reikšmes: pradžioje pagal pomėgį, o vėliau pagal metus didėjančia tvarka.
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

nurodome atbuline tvarka
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}

rikiuojame pagal pomėgį didėjančia tvarka, o vėliau pagal metus mažėjančia
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

nurodome atbuline tvarka
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}

Norint naudoti funkciją <code>sorted()</code> su žodynais, reikia programai nurodyti, pagal kurią žodyno reikšmę nori rikiuoti sąrašą. Tai gali padaryti nurodydamas <code>key=lambda kintamasis: kintamasis[‘reikšmė’]</code>. Parametras ‘’key’’ nurodo funkcijai ‘’sorted’’, kad norėsi naudoti papildoma funkciją. Štai čia mes paduodame bevardę funkciją ‘’lambda’’, kuri ir nurodo, pagal kuriuos parametrus mes norime rikiuoti sąrašą.

=== Pagalbininkė ''map()'' ===
<code>map()</code> yra Python vidinė funkcija, kuri leidžia mums taikyti funkciją kiekvienam elementui sąraše ar kitame iteruojamame objekte. Ši funkcija grąžina naują sąrašą, kuriame kiekvienas elementas yra pritaikytas pagal paduotą funkciją.
<syntaxhighlight lang="python">
map(funkcija, sąrašas)
</syntaxhighlight>

* ‘’funkcija’’ yra funkcija, kuri bus taikoma kiekvienam elementui sąraše.
* ‘’sąrašas’’ yra sąrašas, arba kitas iteruojamas objektas.

Pažiūrėkime į pavyzdį:

<syntaxhighlight lang="python">
# sukuriame sąrašą skaičių
skaičiai = [1, 2, 3, 4, 5]

# apibrėžiame funkciją, kurią norime pritaikyti kiekvienam elementui
def kvadratas(x):
return x**2

# naudojame map() funkciją, kad pritaikytume funkciją kiekvienam sąrašo elementui
skaičiai_kvadratu = map(kvadratas, skaičiai)

# išspausdiname naują sąrašą, kuriame kiekvienas skaičius yra pakeltas kvadratu
print(list(skaičiai_kvadratu)) # [1, 4, 9, 16, 25]
</syntaxhighlight>

Taip pat galime naudoti lambda funkcijas, kad nurodytume funkciją tiesiogiai <code>map()</code> funkcijos viduje, kaip gali pamatyti čia:

<syntaxhighlight lang="python">
# sukuriame sąrašą skaičių
skaičiai = [1, 2, 3, 4, 5]

# naudojame lambda funkciją, kad apibrėžtume funkciją tiesiogiai map() viduje
skaičiai_kvadratu = map(lambda x: x**2, skaičiai)

# išspausdiname naują sąrašą, kuriame kiekvienas skaičius yra pakeltas kvadratu
print(list(skaičiai_kvadratu)) # [1, 4, 9, 16, 25]
</syntaxhighlight>

<code>map()</code> funkcija yra naudinga, kai reikia greitai ir efektyviai pritaikyti tam tikrą funkciją kiekvienam sąrašo ar kitame iteruojamame objekte esančiam elementui, ir gauti naują sąrašą su apdorotais elementais.

Beje, ar atkreipei dėmesį, kad norint atspausdinti sąrašą, aš panaudojau funkciją <code>list()</code>. Ar žinai kodėl?

Tai yra dėl to, kad <code>map()</code> funkcija grąžina iteruojamą objektą, kuris yra vadinamas ''generatoriumi''. Generatorius yra specialus iteruojamas objektas, kuris leidžia gauti reikiamus duomenis vieną po kito pagal poreikį, taip sutaupant atminties resursus. Tačiau, norint matyti visus elementus iš karto, reikia sukurti sąrašą ar kitą tipo objektą, kuris saugotų visus <code>map()</code> funkcijos grąžinamus elementus. Tai padaryti galime, panaudoję <code>list()</code> funkciją, kuri konvertuoja generatoriaus grąžinamą objektą į sąrašą.

=== Filtravimas su ''filter()'' ===

<code>filter()</code> yra Python funkcija, kuri leidžia filtruoti duomenis pagal tam tikras sąlygas. Ši funkcija veikia pagal panašų principą kaip <code>map()</code> funkcija, tačiau jos veikimo būdas yra kitoks. <code>filter()</code> funkcija taiko nurodytą sąlygą (funkciją) kiekvienam elementui iteruojamame objekte ir grąžina tik tuos elementus, kuriuos ta sąlyga tenkina. Tai yra, funkcija išfiltruoja tik tuos elementus, kurie tenkina nurodytą sąlygą.

<code>filter()</code> funkcija naudojama kartu su lambda funkcijomis arba kitomis funkcijomis, kurios grąžina True arba False. Kai reikia išgauti tik tuos elementus, kurie tenkina nurodytą sąlygą, naudojama filter() funkcija.

Pavyzdžiui, norint išfiltruoti tik lyginius skaičius iš sąrašo, galime naudoti šią filter() funkcijos ir lambda funkcijos kombinaciją:

<syntaxhighlight lang="python">
# Sukuriamas sąrašas skaičių
skaičiai = [1, 2, 3, 4, 5]

# Sukuriamas naujas sąrašas tik su lyginiais skaičiais naudojant filter() ir lambda funkciją
lyginiai_skaičiai = filter(lambda x: x % 2 == 0, skaičiai)

# Išspausdinamas naujas sąrašas tik su lyginiais skaičiais
print(list(lyginiai_skaičiai)) # [2, 4]
</syntaxhighlight>

Šioje situacijoje, filter() funkcija išfiltruoja tik tuos skaičius, kurių liekana yra lygi nuliui (t.y. tik lyginiai skaičiai).

Vadovėlis/Pažangios funkcijos

2023-06-23T07:47:02Z

Monika: /* Pagalbininkė map() */

=== Pažangesnės funkcijos ===
Papasakosiu tau apie keletą neįtikėtinų funkcijų ir gudrybių, kurios padės supaprastinti užduočių atlikimą.
''Pradėkime'' :)

=== Lambda funkcija ===

Jau žinai kaip apsirašyti funkciją su žodeliu ‘’def’’. Lambda funkcija yra tokia pati funkcija, tik labai trumpa ir anoniminė - ji neturi jokio vardo. Kai reikia apibrėžti labai trumpą ir paprastą funkciją, kurią naudosime tik vieną kartą ir kuri nereikalauja sudėtingos logikos, galime naudoti lambda funkciją. Tai gali būti ypač naudinga, kai turime sudėtingą funkciją, kurią norime išskaidyti į smulkesnes dalis, arba kai norime panaudoti funkciją kaip argumentą kitai funkcijai. Lambda funkcijos sintaksė yra paprasta, rašome žodį lambda, po to tarp skliaustų nurodome argumentų sąrašą ir funkcijos išraišką. Tai viskas, ko mums reikia, kad apibrėžtume lambda funkciją.

Lambda funkcijos yra naudojamos daugeliui Python standartinių funkcijų, pavyzdžiui, <code>filter()</code>, <code>map()</code>, <code>sorted()</code>, kad būtų paprastesnis kodas. Apie jas daugiau papasakosiu šiame skyriuje, o dabar pažiūrėkime, kaip galime panaudoti lambda funkciją:

<syntaxhighlight lang="python">
# lambda funkcija apskaičiuojanti kvadratą
kvadratas = lambda x: x**2

print(kvadratas(5)) # 25

# lambda funkcija filtruojanti nelyginius skaičius
skaičiai = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
nelyginiai = list(filter(lambda x: x % 2 != 0, skaičiai))

print(nelyginiai) # [1, 3, 5, 7, 9]
</syntaxhighlight>

Lambda funkcija taip pat gali būti naudinga, kai reikia perduoti funkciją kaip argumentą į kitą funkciją. Tai leidžia sukurti trumpą, paprastą ir lengvai suprantamą kodą.

=== Rikiavimas su ''sorted()'' ===
Anksčiau rodžiau rikiavimo funkciją su sąrašais. Sąrašo funkcija <code>sąrašas.sort()</code> modifikuoja savo elementus juos surikiuodamas. Taip kintamasis pakeičia savo reikšmę. Python taip pat turi funkciją <code>sorted()</code> kuri grąžina naują surikiuotą rezultatą, nepakeisdama originalaus kintamojo.
Pažiūrėkim, kaip tai veikia:

<syntaxhighlight lang="python">
# susikuriame sąrašą su atsitiktiniais skaičiais
sąrašas = [3,1,5,23,0]
# sorted grąžina surikiuotą sąrašą, kuri priskiriame naujajam kintamajam.
surikiuotas_sąrašas = sorted(sąrašas)

# atsispausdiname rezultatą. Matysi, kad kintamasis sąrašas nepakeitė reikšmės, o surikiuotas_sąrašas reikšmė yra surikiuota.
print(surikiuotas_sąrašas, sąrašas)

# pažiūrėkim, ką padarys funkcija sort()
sąrašas.sort()
# rezultate matysi du surikiuotus identiškus sąrašus.
print(surikiuotas_sąrašas, sąrašas)

# kaip surikiuoti mažėjančia tvarka? Tiesiog pridėkime prie funkcijos reverse=True
atbulas_sąrašas = sorted(surikiuotas_sąrašas, reverse=True)
print(atbulas_sąrašas, surikiuotas_sąrašas, sąrašas)
</syntaxhighlight>

Rezultatus turėtum matyti tokius:

[0, 1, 3, 5, 23] [3, 1, 5, 23, 0]
[0, 1, 3, 5, 23] [0, 1, 3, 5, 23]
[23, 5, 3, 1, 0] [0, 1, 3, 5, 23] [0, 1, 3, 5, 23]

Akylus skaitytojas pamatys, kad pavyzdyje parodžiau papildomą sorted funkcionalumą atbuliniam sąrašo rikiavimui: <code>sorted(sąrašas, reverse=True)</code>. '''reverse''' anglų kalboje reiškia ''atbulinis'', todėl tai pasako funkcijai, kad mums reikia grąžint sąrašą atbuline tvarka.

Dar vienas labai svarbus skirtumas tarp sąrašas.sort() ir sorted() - ‘’sorted’’ naudojamas visiems iteruojamiems objektams. Pavyzdžiui anksčiau skyriuje minėtiems žodynams.

<syntaxhighlight lang="python">
# pasirašom funkciją sąrašo atvaizdavimui
def spausdink(sąrašas):
for elementas in sąrašas:
print(elementas)
print('')

# apsirašom sąrašą žodynų, kuriuos rikiuosime.
žodynai = [
{"vardas": "Darius", "metai": 15, "pomėgis": "bėgimas"},
{"vardas": "Marius", "metai": 14, "pomėgis": "krepšinis"},
{"vardas": "Karolis", "metai": 16, "pomėgis": "krepšinis"},
{"vardas": "Gileta", "metai": 13, "pomėgis": "tinklinis"},
{"vardas": "Eglė", "metai": 17, "pomėgis": "bėgimas"},
]

print('surikiuojam pagal metus mažėjančia tvarka')
spausdink(sorted(žodynai, key=lambda x: -x['metai']))

print('rikiuojame pagal dvi reikšmes: pradžioje pagal pomėgį, o vėliau pagal metus didėjančia tvarka.')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], x['metai'])) )
print('nurodome atbuline tvarka')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], x['metai']), reverse=True) )

print('rikiuojame pagal pomėgį didėjančia tvarka, o vėliau pagal metus mažėjančia')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], -x['metai'])) )
print('nurodome atbuline tvarka')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], -x['metai']), reverse=True) )

</syntaxhighlight>

Rezultatas bus toks:

surikiuojam pagal metus mažėjančia tvarka
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

rikiuojame pagal dvi reikšmes: pradžioje pagal pomėgį, o vėliau pagal metus didėjančia tvarka.
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

nurodome atbuline tvarka
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}

rikiuojame pagal pomėgį didėjančia tvarka, o vėliau pagal metus mažėjančia
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

nurodome atbuline tvarka
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}

Norint naudoti funkciją <code>sorted()</code> su žodynais, reikia programai nurodyti, pagal kurią žodyno reikšmę nori rikiuoti sąrašą. Tai gali padaryti nurodydamas <code>key=lambda kintamasis: kintamasis[‘reikšmė’]</code>. Parametras ‘’key’’ nurodo funkcijai ‘’sorted’’, kad norėsi naudoti papildoma funkciją. Štai čia mes paduodame bevardę funkciją ‘’lambda’’, kuri ir nurodo, pagal kuriuos parametrus mes norime rikiuoti sąrašą.

=== Pagalbininkė ''map()'' ===
<code>map()</code> yra Python vidinė funkcija, kuri leidžia mums taikyti funkciją kiekvienam elementui sąraše ar kitame iteruojamame objekte. Ši funkcija grąžina naują sąrašą, kuriame kiekvienas elementas yra pritaikytas pagal paduotą funkciją.
<syntaxhighlight lang="python">
map(funkcija, sąrašas)
</syntaxhighlight>

* ‘’funkcija’’ yra funkcija, kuri bus taikoma kiekvienam elementui sąraše.
* ‘’sąrašas’’ yra sąrašas, arba kitas iteruojamas objektas.

Pažiūrėkime į pavyzdį:

<syntaxhighlight lang="python">
# sukuriame sąrašą skaičių
skaičiai = [1, 2, 3, 4, 5]

# apibrėžiame funkciją, kurią norime pritaikyti kiekvienam elementui
def kvadratas(x):
return x**2

# naudojame map() funkciją, kad pritaikytume funkciją kiekvienam sąrašo elementui
skaičiai_kvadratu = map(kvadratas, skaičiai)

# išspausdiname naują sąrašą, kuriame kiekvienas skaičius yra pakeltas kvadratu
print(list(skaičiai_kvadratu)) # [1, 4, 9, 16, 25]
</syntaxhighlight>

Taip pat galime naudoti lambda funkcijas, kad nurodytume funkciją tiesiogiai <code>map()</code> funkcijos viduje, kaip gali pamatyti čia:

<syntaxhighlight lang="python">
# sukuriame sąrašą skaičių
skaičiai = [1, 2, 3, 4, 5]

# naudojame lambda funkciją, kad apibrėžtume funkciją tiesiogiai map() viduje
skaičiai_kvadratu = map(lambda x: x**2, skaičiai)

# išspausdiname naują sąrašą, kuriame kiekvienas skaičius yra kvadratu didesnis nei prieš tai
print(list(skaičiai_kvadratu)) # [1, 4, 9, 16, 25]
</syntaxhighlight>

<code>map()</code> funkcija yra naudinga, kai reikia greitai ir efektyviai pritaikyti tam tikrą funkciją kiekvienam sąrašo ar kitame iteruojamame objekte esančiam elementui, ir gauti naują sąrašą su apdorotais elementais.

Beje, ar atkreipei dėmesį, kad norint atspausdinti sąrašą, aš panaudojau funkciją <code>list()</code>. Ar žinai kodėl?

Tai yra dėl to, kad <code>map()</code> funkcija grąžina iteruojamą objektą, kuris yra vadinamas ''generatoriumi''. Generatorius yra specialus iteruojamas objektas, kuris leidžia gauti reikiamus duomenis vieną po kito pagal poreikį, taip sutaupant atminties resursus. Tačiau, norint matyti visus elementus iš karto, reikia sukurti sąrašą ar kitą tipo objektą, kuris saugotų visus <code>map()</code> funkcijos grąžinamus elementus. Tai padaryti galime, panaudoję <code>list()</code> funkciją, kuri konvertuoja generatoriaus grąžinamą objektą į sąrašą.

=== Filtravimas su ''filter()'' ===

<code>filter()</code> yra Python funkcija, kuri leidžia filtruoti duomenis pagal tam tikras sąlygas. Ši funkcija veikia pagal panašų principą kaip <code>map()</code> funkcija, tačiau jos veikimo būdas yra kitoks. <code>filter()</code> funkcija taiko nurodytą sąlygą (funkciją) kiekvienam elementui iteruojamame objekte ir grąžina tik tuos elementus, kuriuos ta sąlyga tenkina. Tai yra, funkcija išfiltruoja tik tuos elementus, kurie tenkina nurodytą sąlygą.

<code>filter()</code> funkcija naudojama kartu su lambda funkcijomis arba kitomis funkcijomis, kurios grąžina True arba False. Kai reikia išgauti tik tuos elementus, kurie tenkina nurodytą sąlygą, naudojama filter() funkcija.

Pavyzdžiui, norint išfiltruoti tik lyginius skaičius iš sąrašo, galime naudoti šią filter() funkcijos ir lambda funkcijos kombinaciją:

<syntaxhighlight lang="python">
# Sukuriamas sąrašas skaičių
skaičiai = [1, 2, 3, 4, 5]

# Sukuriamas naujas sąrašas tik su lyginiais skaičiais naudojant filter() ir lambda funkciją
lyginiai_skaičiai = filter(lambda x: x % 2 == 0, skaičiai)

# Išspausdinamas naujas sąrašas tik su lyginiais skaičiais
print(list(lyginiai_skaičiai)) # [2, 4]
</syntaxhighlight>

Šioje situacijoje, filter() funkcija išfiltruoja tik tuos skaičius, kurių liekana yra lygi nuliui (t.y. tik lyginiai skaičiai).

Vadovėlis/Pažangios funkcijos

2023-06-23T07:36:11Z

Monika: /* Lambda funkcija */

=== Pažangesnės funkcijos ===
Papasakosiu tau apie keletą neįtikėtinų funkcijų ir gudrybių, kurios padės supaprastinti užduočių atlikimą.
''Pradėkime'' :)

=== Lambda funkcija ===

Jau žinai kaip apsirašyti funkciją su žodeliu ‘’def’’. Lambda funkcija yra tokia pati funkcija, tik labai trumpa ir anoniminė - ji neturi jokio vardo. Kai reikia apibrėžti labai trumpą ir paprastą funkciją, kurią naudosime tik vieną kartą ir kuri nereikalauja sudėtingos logikos, galime naudoti lambda funkciją. Tai gali būti ypač naudinga, kai turime sudėtingą funkciją, kurią norime išskaidyti į smulkesnes dalis, arba kai norime panaudoti funkciją kaip argumentą kitai funkcijai. Lambda funkcijos sintaksė yra paprasta, rašome žodį lambda, po to tarp skliaustų nurodome argumentų sąrašą ir funkcijos išraišką. Tai viskas, ko mums reikia, kad apibrėžtume lambda funkciją.

Lambda funkcijos yra naudojamos daugeliui Python standartinių funkcijų, pavyzdžiui, <code>filter()</code>, <code>map()</code>, <code>sorted()</code>, kad būtų paprastesnis kodas. Apie jas daugiau papasakosiu šiame skyriuje, o dabar pažiūrėkime, kaip galime panaudoti lambda funkciją:

<syntaxhighlight lang="python">
# lambda funkcija apskaičiuojanti kvadratą
kvadratas = lambda x: x**2

print(kvadratas(5)) # 25

# lambda funkcija filtruojanti nelyginius skaičius
skaičiai = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
nelyginiai = list(filter(lambda x: x % 2 != 0, skaičiai))

print(nelyginiai) # [1, 3, 5, 7, 9]
</syntaxhighlight>

Lambda funkcija taip pat gali būti naudinga, kai reikia perduoti funkciją kaip argumentą į kitą funkciją. Tai leidžia sukurti trumpą, paprastą ir lengvai suprantamą kodą.

=== Rikiavimas su ''sorted()'' ===
Anksčiau rodžiau rikiavimo funkciją su sąrašais. Sąrašo funkcija <code>sąrašas.sort()</code> modifikuoja savo elementus juos surikiuodamas. Taip kintamasis pakeičia savo reikšmę. Python taip pat turi funkciją <code>sorted()</code> kuri grąžina naują surikiuotą rezultatą, nepakeisdama originalaus kintamojo.
Pažiūrėkim, kaip tai veikia:

<syntaxhighlight lang="python">
# susikuriame sąrašą su atsitiktiniais skaičiais
sąrašas = [3,1,5,23,0]
# sorted grąžina surikiuotą sąrašą, kuri priskiriame naujajam kintamajam.
surikiuotas_sąrašas = sorted(sąrašas)

# atsispausdiname rezultatą. Matysi, kad kintamasis sąrašas nepakeitė reikšmės, o surikiuotas_sąrašas reikšmė yra surikiuota.
print(surikiuotas_sąrašas, sąrašas)

# pažiūrėkim, ką padarys funkcija sort()
sąrašas.sort()
# rezultate matysi du surikiuotus identiškus sąrašus.
print(surikiuotas_sąrašas, sąrašas)

# kaip surikiuoti mažėjančia tvarka? Tiesiog pridėkime prie funkcijos reverse=True
atbulas_sąrašas = sorted(surikiuotas_sąrašas, reverse=True)
print(atbulas_sąrašas, surikiuotas_sąrašas, sąrašas)
</syntaxhighlight>

Rezultatus turėtum matyti tokius:

[0, 1, 3, 5, 23] [3, 1, 5, 23, 0]
[0, 1, 3, 5, 23] [0, 1, 3, 5, 23]
[23, 5, 3, 1, 0] [0, 1, 3, 5, 23] [0, 1, 3, 5, 23]

Akylus skaitytojas pamatys, kad pavyzdyje parodžiau papildomą sorted funkcionalumą atbuliniam sąrašo rikiavimui: <code>sorted(sąrašas, reverse=True)</code>. '''reverse''' anglų kalboje reiškia ''atbulinis'', todėl tai pasako funkcijai, kad mums reikia grąžint sąrašą atbuline tvarka.

Dar vienas labai svarbus skirtumas tarp sąrašas.sort() ir sorted() - ‘’sorted’’ naudojamas visiems iteruojamiems objektams. Pavyzdžiui anksčiau skyriuje minėtiems žodynams.

<syntaxhighlight lang="python">
# pasirašom funkciją sąrašo atvaizdavimui
def spausdink(sąrašas):
for elementas in sąrašas:
print(elementas)
print('')

# apsirašom sąrašą žodynų, kuriuos rikiuosime.
žodynai = [
{"vardas": "Darius", "metai": 15, "pomėgis": "bėgimas"},
{"vardas": "Marius", "metai": 14, "pomėgis": "krepšinis"},
{"vardas": "Karolis", "metai": 16, "pomėgis": "krepšinis"},
{"vardas": "Gileta", "metai": 13, "pomėgis": "tinklinis"},
{"vardas": "Eglė", "metai": 17, "pomėgis": "bėgimas"},
]

print('surikiuojam pagal metus mažėjančia tvarka')
spausdink(sorted(žodynai, key=lambda x: -x['metai']))

print('rikiuojame pagal dvi reikšmes: pradžioje pagal pomėgį, o vėliau pagal metus didėjančia tvarka.')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], x['metai'])) )
print('nurodome atbuline tvarka')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], x['metai']), reverse=True) )

print('rikiuojame pagal pomėgį didėjančia tvarka, o vėliau pagal metus mažėjančia')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], -x['metai'])) )
print('nurodome atbuline tvarka')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], -x['metai']), reverse=True) )

</syntaxhighlight>

Rezultatas bus toks:

surikiuojam pagal metus mažėjančia tvarka
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

rikiuojame pagal dvi reikšmes: pradžioje pagal pomėgį, o vėliau pagal metus didėjančia tvarka.
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

nurodome atbuline tvarka
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}

rikiuojame pagal pomėgį didėjančia tvarka, o vėliau pagal metus mažėjančia
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

nurodome atbuline tvarka
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}

Norint naudoti funkciją <code>sorted()</code> su žodynais, reikia programai nurodyti, pagal kurią žodyno reikšmę nori rikiuoti sąrašą. Tai gali padaryti nurodydamas <code>key=lambda kintamasis: kintamasis[‘reikšmė’]</code>. Parametras ‘’key’’ nurodo funkcijai ‘’sorted’’, kad norėsi naudoti papildoma funkciją. Štai čia mes paduodame bevardę funkciją ‘’lambda’’, kuri ir nurodo, pagal kuriuos parametrus mes norime rikiuoti sąrašą.

=== Pagalbininkė ''map()'' ===
<code>map()</code> yra Python vidinė funkcija, kuri leidžia mums taikyti funkciją kiekvienam elementui sąraše ar kitame iteruojamame objekte. Ši funkcija grąžina naują sąrašą, kuriame kiekvienas elementas yra pritaikytas pagal paduotą funkciją.
<syntaxhighlight lang="python">
map(funkcija, sąrašas)
</syntaxhighlight>

* ‘’funkcija’’ yra funkcija, kuri bus taikoma kiekvienam elementui sąraše.
* ‘’sąrašas’’ yra sąrašas, arba kitas iteruojamas objektas.

Pažiūrėkime į pavyzdį:

<syntaxhighlight lang="python">
# sukuriame sąrašą skaičių
skaičiai = [1, 2, 3, 4, 5]

# apibrėžiame funkciją, kurią norime pritaikyti kiekvienam elementui
def kvadratas(x):
return x**2

# naudojame map() funkciją, kad pritaikytume funkciją kiekvienam sąrašo elementui
skaičiai_kvadratu = map(kvadratas, skaičiai)

# išspausdiname naują sąrašą, kuriame kiekvienas skaičius yra kvadratu didesnis nei prieš tai
print(list(skaičiai_kvadratu)) # [1, 4, 9, 16, 25]
</syntaxhighlight>

Taip pat galime naudoti lambda funkcijas, kad nurodytume funkciją tiesiogiai <code>map()</code> funkcijos viduje, kaip gali pamatyti čia:

<syntaxhighlight lang="python">
# sukuriame sąrašą skaičių
skaičiai = [1, 2, 3, 4, 5]

# naudojame lambda funkciją, kad apibrėžtume funkciją tiesiogiai map() viduje
skaičiai_kvadratu = map(lambda x: x**2, skaičiai)

# išspausdiname naują sąrašą, kuriame kiekvienas skaičius yra kvadratu didesnis nei prieš tai
print(list(skaičiai_kvadratu)) # [1, 4, 9, 16, 25]
</syntaxhighlight>

<code>map()</code> funkcija yra naudinga, kai reikia greitai ir efektyviai pritaikyti tam tikrą funkciją kiekvienam sąrašo ar kitame iteruojamame objekte esančiam elementui, ir gauti naują sąrašą su apdorotais elementais.

Beje, ar atkreipei dėmesį, kad norint atspausdinti sąrašą, aš panaudojau funkciją <code>list()</code>. Ar žinai kodėl?

Tai yra dėl to, kad <code>map()</code> funkcija grąžina iteruojamą objektą, kuris yra vadinamas ''generatoriumi''. Generatorius yra specialus iteruojamas objektas, kuris leidžia gauti reikiamus duomenis vieną po kito pagal poreikį, taip sutaupant atminties resursus. Tačiau, norint matyti visus elementus iš karto, reikia sukurti sąrašą ar kitą tipo objektą, kuris saugotų visus <code>map()</code> funkcijos grąžinamus elementus. Tai padaryti galime, panaudoję <code>list()</code> funkciją, kuri konvertuoja generatoriaus grąžinamą objektą į sąrašą.

=== Filtravimas su ''filter()'' ===

<code>filter()</code> yra Python funkcija, kuri leidžia filtruoti duomenis pagal tam tikras sąlygas. Ši funkcija veikia pagal panašų principą kaip <code>map()</code> funkcija, tačiau jos veikimo būdas yra kitoks. <code>filter()</code> funkcija taiko nurodytą sąlygą (funkciją) kiekvienam elementui iteruojamame objekte ir grąžina tik tuos elementus, kuriuos ta sąlyga tenkina. Tai yra, funkcija išfiltruoja tik tuos elementus, kurie tenkina nurodytą sąlygą.

<code>filter()</code> funkcija naudojama kartu su lambda funkcijomis arba kitomis funkcijomis, kurios grąžina True arba False. Kai reikia išgauti tik tuos elementus, kurie tenkina nurodytą sąlygą, naudojama filter() funkcija.

Pavyzdžiui, norint išfiltruoti tik lyginius skaičius iš sąrašo, galime naudoti šią filter() funkcijos ir lambda funkcijos kombinaciją:

<syntaxhighlight lang="python">
# Sukuriamas sąrašas skaičių
skaičiai = [1, 2, 3, 4, 5]

# Sukuriamas naujas sąrašas tik su lyginiais skaičiais naudojant filter() ir lambda funkciją
lyginiai_skaičiai = filter(lambda x: x % 2 == 0, skaičiai)

# Išspausdinamas naujas sąrašas tik su lyginiais skaičiais
print(list(lyginiai_skaičiai)) # [2, 4]
</syntaxhighlight>

Šioje situacijoje, filter() funkcija išfiltruoja tik tuos skaičius, kurių liekana yra lygi nuliui (t.y. tik lyginiai skaičiai).

Vadovėlis/Pažangios funkcijos

2023-06-23T07:35:48Z

Monika: /* Lambda funkcija */

=== Pažangesnės funkcijos ===
Papasakosiu tau apie keletą neįtikėtinų funkcijų ir gudrybių, kurios padės supaprastinti užduočių atlikimą.
''Pradėkime'' :)

=== Lambda funkcija ===

Jau žinai kaip apsirašyti funkciją su žodeliu ‘’def’’. Lambda funkcija yra tokia pati funkcija, tik labai trumpa ir anoniminė - ji neturi jokio vardo. Kai reikia apibrėžti labai trumpą ir paprastą funkciją, kurią naudosime tik vieną kartą ir nereikalauja sudėtingos logikos, galime naudoti lambda funkciją. Tai gali būti ypač naudinga, kai turime sudėtingą funkciją, kurią norime išskaidyti į smulkesnes dalis, arba kai norime panaudoti funkciją kaip argumentą kitai funkcijai. Lambda funkcijos sintaksė yra paprasta, rašome žodį lambda, po to tarp skliaustų nurodome argumentų sąrašą ir funkcijos išraišką. Tai viskas, ko mums reikia, kad apibrėžtume lambda funkciją.

Lambda funkcijos yra naudojamos daugeliui Python standartinių funkcijų, pavyzdžiui, <code>filter()</code>, <code>map()</code>, <code>sorted()</code>, kad būtų paprastesnis kodas. Apie jas daugiau papasakosiu šiame skyriuje, o dabar pažiūrėkime, kaip galime panaudoti lambda funkciją:

<syntaxhighlight lang="python">
# lambda funkcija apskaičiuojanti kvadratą
kvadratas = lambda x: x**2

print(kvadratas(5)) # 25

# lambda funkcija filtruojanti nelyginius skaičius
skaičiai = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
nelyginiai = list(filter(lambda x: x % 2 != 0, skaičiai))

print(nelyginiai) # [1, 3, 5, 7, 9]
</syntaxhighlight>

Lambda funkcija taip pat gali būti naudinga, kai reikia perduoti funkciją kaip argumentą į kitą funkciją. Tai leidžia sukurti trumpą, paprastą ir lengvai suprantamą kodą.

=== Rikiavimas su ''sorted()'' ===
Anksčiau rodžiau rikiavimo funkciją su sąrašais. Sąrašo funkcija <code>sąrašas.sort()</code> modifikuoja savo elementus juos surikiuodamas. Taip kintamasis pakeičia savo reikšmę. Python taip pat turi funkciją <code>sorted()</code> kuri grąžina naują surikiuotą rezultatą, nepakeisdama originalaus kintamojo.
Pažiūrėkim, kaip tai veikia:

<syntaxhighlight lang="python">
# susikuriame sąrašą su atsitiktiniais skaičiais
sąrašas = [3,1,5,23,0]
# sorted grąžina surikiuotą sąrašą, kuri priskiriame naujajam kintamajam.
surikiuotas_sąrašas = sorted(sąrašas)

# atsispausdiname rezultatą. Matysi, kad kintamasis sąrašas nepakeitė reikšmės, o surikiuotas_sąrašas reikšmė yra surikiuota.
print(surikiuotas_sąrašas, sąrašas)

# pažiūrėkim, ką padarys funkcija sort()
sąrašas.sort()
# rezultate matysi du surikiuotus identiškus sąrašus.
print(surikiuotas_sąrašas, sąrašas)

# kaip surikiuoti mažėjančia tvarka? Tiesiog pridėkime prie funkcijos reverse=True
atbulas_sąrašas = sorted(surikiuotas_sąrašas, reverse=True)
print(atbulas_sąrašas, surikiuotas_sąrašas, sąrašas)
</syntaxhighlight>

Rezultatus turėtum matyti tokius:

[0, 1, 3, 5, 23] [3, 1, 5, 23, 0]
[0, 1, 3, 5, 23] [0, 1, 3, 5, 23]
[23, 5, 3, 1, 0] [0, 1, 3, 5, 23] [0, 1, 3, 5, 23]

Akylus skaitytojas pamatys, kad pavyzdyje parodžiau papildomą sorted funkcionalumą atbuliniam sąrašo rikiavimui: <code>sorted(sąrašas, reverse=True)</code>. '''reverse''' anglų kalboje reiškia ''atbulinis'', todėl tai pasako funkcijai, kad mums reikia grąžint sąrašą atbuline tvarka.

Dar vienas labai svarbus skirtumas tarp sąrašas.sort() ir sorted() - ‘’sorted’’ naudojamas visiems iteruojamiems objektams. Pavyzdžiui anksčiau skyriuje minėtiems žodynams.

<syntaxhighlight lang="python">
# pasirašom funkciją sąrašo atvaizdavimui
def spausdink(sąrašas):
for elementas in sąrašas:
print(elementas)
print('')

# apsirašom sąrašą žodynų, kuriuos rikiuosime.
žodynai = [
{"vardas": "Darius", "metai": 15, "pomėgis": "bėgimas"},
{"vardas": "Marius", "metai": 14, "pomėgis": "krepšinis"},
{"vardas": "Karolis", "metai": 16, "pomėgis": "krepšinis"},
{"vardas": "Gileta", "metai": 13, "pomėgis": "tinklinis"},
{"vardas": "Eglė", "metai": 17, "pomėgis": "bėgimas"},
]

print('surikiuojam pagal metus mažėjančia tvarka')
spausdink(sorted(žodynai, key=lambda x: -x['metai']))

print('rikiuojame pagal dvi reikšmes: pradžioje pagal pomėgį, o vėliau pagal metus didėjančia tvarka.')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], x['metai'])) )
print('nurodome atbuline tvarka')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], x['metai']), reverse=True) )

print('rikiuojame pagal pomėgį didėjančia tvarka, o vėliau pagal metus mažėjančia')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], -x['metai'])) )
print('nurodome atbuline tvarka')
spausdink( sorted(žodynai, key=lambda x: (x['pomėgis'], -x['metai']), reverse=True) )

</syntaxhighlight>

Rezultatas bus toks:

surikiuojam pagal metus mažėjančia tvarka
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

rikiuojame pagal dvi reikšmes: pradžioje pagal pomėgį, o vėliau pagal metus didėjančia tvarka.
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

nurodome atbuline tvarka
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}

rikiuojame pagal pomėgį didėjančia tvarka, o vėliau pagal metus mažėjančia
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}

nurodome atbuline tvarka
{'vardas': 'Gileta', 'metai': 13, 'pomėgis': 'tinklinis'}
{'vardas': 'Marius', 'metai': 14, 'pomėgis': 'krepšinis'}
{'vardas': 'Karolis', 'metai': 16, 'pomėgis': 'krepšinis'}
{'vardas': 'Darius', 'metai': 15, 'pomėgis': 'bėgimas'}
{'vardas': 'Eglė', 'metai': 17, 'pomėgis': 'bėgimas'}

Norint naudoti funkciją <code>sorted()</code> su žodynais, reikia programai nurodyti, pagal kurią žodyno reikšmę nori rikiuoti sąrašą. Tai gali padaryti nurodydamas <code>key=lambda kintamasis: kintamasis[‘reikšmė’]</code>. Parametras ‘’key’’ nurodo funkcijai ‘’sorted’’, kad norėsi naudoti papildoma funkciją. Štai čia mes paduodame bevardę funkciją ‘’lambda’’, kuri ir nurodo, pagal kuriuos parametrus mes norime rikiuoti sąrašą.

=== Pagalbininkė ''map()'' ===
<code>map()</code> yra Python vidinė funkcija, kuri leidžia mums taikyti funkciją kiekvienam elementui sąraše ar kitame iteruojamame objekte. Ši funkcija grąžina naują sąrašą, kuriame kiekvienas elementas yra pritaikytas pagal paduotą funkciją.
<syntaxhighlight lang="python">
map(funkcija, sąrašas)
</syntaxhighlight>

* ‘’funkcija’’ yra funkcija, kuri bus taikoma kiekvienam elementui sąraše.
* ‘’sąrašas’’ yra sąrašas, arba kitas iteruojamas objektas.

Pažiūrėkime į pavyzdį:

<syntaxhighlight lang="python">
# sukuriame sąrašą skaičių
skaičiai = [1, 2, 3, 4, 5]

# apibrėžiame funkciją, kurią norime pritaikyti kiekvienam elementui
def kvadratas(x):
return x**2

# naudojame map() funkciją, kad pritaikytume funkciją kiekvienam sąrašo elementui
skaičiai_kvadratu = map(kvadratas, skaičiai)

# išspausdiname naują sąrašą, kuriame kiekvienas skaičius yra kvadratu didesnis nei prieš tai
print(list(skaičiai_kvadratu)) # [1, 4, 9, 16, 25]
</syntaxhighlight>

Taip pat galime naudoti lambda funkcijas, kad nurodytume funkciją tiesiogiai <code>map()</code> funkcijos viduje, kaip gali pamatyti čia:

<syntaxhighlight lang="python">
# sukuriame sąrašą skaičių
skaičiai = [1, 2, 3, 4, 5]

# naudojame lambda funkciją, kad apibrėžtume funkciją tiesiogiai map() viduje
skaičiai_kvadratu = map(lambda x: x**2, skaičiai)

# išspausdiname naują sąrašą, kuriame kiekvienas skaičius yra kvadratu didesnis nei prieš tai
print(list(skaičiai_kvadratu)) # [1, 4, 9, 16, 25]
</syntaxhighlight>

<code>map()</code> funkcija yra naudinga, kai reikia greitai ir efektyviai pritaikyti tam tikrą funkciją kiekvienam sąrašo ar kitame iteruojamame objekte esančiam elementui, ir gauti naują sąrašą su apdorotais elementais.

Beje, ar atkreipei dėmesį, kad norint atspausdinti sąrašą, aš panaudojau funkciją <code>list()</code>. Ar žinai kodėl?

Tai yra dėl to, kad <code>map()</code> funkcija grąžina iteruojamą objektą, kuris yra vadinamas ''generatoriumi''. Generatorius yra specialus iteruojamas objektas, kuris leidžia gauti reikiamus duomenis vieną po kito pagal poreikį, taip sutaupant atminties resursus. Tačiau, norint matyti visus elementus iš karto, reikia sukurti sąrašą ar kitą tipo objektą, kuris saugotų visus <code>map()</code> funkcijos grąžinamus elementus. Tai padaryti galime, panaudoję <code>list()</code> funkciją, kuri konvertuoja generatoriaus grąžinamą objektą į sąrašą.

=== Filtravimas su ''filter()'' ===

<code>filter()</code> yra Python funkcija, kuri leidžia filtruoti duomenis pagal tam tikras sąlygas. Ši funkcija veikia pagal panašų principą kaip <code>map()</code> funkcija, tačiau jos veikimo būdas yra kitoks. <code>filter()</code> funkcija taiko nurodytą sąlygą (funkciją) kiekvienam elementui iteruojamame objekte ir grąžina tik tuos elementus, kuriuos ta sąlyga tenkina. Tai yra, funkcija išfiltruoja tik tuos elementus, kurie tenkina nurodytą sąlygą.

<code>filter()</code> funkcija naudojama kartu su lambda funkcijomis arba kitomis funkcijomis, kurios grąžina True arba False. Kai reikia išgauti tik tuos elementus, kurie tenkina nurodytą sąlygą, naudojama filter() funkcija.

Pavyzdžiui, norint išfiltruoti tik lyginius skaičius iš sąrašo, galime naudoti šią filter() funkcijos ir lambda funkcijos kombinaciją:

<syntaxhighlight lang="python">
# Sukuriamas sąrašas skaičių
skaičiai = [1, 2, 3, 4, 5]

# Sukuriamas naujas sąrašas tik su lyginiais skaičiais naudojant filter() ir lambda funkciją
lyginiai_skaičiai = filter(lambda x: x % 2 == 0, skaičiai)

# Išspausdinamas naujas sąrašas tik su lyginiais skaičiais
print(list(lyginiai_skaičiai)) # [2, 4]
</syntaxhighlight>

Šioje situacijoje, filter() funkcija išfiltruoja tik tuos skaičius, kurių liekana yra lygi nuliui (t.y. tik lyginiai skaičiai).

Vadovėlis/Duomenų tyryba ir informacija

2023-04-19T11:29:55Z

Monika: /* Dirbtinis intelektas */

{{navigation |previous=Įvadas į importuotas bibliotekas ir kitas funkcijas|next=Pabaiga}}
==Dirbtinis intelektas==

Dirbtinis intelektas (AI) sparčiai tampa integralia šiandienos technologijų dalimi ir planuojama, kad jis taps dar plačiau naudojamas ateityje. AI technologijos organizacijoms siūlo daugybę naudos, įskaitant pagerintą vertinimo tikslumą, didesnį darbo srauto greitį ir efektyvumą, geresnį klientų aptarnavimą, automatizuotus sprendimų priėmimo procesus, pagalbą spėjimo modeliams ir realiu laiku atliekamą analizę. AI taip pat gali pakeisti žmones atliekant nuobodžius, ar besikartojančius darbus, pvz., elektroninių laiškų rūšiavime ar paprastų duomenų įvedimo užduočių atlikime. Be to, jis kuria naujas darbo vietų galimybes žmonėms, kurie gali užtikrinti, kad AI technologijos veiktų teisingai.

Tačiau šie privalumai nėra be rizikų. Yra įvairių etinių klausimų, susijusių su duomenų etiškumu, kai kuriamos jų AI; tai reikalauja asmenų su reikšmingu žinių lygiu, kad užtikrintų, jog AI technologijos būtų kuriamos teisingai.

Neuroniniai tinklai yra vis populiaresnis įrankis skaičiavimo ir duomenų analizės pasaulyje. Jie yra dirbtinio intelekto rūšis, kuri yra sukurta imituoti žmogaus smegenų procesus, naudojant tarpusavyje susijusius mazgus ir sluoksnius, kad apdoroti didelius kiekius duomenų. Neuroniniai tinklai leidžia greičiau priimti sprendimus ir gauti tiksliausius rezultatus, kai reikia analizuoti sudėtingus duomenų rinkinius. Jų taikymo sritis yra ganėtinai plati, pradedant sukčiavimo apsauga, objektų ir veido atpažinimu.

==Kriptografinės sistemos==

Kriptografija yra saugios komunikacijos mokslas, kuris naudojamas įvairiomis formomis nuo senovės laikų. Šiandien, kriptografinės sistemos yra neišvengiamos mūsų modernioje pasaulyje. Jos padeda apsaugoti viską nuo internetinių finansinių sandorių iki asmeninių medicininių įrašų. Kaip technologijos tobulėja, kriptografija ir susijusios sistemos yra kuriamos ir tobulinamos, kad duomenys būtų saugūs ir apsaugoti.

Simetrinė ir asimetrinė kodavimo technologijos yra du skirtingi kodavimo būdai, naudojami kriptografijoje ir duomenų saugumo srityse. Simetrinė kodavimo technologija naudojama efektyviai perdavimo duomenų šifruotai apsaugoti tarp dviejų šalių, o asimetrinis šifravimas leidžia suprasti perdavimo duomenis tik viena kryptimi, todėl ši technologija yra itin saugi.
Vienas iš paprastesnių simetrinio kodavimo pavyzdžių - "Atbash" kodavimas, kurio esmė yra pakeisti abėcėlės raides vietomis, t.y. pirmoji raidė tampa paskutine, antroji - priešpaskutine, ir taip toliau. Pvz., žinutė "LABAS" užšifruota "OZYZH". Atkoduojant, tiesiog reikia pakeisti raidžių vietomis atgal, ir gautume pradinę žinutę "LABAS".
Kalbant apie asimetrinį kodavimą, pavyzdys galėtų būti RSA kodavimas. Tai yra labai populiari viešojo raktų kriptografijos sistema, kuri naudoja matematinius algoritmus koduojant ir dekoduojant duomenis.

Pavyzdžiui, norint užšifruoti pranešimą "LABAS", reikia naudoti gavėjo viešąjį raktą, kuris gali būti naudojamas tik užšifruoti pranešimus, bet ne dekoduoti juos atgal į pradinę formą. Atkoduojant, naudojamas privatus raktas. Asimetrinis kodavimas yra sudėtingas procesas, reikalaujantis specialių žinių ir įrangos.

==Viešai prieinami duomenys==

Kadangi pasaulis tampa vis labiau orientuotas į duomenis, viešieji duomenys tapo neišvengiamu elementu, padedančiu suprasti, kaip žmonės, organizacijos ir vyriausybės tarpusavyje sąveikauja. Šie duomenys yra laisvai prieinami visuomenei, kad jie galėtų juos peržiūrėti ir analizuoti. Išnaudojus pažinimo procese gautus rezultatus, galime geriau suprasti tendencijas, modelius, koreliacijas ir ryšius tarp skirtingų subjektų.

Viešieji duomenys yra informacijos lobis, kuris gali būti naudojamas priimant sprendimus sudėtinguose projektuose ir verslo operacijose. Strategiškai naudojantis šia informacija, verslai gali gauti nepakeičiamų žinių apie savo operacijas, taip pat pasiekti konkurencinį pranašumą savo pramonėje. Viešųjų duomenų analizė taip pat padeda atskleisti sukčiavimus ir netikslumus esamuose sistemose, kurie galėtų turėti rimtų padarinių visuomenei apskritai.

{{navigation |previous=Įvadas į importuotas bibliotekas ir kitas funkcijas|next=Pabaiga}}
[[Category:Python Vadovėlis]]

Vadovėlis

2023-04-19T11:07:46Z

Monika: Pridėtas skyrius

{{DISPLAYTITLE:Vadovėlis}}
[[Category:Python Vadovėlis]]

Tai - standartinės Python programavimo kalbos vadovėlis 9-10 klasei, išverstas iš [https://en.wikibooks.org/wiki/Non-Programmer%27s_Tutorial_for_Python_3 Non programmer's Tutorial for Python 3].

Šis vadovėlis yra atvirojo kodo, [https://www.gnu.org/licenses/gpl-3.0.html GPL v3] licencija.

==Turinys==
;[[/Autoriai|Autoriai]]
: Originalaus (angliško) vadovėlio autoriai ir vertėjai į lietuvių kalbą.
;[[/Įžanga|Įžanga]]
: Įžanginiai žodžiai
;[[/Įvadas|Įvadas]]
: Python'o diegimas ir naudojimas
;[[/Labas, Pasauli|Labas, Pasauli]]
: Garsioji pirmoji programa – ekrano išvestis – kintamieji – skaičiai ir skaičiavimai
;[[/Kas čia eina?|Kas čia eina?]]
: Interaktyvi įvestis – tekstinė eilutė
;[[/Suskaičiuoti iki 10|Suskaičiuoti iki 10]]
: Ciklai <tt>while</tt>
;[[/Pasirinkimai|Pasirinkimai]]
: <tt>if</tt> sakiniai
;[[/Derinimas|Derinimas]]
: Išsiaiškinti, kas negerai
;[[/Funkcijų apibrėžimas|Funkcijų apibrėžimas]]
: Programų struktūrizavimas naudojant funkcijas
;[[/Rekursinės funkcijos|Rekursinės funkcijos]]
: (Beveik) stulbinantis pavyzdys, kaip programuotojai gali mąstyti
;[[/Sąrašai|Sąrašai]]
: Kintamieji, kuriuose yra daugiau nei viena reikšmė
;[[/Ciklai For|Ciklai For]]
: Dar vienos rūšies ciklai
;[[/Loginiai reiškiniai|Loginiai reiškiniai]]
: Kompiuterinė logika – <tt>True</tt> ir <tt>False</tt> – <tt>and</tt> ir <tt>or</tt> – <tt>not</tt>
;[[/Žodynai|Žodynai]]
: Kintamieji, kuriuose yra raktų/reikšmių poros
;[[/Modulių naudojimas|Modulių naudojimas]]
: Standartinio funkcionalumo plėtiniai
;[[/Daugiau apie sąrašus|Daugiau apie sąrašus]]
: Sąrašų elementų ar dalių naudojimas
;[[/Daugiau apie tekstines eilutes|Daugiau apie tekstines eilutes]]
: Pažangesnės teksto manipuliacijos
;[[/Daugiau apie funkcijas|Daugiau apie funkcijas]]
: Parametrai, reikšmės, programos skaldymas
;[[/Failų tvarkymas|Failų tvarkymas]]
: Skaitymas iš failų ir rašymas į failus
;[[/Siekiant tobulumo|Siekiant tobulumo]]
: Kaip tvarkyti klaidas

;[[/Įvadas į objektinį programavimą Python 3|Įvadas į objektinį programavimą Python 3]]
: OOP pagrindai (Objektinis programavimas, angl. ''Object-Oriented Programming'')
;[[/Įvadas į importuotas bibliotekas ir kitas funkcijas|Įvadas į importuotas bibliotekas ir kitas funkcijas]]
: Pagrindinės funkcijos iš įvairių bibliotekų.
;[[/Duomenų tyryba ir informacija|Duomenų tyryba ir informacija]]
: Informacija apie dirbtinį intelektą, kriptografiją ir duomenis.
;[[/Pabaiga|Pabaiga]]
: Ką toliau daryti
;[[/DUK|D.U.K.]]
: Dažnai užduodami klausimai
;[[/Terminai|Terminai]]
: Terminų žodynas
__NOTOC__ __NOEDITSECTION__

Vadovėlis/Importuotos bibliotekos ir vėžlys

2023-04-19T11:06:23Z

Monika: Pakeista navigacija

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Duomenų tyryba ir informacija}}

Šiame skyriuje apžvelgsime kai kurias funkcijas iš įvairių importuotų bibliotekų, kurios yra dažniausiai naudojamos Python'e. Šis skyrius nėra būtinas norint visiškai suprasti Python'o pagrindus. Šis skyrius skirtas parodyti tolesnes Python'o galimybes, kurias galima panaudoti su tuo, ką jau žinote apie kalbą.

=== math ===

:Matematikos biblioteka aprėpia daug naudingų ir programoms reikalingų funkcijų, kurios atlieka įvarias matematines operacijas (kai neužtenka Python'o operatorių).

:Šiame skyriuje daroma prielaida, kad turi matematikos žinias iki trigonometrijos kurso imtinai.

Šiame sąraše išvardintos visos matematikos bibliotekos funkcijos:
*math.ceil (Suapvalina skaičių iki artimiausio skaičiaus po kablelio)
*math.copysign (Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>)
*math.fabs (Grąžina absoliučią skaičiaus reikšmę, kaip slankiojo kablelio reikšmę)
*math.factorial (Grąžina skaičiaus faktorialą)
*math.floor (Grąžina didžiausią sveikąjį skaičių, mažesnį arba lygų duotajam skaičiui)
*math.fmod (Nėra pati idealiausia funkcija su kuria galima pasiekti nurodytą tikslą. Šiame skyriuje nebus detaliau paaiškinta.)
*math.frexp (Už šios pamokos ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.fsum (Grąžina visų skliausteliuose esančių skaičių sumą)
*math.isfinite (Patikrina ar skaičius yra baigtinis)
*math.isinf (Patikrina ar skaičius yra begalinis ar ne)
*math.isnan (Patikrina, ar reikšmė yra NaN (ne skaičius), ar ne)
*math.modf (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.trunc (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.exp (Apskaičiuoja eksponentinę funkciją e^x, kur e yra matematinė konstanta)
*math.expm1 (Grąžina E^x - 1)
*math.log (Grąžina natūralųjį skaičiaus logaritmą)
*math.log1p (Grąžina log(1+skaičius))
*math.log10 (Grąžina skaičiaus 10 bazinį logaritmą)
*math.pow (Grąžina x reikšmę, pakeltą laipsniu y)
*math.sqrt (Grąžina skaičiaus kvadratinę šaknį)
*math.acos (Grąžina arccos(x))
*math.asin (Grąžina arcsin(x))
*math.atan (Grąžina arctan(x))
*math.cos (Grąžina reikšmės kosinusą)
*math.hypot (Grąžina Euklido normą)
*math.sin (Grąžina reikšmės sinusą)
*math.tan (Grąžina reikšmės tangentą)
*math.degrees (Paverčia radianus į laipsnius)
*math.radians (Paverčia laipsnius į radianus)
*math.pi (Grąžina π reikšmę)
*math.e (Grąžina e reikšmę)

:Žinoma, neapimsime visų šių funkcijų, bet padengsime didelę jų dalį.

Pradėkime nuo dviejų konstantų matematikos bibliotekoje. <code>math.pi</code> yra matematinė konstanta „π“, tavo kompiuteryje pasiekiamu tikslumu. <code>math.e</code> yra matematinė konstanta „e“, tavo kompiuteryje pasiekiamu tikslumu.
Štai yra abiejų konstantų, įvestų interaktyviuoju režimu Python'o terminale, pavyzdys:
>>> import math
>>> math.e
2.718281828459045
>>> math.pi
3.141592653589793

Šios konstantos gali būti saugomos kintamajame, kaip ir bet kuris kitas skaičius. Žemiau pateikiamas būtent toks pavyzdys ir parodytos paprastos šių kintamųjų operacijos:
>>> conste = math.e
>>> (conste + 5 / 2) * 2.21
11.532402840894488
>>> constpi = math.pi
>>> (((7 /2.1) % constpi) * 2)
0.38348135948707984
>>>

Dabar pažvelk į funkcijas: pradėk nuo sąrašo viršaus ir judėk žemyn (kai kurios funkcijos bus praleistos).
Kai žiūrėsi kiekvieną iš pavyzdžių, pabandyk išsiaiškinti, ką kiekviena funkcija daro. Šalia bus pateiktas sakinys ar du, kurie turėtų tau padėti.

Žemiau pateikiamas kiekvienos <code>math</code> modulio funkcijos pavyzdys ir kaip ji naudojama (išskyrus anksčiau nurodytas funkcijas, kurių nereikia paaiškinti)

>>> import math
>>> math.ceil(4.5) ** Suapvalina skaičių iki artimiausio skaičiaus po kablelio **
5
>>> math.ceil(4.1)
5
>>> math.copysign(4, -.4) ** Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>
-4.0
>>> math.copysign(-4, 4)
4.0
>>> math.fabs(-44) ** Grąžina absoliučią skaičiaus reikšmę, kaip slankiojo kablelio reikšmę **
44.0
>>> math.factorial(4) ** Grąžina skaičiaus faktorialą **
24
>>> math.floor(4.3) ** Grąžina didžiausią sveikąjį skaičių, mažesnį arba lygų duotajam skaičiui **
4
>>> math.floor(4.99999)
4
>>> math.fsum([.1,.2,5,45.2,-.054,.4]) ** Grąžina visų skliausteliuose esančių skaičių sumą. Funkcija ne visada tiksli **
50.846000000000004
>>> math.isfinite(3) ** Grąžina <code>True</code>, jei reikšmė nėra begalinė ar NaN. Kitu atveju, grąžina <code>False</code>. **
True

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Duomenų tyryba ir informacija}}
[[Category:Python Vadovėlis]]

Vadovėlis/Duomenų tyryba ir informacija

2023-04-19T11:05:49Z

Monika: Pridėta informacija

{{navigation |previous=Įvadas į importuotas bibliotekas ir kitas funkcijas|next=Pabaiga}}
==Dirbtinis intelektas==

Dirbtinis intelektas (AI) sparčiai tampa integralia šiandienos technologijų dalimi ir planuojama, kad jis taps dar plačiau naudojamas ateityje. AI technologijos organizacijoms siūlo daugybę naudos, įskaitant pagerintą vertinimo tikslumą, didesnį darbo srauto greitį ir efektyvumą, geresnį klientų aptarnavimą, automatizuotus sprendimų priėmimo procesus, pagalbą spėjimo modeliams ir realiu laiku atliekamą analizę. AI taip pat gali pakeisti žmones atliekant nuobodžius, ar besikartojančius darbus, pvz., elektroninių laiškų rūšiavime ar paprastų duomenų įvedimo užduočių atlikime. Be to, jis kuria naujas darbo vietų galimybes žmonėms, kurie gali užtikrinti, kad AI technologijos veiktų teisingai.

Tačiau šie privalumai nėra be rizikų. Yra įvairių etinių klausimų, susijusių su duomenų etiškumu, kai kuriamos jų AI; tai reikalauja asmenų su reikšmingu žinių lygiu, kad užtikrintų, jog AI technologijos būtų kuriamos teisingai.

==Kriptografinės sistemos==

Kriptografija yra saugios komunikacijos mokslas, kuris naudojamas įvairiomis formomis nuo senovės laikų. Šiandien, kriptografinės sistemos yra neišvengiamos mūsų modernioje pasaulyje. Jos padeda apsaugoti viską nuo internetinių finansinių sandorių iki asmeninių medicininių įrašų. Kaip technologijos tobulėja, kriptografija ir susijusios sistemos yra kuriamos ir tobulinamos, kad duomenys būtų saugūs ir apsaugoti.

Simetrinė ir asimetrinė kodavimo technologijos yra du skirtingi kodavimo būdai, naudojami kriptografijoje ir duomenų saugumo srityse. Simetrinė kodavimo technologija naudojama efektyviai perdavimo duomenų šifruotai apsaugoti tarp dviejų šalių, o asimetrinis šifravimas leidžia suprasti perdavimo duomenis tik viena kryptimi, todėl ši technologija yra itin saugi.
Vienas iš paprastesnių simetrinio kodavimo pavyzdžių - "Atbash" kodavimas, kurio esmė yra pakeisti abėcėlės raides vietomis, t.y. pirmoji raidė tampa paskutine, antroji - priešpaskutine, ir taip toliau. Pvz., žinutė "LABAS" užšifruota "OZYZH". Atkoduojant, tiesiog reikia pakeisti raidžių vietomis atgal, ir gautume pradinę žinutę "LABAS".
Kalbant apie asimetrinį kodavimą, pavyzdys galėtų būti RSA kodavimas. Tai yra labai populiari viešojo raktų kriptografijos sistema, kuri naudoja matematinius algoritmus koduojant ir dekoduojant duomenis.

Pavyzdžiui, norint užšifruoti pranešimą "LABAS", reikia naudoti gavėjo viešąjį raktą, kuris gali būti naudojamas tik užšifruoti pranešimus, bet ne dekoduoti juos atgal į pradinę formą. Atkoduojant, naudojamas privatus raktas. Asimetrinis kodavimas yra sudėtingas procesas, reikalaujantis specialių žinių ir įrangos.

==Viešai prieinami duomenys==

Kadangi pasaulis tampa vis labiau orientuotas į duomenis, viešieji duomenys tapo neišvengiamu elementu, padedančiu suprasti, kaip žmonės, organizacijos ir vyriausybės tarpusavyje sąveikauja. Šie duomenys yra laisvai prieinami visuomenei, kad jie galėtų juos peržiūrėti ir analizuoti. Išnaudojus pažinimo procese gautus rezultatus, galime geriau suprasti tendencijas, modelius, koreliacijas ir ryšius tarp skirtingų subjektų.

Viešieji duomenys yra informacijos lobis, kuris gali būti naudojamas priimant sprendimus sudėtinguose projektuose ir verslo operacijose. Strategiškai naudojantis šia informacija, verslai gali gauti nepakeičiamų žinių apie savo operacijas, taip pat pasiekti konkurencinį pranašumą savo pramonėje. Viešųjų duomenų analizė taip pat padeda atskleisti sukčiavimus ir netikslumus esamuose sistemose, kurie galėtų turėti rimtų padarinių visuomenei apskritai.

{{navigation |previous=Įvadas į importuotas bibliotekas ir kitas funkcijas|next=Pabaiga}}
[[Category:Python Vadovėlis]]

Vadovėlis/Rekursinės funkcijos

2023-04-19T10:26:20Z

Monika: Pridėtas pratimas su Fibonačio seka

{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Vieniems šis skyrius gali pasirodyti naudingas, o kitiems - painus. Jeigu tau informacija pasirodys paini, tai nesuk galvos ir praleisk, prie šio skyriaus galėsi grįžti šiek tiek vėliau.

O dabar pabandom pasižiūrėti į klaidingai parašytą programą:

<syntaxhighlight lang="python">
def manoFunkcija():
print("labas")
manoFunkcija() # ojojoi!

manoFunkcija()
</syntaxhighlight>

Tokia programa keletą kartų parašys žodį <code>labas</code> ir tada nuluš... tai yra, galiausiai išspausdins kokią nors mįslingą klaidą, kaip <code>RecursionError: maximum recursion depth exceeded</code>. Kodėl?

Priežastis ta, kad <code>manoFunkcija</code> kiekvieną kartą kviečia save, tai yra, kviečia funkciją <code>manoFunkcija</code>. O tada <code>manoFunkcija</code> vėl kviečia save, tai yra <code>manoFunkcija</code>. Ir taip be galo!

Štai dar vienas panašus (irgi blogas) pavyzdys, pasižiūrėkim:

<syntaxhighlight lang="python">
def pirmaFunkcija():
print("pirma")
antraFunkcija()

def antraFunkcija():
print("antra")
pirmaFunkcija()

pirmaFunkcija()
</syntaxhighlight>

Vėl nulūš programa, vėl nutiks klaida <code>RecursionError</code>. Priežastis ta pati: <code>pirmaFunkcija</code> visuomet kviečia funkciją <code>antraFunkcija</code>, o ši visuomet kviečia <code>pirmaFunkcija</code>. Ir taip be galo! Nei iš vienos funkcijos niekuomet nėra grįžtama.

Aš paprastai labai atsargiai žiūriu į funkcijas, kurios kviečia pačios save (tiesiogiai arba netiesiogiai), kaip kad pavyzdžiuose aukščiau.

Tačiau iš tiesų net ir tokias funkcijas įmanoma panaudoti, nesugriaunant programos. Tiesiog tokia funkcija turi kažkada nustoti kviesti save, ir tiesiog grįžti (<code>return</code>).

Štai nenulūžtančios programos pavyzdys:

<syntaxhighlight lang="python">
def manoFunkcija(skaitiklis):
skaitiklis = skaitiklis + 1
if skaitiklis > 3:
return
print("labas")
manoFunkcija(skaitiklis)

manoFunkcija(0)
</syntaxhighlight>

Ši programa žodį "labas" išspausdins tik 3 kartus, ir tada baigsis. Jokios klaidos. Ar supratai, kodėl?

Parametras "skaitiklis" yra skirtas apsaugai nuo begalinio kartojimosi. Funkcija <code>manoFunkcija</code> kiekvieną kartą stropiai pasitikslina, ar <code>skaitiklis</code> neviršytas, ir kiekvieną kartą pasididina to skaitiklio reikšmę. Kai tik skaitiklis padidėjau daugiau, nei leidžiama, funkcija savęs nebekviečia - tiesiog grįžta.

Taigi, nors funkcija ir kviečia pati save, bet ne begalinį kartų skaičų.

==== Rekursija ====
Funkcijos, kurios kreipiasi pačios į save yra vadinamos rekursinėmis funkcijomis. Šio skyriaus pavyzdžiuose panagrinėsime tokias funkcijas. Tai palengvina programavimo užduočių spendimų įgyvendinimą, nes kartais pakanka apsvarstyti tik vieną problemos žingsnį, o ne visą problemą iš karto. Be to tai leidžia išreikšti kai kurias matematines sąvokas paprastu, lengvai skaitomu kodu.

Bet kokią problemą, kurią galime išspręsti naudojant rekursiją, gali būti išspręsta naudojant ciklus. Jie veikia greičiau, bet kartais ciklus sunku atlikti teisingai.

Turbūt intuityviausias „rekursijos“ apibrėžimas yra toks:
REKURSIJA
Jei vis dar nesupranti, tai skaityk: REKURSIJA.
Pabandyk perskaityti dar kelis pavyzdžius.

=== Pavyzdžiai ===
'''atgalinis_skaičiavimas.py'''
<syntaxhighlight lang="python">
def atgalinis_skaičiavimas(n):
print(n)
if n > 0:
return atgalinis_skaičiavimas(n-1)

atgalinis_skaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0

Šis pavyzdys labai panašus į ankstesnyjį, tik skaitiklis ne didėja, o mažėja. Rekursinė funkcija <code>atgalinis_skaičiavimas</code> turi vidinę apsaugą nuo begalinio kartojimosi, tikrina kintamąjį <code>n</code> ir jį mažina, o nustoja save kvietinėti, kai <code>n</code> sumažėja iki nulio.

'''sudetingas_pavyzdys.py'''
<syntaxhighlight lang="python">
def daug(a, b): # daug reiškia daugybą
if b == 0:
return 0
lik = daug(a, b - 1) #lik reiškia likutį
reikšmė = a + lik
return reikšmė

rezultatas = daug(3, 2)
print("3 * 2 = ", rezultatas)
</syntaxhighlight>

Iš esmės ši programa - tai teigiamų sveikųjų skaičių daugyba (iš tikrųjų Python'o programavimo kalboje daugybos funkcionalumas yra integruotas ir jo išradinėti nebūtina, tiesiog mes pabandėme suprogramuoti, kaip daugybą galima būtų pakeisti sudėties ir atimties veiksmais).

; Kas nutinka, pirmą kartą iškvietus funkciją daug(3, 2)?
: Parametras <code>a</code> gauna jam priskirtą reikšmę 3, o parametras <code>b</code> - jam priskirtą reikšmę 2.
; Kas nutinka tada?
: Vykdoma eilutė <code>if b == 0:</code>. Kadangi <code>b</code> reikšmė yra 2, todėl eilutė <code>return 0</code> praleidžiama.
; Kas vyksta toliau?
: Vykdoma eilutė <code>lik = daug(a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>lik</code> reikšmę į <code>daug(a, b - 1)</code> reikšmę. <code>a</code> reikšmė yra 3, o <code>b</code> - 2, todėl funkcija kviečia funkciją <code>daug(3, 1)</code>
; Taigi kokia yra <code>daug(3, 1)</code> reikšmė?
: Turime iškviesti funkciją <code>daug()</code> su parametrais 3 ir 1.
; Kas nutinka toliau?
: Funkcijos viduje <code>a</code> reikšmė būtų 3, o <code>b</code> reikšmė – 1. Kadangi jie yra lokalūs kintamieji, todėl jie neturi įtakos ankstesnėms <code>a</code> ir <code>b</code> reikšmėms.
; Kas įvyksta toliau?
: Kadangi <code>b</code> turi reikšmę 1, if sąlygos rezultatas yra neigiamas, todėl vykdoma kita eilutė <code>lik = daug(a, b - 1)</code>.
; Ką daro ši eilutė?
: Dabar kintamajam <code>lik</code> priskiriam funkcijos <code>daug(3, 0)</code> reikšmė.
; Kokia ši reikšmė?
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> – 0.
; Kas vyksta toliau?
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code>
; Ką daro <code>return 0</code> eilutė?
: Ši eilutė grąžina funkcijos reikšmę lygią 0 į tą vietą, kur ji buvo iškviesta.
; Kas iš to?
: Dabar mes žinome, kad <code>daug(3, 0)</code> grąžina reikšmę 0. Dar žinome, ką daro eilutė <code>lik = daug(a, b - 1)</code>, nes paleidžiame funkciją <code>daug()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>daug(3, 0)</code> ir dabar vėl pradedame vykdyti <code>daug(3, 1)</code>. Kintamajam <code>lik</code> priskiriama reikšmė yra 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>reikšmė = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reikšmė = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return reikšmė</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.
; Kur yra <code>daug(3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reikšmė = a + lik</code> priskiria kintamajam <code>reikšmė</code> reikšmę <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradedama vykdyti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>rezultatas = daug(3, 2)</code>, kur kintamajam <code>rezultatas</code> dabar priskiriama reikšmė 6
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", rezultatas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>rezultatas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmo skaičiaus ir pirmo bei vienetu mažesnio už antrąjį sandaugos sumai <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Kai viskas surašoma vienoje eilutėje, gauname <code>3 + 3 + 0 </code>

Štai kaip viskas veikia:

daug(3, 2)
3 + daug(3, 1)
3 + 3 + daug(3, 0)
3 + 3 + 0
3 + 3
6

'''faktorialas.py'''
<syntaxhighlight lang="python">
def faktorialas(n):
if n == 0:
return 1
if n < 0:
return "Klaida, neigiami skaičiai neturi faktorialo reikšmių!!"
return n * faktorialas(n - 1)

print("2! =", faktorialas(2))
print("3! =", faktorialas(3))
print("4! =", faktorialas(4))
print("5! =", faktorialas(5))
print("-3! =", faktorialas(-3))
</syntaxhighlight>

Rezultatas:

2! = 2
3! = 6
4! = 24
5! = 120
-3! = Klaida, neigiami skaičiai neturi faktorialo reikšmių!!



=== Pratimai ===
1. Parašyk programą, kuri paprašytų vartotojo įvesti skaičių ir laipsnį. Naudodamas rekursija, atspausdink skaičių pakelta duotuoju laipsniu. (Pvz: 23=8)

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
rezultatas = int()

def keltiLaipsniu(skaičius, laipsnis):
if laipsnis == 0:
return 1
return skaičius * keltiLaipsniu(skaičius, laipsnis - 1)

rezultatas = keltiLaipsniu(2, 3)

print(rezultatas)
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri prašo vartotojo įvesti skaičių ir grąžina sumą nuo 1 iki to skaičiaus. Pavyzdžiui, jei įvedamas skaičius 5, programa grąžina 5 + 4 + 3 + 2 + 1 = '''15'''. Nepamiršk naudoti rekursijos.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def suma_iki_vieno(skaičius, suma):
if skaičius == 0:
return suma
else:
return skaičius + suma_iki_vieno(skaičius - 1, suma)

įvestas_skaičius = int(input("Įvesk skaičių: "))
rezultatas = suma_iki_vieno(įvestas_skaičius, 0)
print ("Suma nuo 1 iki", įvestas_skaičius, ':', rezultatas)
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri išveda Fibonačio seką iki įvesto skaičiaus <code>n</code>. Fibonačio seka - tai tokia sveikųjų skaičių seka, kur kiekvienas skaičius yra lygus prieš jį buvusių skaičių sumai. Pirmieji sekos skaičiai: 0 1 1 2 3 5 8 13 21 ir t.t.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def fibonači(n):
if n <= 1:
return n
else:
return fibonači(n-1) + fibonači(n-2)

įvestas_skaičius = int(input("Įvesk skaičių: "))

for i in range(įvestas_skaičius):
print(fibonači(i))
</syntaxhighlight>
|-
|}

4. Parašyk programą, kuri prašo vartotojo įvesti žodį ir grąžina tą žodį parašytą iš kitos pusės. Pvz “Labas” = “sabaL”. Šios užduoties sprendimui tau prireiks [[Vadovėlis/Daugiau apie sąrašus|daugiau žinių apie sąrašus]].

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def apversk(žodis):
if len(žodis) == 0:
return žodis
else:
return apversk(žodis[1:]) + žodis[0]

įvestas_žodis = input("Įvesk žodį: ")
print(apversk(įvestas_žodis))
</syntaxhighlight>
|-
|}

{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}
[[Category:Python Vadovėlis]]

Vadovėlis/Failų tvarkymas

2023-03-13T09:25:51Z

Monika: Pridėta užduočių

{{navigation |previous=Daugiau apie tekstines eilutes |next=Siekiant tobulumo}}
{{BookCat}}

=== Failų įvestis/išvestis ===

Štai paprastas failo įvesties ir išvesties (I/O, ang. Input/Output) pavyzdys:
<syntaxhighlight lang="python">
# Rašyti į failą
with open("testas.txt", "wt") as rašomas_failas:
rašomas_failas.write("Šis tekstas bus išsiųstas į failą\nPažiūrėk ir pamatysi!")

# Skaityti failą
with open("testas.txt", "rt") as skaitomas_failas:
tekstas = skaitomas_failas.read()

print(tekstas)
</syntaxhighlight>

Failo <code>testas.txt</code> išvestis ir turinys yra:

Šis tekstas bus išsiųstas į failą
Pažiūrėk ir pamatysi!

Atkreipk dėmesį, kad programa sukūrė failą pavadinimu <code>testas.txt</code> kataloge, iš kurio paleidai programą. Eilutėje esantis <code>\n</code> nurodo Python'ui toje vietoje peršokti į naują eilutę.

Apžvelkime visus veiksmus su failais:
* Gauk failo objektą su funkcija <code>open</code>
* Skaityk iš arba rašyk į failo objektą (priklausomai nuo to, kokiu režimu jis buvo atidarytas)
* Jeigu failui atidaryti nenaudojai funkcijos <code>with</code>, turėsi jį uždaryti rankiniu būdu

Pirmas žingsnis yra gauti failo objektą. Tai galima padaryti naudojant funkciją <code>open</code>. Formatas yra <code>failo_objektas = open(failo_pavadinimas, režimas)</code>, kur <code>failo_objektas</code> yra kintamasis, į kurį reikia įdėti failo objektą, <code>failo_pavadinimas</code> yra eilutė su failo pavadinimu, o <code>režimas</code> yra <code>"rt"</code>, kad (ang. ''r''ead) skaityti failą kaip ''t''ekstą arba <code>"wt"</code> (''w''rite) rašytį į failą kaip ''t''ekstą (ir keletą kitų režimų, kuriuos čia praleisime). Toliau galima iškviesti failų objektų funkcijas. Dvi dažniausiai naudojamos funkcijos yra <code>read</code> (skaityti) ir <code>write</code> (rašyti). Funkcija <code>write</code> prideda eilutę prie failo pabaigos. Funkcija <code>read</code> nuskaito failo turinį ir grąžina jį kaip eilutę (kaip padaryta pavyzdyje).

O dabar čia yra nauja telefono numerių programos versija, kurią jau sukūrei anksčiau:

<syntaxhighlight lang="python">
def spausdink_numerius(numeriai):
print("Telefono numeriai:")
for k, v in numeriai.items():
print("Vardas:", k, "\tTelefono numeris:", v)
print()

def pridėk_numerį(numeriai, vardas, numeris):
numeriai[vardas] = numeris

def surask_numerį(numeriai, vardas):
if vardas in numeriai:
return "Telefono numeris yra " + numeriai[vardas]
else:
return vardas + " nebuvo rastas"

def pašalink_numerį(numeriai, vardas):
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas," nebuvo rastas")

def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()

def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Įkelk telefono numerius')
print('6. Išsaugok telefono numerius')
print('7. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu()
while True:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-7): "))
if meniu_pasirinkimas == 1:
spausdink_numerius(numeriai)
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
pridėk_numerį(numeriai, vardas, numeris)
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
pašalink_numerį(numeriai, vardas)
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
print(surask_numerį(numeriai, vardas))
elif meniu_pasirinkimas == 5:
failo_pavadinimas = input("Failo pavadinimas, kurį nori įkelti: ")
įkelti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 6:
failo_pavadinimas = input("Failo pavadinimas išsaugojimui: ")
išsaugoti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 7:
break
else:
spausdink_meniu()

print("Viso!")
</syntaxhighlight>

Gali pastebėti, kad dabar kodas papildomai išsaugo ir perskaito failus. Štai dviejų programos vykdymų išvestis:

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Liepa'''
Telefono numeris: '''1234'''
Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Benas'''
Telefono numeris: '''4321'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''6'''
Failo pavadinimas išsaugojimui: '''numeriai.txt'''
Įvesk skaičių (1-7): '''7'''
Viso!

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''5'''
Failo pavadinimas, kurį nori įkelti: '''numeriai.txt'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''7'''
Viso!

Naujos šios programos dalys yra:
<syntaxhighlight lang="python">
def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()
</syntaxhighlight>

Pirmiausia pažiūrėk į programos išsaugojimo dalį. Visų pirma, sukuriamas failo objektas su komanda <code>open(failo_pavadinimas, "wt")</code>. Toliau sukuriama eilutė kiekvienam telefono numeriui su komanda <code>išvesties_failas.write(k + "," + v + "\n")</code>. Tai išrašo eilutę, kurioje yra vardas, kablelis, telefono numeris, o po jos rašoma nauja eilutė.

Failo skaitymo dalis yra šiek tiek sudėtingesnė. Ji prasideda failo objekto gavimu. Tada ji naudoja <code>while True:</code> ciklą, kad tęstųsi ciklas tol, kol bus aptikta komanda <code>break</code>. Komanda <code>skaitoma_eilutė = skaitymo_failas.readline()</code> perskaito pirmą eilutę ir priskiria kintamajam <code>skaitome_eilutė</code>. Pasiekus failo pabaigą, funkcija <code>readline</code> grąžins tuščią eilutę. Sąlyginis sakinys <code>if</code> tai patikrina ir panaudojant komandą <code>break</code> nutraukia <code>while</code> ciklą. Funkcija <code>readline</code> perskaito ir grąžina vieną eilutę kartu su jos pabaigos simboliu. Tai yra tam, kad būtų galima spręsti ar tai yra tik tuščia eilutė, ar jau failo pabaiga. Taigi turime atsikratyti to paskutinio eilutės pabaigos simbolio. Komanda <code>skaitoma_eilutė = skaitoma_eilutė[:-1]</code> tai padaro už mus, išmesdama paskutinį simbolį. Toliau eilutė <code>vardas, numeris = skaitoma_eilutė.split(",")</code> padalija eilutę ties kableliu į vardą ir telefono numerį ir visa tai įtraukiama į <code>numeriai</code> žodyną.

=== Darbo su failais rėžimai ===
Be <code>"rt"</code> ir <code>"wt"</code> yra ir kitų darbo su failais rėžimų. Lentelėje rasi visų rėžimų sąrašą:
{| class="wikitable"
|+
!Rėžimas
!Paaiškinimas
|-
|"rt"
|Tekstinio failo nuskatymas
|-
|"wt"
|Teksto rašymas į failą
|-
|"xt"
|Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"at"
|Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r"
|Sinonimas "rt" rėžimui. Tekstinio failo nuskatymas
|-
|"w"
|Sinonimas "w" rėžimui. Teksto rašymas į failą
|-
|"x"
|Sinonimas "x" rėžimui. Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"a"
|Sinonimas "a" rėžimui. Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"rb"
|Dvejetainio duomenų failo nuskatymas
|-
|"wb"
|Dvejetainės informacijos rašymas į failą
|-
|"xb"
|Naujo dvejetainio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"ab"
|Dvejetainio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|-
|"r+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|}
Dvvejetainiai rėžimai šiame vadovėlyje plačiau nagrinėjami nėra

=== Pagrindinės darbo su tekstiniais failais operacijos ===
{| class="wikitable"
|+
!Operacija
!Paaiškinimas
|-
|failas.read()
|Nuskaitomas visas failo turinys
|-
|failas.read(kiek)
|Nuskaitomas nuordytas simbolių kiekis iš failo. Pvz naudojant failas.read(3) bus nuskaitomi 3 sekantys simboliai
|-
|failas.readline()
|Nuskaitoma sekanti failo eilutė
|-
|failas.readlines()
|Nuskaitomos visos failo eilutės. Gražinamas sąrašas sudarytas iš teksto eilučių
|-
|failas.close()
|Failo uždarymas. Uždarius failą veiksmai su juo negalimi. Atidarant failą naudojant with funkciją, jis bus uždarytas automatiškai, tad close() naudoti nebereikia
|-
|failas.write(rašomas_tesktas)
|Įrašo nurodytą tekstą į failą.
|-
|failas.writelines(rašomo_teksto_eilučių_sąrašas)
|Sąrašas sudarytas iš teskto eilučių yra įrašomas į failą. Kiekvienas sąrašo elementas bus įrašomas naujoje eilutėje
|}

=== Pažangesnis .txt failų naudojimas ===

Galbūt tau kyla toks klausimas: „Aš žinau, kaip skaityti ir rašyti tekstinį failą, bet ką daryti, jei noriu atspausdinti failą spausdintuvu?"

Yra keletas skirtingų būdų, kaip tai padaryti. Iš tikrųjų, pats lengviausias būdas yra atidaryti kitą programą, tada leisti viskuo pasirūpinti Python'o kodui, kad tau nereikėtų pačiam failo atidarinėti ir spausdinti. Šis metodas apima kitos programos subproceso (arba antrinis procesas; biblioteka 'subprocess') iškvietimą.

Prisimeni failą, į kurį įrašėme išvestį aukščiau esančioje programoje? Panaudokime tą failą.
Turėk omenyje, kad norint išvengti klaidų, ši programa naudoja sąvokas iš kito skyriaus. Nedvejodamas gali dar kartą peržiūrėti šį pavyzdį po kito skyriaus.

<syntaxhighlight lang="Python">
import subprocess
def pagrindinis():
try:
print("Ši maža programa iškviečia spausdinimo funkciją Notepad programoje")
#Atspausdinkime failą, kurį sukūrėme aukščiau esančioje programoje
subprocess.call(['notepad','/p','numeriai.txt'])
except WindowsError:
print("Pakviesto subproceso nėra arba jo negalima iškviesti.")

pagrindinis()
</syntaxhighlight>

<code>subprocess.call</code> turi tris argumentus. Pirmasis argumentas šio pavyzdžio kontekste turėtų būti programos pavadinimas, iš kurios nori iškviesti spausdinimo subprocesą. Antrasis argumentas turėtų būti konkretus tos programos subprocesas. Kad būtų paprasčiau, tiesiog suprask, kad šioje programoje <code>'/p'</code> yra subprocesas, naudojamas norint pasiekti spausdintuvą per nurodytą programą. Paskutinis argumentas turėtų būti failo pavadinimas, kurį norite siųsti į spausdinimo subprocesą. Šiuo atveju tai yra tas pats failas, naudotas anksčiau šiame skyriuje.

=== Pratimai ===
1. Parašyk programą, kuri suskaičiuotų, kiek faile yra eilučių.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
failas = input("Kokio failo eilutes skaičiuoti? ")
įvesties_failas = open(failas, "r")
eilutės = įvesties_failas.readlines()
įvesties_failas.close()

print("Failas", failas, "turi", len(eilutės), " eilutes")
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri nukopijuotų vieno failo lygines eilutes į kitą failą.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
įvesties_failo_pavadinimas = input("Kokio failo eilutes kopijuoti? ")
įvesties_failas = open(įvesties_failo_pavadinimas, "r")

išvesties_failo_pavadinimas = input("Į kokį failą išsaugoti lygines eilutes? ")
išvesties_failas = open(išvesties_failo_pavadinimas, "w")

eilutės_numeris = 0

while True:
eilutė = įvesties_failas.readline()
eilutės_numeris = eilutės_numeris + 1
if not eilutė:
break
else:
if (eilutės_numeris % 2) == 0:
išvesties_failas.write(eilutė)

įvesties_failas.close()
išvesties_failas.close()
</syntaxhighlight>
|-
|}

3. Dabar pakeisk pažymių programą iš skyriaus [[Vadovėlis/Žodynai|Žodynai]], kad ji naudotų failus mokinių pažymiams saugoti.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = { }

def įkelti_pažymius(pažymių_failas):
įvesties_failas = open(pažymių_failas, "r")
pažymiai = [ ]
while True:
mokinys_ir_pažymys = įvesties_failas.readline()
mokinys_ir_pažymys = mokinys_ir_pažymys[:-1]
if not mokinys_ir_pažymys:
break
else:
mokinio_vardas, mokinio_pažymiai = mokinys_ir_pažymys.split(",")
mokinio_pažymiai = mokinio_pažymiai.split(" ")
mokiniai[mokinio_vardas] = mokinio_pažymiai
įvesties_failas.close()
print("Pažymiai įkelti.")

def išsaugoti_pažymius(pažymių_failas):
išvesties_failas = open(pažymių_failas, "w")
for k, v in mokiniai.items():
išvesties_failas.write(k + ",")
for x in v:
išvesties_failas.write(str(x) + " ")
išvesties_failas.write("\n")
išvesties_failas.close()
print("Pažymiai išsaugoti.")

def spausdink_meniu():
print("1. Pridėk mokinį")
print("2. Pašalink mokinį")
print("3. Įkrauti pažymius")
print("4. Įrašyk pažymį")
print("5. Spausdink pažymius")
print("6. Įšsaugoti pažymius")
print("7. Spausdink meniu")
print("9. Išeik")

def spausdink_visus_pažymius():
if mokiniai:
raktai = sorted(mokiniai.keys())
print('\t', end=' ')
for x in užduotys:
print(x, '\t', end=' ')
print()
for x in raktai:
print(x, '\t', end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
else:
print("Neradau pažymių spausdinimui.")

def spausdink_pažymius(pažymiai):
for x in pažymiai:
print(x, '\t', end=' ')
print()

spausdink_meniu()
meniu_pasirinkimas = 0
while meniu_pasirinkimas != 9:
print()
meniu_pasirinkimas = int(input("Meniu pasirinkimas: "))
if meniu_pasirinkimas == 1:
vardas = input("Pridėk mokinį: ")
mokiniai[vardas] = [0] * len(užduotys)
elif meniu_pasirinkimas == 2:
vardas = input("Pašalink mokinį: ")
if vardas in mokiniai:
del mokiniai[vardas]
else:
print("Mokinys vardu:", vardas, " nerastas.")
elif meniu_pasirinkimas == 3:
pažymių_failas = input("Įkrauti pažymius iš kokio failo? ")
įkelti_pažymius(pažymių_failas)
elif meniu_pasirinkimas == 4:
print("Įrašyk pažymį")
vardas = input("Mokinys: ")
if vardas in mokiniai:
pažymiai = mokiniai[vardas]
print("Įrašyk mokinio pažymį")
print("Įrašyk 0 (nulį), kad išeitum")
for i,x in enumerate(užduotys):
print(i + 1, x, '\t', end=' ')
print()
spausdink_pažymius(pažymiai)
kuris = 1234
while kuris != -1:
kuris = int(input("Pažymys, kurį nori pakeisti: "))
kuris -= 1
if 0 <= kuris < len(pažymiai):
pažymys = int(input("Pažymys: "))
pažymiai[kuris] = pažymys
elif kuris != -1:
print("Klaidingas pažymys")
else:
print("Mokinys nerastas")
elif meniu_pasirinkimas == 5:
spausdink_visus_pažymius()
elif meniu_pasirinkimas == 6:
pažymių_failas = input("Į kokį failą išsaugoti pažymius? ")
išsaugoti_pažymius(pažymių_failas)
elif meniu_pasirinkimas != 9:
spausdink_meniu()

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie tekstines eilutes |next=Siekiant tobulumo}}
{{BookCat}}

Vadovėlis/Failų tvarkymas

2023-03-13T08:48:30Z

Monika: Sutvarkyta nuoroda

{{navigation |previous=Daugiau apie tekstines eilutes |next=Siekiant tobulumo}}
{{BookCat}}

=== Failų įvestis/išvestis ===

Štai paprastas failo įvesties ir išvesties (I/O, ang. Input/Output) pavyzdys:
<syntaxhighlight lang="python">
# Rašyti į failą
with open("testas.txt", "wt") as rašomas_failas:
rašomas_failas.write("Šis tekstas bus išsiųstas į failą\nPažiūrėk ir pamatysi!")

# Skaityti failą
with open("testas.txt", "rt") as skaitomas_failas:
tekstas = skaitomas_failas.read()

print(tekstas)
</syntaxhighlight>

Failo <code>testas.txt</code> išvestis ir turinys yra:

Šis tekstas bus išsiųstas į failą
Pažiūrėk ir pamatysi!

Atkreipk dėmesį, kad programa sukūrė failą pavadinimu <code>testas.txt</code> kataloge, iš kurio paleidai programą. Eilutėje esantis <code>\n</code> nurodo Python'ui toje vietoje peršokti į naują eilutę.

Apžvelkime visus veiksmus su failais:
* Gauk failo objektą su funkcija <code>open</code>
* Skaityk iš arba rašyk į failo objektą (priklausomai nuo to, kokiu režimu jis buvo atidarytas)
* Jeigu failui atidaryti nenaudojai funkcijos <code>with</code>, turėsi jį uždaryti rankiniu būdu

Pirmas žingsnis yra gauti failo objektą. Tai galima padaryti naudojant funkciją <code>open</code>. Formatas yra <code>failo_objektas = open(failo_pavadinimas, režimas)</code>, kur <code>failo_objektas</code> yra kintamasis, į kurį reikia įdėti failo objektą, <code>failo_pavadinimas</code> yra eilutė su failo pavadinimu, o <code>režimas</code> yra <code>"rt"</code>, kad (ang. ''r''ead) skaityti failą kaip ''t''ekstą arba <code>"wt"</code> (''w''rite) rašytį į failą kaip ''t''ekstą (ir keletą kitų režimų, kuriuos čia praleisime). Toliau galima iškviesti failų objektų funkcijas. Dvi dažniausiai naudojamos funkcijos yra <code>read</code> (skaityti) ir <code>write</code> (rašyti). Funkcija <code>write</code> prideda eilutę prie failo pabaigos. Funkcija <code>read</code> nuskaito failo turinį ir grąžina jį kaip eilutę (kaip padaryta pavyzdyje).

O dabar čia yra nauja telefono numerių programos versija, kurią jau sukūrei anksčiau:

<syntaxhighlight lang="python">
def spausdink_numerius(numeriai):
print("Telefono numeriai:")
for k, v in numeriai.items():
print("Vardas:", k, "\tTelefono numeris:", v)
print()

def pridėk_numerį(numeriai, vardas, numeris):
numeriai[vardas] = numeris

def surask_numerį(numeriai, vardas):
if vardas in numeriai:
return "Telefono numeris yra " + numeriai[vardas]
else:
return vardas + " nebuvo rastas"

def pašalink_numerį(numeriai, vardas):
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas," nebuvo rastas")

def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()

def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Įkelk telefono numerius')
print('6. Išsaugok telefono numerius')
print('7. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu()
while True:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-7): "))
if meniu_pasirinkimas == 1:
spausdink_numerius(numeriai)
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
pridėk_numerį(numeriai, vardas, numeris)
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
pašalink_numerį(numeriai, vardas)
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
print(surask_numerį(numeriai, vardas))
elif meniu_pasirinkimas == 5:
failo_pavadinimas = input("Failo pavadinimas, kurį nori įkelti: ")
įkelti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 6:
failo_pavadinimas = input("Failo pavadinimas išsaugojimui: ")
išsaugoti_numerius(numeriai, failo_pavadinimas)
elif meniu_pasirinkimas == 7:
break
else:
spausdink_meniu()

print("Viso!")
</syntaxhighlight>

Gali pastebėti, kad dabar kodas papildomai išsaugo ir perskaito failus. Štai dviejų programos vykdymų išvestis:

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Liepa'''
Telefono numeris: '''1234'''
Įvesk skaičių (1-7): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Benas'''
Telefono numeris: '''4321'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''6'''
Failo pavadinimas išsaugojimui: '''numeriai.txt'''
Įvesk skaičių (1-7): '''7'''
Viso!

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Įkelk telefono numerius
6. Išsaugok telefono numerius
7. Išeik

Įvesk skaičių (1-7): '''5'''
Failo pavadinimas, kurį nori įkelti: '''numeriai.txt'''
Įvesk skaičių (1-7): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 1234
Vardas: Benas Telefono numeris: 4321

Įvesk skaičių (1-7): '''7'''
Viso!

Naujos šios programos dalys yra:
<syntaxhighlight lang="python">
def įkelti_numerius(numeriai, failo_pavadinimas):
skaitymo_failas = open(failo_pavadinimas, "rt")
while True:
skaitoma_eilutė = skaitymo_failas.readline()
if not skaitoma_eilutė:
break
skaitoma_eilutė = skaitoma_eilutė[:-1]
vardas, numeris = skaitoma_eilutė.split(",")
numeriai[vardas] = numeris
skaitymo_failas.close()

def išsaugoti_numerius(numeriai, failo_pavadinimas):
išvesties_failas = open(failo_pavadinimas, "wt")
for k, v in numeriai.items():
išvesties_failas.write(k + "," + v + "\n")
išvesties_failas.close()
</syntaxhighlight>

Pirmiausia pažiūrėk į programos išsaugojimo dalį. Visų pirma, sukuriamas failo objektas su komanda <code>open(failo_pavadinimas, "wt")</code>. Toliau sukuriama eilutė kiekvienam telefono numeriui su komanda <code>išvesties_failas.write(k + "," + v + "\n")</code>. Tai išrašo eilutę, kurioje yra vardas, kablelis, telefono numeris, o po jos rašoma nauja eilutė.

Failo skaitymo dalis yra šiek tiek sudėtingesnė. Ji prasideda failo objekto gavimu. Tada ji naudoja <code>while True:</code> ciklą, kad tęstųsi ciklas tol, kol bus aptikta komanda <code>break</code>. Komanda <code>skaitoma_eilutė = skaitymo_failas.readline()</code> perskaito pirmą eilutę ir priskiria kintamajam <code>skaitome_eilutė</code>. Pasiekus failo pabaigą, funkcija <code>readline</code> grąžins tuščią eilutę. Sąlyginis sakinys <code>if</code> tai patikrina ir panaudojant komandą <code>break</code> nutraukia <code>while</code> ciklą. Funkcija <code>readline</code> perskaito ir grąžina vieną eilutę kartu su jos pabaigos simboliu. Tai yra tam, kad būtų galima spręsti ar tai yra tik tuščia eilutė, ar jau failo pabaiga. Taigi turime atsikratyti to paskutinio eilutės pabaigos simbolio. Komanda <code>skaitoma_eilutė = skaitoma_eilutė[:-1]</code> tai padaro už mus, išmesdama paskutinį simbolį. Toliau eilutė <code>vardas, numeris = skaitoma_eilutė.split(",")</code> padalija eilutę ties kableliu į vardą ir telefono numerį ir visa tai įtraukiama į <code>numeriai</code> žodyną.

=== Darbo su failais rėžimai ===
Be <code>"rt"</code> ir <code>"wt"</code> yra ir kitų darbo su failais rėžimų. Lentelėje rasi visų rėžimų sąrašą:
{| class="wikitable"
|+
!Rėžimas
!Paaiškinimas
|-
|"rt"
|Tekstinio failo nuskatymas
|-
|"wt"
|Teksto rašymas į failą
|-
|"xt"
|Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"at"
|Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r"
|Sinonimas "rt" rėžimui. Tekstinio failo nuskatymas
|-
|"w"
|Sinonimas "w" rėžimui. Teksto rašymas į failą
|-
|"x"
|Sinonimas "x" rėžimui. Naujo teskinio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"a"
|Sinonimas "a" rėžimui. Tekstinio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"rb"
|Dvejetainio duomenų failo nuskatymas
|-
|"wb"
|Dvejetainės informacijos rašymas į failą
|-
|"xb"
|Naujo dvejetainio failo kūrimas. Jei toks failas jau egzistuoja bus gaunama klaida
|-
|"ab"
|Dvejetainio failo papildymas. Failo turinys bus pildomas nuo edamo failo pabaigos
|-
|"r+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+"
|Tekstinio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|-
|"r+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys nėra išvalomas.
|-
|"w+b"
|Dvejetainio failo skaitymas ir rašymas. Esamas failo turinys yra išvalomas rašant į failą.
|}
Dvvejetainiai rėžimai šiame vadovėlyje plačiau nagrinėjami nėra

=== Pagrindinės darbo su tekstiniais failais operacijos ===
{| class="wikitable"
|+
!Operacija
!Paaiškinimas
|-
|failas.read()
|Nuskaitomas visas failo turinys
|-
|failas.read(kiek)
|Nuskaitomas nuordytas simbolių kiekis iš failo. Pvz naudojant failas.read(3) bus nuskaitomi 3 sekantys simboliai
|-
|failas.readline()
|Nuskaitoma sekanti failo eilutė
|-
|failas.readlines()
|Nuskaitomos visos failo eilutės. Gražinamas sąrašas sudarytas iš teksto eilučių
|-
|failas.close()
|Failo uždarymas. Uždarius failą veiksmai su juo negalimi. Atidarant failą naudojant with funkciją, jis bus uždarytas automatiškai, tad close() naudoti nebereikia
|-
|failas.write(rašomas_tesktas)
|Įrašo nurodytą tekstą į failą.
|-
|failas.writelines(rašomo_teksto_eilučių_sąrašas)
|Sąrašas sudarytas iš teskto eilučių yra įrašomas į failą. Kiekvienas sąrašo elementas bus įrašomas naujoje eilutėje
|}

=== Pažangesnis .txt failų naudojimas ===

Galbūt tau kyla toks klausimas: „Aš žinau, kaip skaityti ir rašyti tekstinį failą, bet ką daryti, jei noriu atspausdinti failą spausdintuvu?"

Yra keletas skirtingų būdų, kaip tai padaryti. Iš tikrųjų, pats lengviausias būdas yra atidaryti kitą programą, tada leisti viskuo pasirūpinti Python'o kodui, kad tau nereikėtų pačiam failo atidarinėti ir spausdinti. Šis metodas apima kitos programos subproceso (arba antrinis procesas; biblioteka 'subprocess') iškvietimą.

Prisimeni failą, į kurį įrašėme išvestį aukščiau esančioje programoje? Panaudokime tą failą.
Turėk omenyje, kad norint išvengti klaidų, ši programa naudoja sąvokas iš kito skyriaus. Nedvejodamas gali dar kartą peržiūrėti šį pavyzdį po kito skyriaus.

<syntaxhighlight lang="Python">
import subprocess
def pagrindinis():
try:
print("Ši maža programa iškviečia spausdinimo funkciją Notepad programoje")
#Atspausdinkime failą, kurį sukūrėme aukščiau esančioje programoje
subprocess.call(['notepad','/p','numeriai.txt'])
except WindowsError:
print("Pakviesto subproceso nėra arba jo negalima iškviesti.")

pagrindinis()
</syntaxhighlight>

<code>subprocess.call</code> turi tris argumentus. Pirmasis argumentas šio pavyzdžio kontekste turėtų būti programos pavadinimas, iš kurios nori iškviesti spausdinimo subprocesą. Antrasis argumentas turėtų būti konkretus tos programos subprocesas. Kad būtų paprasčiau, tiesiog suprask, kad šioje programoje <code>'/p'</code> yra subprocesas, naudojamas norint pasiekti spausdintuvą per nurodytą programą. Paskutinis argumentas turėtų būti failo pavadinimas, kurį norite siųsti į spausdinimo subprocesą. Šiuo atveju tai yra tas pats failas, naudotas anksčiau šiame skyriuje.

=== Pratimai ===
Dabar pakeisk pažymių programą iš skyriaus [[Vadovėlis/Žodynai|Žodynai]], kad ji naudotų failus mokinių pažymiams saugoti.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = { }

def įkelti_pažymius(pažymių_failas):
įvesties_failas = open(pažymių_failas, "r")
pažymiai = [ ]
while True:
mokinys_ir_pažymys = įvesties_failas.readline()
mokinys_ir_pažymys = mokinys_ir_pažymys[:-1]
if not mokinys_ir_pažymys:
break
else:
mokinio_vardas, mokinio_pažymiai = mokinys_ir_pažymys.split(",")
mokinio_pažymiai = mokinio_pažymiai.split(" ")
mokiniai[mokinio_vardas] = mokinio_pažymiai
įvesties_failas.close()
print("Pažymiai įkelti.")

def išsaugoti_pažymius(pažymių_failas):
išvesties_failas = open(pažymių_failas, "w")
for k, v in mokiniai.items():
išvesties_failas.write(k + ",")
for x in v:
išvesties_failas.write(str(x) + " ")
išvesties_failas.write("\n")
išvesties_failas.close()
print("Pažymiai išsaugoti.")

def spausdink_meniu():
print("1. Pridėk mokinį")
print("2. Pašalink mokinį")
print("3. Įkrauti pažymius")
print("4. Įrašyk pažymį")
print("5. Spausdink pažymius")
print("6. Įšsaugoti pažymius")
print("7. Spausdink meniu")
print("9. Išeik")

def spausdink_visus_pažymius():
if mokiniai:
raktai = sorted(mokiniai.keys())
print('\t', end=' ')
for x in užduotys:
print(x, '\t', end=' ')
print()
for x in raktai:
print(x, '\t', end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
else:
print("Neradau pažymių spausdinimui.")

def spausdink_pažymius(pažymiai):
for x in pažymiai:
print(x, '\t', end=' ')
print()

spausdink_meniu()
meniu_pasirinkimas = 0
while meniu_pasirinkimas != 9:
print()
meniu_pasirinkimas = int(input("Meniu pasirinkimas: "))
if meniu_pasirinkimas == 1:
vardas = input("Pridėk mokinį: ")
mokiniai[vardas] = [0] * len(užduotys)
elif meniu_pasirinkimas == 2:
vardas = input("Pašalink mokinį: ")
if vardas in mokiniai:
del mokiniai[vardas]
else:
print("Mokinys vardu:", vardas, " nerastas.")
elif meniu_pasirinkimas == 3:
pažymių_failas = input("Įkrauti pažymius iš kokio failo? ")
įkelti_pažymius(pažymių_failas)
elif meniu_pasirinkimas == 4:
print("Įrašyk pažymį")
vardas = input("Mokinys: ")
if vardas in mokiniai:
pažymiai = mokiniai[vardas]
print("Įrašyk mokinio pažymį")
print("Įrašyk 0 (nulį), kad išeitum")
for i,x in enumerate(užduotys):
print(i + 1, x, '\t', end=' ')
print()
spausdink_pažymius(pažymiai)
kuris = 1234
while kuris != -1:
kuris = int(input("Pažymys, kurį nori pakeisti: "))
kuris -= 1
if 0 <= kuris < len(pažymiai):
pažymys = int(input("Pažymys: "))
pažymiai[kuris] = pažymys
elif kuris != -1:
print("Klaidingas pažymys")
else:
print("Mokinys nerastas")
elif meniu_pasirinkimas == 5:
spausdink_visus_pažymius()
elif meniu_pasirinkimas == 6:
pažymių_failas = input("Į kokį failą išsaugoti pažymius? ")
išsaugoti_pažymius(pažymių_failas)
elif meniu_pasirinkimas != 9:
spausdink_meniu()

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie tekstines eilutes |next=Siekiant tobulumo}}
{{BookCat}}

Vadovėlis/Daugiau apie tekstines eilutes

2023-03-02T07:18:47Z

Monika: Pridėta užduočių

{{navigation |previous=Daugiau apie sąrašus |next=Failų tvarkymas}}
{{BookCat}}

Šiame skyriuje pamatysi, kiek šaunių dalykų galime padaryti su tekstine reikšme:

<syntaxhighlight lang="python">
def rėk(tekstinė_reikšmė):
for raidė in tekstinė_reikšmė:
print("Duok man " + raidė)
print("'" + raidė + "'")

rėk("Ačiū")

def vidurys(tekstas):
print("Raidė esanti viduryje yra:", tekstas[len(tekstas) // 2])

vidurys("abcdefg")
vidurys("The Python Programming Language")
vidurys("Atlanta")
</syntaxhighlight>

Rezultatas:

Duok man A
'A'
Duok man č
'č'
Duok man i
'i'
Duok man ū
'ū'
Raidė esanti viduryje yra: d
Raidė esanti viduryje yra: r
Raidė esanti viduryje yra: a

Šios dvi programos rodo, kad tekstinė reikšmė (string) yra keliais aspektais panaši į sąrašą (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad su tekstine reikšme galima naudoti sąrašo funkciją <code>len()</code>, taip pat sąrašo indeksavimu ir pjaustymu. Taigi, dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

Kita šio skyriaus funkcija parodo tam tikras tekstinės reikšmės ypatybes:
<syntaxhighlight lang="python">
def pavertimas_didžiosiomis_raidėmis(tekstas):
## Ši funkcija, tekstinę reikšmę užrašo didžiosiomis raidėmis
didžiosios_raidės = ""
for raidė in tekstas:
if 'a' <= raidė <= 'z':
lokacija = ord(raidė) - ord('a')
naujas_ascii = lokacija + ord('A')
raidė= chr(naujas_ascii)
didžiosios_raidės = didžiosios_raidės + raidė
return didžiosios_raidės

print(pavertimas_didžiosiomis_raidėmis("Įrašytas tekstas"))
</syntaxhighlight>

Rezultatas:

ĮRAŠYTAS TEKSTAS

Tai veikia, nes kompiuteris tekstinės reikšmės simbolius šifruoja skaičiais nuo 0 iki 1 114 111. Visos šios tekstinės reikšmės turi savo unikalias unikodo reikšmes. Pavyzdžiui, simboliui „A“ yra priskirtas skaičius 65, simbolis „B“ kompiuterio suprantamas kaip 66, o simbolis א yra 1488. Visi simboliai yra tarsi surikiuoti ir turi savo eilės numerį. Python'o programavimo kalba turi funkciją, vadinamą <code>ord()</code> (trumpinys angliško žodžio ordinal, kuris reiškia iš eilės), kuri grąžina simbolio skaičių (eilės numerį_. Taip pat Python'o programavimo kalba turi ir atvirkščią funkciją, vadinamą <code>chr()</code>, kuri skaičių paverčia simboliu. Supratus, kaip veikia šios funkcijos aukščiau užrašyta programa turėtų atrodyti logiška.

Programos pirmoji eilutė <code>if 'a' <= simbolis <= 'z':</code> patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės:
Pirmiausia eilutė <code>lokacija= ord(simbolis) - ord('a')</code> nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t.
Tada nauja reikšmė randama su kodo eilute <code>naujas_ascii = lokacija + ord ('A')</code>.
Tada ši reikšmė paverčiama atgal į simbolį, kuris dabar yra didžioji raidė.

Žinoma, tai tik programos pavyzdys, tačiau daug paprasčiau tai padaryti naudojantis funkcija <code>tekstoEilutė.upper()</code>, kuri veikia su visomis kalbomis.

O dabar pabandykime pasižiūrėti į šį pavyzdį:

>>> '''# Skaičius į tekstinę reikšmę'''
>>> '''2'''
2
>>> '''str(2)'''
'2'
>>> '''-123'''
-123
>>> '''str(-123)'''
'-123'
>>> '''# Tekstinė reikšmė į skaičių'''
>>> '''"23"'''
'23'
>>> '''int("23")'''
23
>>> '''"23" * 2'''
'2323'
>>> '''int("23") * 2'''
46
>>> '''# Skaičius po kablelio į tekstinę reikšmę'''
>>> '''1.23'''
1.23
>>> '''str(1.23)'''
'1.23'
>>> '''# Skaičius po kablelio į skaičių'''
>>> '''1.23'''
1.23
>>> '''int(1.23)'''
1
>>> '''int(-1.23)'''
-1
>>> '''# Tekstinė reikšmė į skaičių po kablelio'''
>>> '''float("1.23")'''
1.23
>>> '''"1.23"'''
'1.23'
>>> '''float("123")'''
123.0

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę (skaičiai suprantami, kaip simblių seka), o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į sveikąjį skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į dešimtainį skaičių (skaičių su kableliu). Grįžtant prie funkcijos <code>str()</code> – ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

>>> '''str(1)'''
'1'
>>> '''str(234.14)'''
'234.14'
>>> '''str([4, 42, 10])'''
'[4, 42, 10]'

Funkcija <code>int()</code> konvertuoja tekstinę reikšmę (ar dešimtainė skaičių) į sveikąjį skaičių. Panaši funkcija <code>float</code> konvertuoja skaičių ar tekstinę reikšmę į dešimtainį skaičių. Taip pat Python'o programavimo kalba turi funkciją <code>type()</code>, kuri grąžina kintamojo reikšmės tipą. Pavyzdžiui:

<syntaxhighlight lang="python">
v = '123'
print(type(v))
# <class 'str'>

v = 645.123
print(type(v))
# <class 'float'>

v = [1, 2, 3]
print(type(v))
# <class 'list'>
</syntaxhighlight>

Naudojant funkciją <code>type()</code> pasitikrink, ar grąžinamas toks reikšmės tipas, kurio tikėjaisi.

Taip pat naudingas ir dažnai paprastose užduotyse naudojama funkcija <code>split()</code>:

>>> '''"Čia yra tik žodžių kratinys".split()'''
['Čia', 'yra', 'tik', 'žodžių', 'kratinys']
>>> '''tekstas= "Pirma partija, antra partija, trečia, ketvirta"'''
>>> '''tekstas.split(",")'''
['Pirma partija', ' antra partija', ' trečia', ' ketvirta']

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Kai funkcijai nenurodytas argmentas – skyriklis, pagal ką suskirstyti į skirtingus sąrašo elementus, funkcija skirsto pagal tarpus. Antrame pavyzdyje skyriklis yra kablelis.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

>>> '''sąrašas= tekstas.split(",")'''
>>> '''len(sąrašas)'''
4
>>> '''sąrašas[-1]'''
' ketvirta'
>>> '''sąrašas = tekstas.split(",", 2)'''
>>> '''len(sąrašas)'''
3
>>> '''sąrašas[-1]'''
' trečia, ketvirta'


=== Tekstinės (ir sąrašo) reikšmės pjaustymas ir sujungimas ===

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje su sąrašais, kai laužtiniuose skliaustuose <code>[]</code> buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: <code>tekstas[pradžios_indeksas:pabaigos_indeksas]</code> (retais atvejais galime pridėti dar ir trečią argumentą, kaip apačioje esančiame pavyzdyje).

Kad nesusipainiotum įrašydamas indekso skaičius, įsivaizduok, kad žirklėmis karpai tekstą, o programai nurodai, kurioje vietoje kirpti. Štai vienas pavyzdys, kaip tai viekia – geltonai pažymėtos kirpimo vietos, o raudonai ir mėlynai indekso numeris

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | -2
| style="width:2ex" |
| style="width:2ex;color:blue" | -1
| style="width:2ex" |
| style="width:2ex" |
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
|-
| tekstas =
|"
| style="background:#FFFF88" |
!S
| style="background:#FFFF88" |
!T
| style="background:#FFFF88" |
!R
| style="background:#FFFF88" |
!I
| style="background:#FFFF88" |
!N
| style="background:#FFFF88" |
!G
| style="background:#FFFF88" |
|"
|-
|
|
| style="background:#FFFF88" |↑
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |↑
|
|-
|
|
|[:
|
|
|
|
|
|
|
|
|
|
|
|:]
|
|}
</tt>

Įsidėmėk, kad raudonai pažymėti indeksai skaičiuojami nuo pradžios, o mėlyni atvirkščiai nuo kito galo t.y. teksto pabaigos. Taip pat ar pastebėjai, kad skaičiuojant nuo galo nėra -0 reikšmės? Taip yra todėl, kad 0 visada priskiriamas tik reikšmės pradžiai:

<tt>
{|
|-
|tekstas[1:4] || style="width:3em;text-align:center" | → || "TRI"
|-
|tekstas[:5] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[:-1] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[-4:] || style="width:3em;text-align:center" | → || "RING"
|-
|tekstas[2] || style="width:3em;text-align:center" | → || "R"
|-
|tekstas[:] || style="width:3em;text-align:center" | → || "STRING"
|-
|tekstas[::-1] || style="width:3em;text-align:center" | → || "GNIRTS"
|}
</tt>

<tt>tekstas[1:4]</tt> duoda visas <tt>tekstas</tt> reikšmes tarp 1 ir 4, "<tt>TRI</tt>". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: <tt>tekstas[:5]</tt> atspausdina"<tt>STRIN</tt>". Taip pat, tiek su <tt>pradžios_indeksas</tt>, tiek su <tt>pabaigos_indeksas</tt> galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: <tt>tekstas[:-1]</tt> duoda tą patį rezultatą kaip <tt>tekstas[:5]</tt>, todėl, kad indekas -1 šiame žodyje yra toje pačioje vietoje kaip indeksas 5. Jeigu nenaudojame argumento kartu su dvitaškiu, tai skaičius traktuojamas kitaip, pavyzdžiui: <tt>tekstas[2]</tt> duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "<tt>R</tt>". Speciali pjaustymo operacija <tt>tekstas[:]</tt> reiškia nuo pradžios iki pabaigos ir duodą visos tekstinės reikšmės ar sąrašo (list) kopiją.

Na ir galiausiai, pjaustymo operacija gali turėti ir trečią argumentą, kuris suprantamas, kaip „žingsnio dydis“: <tt>tekstas[::-1]</tt> yra <tt>tekstas</tt> nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "<tt>STRING</tt>" atvirkščiai yra "<tt>GNIRTS</tt>" (jeigu nesupratai, tai pabandyk prasitestuoti įrašydamas kaip žingsnio ilgį skaičių 2).

Visos šios pjaustymo operacijos veikia ir su sąrašais (lists). Šiuo atveju tekstinę reikšmę galime suprasti, kaip sąrašą, kai visi sąrašo elementai yra atskiros raidės. Iš šio skyriaus atsimink pagrindinį principą - į viską žiūrėk taip lyg karpytum, tai padės nesusipainioti įrašant indeksus.

Papasakojau tau apie pjaustymą, dabar laikas sužinoti, kaip sujungti sąrašą į vieną tekstinę eilutę. <code>join()</code> yra Python kalbos integruota funkcija, kuri naudojama sujungti kelis teksto fragmentus į vieną eilutę. Ji naudojama su teksto eilute kaip metodo argumentu ir jungia kiekvieną elementą iš sąrašo arba kolekcijos, naudojant tą eilutę kaip jungiamąjį simbolį. Pavyzdžiui:

<syntaxhighlight lang="python">
žodžiai = ["Sujungtas", "sakinys"]
sakinys = " ".join(žodžiai)
print(sakinys) # "Sujungtas sakinys"
</syntaxhighlight>

<syntaxhighlight lang="python">
žodžiai = ["Sujungtas", "sakinys"]
sakinys = ",".join(žodžiai)
print(sakinys) # "Sujungtas,sakinys"
</syntaxhighlight>

=== Daugiau naudingų tekstinės eilutės funkcijų ===

Čia yra keletas kitų dažniausiai naudojamų tekstinės eilutės metodų Python kalboje:

<syntaxhighlight lang="python">

tekstas = 'Čia yra tekstinė eilutė. '

# `upper` keičia visus simbolius eilutėje į didžiąsias raides.
tekstas.upper() # 'ČIA YRA TEKSTINĖ EILUTĖ.'

# `lower` keičia visus simbolius eilutėje į mažąsias raides.
tekstas.lower() # 'čia yra tekstinė eilutė.'

# `strip` pašalina tarpus iš eilutės pradžios ir pabaigos.
tekstas.strip() # 'Čia yra tekstinė eilutė.'

# `replace` keičia visus senos eilutės pasikartojimus nauja eilute.
senas = 'tekstinė'
naujas = 'pakeista'
tekstas.replace(senas, naujas) # 'Čia yra pakeista eilutė.'

# `find` grąžina pirmo pasikartojimo indeksą, arba -1 jei nerasta.
ieškomas_žodis = 'yra'
tekstas.find(ieškomas_žodis) # 4

# `startswith` grąžina 'true' jei eilutė prasideda su nurodytu priešdėliu.
priešdėlis = 'Čia'
tekstas.startswith(priešdėlis) # True

# `endswith` grąžina 'true' jei eilutė baigiasi su nurodyta priesaga.
priesaga = 'eilutė.'
tekstas.endswith(priesaga) # True

</syntaxhighlight>

Svarbu žinoti, kad šie metodai grąžina naują eilutę ir nekeičia originalios eilutės.

Pažiūrėkime iš arčiau į vieną iš šių metodų: <code>strip()</code> yra Python kalbos integruota funkcija, kuri naudojama pašalinti tarpus iš teksto eilutės pradžios ir/arba pabaigos. Jei nori pašalinti kitus simbolius, tau reikia nurodyti juos kaip papildomus argumentus funkcijai. Pavyzdžiui:

<syntaxhighlight lang="python">
tekstas = " Sveikas, Pasauli! "
švarus_tekstas = tekstas.strip()
print(švarus_tekstas) # "Sveikas, Pasauli!"
</syntaxhighlight>

<syntaxhighlight lang="python">
tekstas = "$$$Sveikas, Pasauli!$$$"
švarus_tekstas = tekstas.strip("$")
print(švarus_tekstas) # "Sveikas, Pasauli!"
</syntaxhighlight>

Taigi strip() funkcija leidžia pašalinti ne tik tarpus, bet ir kitus simbolius iš teksto eilutės pradžios ir/arba pabaigos.

=== Ar įvestas sveikasis skaičius? ===
Panagrinėkime paprastą kodą:
<syntaxhighlight lang="python">
#Ši programa patikrina ar įvestas sveikasis sakičius yra lyginis
skaičius = int(input("Sveikasis skaičius: "))
if (skaičius % 2) == 0:
print("Lyginis")
else:
print("Nelyginis")
</syntaxhighlight>Kas atsitiktų, jeigu įvestume ne skaičių, o pavyzdžiui žodį "pitonas"? Jei pabandytumn įvykdyti progamą, pamatytum, jog tokiu atveju įvyktų klaida. Kaip patikrinti ar įvestas tekstas yra skaičius? Tam galime panaudoti funkciją <code>isdecimal()</code> . Ši funkcija gražina ar teksto eilutę galime paversti į sveikąjį skaičių.
Aukšiau pateiktą, kodą galime patobulinti šitaip:

<syntaxhighlight lang="python">
#Ši programa patikrina ar įvestas sakičius yra lyginis
įvestas_skaičius = input("Sveikasis skaičius: ")
if įvestas_skaičius.isdecimal():
skaičius = int(įvestas_skaičius)
if (skaičius % 2) == 0:
print("Lyginis")
else:
print("Nelyginis")
else:
print("Įvedei ne sveikąjį skaičių")
</syntaxhighlight>

Išsiaiškinome kaip patikrinti ar teskto eilutę galime konvertuotį į sveikjį skaičių. O ką daryti jei norime patikrinit ar galime konvertutuoti į realųjį skaičių. Deja tokios paprastos funkcijos nėra, tad reikia naudoti kitokius metodus. Kaip tai padaryti pamatyri perskaitęs skyrių [[Vadovėlis/Siekiant tobulumo|Siekiant tobulumo]].

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa reikalauja dešimtainių skaičių supratimo.
def į_tekstą(į_skaičių):
"""Konvertuoja skaičių į tekstą"""
tekstas = ""
prefiksas = ""
if į_skaičių < 0:
prefiksas = "-"
į_skaičių = -į_skaičių
while į_skaičių // 10 != 0:
tekstas = str(į_skaičių % 10) + tekstas
į_skaičių= į_skaičių// 10
tekstas = str(į_skaičių % 10) + tekstas
return prefiksas + tekstas

def į_skaičių(į_tekstą):
"""Konvertuoja tekstą į skaičių"""
skaičius = 0
if į_tekstą[0] == "-":
daugiklis = -1
į_tekstą = į_tekstą[1:]
else:
daugiklis = 1
for c in į_tekstą:
skaičius = skaičius* 10 + int(c)
return skaičius * daugiklis

print(į_tekstą(2))
print(į_tekstą(23445))
print(į_tekstą(-23445))
print(į_skaičių("14234"))
print(į_skaičių("12345"))
print(į_skaičių("-3512"))
</syntaxhighlight>

Rezultatas:

2
23445
-23445
14234
12345
-3512

=== Pratimai ===
1. Parašyk programą, kuri sukonstruotų žodį iš pirmų 2 ir paskutinių 2 įvestos tekstinės eilutės simbolių. Pvz., įvedus “Moku programuoti pitonu”, programa turėtų išvesti “Monu”. Jei įvesta eilutė yra trumpesnė, nei du simboliai, turėtų būti išvedama tuščia eilutė.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
įvesta_eilutė = input("Įvesk tekstinę eilutę: ")

if len(įvesta_eilutė) < 2:
print("")
else:
print(įvesta_eilutė[:2] + įvesta_eilutė[len(įvesta_eilutė)-2:len(įvesta_eilutė)])
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri prašytų įvesti du žodžius ir išvestų tuos žodžius apverstus ir sujungtus tarpu. Pavyzdžiui, jei vartotojas įveda "Labas" ir "rytas", programa turėtų išvesti "sabaL satyr".

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
pirmas = input("Įvesk pirmą žodį: ")
antras = input("Įvesk antrą žodį: ")

pirmas_apverstas = pirmas[::-1]
antras_apverstas = antras[::-1]

sujungta = " ".join([pirmas_apverstas, antras_apverstas])

print(sujungta)
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri prašo vartotojo įvesti žodį arba sakinį. Tada programa turi pasakyti, ar įvestas žodis/sakinys yra palindromas (žodis, eilėraštis arba frazė, skaitomi iš kairės į dešinę ir iš dešinės į kairę, išlaikantys tą pačią prasmę. Pvz., lietuvių k. žodis savas, sakinys 'Abu gaišo po šia guba')

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">

žodis = input("Iveskite žodį")

def yra_palindromas(ž):
ž_nuo_galo = ""
for i in ž:
ž_nuo_galo = i + ž_nuo_galo
return ž_nuo_galo == ž

ats = yra_palindromas(žodis)

if ats:
print("Įvestas žodis yra palindromas")
else:
print("Įvestas žodis nėra palindromas")

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie sąrašus |next=Failų tvarkymas}}
{{BookCat}}

Vadovėlis/Žodynai

2023-02-27T14:52:43Z

Monika: /* Pratimai */

{{navigation |previous=Loginiai reiškiniai |next=Modulių naudojimas}}

Šis skyrius yra apie žodynus. Žodynai turi raktus ir reikšmes. Raktai naudojami reikšmėms rasti. Štai žodyno pavyzdys:
<syntaxhighlight lang="python">
def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu ()
while meniu_pasirinkimas != 5:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-5): "))
if meniu_pasirinkimas == 1:
print("Telefono numeriai: ")
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
print()
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
numeriai[vardas] = numeris
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas != 5:
print_menu()

</syntaxhighlight>

O čia - mano išvestis:

1. Spausdink telefonų numerius
2. Pridėk telefono numerį
3. Pašalink telefono numerį
4. Ieškok telefono numerio
5. Išeik

Įvesk skaičių (1-5): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Benas'''
Telefono numeris: '''869935951'''
Įvesk skaičių (1-5): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Liepa'''
Telefono numeris: '''869935952'''
Įvesk skaičių (1-5): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Markas'''
Telefono numeris: '''869935957'''
Įvesk skaičių (1-5): '''1'''
Telefono numeriai:
Vardas: Benas Telefono numeris: 869935951
Vardas: Liepa Telefono numeris: 869935952
Vardas: Markas Telefono numeris: 869935957

Įvesk skaičių (1-5): '''4'''
Ieškok telefono numerio
Vardas: '''Benas'''
Telefono numeris yra 869935951
Įvesk skaičių (1-5): '''3'''
Pašalink telefono numerį
Vardas: '''Markas'''
Įvesk skaičių (1-5): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 869935952
Vardas: Benas Telefono numeris: 869935951

Įvesk skaičių (1-5): '''5'''

Ši programa yra panaši į programą su vardų sąrašu, pateiktu prieš tai buvusiame skyriuje apie sąrašus. Štai kaip veikia programa. Pirmiausiai yra aprašoma funkcija <code>spausdink_meniu</code>. <code>spausdink_meniu</code> tiesiog spausdina meniu, kuris vėliau du kartus naudojamas programoje. Po to, pateikiama keistai atrodanti eilutė <code>numeriai = {}</code>. Ši eilutė Python'ui pasako, kad <code>numeriai</code> yra žodynas. Kitos kelios eilutės tiesiog padaro taip, kad meniu veiktų. Vykdydant ciklą:
<syntaxhighlight lang="python">
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
</syntaxhighlight>
einama per žodyną ir spausdinami žodyne esantys elementai. Funkcija <code> numeriai.keys()</code> grąžina žodyno elementų raktų sąrašą, kuris yra vėliau naudojamas <code>for</code> cikle. Sąrašas grąžinamas <code>keys()</code> metodo pagalba neturi jokio eiliškumo, todėl, jei tu nori, kad jis būtų abėcėlės tvarka, jis turi būti surūšiuotas. Taigi, šiuo atveju <code>x</code> yra tekstinė eilutė – vardai. Panašiai kaip sąrašai, komanda <code>numeriai[x]</code> naudojama norint pasiekti konkretų žodyno elementą. Šiuo atveju tai yra telefonų numeriai. Komanda <code>print</code> visa tai atspausdina.
<syntaxhighlight lang="python">
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
numeriai[vardas] = numeris
</syntaxhighlight>
Padarius kitą pasirinkimą, pirmiausiai paklausiamas vardas – tai bus žodyno elemento raktas, ir paklausiamas numeris. Toliau, komanda <code>numeriai[vardas] = telefonas</code> prideda vardą ir telefono numerį į žodyną. Jei <code>vardas</code> jau būtų buvęs žodyne, <code>telefonas</code> pakeistų prieš tai buvusią reikšmę.
Toliau sąlyginis sakinys
<syntaxhighlight lang="python">
if vardas in numeriai:
del numeriai[vardas]
</syntaxhighlight>
tikrina, ar vardas yra žodyne, ir jei yra, jį pašalina. Komanda <code>vardas in numeriai</code> grąžina loginę reikšmę <code>True</code>, jei <code>vardas</code> yra <code>numeriai</code> žodyne, bet kitu atveju grąžina <code>False</code>. Komanda <code>del numeriai[vardas]</code> pašalina raktą <code>vardas</code> ir su tuo raktu susietą reikšmę.
Sąlyginis sakinys
<syntaxhighlight lang="python">
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
</syntaxhighlight>
patikrina, ar žodynas turi tam tikrą raktą ir jei žodynas turi tą raktą, išspausdina su juo susietą numerį. Galiausiai, jei meniu pasirinkimas negalioja, pagrindinis meniu yra atspausdinamas, kad tu galėtum juo pasigrožėti.


Apibendrinimas: žodynai turi raktus ir reikšmes. Raktu gali būti tekstinė eilutė arba
skaičius. Raktai nurodo reikšmes. Reikšmės gali būti bet kokio tipo kintamieji
(įskaitant sąrašus ar net žodynus (žinoma, tuose žodynuose ar sąrašuose
gali būti patys žodynai ar sąrašai (baisu, ane? :-)
))). Štai yra pavyzdys, kai naudojamas sąrašas žodyne:

<syntaxhighlight lang="python">
max_taškai = [25, 25, 50, 25, 100]
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = {'#Max': max_taškai}

def spausdink_meniu():
print("1. Pridėk mokinį")
print("2. Pašalink mokinį")
print("3. Spausdink pažymius")
print("4. Įrašyk pažymį")
print("5. Spausdink meniu")
print("6. Išeik")

def spausdink_visus_pažymius():
print('\t', end=' ')
for i in range(len(užduotys)):
print(užduotys[i], '\t', end=' ')
print()
raktai = list(mokiniai.keys())
raktai.sort()
for x in raktai:
print(x, '\t', end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)

def spausdink_pažymius(pažymiai):
for i in range(len(pažymiai)):
print(pažymiai[i], '\t', end=' ')
print()

spausdink_meniu()
meniu_pasirinkimas = 0
while meniu_pasirinkimas != 6:
print()
meniu_pasirinkimas = int(input("Meniu pasirinkimas (1-6): "))
if meniu_pasirinkimas == 1:
vardas = input("Pridėk mokinį: ")
mokiniai[vardas] = [0] * len(max_taškai)
elif meniu_pasirinkimas == 2:
vardas = input("Pašalink mokinį: ")
if vardas in mokiniai:
del mokiniai[vardas]
else:
print("Vardas: ", vardas, " nebuvo rastas")
elif meniu_pasirinkimas == 3:
spausdink_visus_pažymius()
elif meniu_pasirinkimas == 4:
print("Įrašyk pažymį")
vardas = input("Mokinys: ")
if vardas in mokiniai:
pažymiai = mokiniai[vardas]
print("Įrašyk mokinio pažymį")
print("Įrašyk 0 (nulį), kad išeitum")
for i in range(len(užduotys)):
print(i + 1, užduotys[i], '\t', end=' ')
print()
spausdink_pažymius(pažymiai)
kuris = 1234
while kuris != -1:
kuris = int(input("Pakeisk kuris pažymį: "))
kuris -= 1 #tas pats kaip ir: kuris = kuris - 1
if 0 <= kuris < len(pažymiai):
pažymys = int(input("Pažymys: "))
pažymiai[kuris] = pažymys
elif kuris != -1:
print("Klaidingas pažymys")
else:
print("Mokinys nerastas")
elif meniu_pasirinkimas != 6:
spausdink_meniu()
</syntaxhighlight>

O štai čia yra išvestis:

1. Pridėk mokinį
2. Pašalink mokinį
3. Spausdink pažymius
4. Įrašyk pažymį
5. Spausdink meniu
6. Išeik

Meniu pasirinkimas (1-6): '''3'''
nd sk 1 nd sk 2 viktorina nd sk 3 testas
#Max 25 25 50 25 100

Meniu pasirinkimas (1-6): '''5'''
1. Pridėk mokinį
2. Pašalink mokinį
3. Spausdink pažymius
4. Įrašyk pažymį
5. Spausdink meniu
6. Išeik

Meniu pasirinkimas (1-6): '''1'''
Pridėk mokinį: '''Markas'''

Meniu pasirinkimas (1-6): '''4'''
Įrašyk pažymį
Mokinys: '''Markas'''
Įrašyk mokinio pažymį
Įrašyk 0 (nulį), kad išeitum
1 nd sk 1 2 nd sk 2 3 viktorina 4 nd sk 3 5 testas
0 0 0 0 0
Pakeisk kuris pažymį: '''1'''
Pažymys: '''25'''
Pakeisk kuris pažymį: '''2'''
Pažymys: '''24'''
Pakeisk kuris pažymį: '''3'''
Pažymys: '''45'''
Pakeisk kuris pažymį: '''4'''
Pažymys: '''23'''
Pakeisk kuris pažymį: '''5'''
Pažymys: '''95'''
Pakeisk kuris pažymį: '''0'''

Meniu pasirinkimas (1-6): '''3'''
nd sk 1 nd sk 2 viktorina nd sk 3 testas
#Max 25 25 50 25 100
Markas 25 24 45 23 95

Meniu pasirinkimas (1-6): '''6'''

Štai kaip veikia programa. Iš esmės, kintamasis <code>mokiniai</code> yra žodynas, kurio raktai yra mokinių vardai, o reikšmės – jų pažymiai. Pirmosios dvi eilutės tik sukuria du sąrašus.
Kita eilutė <code>mokiniai = {'#Max': max_taškai}</code> sukuria naują
žodyną su raktu {<code>#Max</code>}, o reikšmė yra <code>[25, 25, 50, 25, 100]</code> (pirmame sakinyje <code>max_taškai</code> buvo padarytas priskyrimas) (aš naudoju raktą <code>#Max</code>, nes rūšiuojant simolis <code>#</code> patenka prieš bet kokias abėcėlės raides). Toliau aprašoma funkcija <code>spausdink_meniu</code>. Kaip jau žinai, ji spausdina meniu.
Po to aprašoma funkcija <code>spausdink_visus_pažymius</code>:
<syntaxhighlight lang="python">
def spausdink_visus_pažymius():
print('\t',end=" ")
for i in range(len(užduotys)):
print(užduotys[i], '\t',end=" ")
print()
raktai = list(mokiniai.keys())
keys.sort()
for x in raktai:
print(x, '\t',end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
</syntaxhighlight>

Atkreipk dėmesį, į tai, kaip žodyno <code>mokiniai</code> raktai yra išimami į kintamąjį <code>raktai</code> su komanda <code>raktai = list(mokiniai.keys())</code>. Kintamasis <code>raktai</code> turės būti rūšiuojamas, todėl yra paverčiamas į sąrašą. Taip bus galima naudoti visas sąrašų funkcijas. Toliau raktai yra surūšiuojami eilutėje <code>raktai.sort()</code>. <code>for</code> yra naudojamas pereiti per visus raktus. Pažymiai yra saugomi kaip sąrašas žodyno viduje, todėl priskyrimas <code>pažymiai = mokiniai[x]</code> duoda <code>pažymiai</code> sąrašą, kuris yra saugomas su <code>x</code> raktu. Funkcija <code>spausdink_pažymius</code> tiesiog spausdina sąrašą ir yra aprašyta keliomis eilutėmis žemiau.

Tolimesnės programos eilutės įgyvendina įvairius meniu pasirinkimus. Eilutė <code>mokiniai[vardas] = [0] * len(max_taškai)</code> prideda mokinį į žodyną: <code>vardas</code> yra naujas raktas. Komanda <code>[0] * len(max_taškai)</code> tiesiog sukuria žodyno elementą – 0-ių sąrašą, kuris yra tokio pat ilgio kaip ir <code>max_taškai</code> sąrašas, kuriame vėliau bus sukelti pažymiai.

Pašalinti mokinį pasirinkimas tiesiog ištrina mokinį, panašiai kaip ir telefonų knygutės pavyzdyje.
Įrašyti mokinį pasirinkimas yra šiek tiek sudėtingesnis. Pažymiai yra gaunami komandinėje eilutėje
<code>pažymiai = mokiniai[vardas]</code>, ji gauna nuorodą į mokinio <code>vardas</code> pažymius. Tada pažymys yra įrašomas komanda <code>pažymiai[kuris] = pažymys</code>. Tu gali pastebėti, kad <code>pažymiai</code> niekada negrąžinami į mokinių žodyną (tokios komandos niekada nerašome: <code>mokiniai[vardas] = pažymiai</code>). Pakeisto pažymių sąrašo į žodyną grąžinti nereikia todėl, kad komanda <code>pažymiai[kuris] = pažymys</code> mes gauname ne realų sąrašą, o nuorodą į tą sąrašą, tada <code>pažymiai</code> iš tiesų yra tik kitas <code>mokiniai[vardas]</code> pavadinimas. Dėl to, keičiant <code>pažymiai</code> keičiasi ir <code>mokiniai[vardas]</code>.

Žodynai turi nesudėtingą metodą susieti raktus su reikšmėmis. Tai gali būti naudojama norint lengvai sekti duomenis, pridedamus prie įvairių raktų.

Pagrindinės operacijos su žodynu:
{| class="wikitable"
|+
!Funkcija
!Paaiškinimas
!Pavyzdys
|-
|keys()
|Gražina žodyno raktus
|print(žodynas.keys())
|-
|values()
|Gražina žodyno reikšmes
|print(žodynas.values())
|-
|del
|Pašalina elementą iš žodyno
|del žodynas[raktas]
|-
|in
|Patikrina ar žodynas turi elementą su nurodytu raktu
|(raktas in žodynas) == True
|-
|not in
|Patikrina ar žodynas neturi elemento su nurodytu raktu
|(raktas not in žodynas) == False
|-
|len
|Gražina žodyno elementų kiekį
|print(len(žodynas))
|-
|clear
|Pašalina visą žodyno turinį
|len(clear(žodynas))==0
|-
|list
|Gražina žodyno raktus, kaip sąrašą
|print(list(žodynas))
|-
|sorted
|Gražina surūšiuotus žodyno raktus, kaip sąrašą
|print(sorted(žodynas))
|}

=== Pratimai ===
1. Parašyk programą, kuri sukurtų žodyną, kurio raktas būtų skaičiai nuo 1 iki 10, o vertė - raktas pakeltas antruoju laipsniu.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
žodynas = {}

for skaičius in range(1, 11):
žodynas[skaičius] = skaičius * skaičius

print(žodynas)
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri patikrintų, ar įvestas raktas jau egzistuoja žodyne.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
žodynas = {"raktas 1": "reikšmė 1", "raktas 2": "reikšmė 2"}

tikrinamas_raktas = input("Įvesk raktą patikrinimui: ")

if tikrinamas_raktas in žodynas.keys():
print("Raktas egzistuoja")
else:
print("Tokio rakto nėra")
</syntaxhighlight>
|-
|}

3. Parašyk balsų skaičiavimo programą, kurioje tu vedi vardus tol, kol yra įvedamas žodis "pabaiga". Tada programa išveda, visus vardus ir kiek kartų jis buvo įvestas.

Įvesits:

Benas, Liepa, Benas, Benas, Benas, Jonas, Liepa

Išvestis:

<syntaxhighlight lang="python">
Benas 4
Liepa 2
Jonas 1
</syntaxhighlight>

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
balsai = dict()
vardas = str()

def balsuoti(naujasBalsas, balsai):
if naujasBalsas in balsai:
balsai[naujasBalsas] += 1
else:
if naujasBalsas != "pabaiga":
balsai[naujasBalsas] = 1

while vardas != "pabaiga":
print("Įrašyk vardą ir spausk 'enter' klavišą")
vardas = input()
balsuoti(vardas, balsai)

print(balsai)
</syntaxhighlight>
|-
|}

{{navigation |previous=Loginiai reiškiniai |next=Modulių naudojimas}}
{{BookCat}}

Vadovėlis/Žodynai

2023-02-27T14:52:09Z

Monika: Pridėta papildomų pratimų

Vadovėlis/Daugiau apie tekstines eilutes

2023-01-27T10:49:20Z

Monika: Naujos dalies proofreadinimas

{{navigation |previous=Daugiau apie sąrašus |next=Failų tvarkymas}}
{{BookCat}}

Šiame skyriuje pamatysi, kiek šaunių dalykų galime padaryti su tekstine reikšme:

<syntaxhighlight lang="python">
def rėk(tekstinė_reikšmė):
for raidė in tekstinė_reikšmė:
print("Duok man " + raidė)
print("'" + raidė + "'")

rėk("Ačiū")

def vidurys(tekstas):
print("Raidė esanti viduryje yra:", tekstas[len(tekstas) // 2])

vidurys("abcdefg")
vidurys("The Python Programming Language")
vidurys("Atlanta")
</syntaxhighlight>

Rezultatas:

Duok man A
'A'
Duok man č
'č'
Duok man i
'i'
Duok man ū
'ū'
Raidė esanti viduryje yra: d
Raidė esanti viduryje yra: r
Raidė esanti viduryje yra: a

Šios dvi programos rodo, kad tekstinė reikšmė (string) yra keliais aspektais panaši į sąrašą (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad su tekstine reikšme galima naudoti sąrašo funkciją <code>len()</code>, taip pat sąrašo indeksavimu ir pjaustymu. Taigi, dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

Kita šio skyriaus funkcija parodo tam tikras tekstinės reikšmės ypatybes:
<syntaxhighlight lang="python">
def pavertimas_didžiosiomis_raidėmis(tekstas):
## Ši funkcija, tekstinę reikšmę užrašo didžiosiomis raidėmis
didžiosios_raidės = ""
for raidė in tekstas:
if 'a' <= raidė <= 'z':
lokacija = ord(raidė) - ord('a')
naujas_ascii = lokacija + ord('A')
raidė= chr(naujas_ascii)
didžiosios_raidės = didžiosios_raidės + raidė
return didžiosios_raidės

print(pavertimas_didžiosiomis_raidėmis("Įrašytas tekstas"))
</syntaxhighlight>

Rezultatas:

ĮRAŠYTAS TEKSTAS

Tai veikia, nes kompiuteris tekstinės reikšmės simbolius šifruoja skaičiais nuo 0 iki 1 114 111. Visos šios tekstinės reikšmės turi savo unikalias unikodo reikšmes. Pavyzdžiui, simboliui „A“ yra priskirtas skaičius 65, simbolis „B“ kompiuterio suprantamas kaip 66, o simbolis א yra 1488. Visi simboliai yra tarsi surikiuoti ir turi savo eilės numerį. Python'o programavimo kalba turi funkciją, vadinamą <code>ord()</code> (trumpinys angliško žodžio ordinal, kuris reiškia iš eilės), kuri grąžina simbolio skaičių (eilės numerį_. Taip pat Python'o programavimo kalba turi ir atvirkščią funkciją, vadinamą <code>chr()</code>, kuri skaičių paverčia simboliu. Supratus, kaip veikia šios funkcijos aukščiau užrašyta programa turėtų atrodyti logiška.

Programos pirmoji eilutė <code>if 'a' <= simbolis <= 'z':</code> patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės:
Pirmiausia eilutė <code>lokacija= ord(simbolis) - ord('a')</code> nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t.
Tada nauja reikšmė randama su kodo eilute <code>naujas_ascii = lokacija + ord ('A')</code>.
Tada ši reikšmė paverčiama atgal į simbolį, kuris dabar yra didžioji raidė.

Žinoma, tai tik programos pavyzdys, tačiau daug paprasčiau tai padaryti naudojantis funkcija <code>tekstoEilutė.upper()</code>, kuri veikia su visomis kalbomis.

O dabar pabandykime pasižiūrėti į šį pavyzdį:

>>> '''# Skaičius į tekstinę reikšmę'''
>>> '''2'''
2
>>> '''str(2)'''
'2'
>>> '''-123'''
-123
>>> '''str(-123)'''
'-123'
>>> '''# Tekstinė reikšmė į skaičių'''
>>> '''"23"'''
'23'
>>> '''int("23")'''
23
>>> '''"23" * 2'''
'2323'
>>> '''int("23") * 2'''
46
>>> '''# Skaičius po kablelio į tekstinę reikšmę'''
>>> '''1.23'''
1.23
>>> '''str(1.23)'''
'1.23'
>>> '''# Skaičius po kablelio į skaičių'''
>>> '''1.23'''
1.23
>>> '''int(1.23)'''
1
>>> '''int(-1.23)'''
-1
>>> '''# Tekstinė reikšmė į skaičių po kablelio'''
>>> '''float("1.23")'''
1.23
>>> '''"1.23"'''
'1.23'
>>> '''float("123")'''
123.0

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę (skaičiai suprantami, kaip simblių seka), o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į sveikąjį skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į dešimtainį skaičių (skaičių su kableliu). Grįžtant prie funkcijos <code>str()</code> – ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

>>> '''str(1)'''
'1'
>>> '''str(234.14)'''
'234.14'
>>> '''str([4, 42, 10])'''
'[4, 42, 10]'

Funkcija <code>int()</code> konvertuoja tekstinę reikšmę (ar dešimtainė skaičių) į sveikąjį skaičių. Panaši funkcija <code>float</code> konvertuoja skaičių ar tekstinę reikšmę į dešimtainį skaičių. Taip pat Python'o programavimo kalba turi funkciją <code>type()</code>, kuri grąžina kintamojo reikšmės tipą. Pavyzdžiui:

<syntaxhighlight lang="python">
v = '123'
print(type(v))
# <class 'str'>

v = 645.123
print(type(v))
# <class 'float'>

v = [1, 2, 3]
print(type(v))
# <class 'list'>
</syntaxhighlight>

Naudojant funkciją <code>type()</code> pasitikrink, ar grąžinamas toks reikšmės tipas, kurio tikėjaisi.

Taip pat naudingas ir dažnai paprastose užduotyse naudojama funkcija <code>split()</code>:

>>> '''"Čia yra tik žodžių kratinys".split()'''
['Čia', 'yra', 'tik', 'žodžių', 'kratinys']
>>> '''tekstas= "Pirma partija, antra partija, trečia, ketvirta"'''
>>> '''tekstas.split(",")'''
['Pirma partija', ' antra partija', ' trečia', ' ketvirta']

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Kai funkcijai nenurodytas argmentas – skyriklis, pagal ką suskirstyti į skirtingus sąrašo elementus, funkcija skirsto pagal tarpus. Antrame pavyzdyje skyriklis yra kablelis.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

>>> '''sąrašas= tekstas.split(",")'''
>>> '''len(sąrašas)'''
4
>>> '''sąrašas[-1]'''
' ketvirta'
>>> '''sąrašas = tekstas.split(",", 2)'''
>>> '''len(sąrašas)'''
3
>>> '''sąrašas[-1]'''
' trečia, ketvirta'


=== Tekstinės (ir sąrašo) reikšmės pjaustymas ir sujungimas ===

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje su sąrašais, kai laužtiniuose skliaustuose <code>[]</code> buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: <code>tekstas[pradžios_indeksas:pabaigos_indeksas]</code> (retais atvejais galime pridėti dar ir trečią argumentą, kaip apačioje esančiame pavyzdyje).

Kad nesusipainiotum įrašydamas indekso skaičius, įsivaizduok, kad žirklėmis karpai tekstą, o programai nurodai, kurioje vietoje kirpti. Štai vienas pavyzdys, kaip tai viekia – geltonai pažymėtos kirpimo vietos, o raudonai ir mėlynai indekso numeris

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | -2
| style="width:2ex" |
| style="width:2ex;color:blue" | -1
| style="width:2ex" |
| style="width:2ex" |
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
|-
| tekstas =
|"
| style="background:#FFFF88" |
!S
| style="background:#FFFF88" |
!T
| style="background:#FFFF88" |
!R
| style="background:#FFFF88" |
!I
| style="background:#FFFF88" |
!N
| style="background:#FFFF88" |
!G
| style="background:#FFFF88" |
|"
|-
|
|
| style="background:#FFFF88" |↑
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |↑
|
|-
|
|
|[:
|
|
|
|
|
|
|
|
|
|
|
|:]
|
|}
</tt>

Įsidėmėk, kad raudonai pažymėti indeksai skaičiuojami nuo pradžios, o mėlyni atvirkščiai nuo kito galo t.y. teksto pabaigos. Taip pat ar pastebėjai, kad skaičiuojant nuo galo nėra -0 reikšmės? Taip yra todėl, kad 0 visada priskiriamas tik reikšmės pradžiai:

<tt>
{|
|-
|tekstas[1:4] || style="width:3em;text-align:center" | → || "TRI"
|-
|tekstas[:5] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[:-1] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[-4:] || style="width:3em;text-align:center" | → || "RING"
|-
|tekstas[2] || style="width:3em;text-align:center" | → || "R"
|-
|tekstas[:] || style="width:3em;text-align:center" | → || "STRING"
|-
|tekstas[::-1] || style="width:3em;text-align:center" | → || "GNIRTS"
|}
</tt>

<tt>tekstas[1:4]</tt> duoda visas <tt>tekstas</tt> reikšmes tarp 1 ir 4, "<tt>TRI</tt>". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: <tt>tekstas[:5]</tt> atspausdina"<tt>STRIN</tt>". Taip pat, tiek su <tt>pradžios_indeksas</tt>, tiek su <tt>pabaigos_indeksas</tt> galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: <tt>tekstas[:-1]</tt> duoda tą patį rezultatą kaip <tt>tekstas[:5]</tt>, todėl, kad indekas -1 šiame žodyje yra toje pačioje vietoje kaip indeksas 5. Jeigu nenaudojame argumento kartu su dvitaškiu, tai skaičius traktuojamas kitaip, pavyzdžiui: <tt>tekstas[2]</tt> duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "<tt>R</tt>". Speciali pjaustymo operacija <tt>tekstas[:]</tt> reiškia nuo pradžios iki pabaigos ir duodą visos tekstinės reikšmės ar sąrašo (list) kopiją.

Na ir galiausiai, pjaustymo operacija gali turėti ir trečią argumentą, kuris suprantamas, kaip „žingsnio dydis“: <tt>tekstas[::-1]</tt> yra <tt>tekstas</tt> nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "<tt>STRING</tt>" atvirkščiai yra "<tt>GNIRTS</tt>" (jeigu nesupratai, tai pabandyk prasitestuoti įrašydamas kaip žingsnio ilgį skaičių 2).

Visos šios pjaustymo operacijos veikia ir su sąrašais (lists). Šiuo atveju tekstinę reikšmę galime suprasti, kaip sąrašą, kai visi sąrašo elementai yra atskiros raidės. Iš šio skyriaus atsimink pagrindinį principą - į viską žiūrėk taip lyg karpytum, tai padės nesusipainioti įrašant indeksus.

Papasakojau tau apie pjaustymą, dabar laikas sužinoti, kaip sujungti sąrašą į vieną tekstinę eilutę. <code>join()</code> yra Python kalbos integruota funkcija, kuri naudojama sujungti kelis teksto fragmentus į vieną eilutę. Ji naudojama su teksto eilute kaip metodo argumentu ir jungia kiekvieną elementą iš sąrašo arba kolekcijos, naudojant tą eilutę kaip jungiamąjį simbolį. Pavyzdžiui:

<syntaxhighlight lang="python">
žodžiai = ["Sujungtas", "sakinys"]
sakinys = " ".join(žodžiai)
print(sakinys) # "Sujungtas sakinys"
</syntaxhighlight>

<syntaxhighlight lang="python">
žodžiai = ["Sujungtas", "sakinys"]
sakinys = ",".join(žodžiai)
print(sakinys) # "Sujungtas,sakinys"
</syntaxhighlight>

=== Daugiau naudingų tekstinės eilutės funkcijų ===

Čia yra keletas kitų dažniausiai naudojamų tekstinės eilutės metodų Python kalboje:

<syntaxhighlight lang="python">

tekstas = 'Čia yra tekstinė eilutė. '

# `upper` keičia visus simbolius eilutėje į didžiąsias raides.
tekstas.upper() # 'ČIA YRA TEKSTINĖ EILUTĖ.'

# `lower` keičia visus simbolius eilutėje į mažąsias raides.
tekstas.lower() # 'čia yra tekstinė eilutė.'

# `strip` pašalina tarpus iš eilutės pradžios ir pabaigos.
tekstas.strip() # 'Čia yra tekstinė eilutė.'

# `replace` keičia visus senos eilutės pasikartojimus nauja eilute.
senas = 'tekstinė'
naujas = 'pakeista'
tekstas.replace(senas, naujas) # 'Čia yra pakeista eilutė.'

# `find` grąžina pirmo pasikartojimo indeksą, arba -1 jei nerasta.
ieškomas_žodis = 'yra'
tekstas.find(ieškomas_žodis) # 4

# `startswith` grąžina 'true' jei eilutė prasideda su nurodytu priešdėliu.
priešdėlis = 'Čia'
tekstas.startswith(priešdėlis) # True

# `endswith` grąžina 'true' jei eilutė baigiasi su nurodyta priesaga.
priesaga = 'eilutė.'
tekstas.endswith(priesaga) # True

</syntaxhighlight>

Svarbu žinoti, kad šie metodai grąžina naują eilutę ir nekeičia originalios eilutės.

Pažiūrėkime iš arčiau į vieną iš šių metodų: <code>strip()</code> yra Python kalbos integruota funkcija, kuri naudojama pašalinti tarpus iš teksto eilutės pradžios ir/arba pabaigos. Jei nori pašalinti kitus simbolius, tau reikia nurodyti juos kaip papildomus argumentus funkcijai. Pavyzdžiui:

<syntaxhighlight lang="python">
tekstas = " Sveikas, Pasauli! "
švarus_tekstas = tekstas.strip()
print(švarus_tekstas) # "Sveikas, Pasauli!"
</syntaxhighlight>

<syntaxhighlight lang="python">
tekstas = "$$$Sveikas, Pasauli!$$$"
švarus_tekstas = tekstas.strip("$")
print(švarus_tekstas) # "Sveikas, Pasauli!"
</syntaxhighlight>

Taigi strip() funkcija leidžia pašalinti ne tik tarpus, bet ir kitus simbolius iš teksto eilutės pradžios ir/arba pabaigos.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa reikalauja dešimtainių skaičių supratimo.
def į_tekstą(į_skaičių):
"""Konvertuoja skaičių į tekstą"""
tekstas = ""
prefiksas = ""
if į_skaičių < 0:
prefiksas = "-"
į_skaičių = -į_skaičių
while į_skaičių // 10 != 0:
tekstas = str(į_skaičių % 10) + tekstas
į_skaičių= į_skaičių// 10
tekstas = str(į_skaičių % 10) + tekstas
return prefiksas + tekstas

def į_skaičių(į_tekstą):
"""Konvertuoja tekstą į skaičių"""
skaičius = 0
if į_tekstą[0] == "-":
daugiklis = -1
į_tekstą = į_tekstą[1:]
else:
daugiklis = 1
for c in į_tekstą:
skaičius = skaičius* 10 + int(c)
return skaičius * daugiklis

print(į_tekstą(2))
print(į_tekstą(23445))
print(į_tekstą(-23445))
print(į_skaičių("14234"))
print(į_skaičių("12345"))
print(į_skaičių("-3512"))
</syntaxhighlight>

Rezultatas:

2
23445
-23445
14234
12345
-3512

=== Pratimai ===
Parašyk programą, kuri prašo vartotojo įvesti žodį arba sakinį. Tada programa turi pasakyti, ar įvestas žodis/sakinys yra palindromas (žodis, eilėraštis arba frazė, skaitomi iš kairės į dešinę ir iš dešinės į kairę, išlaikantys tą pačią prasmę. Pvz., lietuvių k. žodis savas, sakinys 'Abu gaišo po šia guba')

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">

žodis = input("Iveskite žodį")

def yra_palindromas(ž):
ž_nuo_galo = ""
for i in ž:
ž_nuo_galo = i + ž_nuo_galo
return ž_nuo_galo == ž

ats = yra_palindromas(žodis)

if ats:
print("Įvestas žodis yra palindromas")
else:
print("Įvestas žodis nėra palindromas")

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie sąrašus |next=Failų tvarkymas}}
{{BookCat}}

Vadovėlis/Loginiai reiškiniai

2023-01-24T16:06:28Z

Monika: Pridėta užduočių

{{navigation |previous=Ciklai For |next=Žodynai}}
Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina:
<syntaxhighlight lang="python">
a = 6
b = 7
c = 42
print(1, a == 6)
print(2, a == 7)
print(3, a == 6 and b == 7)
print(4, a == 7 and b == 7)
print(5, not a == 7 and b == 7)
print(6, a == 7 or b == 7)
print(7, a == 7 or b == 6)
print(8, not (a == 7 and b == 6))
print(9, not a == 7 and b == 6)
</syntaxhighlight>

Šios programos išvestis yra:

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

Galvoje, turbūt, jau sukasi mintis: kas čia ką tik įvyko? Paaiškinsiu, kaip veikia kiekviena eilutė, kad mintys susidėliotų į savas vietas. Mano programoje gausu <code>print</code> sakinių, iš kurių kiekvienas išspausdina skaičių ir loginę reikšmę. Skaičius man padeda suprasti, kurio <code>print</code> sakinio rezultatas tai yra. Atkreipk dėmesį, kad kiekvienoje išvesties eilutėje yra žodis <code>False</code> (Klaidinga) arba <code>True</code> (Teisinga), o Python'e kiekviena loginė reikšmė <code>False</code> gali būti užrašoma skaičiumi 0, o <code>True</code> 1.

















Eilučių:

<syntaxhighlight lang="python">
print(1, a == 6)
print(2, a == 7)
</syntaxhighlight>

rezultatas atitinkamai yra <code>True</code> ir <code>False</code>, kadangi pirmasis reiškinys yra teisingas, o antrasis yra klaidingas. Trečioji eilutė: <code>print(3, a == 6 and b == 7)</code> - šiek tiek skiriasi nuo prieš tai buvusių - joje yra naudojamas operatorius <code>and</code>. Loginis operatorius <code>and</code> grąžina rezultatą <code>True</code> tik tada, kai reiškiniai iš abiejų <code>and</code> pusių yra teisingi, kitu atveju visas reiškinys bus klaidingas ir grąžins <code>False</code>. Ketvirtoje eilutėje: print(4, a == 7 and b == 7) tik vienas iš reiškinių yra teisingas, dėl to eilutės rezultatas yra <code>False</code>. Operatoriaus <code>and</code> galimi rezultatai gali būti apibrėžti tokia lentele:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>and</code> True
|True
|-
|True <code>and</code> False
|False
|-
|False <code>and</code> True
|False
|-
|False <code>and</code> False
|False
|}

Atkreipk dėmesį, jei pirmas reiškinys yra klaidingas, tai Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys yra klaidingas. Parašyk šias eilutes ir paleisk programą: <code>False and print("Labas")</code> ir palygink rezultatą su šios eilutės <code>True and print("Labas")</code> rezultatu. Techniškai tai yra vadinama sutrumpintos grandies įvertinimas (short-circuit evaluation).
Penktoje eilutėje, <code>print(5, not a == 7 and b == 7)</code>, yra naudojamas <code>not</code> operatorius. <code>not</code> suteikia priešingą reikšmę reiškiniui (reiškinys taip pat galėtų būti užrašomas taip: <code> print(5, a != 7 and b == 7)</code>). Štai lentelė apibrėžianti operatoriaus <code>not</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|<code>not</code> True
|False
|-
|<code>not</code> False
|True
|}

Dvi toliau pateiktos eilutės: <code>print(6, a == 7 or b == 7)</code> ir <code>print(7, a == 7 or b == 6)</code> naudoja operatorių <code>or</code>. Pastarasis operatorius grąžina <code>True</code> jei pirmasis reiškinys yra teisingas arba, jei antrasis reiškinys yra teisingas, arba, jei abu reiškiniai yra teisingi. Jei nei vienas iš reiškinių nėra teisingas, tuomet yra grąžinamas False. Štai lentelė apibrėžianti operatoriaus <code>or</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>or</code> True
| True
|-
|True <code>or</code> False
|True
|-
|False <code>or</code> True
|True
|-
|False <code>or</code> False
| False
|}

Turėk omeny, jei pirmasis reiškinys yra teisingas Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys bus teisingas. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code>, jei bent vienas iš reiškinių yra teisingas, tuomet viso reiškinio galutinis rezultatas bus teisingas. Pirmoji dalis yra teisinga, todėl antroji dalis gali būti klaidinga arba teisinga, tačiau visa išraiška vis dar teisinga.

Aštuntoje: <code>print(8, not (a == 7 and b == 6))</code> ir devintoje: <code>print(9, not a == 7 and b == 6)</code> eilutėse yra atvaizduojamas reiškinių grupavimo pavyzdys. Reiškinius Python’e galima sugrupuoti naudojant skliaustelius. Sugrupavę reiškinius, mes priverčiame Python’ą iš pradžių įvertinti reiškinius skliaustuose ir tik tada likusias reiškinio dalis. Atkreipk dėmesį, kad skliausteliai pakeitė reiškinį iš neteisingo į teisingą. Taip nutiko dėl to, kad operatorius <code>not</code> buvo pritaikytas reiškiniui skliausteliuose, vietoj to, kad būtų pritaikytas tik <code>a == 7</code> daliai.
Parodysiu pavyzdį, kaip rašant kodą galima pritaikyti loginius operatorius:

<syntaxhighlight lang="python">
sąrašas = ["Gyvenimas", "Visata", "Viskas", "Benas", "Liepa", "Gyvenimas", "Liepa"]

# kuriama sąrašo kopija. Peržiūrėk skyrių Daugiau apie sąrašus, kuriame sužinosi ką reiškia [:].
kopija = sąrašas[:]
# surūšiuoti sąrašą
kopija.sort()
ankstesnis = kopija[0]
del kopija[0]

kiekis = 0

# sąraše surask vienodus elementus
while kiekis < len(kopija) and kopija[kiekis] != ankstesnis:
ankstesnis = kopija[kiekis]
kiekis = kiekis + 1

# Jei nėra atitikmens tuomet kiekis negali būti < len
# kadangi ciklas kol bus vykdomas tol, kol kiekis < len
# ir nėra rastas atitikmuo

if kiekis < len(kopija):
print("Pirmasis atitikmuo:", ankstesnis)
</syntaxhighlight>

Šios programos rezultatas:
Pirmasis atitikmuo: Gyvenimas

Programa ieško vienodų elementų, tikrindama šią sąlygą: <code> while kiekis < len(kopija) and kopija[kiekis] nėra lygus ankstesnis </code>. Kai <code>kiekis</code> yra didesnis už paskutinio <code>kopija</code> sąrašo elemento indeksą arba, kai atsiranda sutampantis elementas, operatorius <code>and</code> nebėra tiesa, todėl ciklas pasibaigia. <code>if</code> sakinys patikrina ar ciklas <code>while</code> pasibaigė dėl to, kad buvo rastas sutampantis elementas.

Šioje programoje yra panaudotas dar vienas <code>and</code> operatoriaus „triukas“. Jei dar kartą pažiūrėsi į operatoriaus <code>and</code> lentelę pamatysi, jog trečioje eilutėje yra netiesa ir netiesa. Jei <code>kiekis >= len(kopija)</code> (kitais žodžiais, jei <code>kiekis < len(kopija)</code> yra <code>False</code>), tada kodo dalis <code>kopija[kiekis]</code> nebus tikrinama. Taip yra todėl, kad Python’as žino, jei pirmasis teiginys yra klaidingas, tai abu jie nebegali būti teisingi. Šis „short circuit“ triukas yra naudingas tuomet, kai antrasis <code>and</code> operatoriaus reiškinys gali sukelti klaidą. Aš panaudojau pirmąjį reiškinį (<code>kiekis < len(kopija)</code>), kad patikrinčiau ar kintamasis <code>kiekis</code> yra validus sąrašo <code>kopija</code> indeksas. Jei manimi netiki, tuomet ištrink iš sąrašo elementus „Liepa“ ir „Gyvenimas“, sukeisk vietomis sąlygas <code>kiekis < len(kopija) and kopija[kiekis] != ankstesnis</code> (rašyk: <code>kopija[kiekis] != ankstesnis and kiekis < len(kopija)</code>) ir patikrink ar programa vis dar veikia, kaip turėtų.

Loginiai operatoriai gali būti naudojami, kai mes norime patikrinti dvi arba daugiau skirtingų sąlygų vienu metu.

=== Pastaba apie loginius operatorius ===
Dažna pradedančiųjų programuotojų klaida yra neteisingas supratimas, kaip veikia loginiai operatoriai ir kaip juos „skaito“ Python'o interpretatorius. Pavyzdžiui: vos tik sužinojus apie operatorius <code>and</code> ir <code>or</code>, galima pagalvoti, kad išraiška <code>x == ('a' or 'b')</code> patikrins, ar kintamasis <code>x</code> yra lygus <code>a</code> arba kintamasis <code>x</code> lygus <code>b</code>, tačiau taip nėra. Norint suprasti, apie ką kalbu, pradėk interaktyvią sesiją su interpretatoriumi ir įvesk šias išraiškas:

>>> 'a' == ('a' or 'b')
>>> 'b' == ('a' or 'b')
>>> 'a' == ('a' and 'b')
>>> 'b' == ('a' and 'b')

Štai yra rezultatai, kurie nėra intuityvūs:

>>>''' 'a' == ('a' or 'b')'''
True
>>>''' 'b' == ('a' or 'b')'''
False
>>>''' 'a' == ('a' and 'b')'''
False
>>>''' 'b' == ('a' and 'b')'''
True

Šiuo momentu gali pasirodyti, jog operatoriai <code>and</code> ir <code>or</code> veikia klaidingai. Neatrodo logiška, jog pirmuose reiškiniuose <code>'a'</code> yra lygu <code>'a'</code> arba <code>'b'</code>, tačiau <code>'b'</code> nėra lygu <code>'a'</code> arba <code>'b'</code>. Taip pat yra ir su paskutiniu reiškiniu - jis neatrodo teisingas, nes <code>'b'</code> yra lygus <code>'a'</code> ir <code>'b'</code>. Išsiaiškinus, kaip veikia Python’o interpretatorius pasidaro aišku, kodėl gavome būtent tokius rezultatus.

Kai Python’o interpretatorius „pamato“ reiškinį, kuriame yra naudojamas <code>or</code>, jis paima pirmąjį teiginį ir patikrina ar jo rezultatas yra <code>True</code>. Jei pirmasis teiginys yra <code>True</code>, tuomet Python’as grąžina to teiginio rezultatą, netikrindamas antrojo. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code> užtenka patikrinti ar pirmasis teiginys yra teisingas, nes tada mes jau žinome, kad visas reiškinys yra teisingas ir programai nebereikia papildomai tikrinti antrojo. Iš kitos pusės, jei pirmasis teiginys grąžina <code>False</code>, tada Python’as turi patikrinti ir antrojo teiginio rezultatą bei grąžinti jo reikšmę. Antrasis teiginys nusako visos išraiškos rezultatą, kadangi pirmoji pusė buvo klaidinga. Šis interpretatoriaus „tingus“ įvertinimas vadinamas "short circuiting" ir yra įprastas būdas įvertinti logines išraiškas daugelyje programavimo kalbų.

Panašiai veikia ir operatorius <code>and</code>: Python’as naudoja, "short circuit" techniką, kad pagreitintų išraiškos įvertinimą. Jei pirmasis teiginys yra klaidingas, tada visas reiškinys yra klaidingas. Kitu atveju, jei pirmasis teiginys yra teisingas, tada Python’as patikrina antrąjį ir grąžina galutinę reikšmę.

Reiktų atkreiptį dėmesį į vieną niuansą: ne tik loginių išraiškų rezultatai gali būti apibrėžiami <code>True</code> arba <code>False</code> reikšmėmis. Norėdami patikrinti bet kurio objekto <code>x</code> loginę reikšmę, galite naudoti funkciją <code>bool(x)</code>. Žemiau yra pateikiama lentelė, kurioje yra pavyzdžiai, kokiems objektams Python’as priskiria <code>True</code> arba <code>False</code>:

{| class="wikitable"
|-
!True !!False
|-
|True ||False
|-
|1 ||0
|-
|Skaičiai kitokie nei nulis ||Tekstinė eilutė 'None'
|-
|Ne tuščios tekstinės eilutės ||Tuščios tekstinės eilutės
|-
|Sąrašai (lists) turintys elementų ||Sąrašai (lists) neturintys elementų
|-
|Žodynai (dictionaries) turintys elementų ||Žodynai (dictionaries) neturintys elementų
|}

Dabar galime suprasti gluminančius rezultatus, kuriuos gavome, kai anksčiau išbandėme logines išraiškas. Pažiūrėkime, ką Python'o interpretatorius „mato“, eidamas per šį kodą:

'''Pirmasis atvejis:'''
>>>''' 'a' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'a' == 'a' ''' # teksto eilutė 'a' yra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra True
True

'''Antrasis atvejis:'''
>>>''' 'b' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'b' == 'a' ''' # teksto eilutė 'b' nėra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra False
False

'''Trečiasis atvejis:'''
>>>''' 'a' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' and 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'a' == 'b' ''' # teksto eilutė 'a' nėra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra False
False

'''Ketvirtasis atvejis:'''
>>>''' 'b' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose:
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'b' == 'b' ''' # teksto eilutė 'b' yra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra True
True

Taigi, Python’as tikrai teisingai įvertino duotuosius reiškinius, kurių rezultatai iš pradžių neatrodė akivaizdūs. Kaip minėjau anksčiau, svarbu atpažinti, kokį rezultatą tavo loginė išraiška grąžins ir kodėl.

Grįžtant prie pradinių reiškinių, štai kaip juos turėtum aprašyti, kad jie grąžintų reikšmes, kurių tikiesi:

>>>''' 'a' == 'a' or 'a' == 'b' '''
True
>>>''' 'b' == 'a' or 'b' == 'b' '''
True
>>>''' 'a' == 'a' and 'a' == 'b' '''
False
>>>''' 'b' == 'a' and 'b' == 'b' '''
False

Įvertinus šiuos reiškinius yra gaunamos logines reikšmes <code>True</code> arba <code>False</code>, o ne teksto eilutės, kad galėtume gauti teisingus palyginimo rezultatus.

=== Pavyzdžiai ===
'''slaptazodis1.py'''
<syntaxhighlight lang="python">
## Ši programa prašo vartotojo prisijungimo vardo ir slaptažodžio.
# Kai vartotojas juos įveda, programa įvertina ar jis gali prisijungti.

vardas = input("Koks tavo vardas? ")
slaptažodis = input("Koks tavo slaptažodis? ")
if vardas == "Benas" and slaptažodis == "Penktadienis":
print("Sveikas, Benai!")
elif vardas == "Jonas" and slaptažodis == "Kietas":
print("Sveikas, Jonai!")
else:
print("Aš tavęs nepažįstu.")
</syntaxhighlight>

Pavyzdiniai rezultatai:

Koks tavo vardas? '''Benas'''

Koks tavo slaptažodis? '''Penktadienis'''

Sveikas, Benai!

Koks tavo vardas? '''Andrius'''

Koks tavo slaptažodis? '''Pinigai'''

Aš tavęs nepažįstu.

=== Pratimai ===
1. Parašyk programą, kurioje vartotojas turi atspėti tavo vardą, tačiau jie turės tik 3 spėjimus tai padaryti iki kol programa bus uždaryta.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
print("Pabandyk atspėti mano vardą!")
kiekis = 1
vardas = "gilbertas"
spėjimas = input("Koks mano vardas? ")
while kiekis < 3 and spėjimas.lower() != vardas: # .lower visas didžiąsias raides teksto eilutėje pakeičia į mažąsias, todėl net jei vartotojas įves Gilbertas, tai vis tiek bus teisingas atsakymas
print("Tu neteisus!")
spėjimas = input("Koks mano vardas? ")
kiekis = kiekis + 1

if spėjimas.lower() != vardas:
print("Tu neteisus!") # ši žinutė nėra atspausdinama trečiąjį bandymą, todėl mes tai padarome dabar
print("Tu nebegali spėti.")
else:
print("Taip! Mano vardas yra", vardas + "!")

</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri paprašytų įvesti du skaičius. Programa turėtų išvesti, ar abu skaičiai didesni už 10, ar abu skaičiai mažesni už 10, ar vienas didesnis, kitas mažesnis.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
pirmas_skaičius = int(input("Įvesk pirmą skaičių: "))
antras_skaičius = int(input("Įvesk antrą skaičių: "))

if pirmas_skaičius > 10 and antras_skaičius > 10:
print ("Abu skaičiai didesni nei 10")
elif pirmas_skaičius < 10 and antras_skaičius < 10:
print ("Abu skaičiai mažesni nei 10")
else:
print ("Vienas iš skaičių mažesnis nei 10")
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri paprašytų sukurti stiprų slaptažodį. Reikalavimai stipriam slaptažodžiui:

* Jis turėtų būti sudarytas iš daugiau nei 6 simbolių
* Jis turėtų turėti bent vieną skaitmenį
* Jis turėtų turėti bent vieną specialų simbolį iš šio sąrašo: !#$?

Programa turėtų išvesti, ar slaptažodis pakankamai stiprus, ar ne.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def ar_turi_skaičių(slaptažodis):
skaičiai = "0123456789"
rezultatas = False
for raidė in slaptažodis:
if raidė in skaičiai:
rezultatas = True
break
return rezultatas

def ar_turi_simbolį(slaptažodis):
simboliai = "!#$?"
rezultatas = False
for raidė in slaptažodis:
if raidė in simboliai:
rezultatas = True
break
return rezultatas

def ar_slaptažodis_stiprus(slaptažodis):
ar_užtenka_simbolių = len(slaptažodis) > 6
ar_yra_skaitmuo = ar_turi_skaičių(slaptažodis)
ar_yra_simbolis = ar_turi_simbolį(slaptažodis)
return ar_užtenka_simbolių and ar_yra_skaitmuo and ar_yra_simbolis

įvestas_slaptažodis = input("Įvesk slaptažodį: ")
ar_stiprus = ar_slaptažodis_stiprus(įvestas_slaptažodis)

if ar_stiprus:
print ("Slaptažodis pakankamai stiprus")
else:
print ("Slaptažodis nepakankamai stiprus")
</syntaxhighlight>
|-
|}

{{navigation |previous=Ciklai For |next=Žodynai}}
{{BookCat}}

Vadovėlis/Ciklai For

2023-01-24T15:43:34Z

Monika: Pridėta užduotis

{{navigation |previous=Sąrašai |next=Loginiai reiškiniai}}

{{BookCat}}

=== Ciklas <code>for</code> ===

[[Vaizdas:Ciklai.png|600px|frameless|center|Ciklai]]

Ir štai naujas spausdinimo būdas:
<syntaxhighlight lang="python">
nuo_vieno_iki_dešimt = range(1, 11)
for skaičius in nuo_vieno_iki_dešimt:
print(skaičius)
</syntaxhighlight>

ir kodo išvestis būtų tokia:

1
2
3
4
5
6
7
8
9
10

Išvestis atrodo labai pažįstama, tačiau programos kodas atrodo kitaip. Pirmoje eilutėje naudojama funkcija <code>range</code>. Funkcija <code>range</code> naudoja du argumentus, tokius kaip šie <code>range(pradžia, pabaiga)</code>, kurie nurodo intervalo galus. <code>pradžia</code> yra pirmasis intervalo skaičius. <code>pabaiga</code> yra vienu didesnis nei paskutinis intervalo skaičius. Atkreipk dėmesį, kad šį kodą galima parašyti ir trumpiau:
<syntaxhighlight lang="python">
for skaičius in range(1, 11):
print(skaičius)
</syntaxhighlight>

<code>range</code> funkcija grąžina iteraciją (proceso kartojimas skirtas rezultatų sekos generavimui). Tai galima paversti sąrašu naudojant funkciją <code>list</code>.
Štai keli pavyzdžiai, parodantys, kas nutinka su komanda <code>range</code>:

>>> '''range(1, 10)'''
range(1, 10)
>>> '''list(range(1, 10))'''
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> '''list(range(-32, -20))'''
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> '''list(range(5,21))'''
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> '''list(range(5))'''
[0, 1, 2, 3, 4]
>>> '''list(range(21, 5))'''
[]

Eilutė <code>for skaičius in nuo_vieno_iki_dešimt:</code> naudoja <code>for</code> valdymo struktūrą. <code>for</code> struktūra atrodo taip: <code>for elementas in sąrašas:</code>. <code>sąrašas</code> pereinamas nuo pirmojo sąrašo elemento iki paskutinio. Kai <code>for</code> eina per kiekvieną sąrašo elementą, jis kiekvieną reikšmę priskiria <code>elementas</code> kintamajam. Tai leidžia naudoti <code>elementas</code> kiekvieną kartą, kai ciklas <code>for</code> pereinamas iš eilės. Štai dar vienas pavyzdys, kad būtų lengviau suprasti:
<syntaxhighlight lang="python">
demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9, "oras"]
for elementas in demoSąrašas:
print("Dabartinis elementas yra:", elementas)
</syntaxhighlight>

Rezultatas yra:

Dabartinis elementas yra: gyvybė
Dabartinis elementas yra: 42
Dabartinis elementas yra: visata
Dabartinis elementas yra: 6
Dabartinis elementas yra: ir
Dabartinis elementas yra: 9
Dabartinis elementas yra: oras

Atkreipk dėmesį, kaip ciklas <code>for</code> praeina ir nustato elemento reikšmę kiekvienam sąrašo elementui. Taigi, kam tinkamas <code>for</code>? Pirmasis naudojimas yra peržiūrėti visus sąrašo elementus ir ką nors padaryti su kiekvienu iš jų. Štai greitas būdas sudėti visus elementus:

<syntaxhighlight lang="python">
sąrašas = [2, 4, 6, 8]
suma = 0
for skaičius in sąrašas:
suma = suma + skaičius

print("Suma yra:", suma)
</syntaxhighlight>

o išvestis yra tiesiog:

Suma yra: 20

Arba gali parašyti programą, kad sužinotum, ar sąraše yra dublikatų. Pavyzdžiui kaip ši programa:

<syntaxhighlight lang="python">
sąrašas = [4, 5, 7, 8, 9, 1, 0, 7, 10]
sąrašas.sort()
praeitas = None
for elementas in sąrašas:
if praeitas == elementas:
print("Dublikatas", praeitas, "rastas.")
praeitas = elementas
</syntaxhighlight>

ir turime rezultatą:

Dublikatas 7 rastas.

Gerai, tai kaip gi tai veikia? Čia yra speciali derinimo versija, kuri turėtų tau padėti suprasti (tau to nereikia įvesti):

<syntaxhighlight lang="python">
l = [4, 5, 7, 8, 9, 1, 0, 7, 10]
print("l = [4, 5, 7, 8, 9, 1, 0, 7, 10]", "\t\tl:", l)
l.sort()
print("l.sort()", "\t\tl:", l)
praeitas = l[0]
print("praeitas = l[0]", "\t\tpraeitas:", praeitas)
del l[0]
print("del l[0]", "\t\tl:", l)
for elementas in l:
if praeitas == elementas:
print("Dublikatas", praeitas, "rastas.")
print("if praeitas == elementas:", "\t\tpraeitas:", praeitas, "\telementas:", elementas)
praeitas = elementas
print("praeitas = elementas", "\t\tpraeitas:", praeitas, "\telementas:", elementas)
</syntaxhighlight>

ir kodo išvestis būtų:

l = [4, 5, 7, 8, 9, 1, 0, 7, 10] l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort() l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
praeitas = l[0] praeitas: 0
del l[0] l: [1, 4, 5, 7, 7, 8, 9, 10]
if praeitas == elementas: praeitas: 0 elementas: 1
praeitas = elementas praeitas: 1 elementas: 1
if praeitas == elementas: praeitas: 1 elementas: 4
praeitas = elementas praeitas: 4 elementas: 4
if praeitas == elementas: praeitas: 4 elementas: 5
praeitas = elementas praeitas: 5 elementas: 5
if praeitas == elementas: praeitas: 5 elementas: 7
praeitas = elementas praeitas: 7 elementas: 7
Dublikatas 7 rastas.
if praeitas == elementas: praeitas: 7 elementas: 7
praeitas = elementas praeitas: 7 elementas: 7
if praeitas == elementas: praeitas: 7 elementas: 8
praeitas = elementas praeitas: 8 elementas: 8
if praeitas == elementas: praeitas: 8 elementas: 9
praeitas = elementas praeitas: 9 elementas: 9
if praeitas == elementas: praeitas: 9 elementas: 10
praeitas = elementas praeitas: 10 elementas: 10

Priežastis, kodėl į kodą įdėjau tiek daug <code>print</code> komandų, buvo ta, kad galėtum matyti, kas vyksta kiekvienoje eilutėje (beje, jei kažkada negalėsi suprasti, kodėl programa neveikia, pabandyk įdėti spausdintų komandų tose vietose, kur nori sužinoti, kas vyksta). Pirmiausia programa prasideda nuobodžiu senu sąrašu. Toliau programa surūšiuoja sąrašą. Tai darome tam, kad visi dublikatai būtų dedami vienas šalia kito. Tada programa apibrėžia kintamąjį <code>praeitas</code>. Tada pirmasis sąrašo elementas ištrinamas, kad pirmasis elementas nebūtų klaidingai laikomas dublikatu. Toliau aprašomas <code>for</code> ciklas. Kiekvienas sąrašo elementas tikrinamas, ar jis sutampa su ankstesniu. Jeigu sutampa – dublikatas rastas. Tada kintamasis <code>praeitas</code> yra pakeičiamas taip, kad kitame <code>for</code> cikle kintamasis <code>praeitas</code> būtų ankstesnis dabartinis elementas. Be abejo, nustatytome, kad 7 yra dublikatas. (Atkreipk dėmesį, kaip <code>\t</code> naudojamas spausdinant tabuliavimo žymę (tab'as).)

Kitas būdas naudoti <code>for</code> ciklą yra norint ką nors padaryti tam tikrą skaičių kartų. Štai trumpas kodas, kaip atspausdinti pirmuosius 9 „Fibonacci“ serijos sakičius:
<syntaxhighlight lang="python">
a = 1
b = 1
for c in range(1, 10):
print(a, end=" ")
n = a + b
a = b
b = n
</syntaxhighlight>

su stebėtinu rezultatu:

1 1 2 3 5 8 13 21 34

Viskas, ką galima padaryti naudojant <code>for</code> ciklą, taip pat gali būti padaryta naudojant <code>while</code> ciklą, bet <code>for</code> ciklas suteikia lengvą būdą pereiti per visus sąrašo elementus arba ką nors padaryti tam tikrą skaičių kartų.

=== Sąrašų rūšiavimas ===

Ciklas <code>for</code> taip pat dažnai naudojamas sąrašų rūšiavimo užduotyse. Paprastų sąrašų, kurie yra sudaryti iš skaičių ar eilučių, rūšiavimui gali naudoti funkciją <code>sort</code>, kuri buvo paminėta prieš tai skaitytame skyriuje. Tačiau gali susidurti su situacijomis, kai ši funkcija yra nepakankama. Egzistuoja daug rūšiavimo algoritmų, tačiau čia išmoksi vieną paprasčiausių iš jų - burbuliuko algoritmą (angl. bubble sort).

Algoritmo idėja yra tokia, kad iš kairės į dešinę lyginame gretimų elementų poras ir sukeičiame elementus vietomis, jei pirmasis yra didesnis už antrąjį. Kiekvienos iteracijos metu, didžiausias nesurūšiuotas elementas juda link sąrašo galo. Toks judėjimas primena burbuliukų vandenyje judėjimą į paviršių, iš ko ir kilo algoritmo pavadinimas. Iteracijos kartojamos tol, kol visi elementai yra savo vietose.

[[Vaizdas:1 iteracija.png|miniatiūra]]
Pavyzdžiui, surūšiuokime jau prieš tai naudotą sąrašą [42, 7, 0, 123].

'''Pirma iteracija:'''
* Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
* Lyginami antras ir trečias elementai. Trečiasis yra didesnis už antrąjį, todėl elementai pakeičiami vietomis.
* Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

[[Vaizdas:2 iteracija.png|miniatiūra]]
'''Antra iteracija:'''
* Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
* Lyginami antras ir trečias elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.
* Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

[[Vaizdas:3 iteracija.png|miniatiūra]]
'''Trečia iteracija:'''
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.

Trečios iteracijos metu algoritmas neatlieka jokių pakeitimų, tad nustatoma, kad sąrašas yra surūšiuotas, algoritmas baigtas.

Algoritmo kodą galima užrašyti taip:

<syntaxhighlight lang="python">
def burbuliukoRūšiavimas(sąrašas):
sąrašoIlgis = len(sąrašas)
# Maksimalus iteracijų skaičius - sąrašo ilgis - 1 elementas
for i in range(sąrašoIlgis - 1):
arBuvoPakeitimų = 0
# Kiekvienoje iteracijoje lyginami visi elementai
for j in range(sąrašoIlgis - 1):
if sąrašas[j] > sąrašas[j + 1]:
# Sukuriame laikiną elementą, kuris saugo pirmąjį lyginamą elementą
laikinasElementas = sąrašas[j]
# Pirmąjam elementui priskiriame antro elemento reikšmę
sąrašas[j] = sąrašas[j + 1]
# Antrajam elementui priskiriame laikino elemento reikšmę, kuri yra lygi buvusiam pirmąjam elementui
sąrašas[j + 1] = laikinasElementas
# Pasižymime, kad iteracijos metu buvo padaryti pakeitimai, taigi reikės papildomų iteracijų
arBuvoPakeitimų = 1
# Jei visos iteracijos metu nebuvo nei vieno pakeitimo, algoritmas baigiamas
if arBuvoPakeitimų == 0:
break
return sąrašas

rezultatas = burbuliukoRūšiavimas([42, 7, 0, 123])

print (rezultatas)
</syntaxhighlight >

Programos išvestis:

<code>
[0, 7, 42, 123]
</code>

=== Pratimai ===
1. Sukurk naują sarašą, kuris turėtų tik skaičiaus 3 daliklius (skaičius turi dalintis iš 3) iš 'x' sąrašo ir tik skaičiaus 5 daliklius iš 'y' sąrašo.

x = [1,2,3,4,5,6,7,8,9,10]

y = [11,12,13,14,15,16,17,18,19,20]

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
x = [1,2,3,4,5,6,7,8,9,10]
y = [11,12,13,14,15,16,17,18,19,20]
c = []
for i in x:
if i % 3 == 0:
c.append(i)
for i in y:
if i % 5 == 0:
c.append(i)
print(c)
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri atspausdintų eglutę, pagal vartotojo įvesta eglutės aukštį.

Pvz. Įvestis = 3

Išvestis:
<syntaxhighlight lang="python">
*
**
***
</syntaxhighlight>
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def spausdintiEglutę(aukstis):
for i in range(1, aukstis + 1):
print('*'*i)

spausdintiEglutę(3)
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri prašytų vartotojo įvesti skaičių ir išspausdintų to skaičiaus daugybos lentelę iki 10.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def daugybos_lentelė(skaičius):
for indeksas in range(1, 11):
print (skaičius, " * ", indeksas, " = ", skaičius * indeksas)

įvestas_skaičius = int(input("Įvesk skaičių: "))
daugybos_lentelė(įvestas_skaičius)
</syntaxhighlight>
|-
|}

{{navigation |previous=Sąrašai |next=Loginiai reiškiniai}}
{{BookCat}}

Vadovėlis/Sąrašai

2023-01-23T16:55:16Z

Monika: Pridėta užduočių

{{navigation |previous=Rekursinės funkcijos |next=Ciklai For}}
{{BookCat}}

=== Kintamieji, turintys daugiau nei vieną reikšmę ===
Tu jau žinai įprastus kintamuosius, kuriuose saugoma viena reikšmė. Tačiau kiti kintamųjų tipai gali turėti daugiau nei vieną reikšmę. Jie vadinami konteineriais (containers), nes juose gali būti daugiau nei vienas objektas. Paprasčiausias tipas vadinamas sąrašu (list). Sąrašo pavyzdys:
<syntaxhighlight lang="python">
kuris = int(input("Kuris mėnuo (1-12)? "))
mėnesiai = ["Sausis", "Vasaris", "Kovas", "Balandis", "Gegužė", "Birželis", "Liepa",
"Rugpjūtis", "Rugsėjis", "Spalis", "Lapkritis", "Gruodis"]

if 1 <= kuris <= 12:
print("Mėnuo yra ", mėnesiai[kuris - 1])
</syntaxhighlight>

pavyzdžio išvestis būtų:

Kuris mėnuo (1-12)? '''3'''
Mėnuo yra Kovas

Šiame pavyzdyje <code>mėnesiai</code> yra sąrašas. Kintamasis <code>mėnesiai</code> yra apibrėžtas šia eilute <code>mėnesiai = ["Sausis", "Vasaris", "Kovas", "Balandis", "Gegužė", "Birželis", "Liepa",</code> ir <code>"Rugpjūtis", "Rugsėjis", "Spalis", "Lapkritis", "Gruodis"]</code> (atkreipk dėmesį, kad viena komanda parašyta per dvi eilutes; paprastai keliant eilutę yra naudojamas simbolis / tačiau šiuo atveju jis nėra būtinas, nes Python'as supranta, kad viskas, kas yra laužtiniuose skliaustuose yra kartu). <code>[</code> ir <code>]</code> pradeda ir užbaigia sąrašą, o kableliai (<code>,</code>) atskiria sąrašo elementus. Sąrašas naudojamas šioje dalyje: <code>mėnesiai[kuris - 1]</code>. Sąrašas susideda iš elementų, kurie sunumeruoti pradedant nuo 0. Kitaip tariant, norint sąraše pasiekti elementą "Sausis", turėtum rašyti <code>mėnesiai[0]</code>. Nurodant sąrašui skaičių, tu gauni reikšmę išsaugotą toje sąrašo pozicijoje.

Sąlyginis sakinys <code> if 1 <= kuris <= 12:</code> tikrina, ar skaičius kintamajame <code>kuris</code> yra tarp vieno ir dvylikos imtinai (tiek yra mėnesių ir taip jie numeruojami).

Viename sąraše gali būti saugomi ir skirtingų tipų duomenys. Kiekvienas elementas saugo vis kitą reikšmę. Pavyzdžiui, sąrašas sukurtas šiuo kodu: <code>demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]</code> atrodytų taip:

{| class="wikitable"
!elemento numeris
!0
!1
!2
!3
!4
!5
|-
|demoSąrašas
|"gyvybė"
|42
|"visata"
|6
|"ir"
|9
|}

Kiekvienas elementas pasiekiamas per jo eilės numerį – indeksą, todėl komanda <code>demoSąrašas[0]</code> pateiktų reikšmę: <code>"gyvybė"</code>, o komanda <code>demoSąrašas[1]</code> – reikšmę <code>42</code> ir taip toliau iki kol <code>demoSąrašas[5]</code> pateikia reikšmę <code>9</code>.

=== Daugiau sąrašų funkcijų ===
Kitas pavyzdys yra skirtas parodyti daugybę kitų dalykų, kuriuos gali padaryti sąrašai (šį kartą nesitikiu, kad viską pats sugebėsi parašyti, bet tikriausiai turėtum šiek tiek pažaisti su sąrašais interaktyviame režime, kol apsiprasi su jais). Pavyzdys:
<syntaxhighlight lang="python">
demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]
print("demoSąrašas = ", demoSąrašas)
demoSąrašas.append("oras")
print("po 'oras' pridėjimo, demoSąrašas atrodo taip:")
print(demoSąrašas)
print("len(demoSąrašas) =", len(demoSąrašas))
print("demoSąrašas.index(42) =", demoSąrašas.index(42))
print("demoSąrašas[1] =", demoSąrašas[1])

# o dabar mes pereisime per visą sąrašą "for" ciklu
for c in range(len(demoSąrašas)):
print("demoSąrašas[", c, "] =", demoSąrašas[c])

del demoSąrašas[2]
print("Po 'visata' pašalinimo, demoSąrašas atrodo taip:")
print(demoSąrašas)
if "gyvybė" in demoSąrašas:
print("'gyvybė' buvo rasta kintamajame demoSąrašas")
else:
print("'gyvybė' nebuvo rasta kintamajame demoSąrašas")

if "ameba" in demoSąrašas:
print("'ameba' buvo rasta kintamajame demoSąrašas")

if "ameba" not in demoSąrašas:
print("'ameba' nebuvo rasta kintamajame demoSąrašas")

kitasSąrašas = [42, 7, 0, 123]
kitasSąrašas.sort()
print("Išrikiuotas kitasSąrašas atrodo taip", kitasSąrašas)
</syntaxhighlight>

Kodo išvestis būtų tokia:

demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]
po "oras" pridėjimo, demoSąrašas atrodo taip:
["gyvybė", 42, "visata", 6, "ir", 9, "oras"]
len(demoSąrašas) = 7
demoSąrašas.index(42) = 1
demoSąrašas[1] = 42
demoSąrašas[ 0 ] = gyvybė
demoSąrašas[ 1 ] = 42
demoSąrašas[ 2 ] = visata
demoSąrašas[ 3 ] = 6
demoSąrašas[ 4 ] = ir
demoSąrašas[ 5 ] = 9
demoSąrašas[ 6 ] = oras
Po 'visata' pašalinimo, demoSąrašas atrodo taip:
["gyvybė", 42, 6, "ir", 9, "oras"]
"gyvybė" buvo rasta kintamajame demoSąrašas
"ameba" nebuvo rasta kintamajame demoSąrašas
Išrikiuotas kitasSąrašas atrodo taip [0, 7, 42, 123]

Šiame pavyzdyje rasi daug naujų funkcijų. Atkreipk dėmesį, kad gali tiesiog atspausdinti (<code>print</code>) visą sąrašą. Toliau funkcija <code>append</code> naudojama tam, kad pridėtum naują elementą į sąrašo pabaigą. <code>len</code> grąžina kiek elementų yra sąraše. Tinkami sąrašo indeksai (skaičiai kuriuos naudojame viduje laužtinių skliaustų <code>[]</code>) yra nuo 0 iki <code>len - 1</code>. Funkcija <code>index</code> nurodo, kur sąraše yra pirmoji elemento vieta. Atkreipk dėmesį, kaip <code>demoSąrašas.index(42)</code> pateikia 1, o paleidus <code>demoSąrašas[1]</code> grąžina 42. Norint gauti pagalbos dėl visų sąrašo funkcijų, įvykdyk komandą <code> help(list)</code> interaktyviajame Python'o interpretatoriuje.

Eilutė <code># o dabar mes pereisime per visą sąrašą <code>for</code> ciklu</code> yra tik priminimas programuotojui (dar vadinamas kaip „komentaras“). Python'as ignoruoja viską, kas parašyta esamoje eilutėje po simbolio <code>#</code>. Toliau eilutės:
<syntaxhighlight lang="python">
for c in range(len(demoSąrašas)):
print("demoSąrašas[", c, "] =", demoSąrašas[c])
</syntaxhighlight>
sukuria kintamajį <code>c</code>, kuris prasideda nuo 0 ir didinamas vienetu, kol pasiekia paskutinį sąrašo indeksą. Tuo tarpu <code>print</code> komanda išspausdina kiekvieną sąrašo elementą.

Daug geresnis būdas tai padaryti:
<syntaxhighlight lang="python">
for c, x in enumerate(demoSąrašas):
print("demoSąrašas[", c, "] =", x)
</syntaxhighlight>

Komanda <code>del</code> gali būti naudojama tam tikram sąrašo elementui pašalinti. Kitos kelios eilutės naudoja <code>in</code> operatorių, kad patikrintų, ar elementas yra sąraše, ar ne. Funkcija <code>sort</code> rūšiuoja sąrašą. Tai naudinga, jei tau reikia sąrašo nuo mažiausio iki didžiausio arba abėcėlės tvarka. Atmink, kad tai pakeičia sąrašą. Apibendrinant, su sąrašu yra atliekami šie veiksmai:

{| class="wikitable"
!pavyzdys
!paaiškinimas
|-
|<code>demoSąrašas[2]</code>
|grąžina 2 sąrašo demoSąrašas elementą
|-
|<code>demoSąrašas[2] = 3</code>
|į sąrašo demoSąrašas 2 poziciją (numeruojama nuo 0) įrašo reikšmę 3
|-
|<code>del demoSąrašas[2]</code>
|pašalina sąrašo demoSąrašas elementą, esantį 2 pozicijoje
|-
|<code>len(demoSąrašas)</code>
|grąžina <code>demoSąrašas</code> sąrašo ilgį, t.y. elementų skaičių
|-
|<code>"reikšmė" in demoSąrašas</code>
|yra ''True'' jeigu <tt>"reikšmė"</tt> yra elementas, priklausantis <code>demoSąrašas</code>
|-
|<code>"reikšmė" not in demoSąrašas</code>
|yra ''True'' jeigu <code>"reikšmė"</code> nėra elementas, priklausantis <code>demoSąrašas</code>
|-
|<code>kitasSąrašas.sort()</code>
|surūšiuoja <code>kitasSąrašas</code>. Atmink, kad rūšiavimas pavyktų, visi sąrašo elementai turi būti arba skaičiai, arba eilutės (string).
|-
|<code>demoSąrašas.index("reikšmė")</code>
|grąžina pirmosios vietos, kurioje atsiranda <code>"reikšmė"</code>, indeksą
|-
|<code>demoSąrašas.append("reikšmė")</code>
|sąrašo pabaigoje prideda elementą <code>"reikšmė"</code>
|-
|<code>demoSąrašas.remove("reikšmė")</code>
|pašalina pirmą rastą elementą su nurodyta reikšme iš <code>demoSąrašas</code> (taip pat, kaip <code>del demoSąrašas[demoSąrašas.index("reikšmė")]</code>)
|}

Pavyzdžiai, kur praktiškai naudojamos šios funkcijos:
<syntaxhighlight lang="python">
meniuElementas = 0
vardųSarašas = []
while meniuElementas != 9:
print("--------------------")
print("1. Spausdinti sąrašą")
print("2. Pridėti vardą prie sąrašo")
print("3. Pašalinti vardą iš sąrašo")
print("4. Pakeisti elementą sąraše")
print("9. Išeiti")
meniuElementas = int(input("Pasirinkite elementą iš meniu: "))
if meniuElementas == 1:
dabartinis = 0
if len(vardųSarašas) > 0:
while dabartinis < len(vardųSarašas):
print(dabartinis, ".", vardųSarašas[dabartinis])
dabartinis = dabartinis + 1
else:
print("Sąrašas tuščias")
elif meniuElementas == 2:
vardas = input("Įveskite vardą, kurį norite pridėti: ")
vardųSarašas.append(vardas)
elif meniuElementas == 3:
šalinamasVardas = input("Kokį vardą norėtumėte pašalinti:")
if šalinamasVardas in vardųSarašas:
# vardųSarašas.remove(šalinamasVardas) veiktų taip pat gerai
elementoIndeksas = vardųSarašas.index(šalinamasVardas)
del vardųSarašas[elementoIndeksas]
# Aukščiau pateiktas kodas pašalina tik pirmąjį surasta vardą.
# Žemiau esantis kodas pašalina visus.
# while šalinamasVardas in vardųSarašas:
# elementoIndeksas = vardųSarašas.index(šalinamasVardas)
# del vardųSarašas[elementoIndeksas]
else:
print(šalinamasVardas, "nerastas")
elif meniuElementas == 4:
senasVardas = input("Kokį vardą norėtumėte pakeisti:")
if senasVardas in vardųSarašas:
elementoIndeksas = vardųSarašas.index(senasVardas)
naujasVardas = input("Koks yra naujas vardas: ")
vardųSarašas[elementoIndeksas] = naujasVardas
else:
print(senasVardas, "nerastas")

print("Iki pasimatymo")
</syntaxhighlight>

Ir čia yra išvesties dalis:

--------------------
1. Spausdinti sąrašą
2. Pridėti vardą prie sąrašo
3. Pašalinti vardą iš sąrašo
4. Pakeisti elementą sąraše
9. Išeiti

Pasirinkite elementą iš meniu: '''2'''
Įveskite vardą, kurį norite pridėti: '''Benas'''

Pasirinkite elementą iš meniu: '''2'''
Įveskite vardą, kurį norite pridėti: '''Liepa'''

Pasirinkite elementą iš meniu: '''1'''
0. Benas
1. Liepa

Pasirinkite elementą iš meniu: '''3'''
Kokį vardą norėtumėte pašalinti: '''Benas'''

Pasirinkite elementą iš meniu: '''4'''
Kokį vardą norėtumėte pakeisti: '''Liepa'''
Koks yra naujas vardas: '''Liepa Petraitė'''

Pasirinkite elementą iš meniu: '''1'''
0. Liepa Petraitė

Pasirinkite elementą iš meniu: '''9'''
Iki pasimatymo

Tai buvo ilga programa. Panagrinėkime pirminį programos tekstą. Eilutė <code>vardųSarašas = []</code> sukuria kintamajį <code>vardųSarašas</code>, tuščia sąrašą, be elementų. Kita svarbi eilutė yra <code>while meniuElementas != 9:</code>. Ši eilutė pradeda ciklą, leidžiantį šios programos meniu sistemai veikti. Kitos eilutės parodo meniu ir nusprendžia, kurią programos dalį paleisti.

Ši dalis:
<syntaxhighlight lang="python">
dabartinis = 0
if len(vardųSarašas) > 0:
while dabartinis < len(vardųSarašas):
print(dabartinis, ".", vardųSarašas[dabartinis])
dabartinis = dabartinis + 1
else:
print("Sąrašas tuščias")
</syntaxhighlight>
eina per sąrašą ir spausdina kiekvieną vardą. <code>len(vardųSarašas)</code> nurodo, kiek elementų yra sąraše. Jei <code>len</code> grąžina <code>0</code>, tai reiškia sąrašas tuščias.

Toliau po kelių eilučių matysi sakinį <code>vardųSarašas.append(vardas)</code>. Jis naudoja funkciją <code>append</code>, kad pridėtų elementą į sąrašo pabaigą. Peršokus dar dvi eilutes, pastebėsi šią kodo dalį:
<syntaxhighlight lang="python">
elementoIndeksas = vardųSarašas.index(šalinamasVardas)
del vardųSarašas[elementoIndeksas]
</syntaxhighlight>
Čia funkcija <code>index</code> yra naudojama norint rasti indekso reikšmę, kuri vėliau bus naudojama elementui pašalinti. <code>del vardųSarašas[elementoIndeksas]</code> naudojamas sąrašo elementui pašalinti.

Kitoje kodo dalyje
<syntaxhighlight lang="python">
senasVardas = input("Kokį vardą norėtumėte pakeisti:")
if senasVardas in vardųSarašas:
elementoIndeksas = vardųSarašas.index(senasVardas)
naujasVardas = input("Koks yra naujas vardas: ")
vardųSarašas[elementoIndeksas] = naujasVardas
else:
print(senasVardas, "nerastas")
</syntaxhighlight>
naudojamas <code>index</code>, kad surastų <code>elementoIndeksas</code> ir tada įdėtų <code>naujasVardas</code> ten, kur buvo <code>senasVardas</code>.

Sveikinu, perpratus sąrašus, dabar tu pakankamai žinai kalbą, kad galėtum atlikti bet kokius skaičiavimus, kuriuos gali atlikti kompiuteris (tai techniškai žinoma kaip [[Wikipedia:Turing_completeness|Turing-Completeness]]). Žinoma, vis dar yra daug funkcijų, kurias naudojant tu pasilengvinsi sau gyvenimą.

=== Pavyzdžiai ===
'''testas.py'''
<syntaxhighlight lang="python">
## Ši programa atlieka žinių patikrinimą

# Pirmiausia surenkame testo klausimus.
# Vėliau šią dalį pakeisime, kad būtų naudojama failinė sistema.
def gauti_klausimus():
# atkreipk dėmesį, kad duomenys saugomi kaip sąrašų sąrašas
return [["Kokios spalvos yra dangus giedrą dieną? ", "mėlynas"],
["Koks atsakymas į gyvenimą, visatą ir viską? ", "42"],
["Kas yra keturių raidžių žodis pelės gaudyklei? ", "katė"]]

# Ši dalis patikrins vieną klausimą
# pateikiamas vienas klausimas
# grąžinama teisinga (True), jei vartotojas įvedė teisingą atsakymą, kitu atveju - klaidinga (False)

def pateik_klausimą(klausimas_ir_atsakymas):
# ištraukiame klausimą ir atsakymą iš sąrašo
# Ši funkcija priima dviejų elementų sąrašą, klausimą ir atsakymą.
klausimas = klausimas_ir_atsakymas[0]
atsakymas = klausimas_ir_atsakymas[1]
# užduodame klausimą vartotojui
duotas_atsakymas = input(klausimas)
# palyginame vartotojo atsakymą su teisingu atsakymu
if atsakymas == duotas_atsakymas:
print("Teisingai")
return True
else:
print("Neteisingai. Teisingas atsakymas: ", atsakymas)
return False

# Šis kodas apims visus klausimus
def atlikti_testus(klausimai):
if len(klausimai) == 0:
print("Nepateiktas nei vienas klausimas.")
# `return` išeis iš funkcijos
return
indeksas = 0
teisingai = 0
while indeksas < len(klausimai):
# patikriname klausimą
# Atkreipk dėmesį, kad tai yra klausimų ir atsakymų sąrašo ištraukimas iš sąrašų sąrašo.
if pateik_klausimą(klausimai[indeksas]):
teisingai = teisingai + 1
# pareiname prie kito klausimo
indeksas = indeksas + 1
# atkreipk dėmesį į skaičiavimo tvarką: pirmiausia padaugini, tada padalini
print("Atsakei teisingai į ", teisingai * 100 / len(klausimai),\
"% klausimų iš ", len(klausimai))

# dabar paimkime klausimus iš funkcijos gauti_klausimus ir
# paduokime grąžintą sąrašų sąrašą kaip argumentą funkcijai atlikti_testus.

atlikti_testus(gauti_klausimus())

</syntaxhighlight>

Reikšmės <code>True</code> ir <code>False</code> turi reikšmes atitinkamai 1 ir 0. Jie dažnai naudojami loginės sekos patikrinimui, ciklo sąlygoms ir pan. Daugiau apie tai sužinosi šiek tiek vėliau (skyrius [[Vadovėlis/Loginiai reiškiniai|Loginiai reiškiniai]]).
Atkreipk dėmesį, kad gauti_klausimus() iš esmės yra sąrašas, nors tai techniškai yra funkcija - sąrašų grąžinimas yra vienintelis dalykas, kurį jis daro.

Pavyzdžio išvestis:

Kokios spalvos yra dangus giedrą dieną? '''žalias'''
Neteisingai. Teisingas atsakymas: mėlynas
Koks atsakymas į gyvenimą, visatą ir viską? '''42'''
Teisingai
Kas yra keturių raidžių žodis pelės gaudyklei? '''katė'''
Teisingai
Atsakei teisingai į 66% klausimų iš 3

=== Pratimai ===

Išplėsk testas.py programą, kad ji turėtų meniu, kuriame būtų galima atlikti testą,
peržiūrėti klausimų ir atsakymų sąrašą ir pasirinkti išeiti iš programos. Taip pat, pridėk naują klausimą:
„Kokį triukšmą kelia tikrai pažangi mašina?“ su teisingu atsakymu „ping“.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
## Ši programa atlieka žinių patikrinimą

klausimai = [["Kokios spalvos yra dangus giedrą dieną? ", "mėlynas"],
["Koks atsakymas į gyvenimą, visatą ir viską? ", "42"],
["Kas yra keturių raidžių žodis pelės gaudyklei? ", "katė"],
["Kokį triukšmą kelia tikrai pažangi mašina?", "ping"]]

# Ši dalis patikrins vieną klausimą
# pateikiamas vienas klausimas
# grąžinama teisinga (True), jei vartotojas įvedė teisingą atsakymą, kitu atveju - klaidinga (False)

def pateik_klausimą(klausimas_ir_atsakymas):
# ištraukiame klausimą ir atsakymą iš sąrašo
# Ši funkcija priima dviejų elementų sąrašą, klausimą ir atsakymą.
klausimas = klausimas_ir_atsakymas[0]
atsakymas = klausimas_ir_atsakymas[1]
# užduodame klausimą vartotojui
duotas_atsakymas = input(klausimas)
# palyginame vartotojo atsakymą su teisingu atsakymu
if atsakymas == duotas_atsakymas:
print("Teisingai")
return True
else:
print("Neteisingai. Teisingas atsakymas: ", atsakymas)
return False

# Šis kodas apims visus klausimus
def atlikti_testus(klausimai):
if len(klausimai) == 0:
print("Nepateiktas nei vienas klausimas.")
# `return` išeis iš funkcijos
return
indeksas = 0
teisingai = 0
while indeksas < len(klausimai):
# patikriname klausimą
# Atkreipk dėmesį, kad tai yra klausimų ir atsakymų sąrašo ištraukimas iš sąrašų sąrašo.
if pateik_klausimą(klausimai[indeksas]):
teisingai = teisingai + 1
# pareiname prie kito klausimo
indeksas = indeksas + 1
# atkreipk dėmesį į skaičiavimo tvarką: pirmiausia padaugini, tada padalini
print("Atsakei teisingai į ", teisingai * 100 / len(klausimai),\
"% klausimų iš ", len(klausimai))

#rodomas klausimų ir atsakymų sąrašas
def rodyk_klausimus():
k = 0
while k < len(klausimai):
a = 0
print("K:" , klausimai[k][a])
a = 1
print("A:" , klausimai[k][a])
k = k + 1

# dabar apibrėžiu meniu funkciją
def meniu():
print("-----------------")
print("Meniu:")
print("1 - Atlikti testą")
print("2 - Peržiūrėti klausimų ir atsakymų sąrašą")
print("3 - Peržiūrėti meniu")
print("5 - Išeiti")
print("-----------------")

pasirinkimas = "3"
while pasirinkimas != "5":
if pasirinkimas == "1":
atlikti_testus(klausimai)
elif pasirinkimas == "2":
rodyk_klausimus()
elif pasirinkimas == "3":
meniu()
print()
pasirinkimas = input("Pasirinkite savo parinktį iš aukščiau pateikto meniu: ")

</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri ištrintų pasikartojančius elementus iš sąrašo.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
pradinis_sąrašas = ["a", "b", "c", "a"]
naujas_sąrašas = []
indeksas = 0

while indeksas < len(pradinis_sąrašas):
if pradinis_sąrašas[indeksas] not in naujas_sąrašas:
naujas_sąrašas.append(pradinis_sąrašas[indeksas])
indeksas = indeksas + 1

print(naujas_sąrašas)
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri rastų didžiausią ir mažiausią sąrašo skaičius.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
pradinis_sąrašas = [5, 25, 0, 100, 6, -6, 500]
didžiausias = pradinis_sąrašas[0]
mažiausias = pradinis_sąrašas[0]
indeksas = 0

while indeksas < len(pradinis_sąrašas):
if pradinis_sąrašas[indeksas] > didžiausias:
didžiausias = pradinis_sąrašas[indeksas]
if pradinis_sąrašas[indeksas] < mažiausias:
mažiausias = pradinis_sąrašas[indeksas]
indeksas = indeksas + 1

print ("Didžiausias skaičius: ", didžiausias)
print ("Mažiausias skaičius: ", mažiausias)
</syntaxhighlight>
|-
|}

{{navigation |previous=Rekursinės funkcijos |next=Ciklai For}}
{{BookCat}}

Vadovėlis/Rekursinės funkcijos

2023-01-23T16:35:06Z

Monika: Pridėta užduotis

{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Vieniems šis skyrius gali pasirodyti naudingas, o kitiems - painus. Jeigu tau informacija pasirodys paini, tai nesuk galvos ir praleisk, prie šio skyriaus galėsi grįžti šiek tiek vėliau. O dabar pabandom pasižiūrėti į mūsų parašytą programą:
<syntaxhighlight lang="python">
def daug(a, b): # daug reiškia daugybą
if b == 0:
return 0
lik = daug(a, b - 1) #lik reiškia likutį
reikšmė = a + lik
return reikšmė
rezultatas = daug(3, 2)
print("3 * 2 = ", rezultatas)
</syntaxhighlight>

Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reikia atkreipti dėmesį į tai, kad Python'o programavimo kalboje jau yra integruota funkcija dauginimui, čia mes patys parašėme lengvai suprantamą pavyzdį (jeigu kurtume tokią funkciją patys), kuris parodo kaip atrodo daugybos veiksmas. Šioje programoje gali pamatyti rekursijos naudojimą, tai yra iteracijos (kartojimo) forma, kai funkcija yra pakartotinai iškviečiama, kol bus įvykdyta sukurta išvesties sąlyga. Programa naudoja pakartotinius papildymus, kad gautų tą patį rezultatą kaip ir daugyba: pavyzdžiui 3 + 3 (sudėtis) duoda tą patį rezultatą kaip ir 3 * 2 (daugyba).

; ''Klausimas:'' Ką pirmiausia daro programa?
: ''Atsakymas:'' Pirmiausia yra aprašyta daugybos funkcija:
<syntaxhighlight lang="python">
def daug(a, b):
if b == 0:
return 0
lik = daug(a, b - 1)
reikšmė = a + lik
return reikšmė
</syntaxhighlight>
: Ši funkcija paima du parametrus ir grąžina reikšmę. Vėliau šią funkciją galima bus iškviesti.
; Kas nutinka toliau?
: Vykdoma kita eilutė einanti po funkcijos <code>rezultatas = daug(3, 2)</code>
; Ką daro ši eilutė?
: Ši eilutė priskiria funkcijos <code>daug(3, 2)</code> grąžinamą reikšmę kintamajam <code>rezultatas</code>.
; Ką grąžina <code>daug(3, 2)</code>?
: Norėdami tai išsiaiškinti, turime peržiūrėti funkciją <code>daug()</code>.
; Kas vyksta su kodu?
: Kintamasis <code>a</code> gauna jam priskirtą reikšmę 3, o kintamasis <code>b</code> - jam priskirtą reikšmę 2.
; Kas nutinka tada?
: Vykdoma eilutė <code>if b == 0:</code>. Kadangi <code>b</code> reikšmė yra 2, todėl eilutė <code>return 0</code> praleidžiama.
; Kas vyksta toliau?
: Vykdoma eilutė <code>lik = daug(a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>lik</code> reikšmę į <code>daug(a, b - 1)</code> reikšmę. <code>a</code> reikšmė yra 3, o <code>b</code> - 2, todėl funkcija kviečia funkciją <code>daug(3, 1)</code>
; Taigi kokia yra <code>daug(3, 1)</code> reikšmė?
: Turime paleisti funkciją <code>daug()</code> su parametrais, kurie yra 3 ir 1.
; Kas nutinka toliau?
: Lokalūs kintamieji vėl pasileidus kodui jau yra nustatyti, todėl <code>a</code> reikšmė būtų 3, o <code>b</code> reikšmė – 1. Kadangi jie yra lokalūs kintamieji, todėl jie neturi įtakos ankstesnėms <code>a</code> ir <code>b</code> reikšmėms.
; Kas įvyksta toliau?
: Kadangi <code>b</code> turi reikšmę 1, if sąlygos rezultatas yra neigiamas, todėl vykdoma kita eilutė <code>lik = daug(a, b - 1)</code>.
; Ką daro ši eilutė?
: Dabar kintamajam <code>lik</code> priskiriam funkcijos <code>daug(3, 0)</code> reikšmė.
; Kokia ši reikšmė?
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> – 0.
; Kas vyksta toliau?
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code>
; Ką daro <code>return 0</code> eilutė?
: Ši eilutė grąžina funkcijos reikšmę lygią 0 į tą vietą, kur ji buvo iškviesta.
; Kas iš to?
: Dabar mes žinome, kad <code>daug(3, 0)</code> grąžina reikšmę 0. Dar žinome, ką daro eilutė <code>lik = daug(a, b - 1)</code>, nes paleidžiame funkciją <code>daug()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>daug(3, 0)</code> ir dabar vėl pradedame vykdyti <code>daug(3, 1)</code>. Kintamajam <code>lik</code> priskiriama reikšmė yra 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>reikšmė = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reikšmė = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return reikšmė</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.
; Kur yra <code>daug(3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reikšmė = a + lik</code> priskiria kintamajam <code>reikšmė</code> reikšmę <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradedama vykdyti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>rezultatas = daug(3, 2)</code>, kur kintamajam <code>rezultatas</code> dabar priskiriama reikšmė 6
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", rezultatas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>rezultatas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmo skaičiaus ir pirmo bei vienetu mažesnio už antrąjį sandaugos sumai <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Kai viskas surašoma vienoje eilutėje, gauname <code>3 + 3 + 0 </code>

Štai kaip viskas veikia:

daug(3, 2)
3 + daug(3, 1)
3 + 3 + daug(3, 0)
3 + 3 + 0
3 + 3
6

==== Rekursija ====
Funkcijos, kurios kreipiasi pačios į save yra vadinamos rekursinėmis funkcijomis. Šio skyriaus pavyzdžiuose panagrinėsime tokias funkcijas. Tai palengvina programavimo užduočių spendimų įgyvendinimą, nes kartais pakanka apsvarstyti tik vieną problemos žingsnį, o ne visą problemą iš karto. Be to tai leidžia išreikšti kai kurias matematines sąvokas paprastu, lengvai skaitomu kodu.

Bet kokią problemą, kurią galime išspręsti naudojant rekursiją, gali būti išspręsta naudojant ciklus. Jie veikia greičiau, bet kartais ciklus sunku atlikti teisingai.

Turbūt intuityviausias „rekursijos“ apibrėžimas yra toks:
REKURSIJA
Jei vis dar nesupranti, tai skaityk: REKURSIJA.
Pabandyk perskaityti dar kelis pavyzdžius.

=== Pavyzdžiai ===
'''faktorialas.py'''
<syntaxhighlight lang="python">
#apibrėžia funkciją, kuri apskaičiuoja koeficientą

def faktorialas(n):
if n == 0:
return 1
if n < 0:
return "Klaida, neigiami skaičiai neturi faktorialo reikšmių!!"
return n * faktorialas(n - 1)

print("2! =", faktorialas(2))
print("3! =", faktorialas(3))
print("4! =", faktorialas(4))
print("5! =", faktorialas(5))
print("-3! =", faktorialas(-3))
</syntaxhighlight>

Rezultatas:

2! = 2
3! = 6
4! = 24
5! = 120
-3! = Klaida, neigiami skaičiai neturi faktorialo reikšmių!!

'''atgalinis_skaičiavimas.py'''
<syntaxhighlight lang="python">
def atgalinis_skaičiavimas(n):
print(n)
if n > 0:
return atgalinis_skaičiavimas(n-1)

atgalinis_skaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



=== Pratimai ===
1. Parašyk programą, kuri paprašytų vartotojo įvesti skaičių ir laipsnį. Naudodamas rekursija, atspausdink skaičių pakelta duotuoju laipsniu. (Pvz: 23=8)

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
rezultatas = int()

def keltiLaipsniu(skaičius, laipsnis):
if laipsnis == 0:
return 1
return skaičius * keltiLaipsniu(skaičius, laipsnis - 1)

rezultatas = keltiLaipsniu(2, 3)

print(rezultatas)
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri prašo vartotojo įvesti skaičių ir grąžina sumą nuo 1 iki to skaičiaus. Pavyzdžiui, jei įvedamas skaičius 5, programa grąžina 5 + 4 + 3 + 2 + 1 = '''15'''. Nepamiršk naudoti rekursijos.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def suma_iki_vieno(skaičius, suma):
if skaičius == 0:
return suma
else:
return skaičius + suma_iki_vieno(skaičius - 1, suma)

įvestas_skaičius = int(input("Įvesk skaičių: "))
rezultatas = suma_iki_vieno(įvestas_skaičius, 0)
print ("Suma nuo 1 iki", įvestas_skaičius, ':', rezultatas)
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri prašo vartotojo įvesti žodį ir grąžina tą žodį parašytą iš kitos pusės. Pvz “Labas” = “sabaL”. Šios užduoties sprendimui tau prireiks [[Vadovėlis/Daugiau apie sąrašus|daugiau žinių apie sąrašus]].

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def apversk(žodis):
if len(žodis) == 0:
return žodis
else:
return apversk(žodis[1:]) + žodis[0]

įvestas_žodis = input("Įvesk žodį: ")
print(apversk(įvestas_žodis))
</syntaxhighlight>
|-
|}

{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Vadovėlis/Rekursinės funkcijos

2023-01-18T15:12:39Z

Monika: Pridėta antra užduotis

{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Vieniems šis skyrius gali pasirodyti naudingas, o kitiems - painus. Jeigu tau informacija pasirodys paini, tai nesuk galvos ir praleisk, prie šio skyriaus galėsi grįžti šiek tiek vėliau. O dabar pabandom pasižiūrėti į mūsų parašytą programą:
<syntaxhighlight lang="python">
def daug(a, b): # daug reiškia daugybą
if b == 0:
return 0
lik = daug(a, b - 1) #lik reiškia likutį
reikšmė = a + lik
return reikšmė
rezultatas = daug(3, 2)
print("3 * 2 = ", rezultatas)
</syntaxhighlight>

Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reikia atkreipti dėmesį į tai, kad Python'o programavimo kalboje jau yra integruota funkcija dauginimui, čia mes patys parašėme lengvai suprantamą pavyzdį (jeigu kurtume tokią funkciją patys), kuris parodo kaip atrodo daugybos veiksmas. Šioje programoje gali pamatyti rekursijos naudojimą, tai yra iteracijos (kartojimo) forma, kai funkcija yra pakartotinai iškviečiama, kol bus įvykdyta sukurta išvesties sąlyga. Programa naudoja pakartotinius papildymus, kad gautų tą patį rezultatą kaip ir daugyba: pavyzdžiui 3 + 3 (sudėtis) duoda tą patį rezultatą kaip ir 3 * 2 (daugyba).

; ''Klausimas:'' Ką pirmiausia daro programa?
: ''Atsakymas:'' Pirmiausia yra aprašyta daugybos funkcija:
<syntaxhighlight lang="python">
def daug(a, b):
if b == 0:
return 0
lik = daug(a, b - 1)
reikšmė = a + lik
return reikšmė
</syntaxhighlight>
: Ši funkcija paima du parametrus ir grąžina reikšmę. Vėliau šią funkciją galima bus iškviesti.
; Kas nutinka toliau?
: Vykdoma kita eilutė einanti po funkcijos <code>rezultatas = daug(3, 2)</code>
; Ką daro ši eilutė?
: Ši eilutė priskiria funkcijos <code>daug(3, 2)</code> grąžinamą reikšmę kintamajam <code>rezultatas</code>.
; Ką grąžina <code>daug(3, 2)</code>?
: Norėdami tai išsiaiškinti, turime peržiūrėti funkciją <code>daug()</code>.
; Kas vyksta su kodu?
: Kintamasis <code>a</code> gauna jam priskirtą reikšmę 3, o kintamasis <code>b</code> - jam priskirtą reikšmę 2.
; Kas nutinka tada?
: Vykdoma eilutė <code>if b == 0:</code>. Kadangi <code>b</code> reikšmė yra 2, todėl eilutė <code>return 0</code> praleidžiama.
; Kas vyksta toliau?
: Vykdoma eilutė <code>lik = daug(a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>lik</code> reikšmę į <code>daug(a, b - 1)</code> reikšmę. <code>a</code> reikšmė yra 3, o <code>b</code> - 2, todėl funkcija kviečia funkciją <code>daug(3, 1)</code>
; Taigi kokia yra <code>daug(3, 1)</code> reikšmė?
: Turime paleisti funkciją <code>daug()</code> su parametrais, kurie yra 3 ir 1.
; Kas nutinka toliau?
: Lokalūs kintamieji vėl pasileidus kodui jau yra nustatyti, todėl <code>a</code> reikšmė būtų 3, o <code>b</code> reikšmė – 1. Kadangi jie yra lokalūs kintamieji, todėl jie neturi įtakos ankstesnėms <code>a</code> ir <code>b</code> reikšmėms.
; Kas įvyksta toliau?
: Kadangi <code>b</code> turi reikšmę 1, if sąlygos rezultatas yra neigiamas, todėl vykdoma kita eilutė <code>lik = daug(a, b - 1)</code>.
; Ką daro ši eilutė?
: Dabar kintamajam <code>lik</code> priskiriam funkcijos <code>daug(3, 0)</code> reikšmė.
; Kokia ši reikšmė?
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> – 0.
; Kas vyksta toliau?
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code>
; Ką daro <code>return 0</code> eilutė?
: Ši eilutė grąžina funkcijos reikšmę lygią 0 į tą vietą, kur ji buvo iškviesta.
; Kas iš to?
: Dabar mes žinome, kad <code>daug(3, 0)</code> grąžina reikšmę 0. Dar žinome, ką daro eilutė <code>lik = daug(a, b - 1)</code>, nes paleidžiame funkciją <code>daug()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>daug(3, 0)</code> ir dabar vėl pradedame vykdyti <code>daug(3, 1)</code>. Kintamajam <code>lik</code> priskiriama reikšmė yra 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>reikšmė = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reikšmė = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return reikšmė</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.
; Kur yra <code>daug(3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reikšmė = a + lik</code> priskiria kintamajam <code>reikšmė</code> reikšmę <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradedama vykdyti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>rezultatas = daug(3, 2)</code>, kur kintamajam <code>rezultatas</code> dabar priskiriama reikšmė 6
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", rezultatas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>rezultatas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmo skaičiaus ir pirmo bei vienetu mažesnio už antrąjį sandaugos sumai <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Kai viskas surašoma vienoje eilutėje, gauname <code>3 + 3 + 0 </code>

Štai kaip viskas veikia:

daug(3, 2)
3 + daug(3, 1)
3 + 3 + daug(3, 0)
3 + 3 + 0
3 + 3
6

==== Rekursija ====
Funkcijos, kurios kreipiasi pačios į save yra vadinamos rekursinėmis funkcijomis. Šio skyriaus pavyzdžiuose panagrinėsime tokias funkcijas. Tai palengvina programavimo užduočių spendimų įgyvendinimą, nes kartais pakanka apsvarstyti tik vieną problemos žingsnį, o ne visą problemą iš karto. Be to tai leidžia išreikšti kai kurias matematines sąvokas paprastu, lengvai skaitomu kodu.

Bet kokią problemą, kurią galime išspręsti naudojant rekursiją, gali būti išspręsta naudojant ciklus. Jie veikia greičiau, bet kartais ciklus sunku atlikti teisingai.

Turbūt intuityviausias „rekursijos“ apibrėžimas yra toks:
REKURSIJA
Jei vis dar nesupranti, tai skaityk: REKURSIJA.
Pabandyk perskaityti dar kelis pavyzdžius.

=== Pavyzdžiai ===
'''faktorialas.py'''
<syntaxhighlight lang="python">
#apibrėžia funkciją, kuri apskaičiuoja koeficientą

def faktorialas(n):
if n == 0:
return 1
if n < 0:
return "Klaida, neigiami skaičiai neturi faktorialo reikšmių!!"
return n * faktorialas(n - 1)

print("2! =", faktorialas(2))
print("3! =", faktorialas(3))
print("4! =", faktorialas(4))
print("5! =", faktorialas(5))
print("-3! =", faktorialas(-3))
</syntaxhighlight>

Rezultatas:

2! = 2
3! = 6
4! = 24
5! = 120
-3! = Klaida, neigiami skaičiai neturi faktorialo reikšmių!!

'''atgalinis_skaičiavimas.py'''
<syntaxhighlight lang="python">
def atgalinis_skaičiavimas(n):
print(n)
if n > 0:
return atgalinis_skaičiavimas(n-1)

atgalinis_skaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



=== Pratimai ===
1. Parašyk programą, kuri paprašytų vartotojo įvesti skaičių ir laipsnį. Naudodamas rekursija, atspausdink skaičių pakelta duotuoju laipsniu. (Pvz: 23=8)

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
rezultatas = int()

def keltiLaipsniu(skaičius, laipsnis):
if laipsnis == 0:
return 1
return skaičius * keltiLaipsniu(skaičius, laipsnis - 1)

rezultatas = keltiLaipsniu(2, 3)

print(rezultatas)
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri prašo vartotojo įvesti skaičių ir grąžina sumą nuo 1 iki to skaičiaus. Pavyzdžiui, jei įvedamas skaičius 5, programa grąžina 5 + 4 + 3 + 2 + 1 = '''15'''. Nepamiršk naudoti rekursijos.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def suma_iki_vieno(skaičius, suma):
if skaičius == 0:
return suma
else:
return skaičius + suma_iki_vieno(skaičius - 1, suma)

įvestas_skaičius = int(input("Įvesk skaičių: "))
rezultatas = suma_iki_vieno(įvestas_skaičius, 0)
print ("Suma nuo 1 iki", įvestas_skaičius, ':', rezultatas)
</syntaxhighlight>
|-
|}

{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Vadovėlis/Funkcijų apibrėžimas

2023-01-18T14:46:17Z

Monika: Pridėta užduotis

{{navigation |previous=Derinimas |next=Rekursinės funkcijos}}

=== Funkcijų kūrimas ===
Prieš pradėdami šį skyrių pateiksime tau pavyzdį, kurio gali nepersirašinėti:
<syntaxhighlight lang=python>
a = 23
b = -23

if a < 0:
a = -a
if b < 0:
b = -b
if a == b:
print("Absoliučios", a, "ir", b, "reikšmės yra lygios.")
else:
print("Absoliučios", a, "ir", b, "reikšmės yra skirtingos.")
</syntaxhighlight>

Programos rezultatas:

Absoliučios 23 ir 23 reikšmės yra lygios.

Ar neatrodo, kad programa yra šiek tiek pasikartojanti?.. Ir tikriausiai jau numanai, programuotojai nemėgsta pasikartojančių dalykų, nes juk pasikartojantiems dalykams atlikti ir yra sukurti kompiuteriai!! Be to atkreipk dėmesį, kad radus absoliučią reikšmę pasikeitė kintamojo vertė, todėl programa spausdina 23, o ne -23. Mūsų laimei Python'as leidžia sukurti funkcijas, kurios šalina dubliavimą:
<syntaxhighlight lang=python>
a = 23
b = -23

def absoliuti_reikšmė(n):
if n < 0:
n = -n
return n

if absoliuti_reikšmė(a) == absoliuti_reikšmė(b):
print("Absoliučios", a, "ir", b, "reikšmės yra lygios.")
else:
print("Absoliučios", a, "ir", b, "reikšmės yra skirtingos.")
</syntaxhighlight>

Programos rezultatas:

Absoliučios 23 ir -23 reikšmės yra lygios.

Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. pabandykime patyrinėti dar kelias naujas funkcijas.

Ar pastebėjai, kad <code>a</code> ir <code>b</code> reikšmės nepasikeitė?

Funkcijos taip pat gali būti naudojamos vykdant užduotis, kurios negrąžina reikšmių. Štai keli pavyzdžiai, kuriuose skirtingai aprašomos funkcijos:
<syntaxhighlight lang="python">
def labas():
print("Labas")

def plotas(plotis, aukštis):
return plotis * aukštis

def rašyk_mano_vardas(vardas):
print("Mano vardas", vardas)

labas()
labas()

rašyk_mano_vardas("Benas")
w = 4
h = 5
print("plotis =", w, " aukštis=", h, " plotas=", plotas(w, h))
</syntaxhighlight>

programos rezultatas

Labas
Labas
Mano vardas Benas
plotis = 4 aukštis = 5 plotas = 20

Šis pavyzdys parodo ir daugiau dalykų, kuriuos galima padaryti su funkcijomis. Atkreipk dėmesį, kad galima nenaudoti argumentų arba galima naudoti du argumentus, ar daugiau. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.



=== Kintamieji funkcijose ===
Dažnai pasitaiko, kad pasikartojančiam kode yra kintamųjų, todėl į juos reikia atkreipti dėmesį, kai šaliname pakartotiną kodą. Iki šiol visi kintamieji, kuriuos matėme buvo globalūs. Tokie kintamieji gali būti pasiekiami ir naudojami bet kurioje programos vietoje. Funkcijose esantys kintamieji yra vadinami specialiu pavadinimu - lokalūs kintamieji. Šie kintamieji egzistuoja tik veikiant funkcijai. Kai lokalus kintamasis turi globalaus kintamojo pavadinimą, tai funkcijoje pirmenybė teikiama ir naudojamas lokalus kintamasis. Skamba painiai? Štai keli pavyzdžiai:

<syntaxhighlight lang="python">
a = 4

def manoFunkcija():
a = 17
print("Mano funkcijoje a =", a)

manoFunkcija()
print("a = ", a)
</syntaxhighlight>

Gaunamas rezultatas
Mano funkcijoje a = 17
a = 4

Kaip matai pavyzdyje, funkcijos viduje esantis kintamasis nepaiso globalaus kintamojo, nes jis egzistuoja tik funkcijos viduje. Taip pat, turėjai pastebėti, kad funkcijos viduje kintamajam <code>a</code> buvo priskirta nauja reikšmė, bet ji buvo aktuali tik funkcijoje, o ne už jos ribų - globalus kintamasis <code>a</code> liko nepakitęs.

Kitas kiek sudėtingesnis kodo pavyzdys:
<syntaxhighlight lang="python">
kintamasis_a = 10
kintamasis_b = 15
kintamasis_e = 25

def funkcija(kintamasis_a):
print("funkcijoje kintamasis_a =", kintamasis_a)
kintamasis_b = 100 + kintamasis_a
kintamasis_d = 2 * kintamasis_a
print("funkcijoje kintamasis_b =", kintamasis_b)
print("funkcijoje kintamasis_d =", kintamasis_d)
print("funkcijoje kintamasis_e =", kintamasis_e)
return kintamasis_b + 10

kintamasis_c = funkcija(kintamasis_b)

print("kintamasis_a =", kintamasis_a)
print("kintamasis_b =", kintamasis_b)
print("kintamasis_c =", kintamasis_c)
print("kintamasis_d =", kintamasis_d)

</syntaxhighlight>

rezultatas:

funkcijoje kintamasis_a = 15
funkcijoje kintamasis_b = 115
funkcijoje kintamasis_d = 30
funkcijoje kintamasis_e = 25
kintamasis_a = 10
kintamasis_b = 15
kintamasis_c = 125
kintamasis_d =

Klaida (paskutinė aptikta klaida):
File "C:\def2.py", eilutė 19, in <module> (modulyje)
print("kintamasis_d = ", kintamasis_d)
NameError: pavadinimas 'kintamasis_d' yra neapibrėžtas

Šiame pavyzdyje kintamieji <code>kintamasis_a</code>, <code>kintamasis_b</code> ir <code>kintamasis_d</code>, esantys funkcijos viduje, yra lokalūs kintamieji. Po paskutinės funkcijos eilutės <code>return kintamasis_b + 10</code> įvykdymo, visi jie nustoja egzistuoti. Kintamasis <code>kintamasis_a</code> yra parametro pavadinimas, todėl tai jį automatiškai padaro lokaliu kintamuoju. Kintamieji <code>kintamasis_b</code> ir <code>kintamasis_d</code> yra lokalūs kintamieji, nes jie rodomi funkcijos lygybės ženklo kairėje pusėje esančiuose teiginiuose <code>kintamasis_b = 100 + kintamasis_a</code> ir <code>kintamasis_d = 2 * kintamasis_a</code>.

Kai funkcija iškviečiama naudojant <code>kintamasis_c = funkcija(kintamasis_b)</code>, 15 priskiriama kintamajam <code>kintamasis_a</code>, nes tuo metu, kai kviečiama funkcija <code>funkcija(kintamasis_b)</code>, globalaus <code>kintamasis_b</code> reikšmė yra 15. Taigi <code>kintamasis_a</code> reikšmė nustatoma į 15, kai jis yra funkcijos <code>funkcija()</code> viduje.

Kaip matai, pasibaigus funkcijai, lokalūs kintamieji <code>kintamasis_a</code> ir <code>kintamasis_b</code>, kurie buvo naudojami funkcijos viduje, dingo. Tad komanda <code>print ("kintamasis_a =", kintamasis_a)</code> atspausdina reikšmę <code>10</code>, t. y. globaliojo kintamojo <code>kintamasis_a</code> reikšmę.

Taip pat, atkreipk dėmesį į klaidą <code> NameError </code>, kuri atsiranda mūsų programos pabaigoje. Tai nutinka, nes kintamasis <code>kintamasis_d</code> nebeegzistuoja nuo tada, kai baigėsi <code>funkcija()</code>. Pasibaigus funkcijai, visi lokalūs kintamieji ištrinami. Jeigu nori, ką nors gauti iš funkcijos, turėsi naudoti komandą <code>return</code>.

Paskutinis dalykas, į kurį reikia atkreipti dėmesį, yra tai, kad funkcijos viduje <code>kintamasis_e</code> reikšmė išlieka nepakitusi, nes tai nėra nei parametras, nei lokalus kintamasis – jis niekada nerodomas kairėje lygybės pusėje. Kai funkcijos viduje kreipiamasi į globalų kintamąjį, tai jis naudoja reikšmę, įgytą už funkcijos ribų.

Funkcijos naudoja lokalius kintamuosius, kurie egzistuoja tik funkcijos viduje, ir gali ignoruoti kitus kintamuosius, kurie yra už funkcijos ribų.

=== Pavyzdžiai ===
'''temperatūra2.py'''
<syntaxhighlight lang="python">
#! /usr/bin/python
#-*-coding: utf-8 -*-
# konvertuoja temperatūrą į Farenheitus ar Celsijų

def spausdinti_pasirinkimus():
print("Pasirinkimai:")
print(" 's' spausdinti pasirinkimus")
print(" 'c' konvertuoti iš Celsijaus")
print(" 'f' konvertuoti iš Farenheitų")
print(" 'i' išjungti programą")

def celsijus_į_farenheitus(c_temp):
return 9.0 / 5.0 * c_temp + 32

def farenheitai_į_celsijų(f_temp):
return (f_temp - 32.0) * 5.0 / 9.0

pasirinkimas = "s"
while pasirinkimas != "i":
if pasirinkimas == "c":
c_temp = float(input("Celsijaus temperatūra: "))
print("Farenheitai:", celsijus_į_farenheitus(c_temp))
pasirinkimas = input("pasirinkimas: ")
elif pasirinkimas == "f":
f_temp = float(input("farenheitai_į_celsijų: "))
print("Celsijus:", farenheitai_į_celsijų(f_temp))
pasirinkimas= input("pasirinkimas: ")
else:
pasirinkimas= "s" #Arba pasirinkimas! = "i": kad spausdintų
#kai įrašoma, kas nors netikėto
spausdinti_pasirinkimus()
pasirinkimas = input("pasirinkimas: ")
</syntaxhighlight>

Kaip tai veikia?:

Pasirinkimai:
's' spausdinti pasirinkimus
'c' konvertuoti iš Celsijaus
'f' konvertuoti iš Farenheitų
'i' išjungti programą
pasirinkimas: '''c'''
Celsijaus temperatūra: '''30'''
Farenheitai: 86.0
pasirinkimas: '''f'''
Farenheitų temperatūra: '''60'''
Celsijus: 15.5555555556
pasirinkimas: '''i'''

'''plotas2.py'''
<syntaxhighlight lang="python">
#! /usr/bin/python
#-*-coding: utf-8 -*-
# apskaičiuoja duotą stačiakampio plotą

def pasisveikinimas():
print('Labas!')

def plotas(plotis, aukštis):
return plotis * aukštis

def mano_vardas(vardas):
print('Mano vardas yra,', vardas)

def teigiama_įvestis(sugalvotas_skaičius):
skaičius = float(input(sugalvotas_skaičius))
while skaičius<= 0:
print('Privalo būti teigiamas skaičius')
skaičius = float(input(sugalvotas_skaičius))
return skaičius

vardas = input('Tavo vardas: ')
pasisveikinimas()
mano_vardas(name)
print()
print('Kad rastum stačiakampio plotą,')
print('įrašyk plotį ir aukštį')
print()
w = teigiama_įvestis('Plotis: ')
h = teigiama_įvestis('Aukštis: ')

print('Plotis =', w, ' Aukštis =', h, ' Plotas =', area(w, h))
</syntaxhighlight>

Kaip veikia ši programa?

Tavo vardas: '''Benas'''
Labas!
Mano vardas yra Benas

Kad rastum stačiakampio plotą,
įrašyk plotį ir aukštį.

Plotis: '''-4'''
Privalo būti teigiamas skaičius
Plotis: '''4'''
Aukštis: '''3'''
Plotis = 4 Aukštis = 3 Plotas = 12

=== Pratimai ===

1. Parašyk programą, kurioje būtų funkcija, kuriai padavus skaičių, ji grąžina to skaičiaus, pakelto kubu, reikšmę. Patikrink funkcijos veikimą išvesdamas kelių skirtingų skaičių, pakeltų kubu, reikšmes.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def pakelk_kubu(skaičius):
kubas = skaičius * skaičius * skaičius
print(skaičius, " pakelta kubu yra ", kubas)

pakelk_kubu(1)
pakelk_kubu(2)
pakelk_kubu(3)
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri prašytų vartotojo įvesti du skaičius. Programoje turėtų būti funkcija, kuriai padavus du skaičius, ji grąžintų rezultatą, kuris skaičius yra didesnis arba, kad skaičiai yra lygūs.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kuris_didesnis(pirmas, antras):
if pirmas > antras:
return 'Pirmas skaičius didesnis'
elif antras > pirmas:
return 'Antras skaičius didesnis'
else:
return 'Skaičiai lygūs'

pirmas_skaičius = int(input("Įvesk pirmą skaičių: "))
antras_skaičius = int(input("Įvesk antrą skaičių: "))

rezultatas = kuris_didesnis(pirmas_skaičius, antras_skaičius)
print (rezultatas)
</syntaxhighlight>
|-
|}

3. Perrašyk programą plotas2.py, kuri yra aukščiau pateiktame pavyzdyje, taip, kad būtų parašytos atskiros kvadrato, stačiakampio ir apskritimo ploto funkcijos ((<code>3.14 * spindulys**2</code>). Taip pat šioje programoje turėtų būti sukurtas toks pasirinkimų meniu:

Pasirinkimai:
s = skaičiuoti kvadrato plotą.
c = skaičiuoti apskritimo plotą.
r = skaičiuoti stačiakampio plotą.
q = išeiti.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

def stačiakampis(aukštis, plotis):
return aukštis * plotis

def apskritimas(spindulys):
return 3.14159 * spindulys** 2

def parinktys():
print()
print("Pasirinkimai:")
print("s = skaičiuoti kvadrato plotą.")
print("c = skaičiuoti apskritimo plotą.")
print("r = skaičiuoti stačiakampio plotą.")
print("q = išeiti")
print()

print("Ši programa apskaičiuos kvadrato, apskritimo ar stačiakampio plotą.")
pasirinkimas = "x"
parinktys()
while pasirinkimas != "q":
choice = input("Įrašyk savo pasirinkimą: ")
if pasirinkimas== "s":
L = float(input("Kvadrato kraštinės ilgis: "))
print("Šio kvadrato plotas", kvadratas(L))
parinktys()
elif pasirinkimas == "c":
spindulys = float(input("Apskritimo spindulys yra: "))
print("Apskritimo plotas yra", apskritimas(spindulys))
parinktys()
elif pasirinkimas == "r":
plotis = float(input("Stačiakampio plotis: "))
aukštis = float(input("Stačiakampio aukštis: "))
print("Stačiakampio plotas yra", kvadratas(plotis, aukštis))
parinktys()
elif pasirinkimas == "q":
print(" ",end="")
else:
print("Neatpažintas pasirinkimas.")
parinktys()
</syntaxhighlight>
|-
|}

{{navigation |previous=Derinimas |next=Rekursinės funkcijos}}

Vadovėlis/Funkcijų apibrėžimas

2023-01-06T14:29:12Z

Monika: Pridėta užduotis

{{navigation |previous=Derinimas |next=Rekursinės funkcijos}}

=== Funkcijų kūrimas ===
Prieš pradėdami šį skyrių pateiksime tau pavyzdį, kurio gali nepersirašinėti:
<syntaxhighlight lang=python>
a = 23
b = -23

if a < 0:
a = -a
if b < 0:
b = -b
if a == b:
print("Absoliučios", a, "ir", b, "reikšmės yra lygios.")
else:
print("Absoliučios", a, "ir", b, "reikšmės yra skirtingos.")
</syntaxhighlight>

Programos rezultatas:

Absoliučios 23 ir 23 reikšmės yra lygios.

Ar neatrodo, kad programa yra šiek tiek pasikartojanti?.. Ir tikriausiai jau numanai, programuotojai nemėgsta pasikartojančių dalykų, nes juk pasikartojantiems dalykams atlikti ir yra sukurti kompiuteriai!! Be to atkreipk dėmesį, kad radus absoliučią reikšmę pasikeitė kintamojo vertė, todėl programa spausdina 23, o ne -23. Mūsų laimei Python'as leidžia sukurti funkcijas, kurios šalina dubliavimą:
<syntaxhighlight lang=python>
a = 23
b = -23

def absoliuti_reikšmė(n):
if n < 0:
n = -n
return n

if absoliuti_reikšmė(a) == absoliuti_reikšmė(b):
print("Absoliučios", a, "ir", b, "reikšmės yra lygios.")
else:
print("Absoliučios", a, "ir", b, "reikšmės yra skirtingos.")
</syntaxhighlight>

Programos rezultatas:

Absoliučios 23 ir -23 reikšmės yra lygios.

Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. pabandykime patyrinėti dar kelias naujas funkcijas.

Ar pastebėjai, kad <code>a</code> ir <code>b</code> reikšmės nepasikeitė?

Funkcijos taip pat gali būti naudojamos vykdant užduotis, kurios negrąžina reikšmių. Štai keli pavyzdžiai, kuriuose skirtingai aprašomos funkcijos:
<syntaxhighlight lang="python">
def labas():
print("Labas")

def plotas(plotis, aukštis):
return plotis * aukštis

def rašyk_mano_vardas(vardas):
print("Mano vardas", vardas)

labas()
labas()

rašyk_mano_vardas("Benas")
w = 4
h = 5
print("plotis =", w, " aukštis=", h, " plotas=", plotas(w, h))
</syntaxhighlight>

programos rezultatas

Labas
Labas
Mano vardas Benas
plotis = 4 aukštis = 5 plotas = 20

Šis pavyzdys parodo ir daugiau dalykų, kuriuos galima padaryti su funkcijomis. Atkreipk dėmesį, kad galima nenaudoti argumentų arba galima naudoti du argumentus, ar daugiau. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.



=== Kintamieji funkcijose ===
Dažnai pasitaiko, kad pasikartojančiam kode yra kintamųjų, todėl į juos reikia atkreipti dėmesį, kai šaliname pakartotiną kodą. Iki šiol visi kintamieji, kuriuos matėme buvo globalūs. Tokie kintamieji gali būti pasiekiami ir naudojami bet kurioje programos vietoje. Funkcijose esantys kintamieji yra vadinami specialiu pavadinimu - lokalūs kintamieji. Šie kintamieji egzistuoja tik veikiant funkcijai. Kai lokalus kintamasis turi globalaus kintamojo pavadinimą, tai funkcijoje pirmenybė teikiama ir naudojamas lokalus kintamasis. Skamba painiai? Štai keli pavyzdžiai:

<syntaxhighlight lang="python">
a = 4

def manoFunkcija():
a = 17
print("Mano funkcijoje a =", a)

manoFunkcija()
print("a = ", a)
</syntaxhighlight>

Gaunamas rezultatas
Mano funkcijoje a = 17
a = 4

Kaip matai pavyzdyje, funkcijos viduje esantis kintamasis nepaiso globalaus kintamojo, nes jis egzistuoja tik funkcijos viduje. Taip pat, turėjai pastebėti, kad funkcijos viduje kintamajam <code>a</code> buvo priskirta nauja reikšmė, bet ji buvo aktuali tik funkcijoje, o ne už jos ribų - globalus kintamasis <code>a</code> liko nepakitęs.

Kitas kiek sudėtingesnis kodo pavyzdys:
<syntaxhighlight lang="python">
kintamasis_a = 10
kintamasis_b = 15
kintamasis_e = 25

def funkcija(kintamasis_a):
print("funkcijoje kintamasis_a =", kintamasis_a)
kintamasis_b = 100 + kintamasis_a
kintamasis_d = 2 * kintamasis_a
print("funkcijoje kintamasis_b =", kintamasis_b)
print("funkcijoje kintamasis_d =", kintamasis_d)
print("funkcijoje kintamasis_e =", kintamasis_e)
return kintamasis_b + 10

kintamasis_c = funkcija(kintamasis_b)

print("kintamasis_a =", kintamasis_a)
print("kintamasis_b =", kintamasis_b)
print("kintamasis_c =", kintamasis_c)
print("kintamasis_d =", kintamasis_d)

</syntaxhighlight>

rezultatas:

funkcijoje kintamasis_a = 15
funkcijoje kintamasis_b = 115
funkcijoje kintamasis_d = 30
funkcijoje kintamasis_e = 25
kintamasis_a = 10
kintamasis_b = 15
kintamasis_c = 125
kintamasis_d =

Klaida (paskutinė aptikta klaida):
File "C:\def2.py", eilutė 19, in <module> (modulyje)
print("kintamasis_d = ", kintamasis_d)
NameError: pavadinimas 'kintamasis_d' yra neapibrėžtas

Šiame pavyzdyje kintamieji <code>kintamasis_a</code>, <code>kintamasis_b</code> ir <code>kintamasis_d</code>, esantys funkcijos viduje, yra lokalūs kintamieji. Po paskutinės funkcijos eilutės <code>return kintamasis_b + 10</code> įvykdymo, visi jie nustoja egzistuoti. Kintamasis <code>kintamasis_a</code> yra parametro pavadinimas, todėl tai jį automatiškai padaro lokaliu kintamuoju. Kintamieji <code>kintamasis_b</code> ir <code>kintamasis_d</code> yra lokalūs kintamieji, nes jie rodomi funkcijos lygybės ženklo kairėje pusėje esančiuose teiginiuose <code>kintamasis_b = 100 + kintamasis_a</code> ir <code>kintamasis_d = 2 * kintamasis_a</code>.

Kai funkcija iškviečiama naudojant <code>kintamasis_c = funkcija(kintamasis_b)</code>, 15 priskiriama kintamajam <code>kintamasis_a</code>, nes tuo metu, kai kviečiama funkcija <code>funkcija(kintamasis_b)</code>, globalaus <code>kintamasis_b</code> reikšmė yra 15. Taigi <code>kintamasis_a</code> reikšmė nustatoma į 15, kai jis yra funkcijos <code>funkcija()</code> viduje.

Kaip matai, pasibaigus funkcijai, lokalūs kintamieji <code>kintamasis_a</code> ir <code>kintamasis_b</code>, kurie buvo naudojami funkcijos viduje, dingo. Tad komanda <code>print ("kintamasis_a =", kintamasis_a)</code> atspausdina reikšmę <code>10</code>, t. y. globaliojo kintamojo <code>kintamasis_a</code> reikšmę.

Taip pat, atkreipk dėmesį į klaidą <code> NameError </code>, kuri atsiranda mūsų programos pabaigoje. Tai nutinka, nes kintamasis <code>kintamasis_d</code> nebeegzistuoja nuo tada, kai baigėsi <code>funkcija()</code>. Pasibaigus funkcijai, visi lokalūs kintamieji ištrinami. Jeigu nori, ką nors gauti iš funkcijos, turėsi naudoti komandą <code>return</code>.

Paskutinis dalykas, į kurį reikia atkreipti dėmesį, yra tai, kad funkcijos viduje <code>kintamasis_e</code> reikšmė išlieka nepakitusi, nes tai nėra nei parametras, nei lokalus kintamasis – jis niekada nerodomas kairėje lygybės pusėje. Kai funkcijos viduje kreipiamasi į globalų kintamąjį, tai jis naudoja reikšmę, įgytą už funkcijos ribų.

Funkcijos naudoja lokalius kintamuosius, kurie egzistuoja tik funkcijos viduje, ir gali ignoruoti kitus kintamuosius, kurie yra už funkcijos ribų.

=== Pavyzdžiai ===
'''temperatūra2.py'''
<syntaxhighlight lang="python">
#! /usr/bin/python
#-*-coding: utf-8 -*-
# konvertuoja temperatūrą į Farenheitus ar Celsijų

def spausdinti_pasirinkimus():
print("Pasirinkimai:")
print(" 's' spausdinti pasirinkimus")
print(" 'c' konvertuoti iš Celsijaus")
print(" 'f' konvertuoti iš Farenheitų")
print(" 'i' išjungti programą")

def celsijus_į_farenheitus(c_temp):
return 9.0 / 5.0 * c_temp + 32

def farenheitai_į_celsijų(f_temp):
return (f_temp - 32.0) * 5.0 / 9.0

pasirinkimas = "s"
while pasirinkimas != "i":
if pasirinkimas == "c":
c_temp = float(input("Celsijaus temperatūra: "))
print("Farenheitai:", celsijus_į_farenheitus(c_temp))
pasirinkimas = input("pasirinkimas: ")
elif pasirinkimas == "f":
f_temp = float(input("farenheitai_į_celsijų: "))
print("Celsijus:", farenheitai_į_celsijų(f_temp))
pasirinkimas= input("pasirinkimas: ")
else:
pasirinkimas= "s" #Arba pasirinkimas! = "i": kad spausdintų
#kai įrašoma, kas nors netikėto
spausdinti_pasirinkimus()
pasirinkimas = input("pasirinkimas: ")
</syntaxhighlight>

Kaip tai veikia?:

Pasirinkimai:
's' spausdinti pasirinkimus
'c' konvertuoti iš Celsijaus
'f' konvertuoti iš Farenheitų
'i' išjungti programą
pasirinkimas: '''c'''
Celsijaus temperatūra: '''30'''
Farenheitai: 86.0
pasirinkimas: '''f'''
Farenheitų temperatūra: '''60'''
Celsijus: 15.5555555556
pasirinkimas: '''i'''

'''plotas2.py'''
<syntaxhighlight lang="python">
#! /usr/bin/python
#-*-coding: utf-8 -*-
# apskaičiuoja duotą stačiakampio plotą

def pasisveikinimas():
print('Labas!')

def plotas(plotis, aukštis):
return plotis * aukštis

def mano_vardas(vardas):
print('Mano vardas yra,', vardas)

def teigiama_įvestis(sugalvotas_skaičius):
skaičius = float(input(sugalvotas_skaičius))
while skaičius<= 0:
print('Privalo būti teigiamas skaičius')
skaičius = float(input(sugalvotas_skaičius))
return skaičius

vardas = input('Tavo vardas: ')
pasisveikinimas()
mano_vardas(name)
print()
print('Kad rastum stačiakampio plotą,')
print('įrašyk plotį ir aukštį')
print()
w = teigiama_įvestis('Plotis: ')
h = teigiama_įvestis('Aukštis: ')

print('Plotis =', w, ' Aukštis =', h, ' Plotas =', area(w, h))
</syntaxhighlight>

Kaip veikia ši programa?

Tavo vardas: '''Benas'''
Labas!
Mano vardas yra Benas

Kad rastum stačiakampio plotą,
įrašyk plotį ir aukštį.

Plotis: '''-4'''
Privalo būti teigiamas skaičius
Plotis: '''4'''
Aukštis: '''3'''
Plotis = 4 Aukštis = 3 Plotas = 12

=== Pratimai ===

1. Parašyk programą, kurioje būtų funkcija, kuriai padavus skaičių, ji grąžina to skaičiaus, pakelto kubu, reikšmę. Patikrink funkcijos veikimą išvesdamas kelių skirtingų skaičių, pakeltų kubu, reikšmes.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def pakelk_kubu(skaičius):
kubas = skaičius * skaičius * skaičius
print(skaičius, " pakelta kubu yra ", kubas)

pakelk_kubu(1)
pakelk_kubu(2)
pakelk_kubu(3)
</syntaxhighlight>
|-
|}

2. Perrašyk programą plotas2.py, kuri yra aukščiau pateiktame pavyzdyje, taip, kad būtų parašytos atskiros kvadrato, stačiakampio ir apskritimo ploto funkcijos ((<code>3.14 * spindulys**2</code>). Taip pat šioje programoje turėtų būti sukurtas toks pasirinkimų meniu:

Pasirinkimai:
s = skaičiuoti kvadrato plotą.
c = skaičiuoti apskritimo plotą.
r = skaičiuoti stačiakampio plotą.
q = išeiti.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

def stačiakampis(aukštis, plotis):
return aukštis * plotis

def apskritimas(spindulys):
return 3.14159 * spindulys** 2

def parinktys():
print()
print("Pasirinkimai:")
print("s = skaičiuoti kvadrato plotą.")
print("c = skaičiuoti apskritimo plotą.")
print("r = skaičiuoti stačiakampio plotą.")
print("q = išeiti")
print()

print("Ši programa apskaičiuos kvadrato, apskritimo ar stačiakampio plotą.")
pasirinkimas = "x"
parinktys()
while pasirinkimas != "q":
choice = input("Įrašyk savo pasirinkimą: ")
if pasirinkimas== "s":
L = float(input("Kvadrato kraštinės ilgis: "))
print("Šio kvadrato plotas", kvadratas(L))
parinktys()
elif pasirinkimas == "c":
spindulys = float(input("Apskritimo spindulys yra: "))
print("Apskritimo plotas yra", apskritimas(spindulys))
parinktys()
elif pasirinkimas == "r":
plotis = float(input("Stačiakampio plotis: "))
aukštis = float(input("Stačiakampio aukštis: "))
print("Stačiakampio plotas yra", kvadratas(plotis, aukštis))
parinktys()
elif pasirinkimas == "q":
print(" ",end="")
else:
print("Neatpažintas pasirinkimas.")
parinktys()
</syntaxhighlight>
|-
|}

{{navigation |previous=Derinimas |next=Rekursinės funkcijos}}

Vadovėlis/Derinimas

2023-01-05T09:18:20Z

Monika: Pridėta papildoma užduotis

{{navigation |previous=Pasirinkimai |next=Funkcijų apibrėžimas}}
{{BookCat}}

=== Kas yra derinimas? ===
:„Pradėjus programuoti supratau, kad nėra taip lengva kurti teisingai veikiančias programas. Atsimenu akimirką, kai supratau, kad didedė dalis mano gyvenimo, bus skirta klaidų ieškojimui mano paties kurtose programose. Taip atsidaro derinimas.“ — ''Maurice Wilkes atranda derinimą'', 1949

Jei jau bandei parašyti kelias programas, turbūt pastebėjai, kad kartais programa daro ką nors, ko neturėtų daryti. Tai yra tikrai dažna situacija. Derinimas tai yra procesas, kuomet bandoma suprasti, ką kompiuteris daro ir kaip jį priversti daryti tai, ką norėtum, kad jis darytų. Tai gali būti sudėtinga. Vieną kartą aš praleidau beveik savaitę ieškodamas ir taisydamas klaidą, kurią sukėlė kitas žmogus, kode parašęs <code>x</code> vietoje <code>y</code>.

Ši dalis bus abstraktesnė, nei prieš tai buvusios dalys.

=== Ką turėtų daryti programa? ===

Pirmas dalykas, ką reikia padaryti (kad ir kaip akivaizdžiai tai skamba), tai suprasti, ką turėtų daryti teisingai veikianti programa. Sugalvok kelis tikrinimo scenarijus ir pažiūrėk, kas nutiks. Tarkime, kad aš noriu sukurti programą, kuri suskaičiuoja stačiakampio perimetrą (visų kraštinių sumą). Turiu tokius tikrinimo scenarijus:

{| class="wikitable"
|-
!aukštis !! plotis !!perimetras
|-
|3 ||4 ||14
|--
|2 ||3 ||10
|-
|4 ||4 ||16
|-
|2 ||2 ||8
|-
|5 ||1 ||12
|-
|}

Dabar galiu vykdyti savo programą su visais tikrinimo scenarijais ir pamatyti, ar programa daro tai, ko tikiuosi. Jei ne, turiu suprasti, ką iš tiesų daro kompiuteris.

Dažniausiai, dalis tikrinimo scenarijų veikia, dalis - ne. Jei toks yra ir tavo atvejis, turėtum bandyti suprasti, ką veikiantys scenarijai turi bendro.
Pavyzdžiui, apačioje yra perimetro programos išvestis (kodas bus pateiktas kiek vėliau):

Aukštis: '''3'''
Plotis: '''4'''
Perimetras = 15

Aukštis: '''2'''
Plotis: '''3'''
Perimetras = 11

Aukštis: '''4'''
Plotis: '''4'''
Perimetras = 16

Aukštis: '''2'''
Plotis: '''2'''
Perimetras = 8

Aukštis: '''5'''
Plotis: '''1'''
Perimetras = 8

Gali pastebėti, kad programa neveikė su pirmomis dvejomis įvestimis, veikė su sekančiomis dvejomis ir vėl neveikė su paskutine. Pabandyk sugalvoti, kas yra bendro tarp veikiančių scenarijų. Kai supranti, kokia yra programos problema, atrasti jos priežastį yra daug lengviau. Jei reikia, savo programoms gali sugalvoti ir daugiau tikrinimo scenarijų.

=== Ką daro programa? ===

Kitas dalykas, ką reikia padaryti, tai peržiūrėti pirminį programos tekstą. Tai vienas iš svarbiausių dalykų programavime. Pagrindinis būdas, kaip tai daroma - tai kodo peržiūros.

Kodo peržiūra prasideda pirma eilute ir tęsiasi iki programos galo. <code>while</code> ciklai ir <code>if</code> sakiniai reiškia, kad kai kurios eilutės gali būti nekviečiamos niekada, o kai kurios - vykdomos keletą kartų. Kiekvienoje eilutėje turi suprasti, ką daro Python'as.

Pradėkime su paprasta parametro programa. Šios programos nerašyk. Tau reikės ją tik skaityti, ne vykdyti. Programos pirminis tekstas:

<syntaxhighlight lang="python">
aukstis = int(input("Aukštis: "))
plotis = int(input("Plotis: "))
print("perimetras =", plotis + aukstis + plotis + plotis)
</syntaxhighlight>

; ''Klausimas:'' Kuri eilutė vykdoma pirma?
: ''Atsakymas:'' Pirmoji kodo eilutė visada yra vykdoma pirma. Šiuo atveju tai: <code>aukstis = int(input("Aukštis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Aukštis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>aukstis</code>.
; Kuri eilutė vykdoma po to?
: Bendrai, tai yra kita eilutė, kuri yra <code>plotis = int(input("Plotis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Plotis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>plotis</code>.
; Kuri eilutė vykdoma po to?
: Kai kita eilutė nėra daugiau ar mažiau įtraukta, nei esama eilutė, ji ir yra vykdoma. Šiuo atveju tai: <code>print("perimetras =", plotis + aukstis + plotis + plotis)</code> (Taip pat gali būti kviečiama funkcija esamoje eilutėje, bet tai bus paaiškinta tolimesniame skyriuje)
; Ką daro ši eilutė?
: Visų pirma, ji spausdina <code>perimetras = </code>, o tada - sumą, sudarytą iš kintamųjų <code>plotis</code> ir <code>aukstis</code>, kuri užrašoma taip: <code>plotis + aukstis + plotis + plotis</code>.
; Ar kodas <code>plotis + aukstis + plotis + plotis</code> skaičiuoja perimetrą teisingai?
: Pažiūrėk: stačiakampio perimetras yra apatinė kraštinė (plotis), plius kairė (aukstis), plius viršutinė (plotis), plius dešinė kraštinė (a?). Paskutinis kintamasis turėtų būti dešinės kraštinės ilgis, arba kitaip - aukštis.
; Ar supranti, kodėl, kai kuriais atvejais, skaičiuojant perimetrą buvo gaunamas teisingas atsakymas?
: Teisingas atsakymas buvo gaunamas kai aukštis ir plotis buvo lygūs.

Kita programa, kurios kodo peržiūrą darysime, tai programa, kuri turėtų ekrane išvesti 5 taškus. Tačiau, programos išvestis yra:

. . . .

Programa:
<syntaxhighlight lang="python">
skaicius = 5
while skaicius > 1:
print(".", end = " ")
skaicius = skaicius - 1
print()
</syntaxhighlight>

Šios programos peržiūra bus kiek sudėtingesnė, nes joje yra įtrauktų kodo dalių. Pradėk.
; Kuri eilutė vykdoma pirma?
: Pirmoji kodo eilutė: <code>skaicius = 5</code>
; Ką ji daro?
: Priskiria skaičių 5 kintamajam <code>skaicius</code>.
; Kuri eilutė vykdoma po to?
: Kita eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Na, <code>while</code> sakiniai žiūri į juose esančius reiškinius. Jei jie yra tesingi, vykdomas kitas įtrauktas blokas. Jei klaidingi – įtrauktas blokas yra praleidžiamas.
; Tai ką ji daro šiuo atveju?
: Jei <code>skaicius > 1</code> yra ''teisinga'', bus vykdomos kitos dvi eilutės.
; Taigi, ar <code>skaicius > 1</code>?
: Paskutinė vertė, kuri buvo priskirta <code>skaicius</code> buvo <code>5</code> ir <code>5 > 1</code>, taigi – taip.
; O kuri eilutė vykdoma po to?
: Kadangi <code>while</code> buvo teisinga, tai kita eilutė yra: <code>print(".", end = " ")</code>
; Ką daro ši eilutė?
: Spausdina vieną tašką. Kadangi funkcija turi papildomą argumentą <code>end = " "</code>, toliau spausdinamas tekstas nebus pradedamas naujoje eilutėje.
; Kuri eilutė vykdoma po to?
: <code>skaicius = skaicius - 1</code>, nes tai yra kita eilutė ir nėra jokių įtraukos pasikeitimų.
; Ką ji daro?
: Eilutė skaičiuoja <code>skaicius - 1</code>: iš esamos <code>skaicius</code> vertės (5) atimamas 1, ir tai tampa nauja kintamojo <code>skaicius</code> reikšmė. Sutrumpintai, <code>skaicius</code> vertė yra pakeičiama iš 5 į 4.
; Kuri eilutė vykdoma po to?
: Įtraukos lygis keičiasi, todėl turi žiūrėti į tai, kokią valdymo struktūrą turime. Peržiūrėk <code>while</code> ciklą, taigi turi grįžti į <code>while</code> sąlygą, kuri yra <code>while skaicius > 1:</code>
; Ką ji daro?
: Eilutė žiūri į <code>skaicius</code> reikšmę, kuri yra 4, ir lygina ją su 1. Kadangi <code>4 > 1</code>, ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo teisinga, kita eilutė yra: <code>print(".", end = " ")</code>
; Ką ji daro?
: Ekrane išspausdina dar vieną tašką, po jo padėdama tarpą.
; Kuri eilutė vykdoma po to?
: Nėra įtraukos pokyčio, todėl: <code>skaicius = skaicius - 1</code>
; Ir ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (4), atima 1, kas yra lygu 3 ir priskiria 3 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Kadangi turime įtraukos pokytį dėl ciklo, kita eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę <code>skaicius</code> reikšmę (3) su 1. <code>3 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga yra teisinga, kita eilutė: <code>print(".", end = " ")</code>
; O ji daro?
: Trečias taškas yra spausdinamas eilutėje.
; Kuri eilutė vykdoma po to?
: Tai: <code>skaicius = skaicius - 1</code>
; Ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (3), atima 1, kas yra lygu 2 ir priskiria 2 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Vėl grįžtame į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę <code>skaicius</code> reikšmę (2) su 1. <code>2 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklas tęsiasi: <code>print(".", end = " ")</code>
; Ką ji daro?
: Atranda atsakymą gyvenimui, Visatai, ir viskam. Juokauju (turėjau patikrinti, kad dar neužmigai). Eilutė spausdina ketvirtą tašką ekrane.
; Kuri eilutė vykdoma po to?
: Tai: <code>skaicius = skaicius - 1</code>
; Ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (2), atima 1, kas yra lygu 1 ir priskiria 1 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Atgal į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką daro ši eilutė?
: Ji palygina <code>skaicius</code> reikšmę (1) to 1. Kadangi <code>1 > 1</code> yra ''klaidinga'' (vienas nėra daugiau nei vienas), ciklas baigiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo klaidinga, vykdoma kita eilutė esanti už ciklo. Tai yra: <code>print()</code>
; Ką daro ši eilutė?
: Priverčia teksto žymeklį ekrane peršokti į kitą eilutę.
; Kodėl programa nespausdina 5 taškų?
: Ciklas baigiasi vienu tašku per anksti.
; Kaip tai sutvarkyti?
: Priversti ciklą baigtis vienu tašku vėliau.
; Ir kaip tai padaryti?
: Yra keli būdai. Vienas iš jų yra pakeisti ciklo sąlygą į: <code>while skaicius > 0:</code>. Kitas būdas pakeisti sąlygą į: <code>skaicius >= 1</code>. Yra ir daugiau būdų.

=== Kaip turėčiau taisyti savo programą? ===

Tau reikia suprasti, ką programa daro. Tau reikia suprasti, ką programa turėtų daryti. Suprasti, koks skirtumas tarp šių dviejų dalykų. Derinimas - tai įgūdis, kurį norint išmokti, reikia daug praktikos. Jei po valandos nepavyksta išspręsti problemos, pailsėk, pakalbėk su kuo nors apie tai. Po kurio laiko sugrįžk prie problemos ir greičiausiai turėsi naujų minčių, kaip ją įveikti. Sėkmės.

=== Pratimai ===

Žemiau esančiose programose įsivėlė klaidų. Padėk jas surasti.

1. Programos tikslas: programa turėtų išvesti skaičius nuo 1 iki 10.

<syntaxhighlight lang="python">
skaičius = 1

while skaičius < 10:
skaičius = skaičius + 1
print(skaičius)
</syntaxhighlight>

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
Programa išveda skaičius nuo 2 iki 10. Tam, kad būtų išvedama nuo 1, reikėtų pakeisti pradinę <code>skaičius</code> reikšmę į 0.
<syntaxhighlight lang="python">
skaičius = 0

while skaičius < 10:
skaičius = skaičius + 1
print(skaičius)
</syntaxhighlight>
|-
|}

2. Programos tikslas: programa turėtų prašyti įvesti 5 skaičius ir išvesti jų sandaugą.

<syntaxhighlight lang="python">
sandauga = 0
įvesta_skaičių = 0
while įvesta_skaičių <5:
naujas_skaičius = int(input("Skaičius: "))
sandauga = sandauga * naujas_skaičius
įvesta_skaičių = įvesta_skaičių + 1

print(sandauga)
</syntaxhighlight>

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
Įvedus bet kokius skaičius, programa visada grąžina sandaugą lygią 0. Taip yra todėl, kad pradinė sandaugos reikšmė yra 0 ir daugyba su nuliu visada bus 0. Tam, kad programa veiktų teisingai, reikia pradinę sandaugos reikšmę pakeisti į 1.
<syntaxhighlight lang="python">
sandauga = 1
įvesta_skaičių = 0
while įvesta_skaičių <5:
naujas_skaičius = int(input("Skaičius: "))
sandauga = sandauga * naujas_skaičius
įvesta_skaičių = įvesta_skaičių + 1

print(sandauga)
</syntaxhighlight>
|-
|}

3. Programos tikslas: programa turėtų išvesti reiškinio (2023 - 2000) * (9 + 10) reikšmę.

<syntaxhighlight lang="python">
print((2023 - 2000) * 9 + 10)
</syntaxhighlight>

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
Programos išvedama reikšmė yra 217, o tikroji reiškinio reikšmė: 437. Taip nutiko todėl, kad programoje skaičiavimai atliekami netinkama tvarka, trūksta skliaustų.
<syntaxhighlight lang="python">
print((2023 - 2000) * (9 + 10))
</syntaxhighlight>
|-
|}

{{navigation |previous=Pasirinkimai |next=Funkcijų apibrėžimas}}

Vadovėlis/Derinimas

2023-01-05T09:14:28Z

Monika: Prdėtos užduotys

{{navigation |previous=Pasirinkimai |next=Funkcijų apibrėžimas}}
{{BookCat}}

=== Kas yra derinimas? ===
:„Pradėjus programuoti supratau, kad nėra taip lengva kurti teisingai veikiančias programas. Atsimenu akimirką, kai supratau, kad didedė dalis mano gyvenimo, bus skirta klaidų ieškojimui mano paties kurtose programose. Taip atsidaro derinimas.“ — ''Maurice Wilkes atranda derinimą'', 1949

Jei jau bandei parašyti kelias programas, turbūt pastebėjai, kad kartais programa daro ką nors, ko neturėtų daryti. Tai yra tikrai dažna situacija. Derinimas tai yra procesas, kuomet bandoma suprasti, ką kompiuteris daro ir kaip jį priversti daryti tai, ką norėtum, kad jis darytų. Tai gali būti sudėtinga. Vieną kartą aš praleidau beveik savaitę ieškodamas ir taisydamas klaidą, kurią sukėlė kitas žmogus, kode parašęs <code>x</code> vietoje <code>y</code>.

Ši dalis bus abstraktesnė, nei prieš tai buvusios dalys.

=== Ką turėtų daryti programa? ===

Pirmas dalykas, ką reikia padaryti (kad ir kaip akivaizdžiai tai skamba), tai suprasti, ką turėtų daryti teisingai veikianti programa. Sugalvok kelis tikrinimo scenarijus ir pažiūrėk, kas nutiks. Tarkime, kad aš noriu sukurti programą, kuri suskaičiuoja stačiakampio perimetrą (visų kraštinių sumą). Turiu tokius tikrinimo scenarijus:

{| class="wikitable"
|-
!aukštis !! plotis !!perimetras
|-
|3 ||4 ||14
|--
|2 ||3 ||10
|-
|4 ||4 ||16
|-
|2 ||2 ||8
|-
|5 ||1 ||12
|-
|}

Dabar galiu vykdyti savo programą su visais tikrinimo scenarijais ir pamatyti, ar programa daro tai, ko tikiuosi. Jei ne, turiu suprasti, ką iš tiesų daro kompiuteris.

Dažniausiai, dalis tikrinimo scenarijų veikia, dalis - ne. Jei toks yra ir tavo atvejis, turėtum bandyti suprasti, ką veikiantys scenarijai turi bendro.
Pavyzdžiui, apačioje yra perimetro programos išvestis (kodas bus pateiktas kiek vėliau):

Aukštis: '''3'''
Plotis: '''4'''
Perimetras = 15

Aukštis: '''2'''
Plotis: '''3'''
Perimetras = 11

Aukštis: '''4'''
Plotis: '''4'''
Perimetras = 16

Aukštis: '''2'''
Plotis: '''2'''
Perimetras = 8

Aukštis: '''5'''
Plotis: '''1'''
Perimetras = 8

Gali pastebėti, kad programa neveikė su pirmomis dvejomis įvestimis, veikė su sekančiomis dvejomis ir vėl neveikė su paskutine. Pabandyk sugalvoti, kas yra bendro tarp veikiančių scenarijų. Kai supranti, kokia yra programos problema, atrasti jos priežastį yra daug lengviau. Jei reikia, savo programoms gali sugalvoti ir daugiau tikrinimo scenarijų.

=== Ką daro programa? ===

Kitas dalykas, ką reikia padaryti, tai peržiūrėti pirminį programos tekstą. Tai vienas iš svarbiausių dalykų programavime. Pagrindinis būdas, kaip tai daroma - tai kodo peržiūros.

Kodo peržiūra prasideda pirma eilute ir tęsiasi iki programos galo. <code>while</code> ciklai ir <code>if</code> sakiniai reiškia, kad kai kurios eilutės gali būti nekviečiamos niekada, o kai kurios - vykdomos keletą kartų. Kiekvienoje eilutėje turi suprasti, ką daro Python'as.

Pradėkime su paprasta parametro programa. Šios programos nerašyk. Tau reikės ją tik skaityti, ne vykdyti. Programos pirminis tekstas:

<syntaxhighlight lang="python">
aukstis = int(input("Aukštis: "))
plotis = int(input("Plotis: "))
print("perimetras =", plotis + aukstis + plotis + plotis)
</syntaxhighlight>

; ''Klausimas:'' Kuri eilutė vykdoma pirma?
: ''Atsakymas:'' Pirmoji kodo eilutė visada yra vykdoma pirma. Šiuo atveju tai: <code>aukstis = int(input("Aukštis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Aukštis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>aukstis</code>.
; Kuri eilutė vykdoma po to?
: Bendrai, tai yra kita eilutė, kuri yra <code>plotis = int(input("Plotis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Plotis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>plotis</code>.
; Kuri eilutė vykdoma po to?
: Kai kita eilutė nėra daugiau ar mažiau įtraukta, nei esama eilutė, ji ir yra vykdoma. Šiuo atveju tai: <code>print("perimetras =", plotis + aukstis + plotis + plotis)</code> (Taip pat gali būti kviečiama funkcija esamoje eilutėje, bet tai bus paaiškinta tolimesniame skyriuje)
; Ką daro ši eilutė?
: Visų pirma, ji spausdina <code>perimetras = </code>, o tada - sumą, sudarytą iš kintamųjų <code>plotis</code> ir <code>aukstis</code>, kuri užrašoma taip: <code>plotis + aukstis + plotis + plotis</code>.
; Ar kodas <code>plotis + aukstis + plotis + plotis</code> skaičiuoja perimetrą teisingai?
: Pažiūrėk: stačiakampio perimetras yra apatinė kraštinė (plotis), plius kairė (aukstis), plius viršutinė (plotis), plius dešinė kraštinė (a?). Paskutinis kintamasis turėtų būti dešinės kraštinės ilgis, arba kitaip - aukštis.
; Ar supranti, kodėl, kai kuriais atvejais, skaičiuojant perimetrą buvo gaunamas teisingas atsakymas?
: Teisingas atsakymas buvo gaunamas kai aukštis ir plotis buvo lygūs.

Kita programa, kurios kodo peržiūrą darysime, tai programa, kuri turėtų ekrane išvesti 5 taškus. Tačiau, programos išvestis yra:

. . . .

Programa:
<syntaxhighlight lang="python">
skaicius = 5
while skaicius > 1:
print(".", end = " ")
skaicius = skaicius - 1
print()
</syntaxhighlight>

Šios programos peržiūra bus kiek sudėtingesnė, nes joje yra įtrauktų kodo dalių. Pradėk.
; Kuri eilutė vykdoma pirma?
: Pirmoji kodo eilutė: <code>skaicius = 5</code>
; Ką ji daro?
: Priskiria skaičių 5 kintamajam <code>skaicius</code>.
; Kuri eilutė vykdoma po to?
: Kita eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Na, <code>while</code> sakiniai žiūri į juose esančius reiškinius. Jei jie yra tesingi, vykdomas kitas įtrauktas blokas. Jei klaidingi – įtrauktas blokas yra praleidžiamas.
; Tai ką ji daro šiuo atveju?
: Jei <code>skaicius > 1</code> yra ''teisinga'', bus vykdomos kitos dvi eilutės.
; Taigi, ar <code>skaicius > 1</code>?
: Paskutinė vertė, kuri buvo priskirta <code>skaicius</code> buvo <code>5</code> ir <code>5 > 1</code>, taigi – taip.
; O kuri eilutė vykdoma po to?
: Kadangi <code>while</code> buvo teisinga, tai kita eilutė yra: <code>print(".", end = " ")</code>
; Ką daro ši eilutė?
: Spausdina vieną tašką. Kadangi funkcija turi papildomą argumentą <code>end = " "</code>, toliau spausdinamas tekstas nebus pradedamas naujoje eilutėje.
; Kuri eilutė vykdoma po to?
: <code>skaicius = skaicius - 1</code>, nes tai yra kita eilutė ir nėra jokių įtraukos pasikeitimų.
; Ką ji daro?
: Eilutė skaičiuoja <code>skaicius - 1</code>: iš esamos <code>skaicius</code> vertės (5) atimamas 1, ir tai tampa nauja kintamojo <code>skaicius</code> reikšmė. Sutrumpintai, <code>skaicius</code> vertė yra pakeičiama iš 5 į 4.
; Kuri eilutė vykdoma po to?
: Įtraukos lygis keičiasi, todėl turi žiūrėti į tai, kokią valdymo struktūrą turime. Peržiūrėk <code>while</code> ciklą, taigi turi grįžti į <code>while</code> sąlygą, kuri yra <code>while skaicius > 1:</code>
; Ką ji daro?
: Eilutė žiūri į <code>skaicius</code> reikšmę, kuri yra 4, ir lygina ją su 1. Kadangi <code>4 > 1</code>, ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo teisinga, kita eilutė yra: <code>print(".", end = " ")</code>
; Ką ji daro?
: Ekrane išspausdina dar vieną tašką, po jo padėdama tarpą.
; Kuri eilutė vykdoma po to?
: Nėra įtraukos pokyčio, todėl: <code>skaicius = skaicius - 1</code>
; Ir ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (4), atima 1, kas yra lygu 3 ir priskiria 3 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Kadangi turime įtraukos pokytį dėl ciklo, kita eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę <code>skaicius</code> reikšmę (3) su 1. <code>3 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga yra teisinga, kita eilutė: <code>print(".", end = " ")</code>
; O ji daro?
: Trečias taškas yra spausdinamas eilutėje.
; Kuri eilutė vykdoma po to?
: Tai: <code>skaicius = skaicius - 1</code>
; Ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (3), atima 1, kas yra lygu 2 ir priskiria 2 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Vėl grįžtame į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę <code>skaicius</code> reikšmę (2) su 1. <code>2 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklas tęsiasi: <code>print(".", end = " ")</code>
; Ką ji daro?
: Atranda atsakymą gyvenimui, Visatai, ir viskam. Juokauju (turėjau patikrinti, kad dar neužmigai). Eilutė spausdina ketvirtą tašką ekrane.
; Kuri eilutė vykdoma po to?
: Tai: <code>skaicius = skaicius - 1</code>
; Ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (2), atima 1, kas yra lygu 1 ir priskiria 1 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Atgal į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką daro ši eilutė?
: Ji palygina <code>skaicius</code> reikšmę (1) to 1. Kadangi <code>1 > 1</code> yra ''klaidinga'' (vienas nėra daugiau nei vienas), ciklas baigiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo klaidinga, vykdoma kita eilutė esanti už ciklo. Tai yra: <code>print()</code>
; Ką daro ši eilutė?
: Priverčia teksto žymeklį ekrane peršokti į kitą eilutę.
; Kodėl programa nespausdina 5 taškų?
: Ciklas baigiasi vienu tašku per anksti.
; Kaip tai sutvarkyti?
: Priversti ciklą baigtis vienu tašku vėliau.
; Ir kaip tai padaryti?
: Yra keli būdai. Vienas iš jų yra pakeisti ciklo sąlygą į: <code>while skaicius > 0:</code>. Kitas būdas pakeisti sąlygą į: <code>skaicius >= 1</code>. Yra ir daugiau būdų.

=== Kaip turėčiau taisyti savo programą? ===

Tau reikia suprasti, ką programa daro. Tau reikia suprasti, ką programa turėtų daryti. Suprasti, koks skirtumas tarp šių dviejų dalykų. Derinimas - tai įgūdis, kurį norint išmokti, reikia daug praktikos. Jei po valandos nepavyksta išspręsti problemos, pailsėk, pakalbėk su kuo nors apie tai. Po kurio laiko sugrįžk prie problemos ir greičiausiai turėsi naujų minčių, kaip ją įveikti. Sėkmės.

=== Pratimai ===

Žemiau esančiose programose įsivėlė klaidų. Padėk jas surasti.

1. Programos tikslas: programa turėtų išvesti skaičius nuo 1 iki 10.

<syntaxhighlight lang="python">
skaičius = 1

while skaičius < 10:
skaičius = skaičius + 1
print(skaičius)
</syntaxhighlight>

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
Programa išveda skaičius nuo 2 iki 10. Tam, kad būtų išvedama nuo 1, reikėtų pakeisti pradinę <code>skaičius</code> reikšmę į 0.
<syntaxhighlight lang="python">
skaičius = 0

while skaičius < 10:
skaičius = skaičius + 1
print(skaičius)
</syntaxhighlight>
|-
|}

2. Programos tikslas: programa turėtų prašyti įvesti 5 skaičius ir išvesti jų sandaugą.

<syntaxhighlight lang="python">
sandauga = 0
įvesta_skaičių = 0
while įvesta_skaičių <5:
naujas_skaičius = int(input("Skaičius: "))
sandauga = sandauga * naujas_skaičius
įvesta_skaičių = įvesta_skaičių + 1

print(sandauga)
</syntaxhighlight>

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
Įvedus bet kokius skaičius, programa visada grąžina sandaugą lygią 0. Taip yra todėl, kad pradinė sandaugos reikšmė yra 0 ir daugyba su nuliu visada bus 0. Tam, kad programa veiktų teisingai, reikia pradinę sandaugos reikšmę pakeisti į 1.
<syntaxhighlight lang="python">
sandauga = 1
įvesta_skaičių = 0
while įvesta_skaičių <5:
naujas_skaičius = int(input("Skaičius: "))
sandauga = sandauga * naujas_skaičius
įvesta_skaičių = įvesta_skaičių + 1

print(sandauga)
</syntaxhighlight>
|-
|}

{{navigation |previous=Pasirinkimai |next=Funkcijų apibrėžimas}}

Vadovėlis/Suskaičiuoti iki 10

2023-01-04T12:57:51Z

Monika: Pridėtos užduotys

{{navigation |previous=Kas čia eina? |next=Pasirinkimai}}

=== Ciklai kol (While loops) ===
Šiame skyriuje susipažinsi su ciklu <code>while</code>(liet. kol). Kaip jau sužinojai praeitame skyriuje, kompiuteris įprastai programą pradeda skaityti ir vykdyti nuo pirmos eilutės ir taip eilutė po eilutės keliauja žemyn per visas duoto kodo eilutes. Tačiau ciklas <code>while</code> šią tvarką pakeičia ir dėl to kompiuteris priėjęs šią kodo vietą eilutes skaito iki galo, pagal šio ciklo nustatytą tvarką. Štai čia yra programos su ciklo <code>while</code> pavyzdžiu:

<syntaxhighlight lang="python">
a = 0 # PIRMA, nustatome pradinio kintamojo a reikšmę 0 (nuliui).
while a < 10: # Kol kintamojo a vertė yra mažesnė nei 10, programa atlieka šiuos veiksmus:
a = a + 1 # Padidina kintamojo a reikšmę 1 (vienu), visai taip kaip nurodyta: a = a + 1!
print(a) # Tuomet nurodome, kad spausdintų. Viskas tam, kad pamatytumėte, kokia yra dabartinė kintamojo a vertė.
# Ir visą šitą ciklą programa vykdo tol, kol kintamojo a reikšmė bus lygi 9!? Žr. Pastabą.

# PASTABA:
# Kintamojo a vertė padidės 1
# su kiekvienu pakartojimu ar ciklu, kol pasieks nustatytą sąlygą ir sustos.
# pvz. a = 1, tada a = 2, tada a = 3 ir t.t., kol a bus lygus 9 (a = 9), tada...
# kodas baigs pridėjinėti po 1 prie a, nes taps lygus 10 (a = 10) kaip ir
# numatyta mūsų parašytoje sąlygoje.
# O kai mūsų nurodyta sąlyga yra patenkinama, programa atspausdina rezultatą.
# --
# While a < 10: |
# a = a + 1 |<--[ Ciklo Kol sąlygos blokas ]
# print (a) |
# --
</syntaxhighlight>

Na, o jeigu paleidžiame programą, tai turime štai tokį įdomų rezultatą:

1
2
3
4
5
6
7
8
9
10

(Tikriausiai iki šios pamokos net nesusimąstei, kad kompiuterį gali paversti pigiu skaičiuotuvu...)

Na, o dabar pasiaiškinkime kaip veikia ši programa. Pirmiausia kompiuteris mato eilutę <code>a = 0</code> ir nustato <code>a</code> reikšmę lygią nuliui. Tada programa mato sąlygą <code>while a < 10:</code>, todėl kompiuteris patikrina, ar <code>a < 10</code>. Kompiuteriui pirmą kartą matant šį teiginį, <code>a</code> yra lygus 0, ir akivaizdu, kad turima reikšmė yra mažesnė nei 10. Kitaip tariant, kol <code>a</code> yra mažesnis skaičius nei dešimt, tol kompiuteris tikrins teiginį ir kartos jį (t.y. pridėjinės po 1). Ciklas baigsis, kai <code>a</code> bus lygus dešimčiai. Kadangi šiame kode daugiau nieko nėra, tai programa sustoja.

ĮSIDĖMĖK: Nepamiršk parašyti dvitaškio <code>:</code> eilutės pabaigoje, tik taip kompiuteris supras, kad čia yra komanda!

Kitas ciklo <code>while</code> pavyzdys:
<syntaxhighlight lang="python">
a = 1
s = 0
print("Įvesk skaičius, kuriuos nori pridėti prie sumos")
print("Norint išeiti, įvesk 0.")
while a != 0:
print("Dabartinė suma:", s)
a = float(input("Skaičius? "))
s = s + a
print("Galutinė suma =", s)
</syntaxhighlight>

Galimas programos scenarijus:

Įvesk skaičius, kuriuos nori pridėti prie sumos.
Norint išeiti, įveskite 0.
Dabartinė suma: 0
Skaičius? '''200'''
Dabartinė suma: 200.0
Skaičius? '''-15.25'''
Dabartinė suma: 184.75
Skaičius? '''-151.85'''
Dabartinė suma: 32.9
Skaičius? '''10.00'''
Dabartinė suma: 42.9
Skaičius? '''0'''
Galutinė suma = 42.9

Atkreipk dėmesį, kad <code>print('Galutinė suma =', s)</code> yra įvykdoma tik pačioje pabaigoje, kai jau ciklas būna nutrauktas. Komanda <code>while</code> veikia tik tas eilutes, kurios yra atitrauktos nuo krašto ir priklauso ciklo <code>while</code> blokui. <code>!=</code> reiškia nelygu, taigi <code>while a != 0:</code> reiškia tol, kol <code>a</code> nėra nulis, programa vykdo kodą.

Ar pastebėjai, kad šiuo atveju <code>a</code> yra skaičius su reikšme po kablelio ir ne visi tokie skaičiai gali būti tiksliai atvaizduoti, kai naudojamas <code>!=</code>. Pabandyk paleidęs programą įvesti 1.1

==== Begaliniai ciklai (infinitive loops) arba niekada nesibaigaintys ciklai (Never Ending Loop)====
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis:
<syntaxhighlight lang="python">
while True:
print("Padėk! Užstrigau cikle!")
</syntaxhighlight>
Operatorius <code>==</code> naudojamas abiejų operatoriaus pusių išraiškų lygybei patikrinti, kaip ir <code> < </code> buvo naudojami norint pasakyt „mažiau nei“ (kitame skyriuje rasi išsamų visų palyginimo operatorių sąrašą).

Ši mūsų sukurta programa spausdins <code>Padėk! Užstrigau cikle!</code> visą amžinybę... Tol, kol pats ją sustabdysi, todėl kad ji visą laiką yra <code>True</code> (visada atitinka teigiamą reikšmę) ir niekada nesikeičia (''True'', lietuviškai ''teisinga'' arba ''tiesa'', paprastai programavime dar rašomas kaip 1). Kaip programą sustabdyti? Paprasčiausiai paspausk ctrl + c mygtukus.

=== Pavyzdžiai ===
==== Fibonačio skaičių seka ====
Fibonačio skaičių seka – sveikųjų skaičių seka. Seka prasideda šiais skaičiais: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233. Kiekvienas šios sekos skaičius lygus dviejų prieš jį einančių skaičių sumai. Toliau parodysiu, kaip gali atvaizduoti pirmus dvidešimt Fibonačio skaičius 3 skirtingais būdais.

'''Fibonacci-metodas1.py'''
<syntaxhighlight lang="python">
# Ši programa skaičiuoja Fibonačio seką
a = 0
b = 1
pradinis_skaičius = 0
maksimalus_skaičius = 20

while pradinis_skaičius < maksimalus_skaičius:
pradinis_skaičius = pradinis_skaičius + 1
print(a, end = " ") # Atkreipkite dėmesį į end = " " spausdinimo funkcijos argumentuose
# būtent tai neleidžia sukurti naujos eilutės.
senas_a = a # turime sekti, nes mes jį keičiame.
a = b
b = senas_a + b
print() # gauna naują (tuščią) eilutę.
</syntaxhighlight>
Išvestis :
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

Įsidėmėk, kad išvestis yra vienoje eilutėje dėl papildomų argumentų <code>end = " "</code> funkcijos <code>print</code> argumentuose.

'''Fibonacci-metodas2.py'''
<syntaxhighlight lang="python">
# Supaprastintas ir greitesnis Fibonačio sekos apskaičiavimo metodas
a = 0
b = 1
pradinis_skaičius = 0
maksimalus_skaičius = 10

while pradinis_skaičius < maksimalus_skaičius:
pradinis_skaičius = pradinis_skaičius + 1
print(a, b, end=" ") # Įsidėmėk end=" "
a = a + b
b = a + b
print() # gauna naują (tuščią) eilutę.
</syntaxhighlight>

Išvestis:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

'''Fibonacci-metodas3.py'''
<syntaxhighlight lang="python">
a = 0
b = 1
pradinis_skaičius = 0
maksimalus_skaičius = 20

#kai ciklas prasideda, mes jame pasiliekame
while pradinis_skaičius < maksimalus_skaičius:
pradinis_skaičius += 1
senas_a = a
a = a + b
b = senas_a
print(senas_a,end=" ")
print()
</syntaxhighlight>

Išvestis:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

==== Įvesk slaptažodį ====
'''Slaptaždis.py'''
<syntaxhighlight lang="python">
# Laukia, kol bus įvestas slaptažodis. Naudok „ctrl+ C“, kad sustabdytum programą
# be slaptažodžio

#atkreipk dėmesį, kad tai neturi būti slaptažodis, kad
# ciklas while turi prasisukti bent kartą.
slaptažodis= str()

# įsidėmėk != reiškia nelygu
while slaptažodis!= "Angis":
slaptažodis = input("Slaptažodis: ")
print("Prisijungimas sėkmingas")
</syntaxhighlight>

Kaip programa veikia:
Slaptažodis: '''auo'''
Slaptažodis: '''y22'''
Slaptažodis: '''slaptažodis'''
Slaptažodis: '''Sezamai atsiverk'''
Slaptažodis: '''Angis'''
Prisijungimas sėkmingas

=== Pratimai ===
1. Parašyk programą, kuri prašo vartotojo įvesti skaičius tol, kol jis įveda <code>0</code>. Tada programa turi išvesti skaičių vidurkį. Gali remtis skyriuje aptartu skaičių sumos pavyzdžiu.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
skaičius = -1
skaičių_suma = 0
viso_skaičių = 0

while skaičius != 0:
skaičius = int(input("Įveskite skaičių: "))
if skaičius != 0:
skaičių_suma = skaičių_suma + skaičius
viso_skaičių = viso_skaičių + 1

print("Skaičių vidurkis:", skaičių_suma / viso_skaičių)
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri prašo vartotojo įvesti skaičių ir išveda to skaičiaus, pakelto kubu, reikšmę. Programa turėtų veiksmą kartoti tol, kol vartotojas įveda <code>0</code>.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
skaičius = 1

while skaičius != 0:
skaičius = int(input("Įvesk skaičių: "))
if skaičius != 0:
skaičius_kubu = skaičius * skaičius * skaičius
print(skaičius, " pakelta kubu yra ", skaičius_kubu)
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri prašo vartotojo įvesti penkis skaičius ir išveda jų sandaugą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
sandauga = 1
skaičių_kiekis = 0

while skaičių_kiekis < 5:
naujas_skaičius = int(input("Įvesk skaičių: "))
sandauga = sandauga * naujas_skaičius
skaičių_kiekis = skaičių_kiekis + 1

print("Įvestų skaičių sandauga: ", sandauga)
</syntaxhighlight>
|-
|}

4. Parašyk programą, kuri prašo vartotojo įvesti skaičių ir išveda to skaičiaus daugybos lentelę nuo 1 iki 10. Pavyzdžiui, jei įvestas skaičius yra 11, išvestis turėtų būti:

11 x 1 = 11

11 x 2 = 22

11 x 3 = 33

11 x 4 = 44

11 x 5 = 55

11 x 6 = 66

11 x 7 = 77

11 x 8 = 88

11 x 9 = 99

11 x 10 = 110

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
skaičius = int(input("Įvesk skaičių: "))
indeksas = 1

while indeksas <= 10:
print(skaičius, " * ", indeksas, " = ", skaičius * indeksas)
indeksas = indeksas + 1
</syntaxhighlight>
|-
|}

{{navigation |previous=Kas čia eina? |next=Pasirinkimai}}

Vadovėlis/Kas čia eina?

2023-01-03T14:34:06Z

Monika: Pridėtos dvi užduotys

{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}
{{BookCat}}

=== Įvestis ir kintamieji ===

[[Vaizdas:Kintamieji.png|600px|frameless|center|Kintamieji]]

Jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:
<syntaxhighlight lang="python">
print("Stop!")
vartotojo_įvestis = input("Kas čia eina? ")
print("Gali praeiti,", vartotojo_įvestis )
</syntaxhighlight>

Kai '''aš''' paleidau programą, štai ką '''mano''' ekranas parodė:

Stop!
Kas čia eina? '''Benas'''
Gali praeiti, Benas

''Pastaba: Jei paleisi kodą spausdamas "F5", Python išvestis bus tik tokia:''

Stop!
Kas čia eina?

''Tu turi įvesti savo vardą į Python [http://www.ims.mii.lt/EK%C5%BD/enciklo.html?word=apvalkalas apvalkalą] ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''

Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.
Kai paleidai programą (juk paleidai, tiesa?), tu turėjai surinkti savo vardą ir tada paspausti Enter.
Programa atspausdino dalį teksto ir tavo vardą. Taip atrodo ''įvesties'' pavyzdys.
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojo įvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.

Žinoma, gauti informaciją iš vartotojo pasaulio nieko verta, jei tos informacijos nėra kur padėti. Ir šioje vietoje atsiranda kintamieji.

Pavyzdinėje programoje <code>vartotojo_įvestis</code> yra ''kintamasis''. Kintamieji yra kaip dėžės, į kurias galima įdėti norimas informacijos dalis.

Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Benas"
b = 432
c = a + b
print("a + b yra", c)
print("vardas yra", vardas)
print("Rūšiuotos dalys, Po vidurnakčio ar", b23)
</syntaxhighlight>

Štai kokia išvestis:

a + b yra 555.4
vardas yra Benas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji laiko duomenis. Viršuje aprašytoje programoje kintamieji yra <code>a</code>, <code>b23</code>, <code>vardas</code>, <code>b</code> ir <code>c</code>. Pagrindiniai du kintamųjų tipai yra ''tekstas'' ir ''skaičius''. Tekstas yra raidžių, skaičių ir kitų simbolių seka. Šiame pavyzdyje <code>b23</code> ir <code>vardas</code> yra tekstinio tipo kintamieji. <code>Šlamštas</code>, <code>Benas</code>, <code>a + b yra</code>, <code>vardas yra</code>, ir <code>Rūšiuotos dalys, Po vidurnakčio ar</code> šioje programoje yra tiesiog tekstinės reikšmės. Paprastas tekstas yra apsuptas kabučių <code>"</code> arba <code>'</code>.

Kitas kintamojo tipas yra skaičius. Atkreipkite dėmesį, kad kintamieji, kurie naudojami saugoti reikšmes, nenaudoja kabučių (" ir '). Jei norite naudoti realias ''reikšmes'', privalote naudoti kabutes.

<syntaxhighlight lang="python">
reikšmė1 == Oho
reikšmė2 == "Oho"
</syntaxhighlight>

Abu pavyzdžiai atrodo vienodai, bet pirmu atveju Python tikrins ar reikšmė, patalpinta kintamajame <code>reikšmė1</code>, yra tokia pati kaip ''kintamojo'' <code>Oho</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>h</code> ir <code>o</code>) yra tokios pat kaip ir <code>reikšmė2</code> (toliau daugiau paaiškinsiu apie tekstą ir <code>==</code>).

=== Priskyrimai ===

Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kuri gali būti kintamajame. Kompiuteris pamatys tokią eilutę <code>vardas = "Benas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Benas</code> į dėžę (ar kintamąjį) <code>vardas</code>". Vėliau, pamatęs sakinį <code>c = a + b</code> jį perskaitys kaip "padėt sumą <code>a + b</code> arba <code>123.4 + 432</code>, kas lygu <code>555.4</code>, į <code>c</code>". Dešinė sakinio pusė ''konvertuosis'' ir rezultatas bus padėtas į kintamajį kairėje pusėje (<code>c</code>). Tai yra vadinama ''priskyrimu''. Turėtume nemaišyti priskyrimo ir matematinio lygybės ženklo (<code>=</code>). Ką reiškia <code>==</code> aptarsime vėliau.

O štai ir kitas kintamųjų naudojimo pavyzdys:
<syntaxhighlight lang="python">
a = 1
print(a)
a = a + 1
print(a)
a = a * 2
print(a)
</syntaxhighlight>

Ir žinoma štai tokį rezultatą gausime:

1
2
4

Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), kompiuteris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"

Dar viena programa prieš man pabangiant šį skyrių:
<syntaxhighlight lang="python">
skaičius = float(input("Įvesk skaičių: "))
sveikasSkaičius = int(input("Įvesk sveiką skaičių: "))
tekstas = input("Įvesk tekstą: ")
print("skaičius =", skaičius)
print("skaičius yra", type(skaičius))
print("skaičius * 2 =", skaičius * 2)
print("sveikas skaičius =", sveikasSkaičius)
print("sveikas skaičius yra", type(sveikasSkaičius))
print("sveikasSkaičius * 2 =", sveikasSkaičius * 2)
print("tekstas =", tekstas)
print("tekstas yra", type(tekstas))
print("tekstas * 2 =", tekstas * 2)

</syntaxhighlight>

Rezultatas:

Įvesk skaičių: '''12.34'''
Įvesk sveiką skaičių: '''-3'''
Įvesk tekstą: '''Labas'''
skaičius = 12.34
skaičius yra <class 'float'>
skaičius * 2 = 24.68
sveikas skaičius = -3
sveikas skaičius yra <class 'int'>
sveikasSkaičius * 2 = -6
tekstas = Labas
tekstas yra <class 'str'>
tekstas * 2 = LabasLabas

Atkreipk dėmesį, kad kintamasis <code>skaičius</code> buvo sukurtas su <code>float(input())</code>, išsaugos, o vėliau atspausdins tokį skaičių, koks buvo įvestas – su kableliu. Kintamasis <code>sveikasSkaičius</code>, kuris buvo sukurtas su <code>int(input())</code>, grąžina sveiką skaičių – reikšmę be kablelio. Tuo tarpu <code>tekstas</code>, kuris buvo sukurtas su <code>input()</code>, grąžino tekstinę eilutę (gali būti aprašoma ir <code>str(input())</code>). Jei tu nori, kad vartotojas įvestų skaičių su kableliu, naudok <code>float(input())</code> kintamojo tipą. Jei nori, kad vartotojas įvestų sveiką skaičių, naudok <code>int(input())</code> (jeigu vartotojas įves skaičių su kabliu – dalį po kabelio programa tiesiog ignoruos), bet jei nori teksto – naudok <code>input()</code>.

Antra pusė programos naudoja <code>type()</code> funkciją, kuri nusako, kokio tipo kintamasis yra. Skaičius yra <code>int</code> arba <code>float</code> tipo. Tai yra angliškų žodžių ''integer'' (sveikas skaičius) ir ''floating point'' (slankusis kablelis, naudojamas daugiausiai skaičiams su kableliu) trumpiniai. Tekstinė eilutė yra <code>str</code>, trumpinys ''string'' (tekstinė eilutė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas – ne. Atkreipk dėmesį, kai Python'as daugina skaičių iš sveiko skaičiaus gaunamas rezultatas, kurio ir galima tikėtis, tačiau jei tekstas padauginamas iš sveiko skaičiaus – sukuriamos kelios teksto kopijos (pavyzdžiui, <code>tekstas * 2 = LabasLabas</code>)

Tos pačios operacijos su teksto tipu daro kitokius dalykus nei su skaičiais. Taip pat, kai kurios operacijos veikia tik su skaičiais ir grąžina klaidą, jei bus bandoma panaudoti tesktą. Štai keletas interaktyvių pavyzdžių:

<pre>
>>> print("Čia" + " " + "yra" + " junginys.")
Čia yra junginys.
>>> print("Ha, " * 5)
Ha, Ha, Ha, Ha, Ha,
>>> print("Ha, " * 5 + "ha!")
Ha, Ha, Ha, Ha, Ha, ha!
>>> print(3 - 1)
2
>>> print("3" - "1")
Traceback (most recent call last):
File "<string>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operacija
!Symbolis
!Pavyzdys
|-
|Pakartojimas
|<code>*</code>
|<code>"i" * 5 == "iiiii"</code>
|-
|Sujungimas
|<code>+</code>
|<code>"Hello, " + "World!" == "Hello, World!"</code>
|}

=== Pavyzdžiai ===

'''Laikas.py'''
<syntaxhighlight lang="python">
# ši programa apskaičiuoja laiko priklausomybę nuo greičio ir atstumo
print("Įvesk greitį ir atstumą")
greitis = float(input("Greitis: "))
atstumas = float(input("Atstumas: "))
laikas = (atstumas / greitis)
print("Laikas:", laikas)

</syntaxhighlight>

Rezultatas:

Įvesk greitį ir atstumą
Greitis: '''5'''
Atstumas: '''10'''
Laikas: 2.0

Įvesk greitį ir atstumą
Greitis: '''3.52'''
Atstumas: '''45.6'''
Laikas: 12.9545454545

'''Plotas.py'''
<syntaxhighlight lang="python">
# Ši programa apskaičiuoja stačiakampio perimetrą ir plotą
print("Įveskite stačiakampio informaciją")
ilgis = float(input("Ilgis: "))
plotis = float(input("Plotis: "))
perimetras = (2 * ilgis + 2 * plotis)
print("Plotas:", ilgis * plotis)
print("Perimetras:", perimetras)
</syntaxhighlight>

Pavyzdžio rezultatas:

Įveskite stačiakampio informaciją
Ilgis: '''4'''
Plotis: '''3'''
Plotas: 12.0
Perimetras: 14.0

Įveskite stačiakampio informaciją
Ilgis: '''2.53'''
Plotis: '''5.2'''
Plotas: 13.156
Perimetras: 15.46

'''temperatura.py'''
<syntaxhighlight lang="python">
# Ši programa konvertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatūra Farenheitais: "))
cels_temp = (far_temp - 32.0) * (5.0 / 9.0)
print("Temperatūra Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatūra Farenheitais: '''32'''
Temperatūra Celsijaus laipsniais: 0.0

Temperatūra Farenheitais: '''-40'''
Temperatūra Celsijaus laipsniais: -40.0

Temperatūra Farenheitais: '''212'''
Temperatūra Celsijaus laipsniais: 100.0

Temperatūra Farenheitais: '''98.6'''
Temperatūra Celsijaus laipsniais: 37.0

=== Pratimai ===
1. Parašyk programą, kuri priima 2 tekstines reikšmes ir 2 skaičius iš vartotojo įvesties, sujungia tekstus be tarpų ir atvaizduoja gautą rezultatą, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
tekstas1 = input('Tekstas 1: ')
tekstas2 = input('Tekstas 2: ')
skaičius1 = float(input('Skaičius 1: '))
skaičius2 = float(input('Skaičius 2: '))
print(tekstas1 + tekstas2)
print(skaičius1 * skaičius2)
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri paprašytų įvesti savo vardą ir amžių, o ji atspausdintų tekstą “Labas, aš {vardas}. Man {metai} metų.”. Kur {vardas} ir {metai} yra įvesti duomenys.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
vardas = input("Įvesk savo vardą: ")
metai = input("Įvesk savo amžių: ")
print("Labas, aš ", vardas, ". Man ", metai, " metų.")
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuriai įvestum sekundžių skaičių, o ji išvestų, kiek tai yra minučių.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
sekundės = int(input("Įvesk sekundžių skaičių: "))
minutės = sekundės / 60
print(sekundės, "s = ", minutės, "min")
</syntaxhighlight>
|-
|}

{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}

Vadovėlis/Labas, Pasauli

2023-01-03T14:25:07Z

Monika:

{{navigation |previous=Įvadas |next=Kas čia eina?}}

=== Ką sužinosi? ===
Perskaitęs šį skyrių, turėtum suprasti kaip teksto redaktoriumi rašyti programas, kaip parašytas programas išsaugoti kompiuterio atmintyje ir kaip jas paleisti.

=== Spausdinimas ===
Istoriškai taip jau susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programėlės pavadinimu „Labas, Pasauli!“ arba angliškai „Hello, World!“.

[[Vaizdas:Labas, pasauli.png|600px|frameless|center]]

Python'o programavimo kalboje programa atrodytų taip:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

==== Programavimas kodo redaktoriumi ====

Programavimui rekomenduoju naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Python Vadovėlis/Įvadas#Python_ir_Visual_Studio_Code_diegimas|Python ir Visual Studio Code diegimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File arba Failas -> Naujas failas), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save arba Failas -> Išsaugoti) pavadinimu <code>labas.py</code>.

Sveikiname! Sukūrei savo pirmą Python programą.

(Jeigu tokios programavimo aplinkos įsidiegti savo kompiuteryje negali, žr. kitą žingsnį).

Dabar parašytą programą paleisk vykdyti: tiesiog paspausk žalią mygtuką dešinėje viršuje.

Kai paleisi šią programą, ji suveiks ir terminale atsiras užrašas:

Labas, Pasauli!

==== Alternatyvus būdas: Programavimas paprastu teksto redaktoriumi ====

Jeigu kodo redaktoriaus negali įsidiegti savo kompiuteryje dėl kokių nors priežasčių, programuoti galima ir tiesiog paprasčiausiu teksto redaktoriumi, pvz. Notepad.

Tiesiog sukurk naują paprastą tekstinį failą (.txt), jame įrašyk programinį kodą <code>print("Labas, Pasauli!")</code>, failą išsaugok pavadinimu <code>labas.py</code>.

Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 labas.py</code>

Tavo programa parašys:

Labas, Pasauli!

=== Eime toliau ===

Labai rekomenduoju kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. Mūsų praktikoje toks mokymosi procesas yra pats efektyviausias ir veiksmingiausias.

Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:

<syntaxhighlight lang="python">
print("Gyveno kadaise Paryžiuj bobutė –")
print("Prie Eifelio bokšto turėjo ji butą.")
print("Ji visko pasauly klausytis norėjo,")
print("Bet viena kairiąja ausim tegirdėjo.")
</syntaxhighlight>

Kai paleidi šią programą, ji parašo J. Erlicko eilėraščio Bobutė iš Paryžiaus (2) ištrauką:

Gyveno kadaise Paryžiuj bobutė –
Prie Eifelio bokšto turėjo ji butą.
Ji visko pasauly klausytis norėjo,
Bet viena kairiąja ausim tegirdėjo.

Kai kompiuteris paleidžia programą, pirmiausia jis mato:

<syntaxhighlight lang="python">
print("Gyveno kadaise Paryžiuj bobutė –")
</syntaxhighlight>

Todėl kompiuteris užrašo:

Gyveno kadaise Paryžiuj bobutė –

Tada kompiuteris skaito kitą eilutę ir mato:

<syntaxhighlight lang="python">
print("Prie Eifelio bokšto turėjo ji butą.")
</syntaxhighlight>

Todėl ir ją užrašo kompiuterio ekrane:

Prie Eifelio bokšto turėjo ji butą.

Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs - eina toliau: skaito kitą eilutę, ją įvykdo ir t.t. Taip kompiuteris vykdo visas surašytas komandas, kol pasiekia programos pabaigą.

==== Terminologija ====
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.

Prieš tai rašydami kodą, mes naudojame „funkciją“ pavadinimu <code>print</code>. Po funkcijos pavadinimo <code>print</code> rašomi skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

funkcijai duodamas vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Programuotojai tai vadina „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme, angliškai 'string'). Kitas tekstinės reikšmės pavyzdys yra <code>"Gyveno kadaise Paryžiuj bobutė"</code>.

Užrašyta funkcija su argumentais yra komanda, kurią supranta Python'as. Sakinio pavyzdys:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

Paprasčiau tariant, komandą gali įsivaizduoti kaip vieną programos eilutę.

Kol kas terminologijos pakaks, keliaujam į kitą poskyrį ir mokomės toliau.

====Ženklo \n naudojimas====
<code>\n</code> (kaitos ženklas, angliškai - escape character), arba nauja eilutė. Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Pabandyk suprasti šią programą:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\nKą turėčiau daryti?")
</syntaxhighlight>

Kurios rezultatas yra toks:

Labas, Pasauli!
Ką turėčiau daryti?

<code>\n</code> naudojamas, kai norime tekstą perkelti į kitą eilutę, bet nenorime naudoti kelių <code>print()</code> komandų.

Spausdinimo komanda automatiškai naudoja <code>\n</code>, t.y. kiekviena komanda tekstą spausdina vis naujoje eilutėje, net jeigu pats <code>\n</code> ir neužrašai. Paprasčiau suprasti bus pamačius pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

iš tikrųjų yra:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\n")
</syntaxhighlight>

=== Aritmetinės operacijos ===
Programos pavyzdys:

<syntaxhighlight lang="python">
print("2 + 2 yra", 2 + 2)
print("3 * 4 yra", 3 * 4)
print("100 - 1 yra", 100 - 1)
# Atkreipk dėmesį, python'e aritmetikoje skaičiai po kablelio rašomi su tašku (.)
print("((33 + 2) / 5 + 11.5 yra", (33 + 2) / 5 + 11.5)
</syntaxhighlight>

Rezultatas:

2 + 2 yra 4
3 * 4 yra 12
100 - 1 yra 99
(33 + 2) / 5 + 11.5 yra 18.5

==== Aritmetinės išraiškos ====

Šiame pavyzdyje, rašymo funkcija <code>print()</code> yra su dvejais argumentais, kurie atskirti kableliu. Panagrinėkime pirmoje eilutėje užrašytą komandą:

<syntaxhighlight lang="python">
print("2 + 2 yra", 2 + 2)
</syntaxhighlight>

Pirmas argumentas yra teksto eilutė <code>"2 + 2 yra"</code> ir antras argumentas yra aritmetinė išraiška <code>2 + 2</code>, tiksliau tariant viena iš aritmetinių operacijų.

Atkreipk dėmesį, kad eilutė, kuri yra užrašyta kabutėse yra atspausdinama kaip tekstas, o išraiška užrašyta be kabučių yra apskaičiuojama ir užrašomas atsakymas.

Python'o programavimo kalba turi septynias pagrindines skaičių operacijas.

{| class="wikitable"
! Operacija
! Simbolis
! Pavyzdys
|-
|Kėlimas laipsniu
| <code>**</code>
| <code>5 ** 2 == 25</code>
|-
|Daugyba
| <code>*</code>
|<code>2 * 3 == 6</code>
|-
|Dalyba
| <code>/</code>
| <code>14 / 3 == 4.666666666666667</code>
|-
|Sveikųjų skaičių dalyba
| <code>//</code>
| <code>14 // 3 == 4</code>
|-
|Liekana
| <code>%</code>
| <code>14 % 3 == 2</code>
|-
|Sudėtis
| <code>+</code>
| <code>1 + 2 == 3</code>
|-
|Atimtis
| <code>-</code>
| <code>4 - 3 == 1</code>
|}

Atkreipk dėmesį, kad yra trys dalybos būdai: vienas grąžina dešimtainį skaičių, antras – tik dalybos sveikąją dalį, o trečias – liekaną.
Operacijų tvarka tokia pati kaip matematikoje:
* pirmiausiai atliekami veiksmai skliausteliuose <code>()</code>
* kėlimas laipsniu <code>**</code>
* iš kairės į dešinę: daugyba <code>*</code>, dalyba<code>/</code>, sveikoji dalyba <code>//</code>, dalybos liekana <code>%</code>
* iš kairės į dešinę: sudėtis <code>+</code> ir atimtis <code>-</code>

Taigi, užrašydamas formules, nepamiršk skliaustelių!

=== Komentarai ===

Rašant daug kodo, ateityje tikrai ne viską atsiminsi. Todėl programoje gali naudoti komentarus, kurie yra tiesiog pastabos/paaiškinimai sau pačiam arba kitiems programuotojams. Pavyzdžiui:

<syntaxhighlight lang="python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22 / 7)
</syntaxhighlight>

Rezultatas:

3.14285714286

Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra skirti žmonėms, pagerinti programos skaitomumą.

Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris visą šį tekstą ignoruos iki pat eilutės galo.

<syntaxhighlight lang = "python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22/7) # tokiu būdu gauname tik apytikslę PI reikšmę
</syntaxhighlight>

=== Pavyzdžiai ===
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python'o kodo redaktorių ir pažiūrėti kaip viekia. Jeigu suprasi, keliauk toliau, jeigu ne, bandyk dar kartą perskaityti skyriaus medžiagą ir suprasti pavyzdžių logiką.

'''Danija.py'''

<syntaxhighlight lang="python">
print("Būti ar nebūti, štai kur klausimas.")
print(" -- Šekspyras")
</syntaxhighlight>

Rezultatas:

Būti ar nebūti, štai kur klausimas.
-- Šekspyras

'''Mokykla.py'''

<syntaxhighlight lang="python">
print("Pirmoji klasė")
print("1 + 1 =", 1 + 1)
print("2 + 4 =", 2 + 4)
print("5 - 2 =", 5 - 2)
print()
print("Trečioji klasė")
print("243 - 23 =", 243 - 23)
print("12 * 4 =", 12 * 4)
print("12 / 3 =", 12 / 3)
print("13 / 3 =", 13 // 3, "liekana", 13 % 3)
print()
print("Penktoji klasė")
print("123.56 - 62.12 =", 123.56 - 62.12)
print("(4 + 3) * 2 =", (4 + 3) * 2)
print("4 + 3 * 2 =", 4 + 3 * 2)
print("3 ** 2 =", 3 ** 2)
</syntaxhighlight>

Rezultatas:

Pirma klasė
1 + 1 = 2
2 + 4 = 6
5 - 2 = 3

Trečia klasė
243 - 23 = 220
12 * 4 = 48
12 / 3 = 4
13 / 3 = 4 liekana 1

Penktoji klasė
123.56 - 62.12 = 61.44
(4 + 3) * 2 = 14
4 + 3 * 2 = 10
3 ** 2 = 9

=== Pratimai ===

1. Parašyk programą, kuri atspausdintų tavo vardą, pavardę ir gimtadienį kaip atskiras eilutes.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #1  
|-
|
<syntaxhighlight lang="python">
print("Ada Lovelace", "gimusi", "1815 m. gruodžio 10 d.")
</syntaxhighlight>

<syntaxhighlight lang="python">
print("Albertas Einšteinas", "gimęs", "1879 m. kovo 14 d.")
</syntaxhighlight>

<syntaxhighlight lang="python">
print(("Styvas Džobsas"), ("gimęs"), ("1955 m. vasario 24 d."))
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri parodytų visų 7 [[#Aritmetinės_išraiškos|artimetinių operacijų]] panaudojimą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #2  
|-
|
<syntaxhighlight lang="python">
print("5**5 =", 5**5)
print("6*7 =", 6*7)
print("56/8 =", 56/8)
print("14//6 =", 14//6)
print("14%6 =", 14%6)
print("5+6 =", 5+6)
print("9-0 =", 9-0)
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri išvestų reiškinio (2023 - 2000) * (9 + 10) reikšmę.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #3  
|-
|
<syntaxhighlight lang="python">
print("(2023 - 2000) * (9 + 10) =", (2023-2000)*(9+10))
</syntaxhighlight>
|-
|}

----
==== Išnašos====

{{navigation |previous=Įvadas |next=Kas čia eina?}}

Vadovėlis/Labas, Pasauli

2023-01-03T14:22:52Z

Monika: Pridėta trečia užduotis

{{navigation |previous=Įvadas |next=Kas čia eina?}}

=== Ką sužinosi? ===
Perskaitęs šį skyrių, turėtum suprasti kaip teksto redaktoriumi rašyti programas, kaip parašytas programas išsaugoti kompiuterio atmintyje ir kaip jas paleisti.

=== Spausdinimas ===
Istoriškai taip jau susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programėlės pavadinimu „Labas, Pasauli!“ arba angliškai „Hello, World!“.

[[Vaizdas:Labas, pasauli.png|600px|frameless|center]]

Python'o programavimo kalboje programa atrodytų taip:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

==== Programavimas kodo redaktoriumi ====

Programavimui rekomenduoju naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Python Vadovėlis/Įvadas#Python_ir_Visual_Studio_Code_diegimas|Python ir Visual Studio Code diegimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File arba Failas -> Naujas failas), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save arba Failas -> Išsaugoti) pavadinimu <code>labas.py</code>.

Sveikiname! Sukūrei savo pirmą Python programą.

(Jeigu tokios programavimo aplinkos įsidiegti savo kompiuteryje negali, žr. kitą žingsnį).

Dabar parašytą programą paleisk vykdyti: tiesiog paspausk žalią mygtuką dešinėje viršuje.

Kai paleisi šią programą, ji suveiks ir terminale atsiras užrašas:

Labas, Pasauli!

==== Alternatyvus būdas: Programavimas paprastu teksto redaktoriumi ====

Jeigu kodo redaktoriaus negali įsidiegti savo kompiuteryje dėl kokių nors priežasčių, programuoti galima ir tiesiog paprasčiausiu teksto redaktoriumi, pvz. Notepad.

Tiesiog sukurk naują paprastą tekstinį failą (.txt), jame įrašyk programinį kodą <code>print("Labas, Pasauli!")</code>, failą išsaugok pavadinimu <code>labas.py</code>.

Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 labas.py</code>

Tavo programa parašys:

Labas, Pasauli!

=== Eime toliau ===

Labai rekomenduoju kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. Mūsų praktikoje toks mokymosi procesas yra pats efektyviausias ir veiksmingiausias.

Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:

<syntaxhighlight lang="python">
print("Gyveno kadaise Paryžiuj bobutė –")
print("Prie Eifelio bokšto turėjo ji butą.")
print("Ji visko pasauly klausytis norėjo,")
print("Bet viena kairiąja ausim tegirdėjo.")
</syntaxhighlight>

Kai paleidi šią programą, ji parašo J. Erlicko eilėraščio Bobutė iš Paryžiaus (2) ištrauką:

Gyveno kadaise Paryžiuj bobutė –
Prie Eifelio bokšto turėjo ji butą.
Ji visko pasauly klausytis norėjo,
Bet viena kairiąja ausim tegirdėjo.

Kai kompiuteris paleidžia programą, pirmiausia jis mato:

<syntaxhighlight lang="python">
print("Gyveno kadaise Paryžiuj bobutė –")
</syntaxhighlight>

Todėl kompiuteris užrašo:

Gyveno kadaise Paryžiuj bobutė –

Tada kompiuteris skaito kitą eilutę ir mato:

<syntaxhighlight lang="python">
print("Prie Eifelio bokšto turėjo ji butą.")
</syntaxhighlight>

Todėl ir ją užrašo kompiuterio ekrane:

Prie Eifelio bokšto turėjo ji butą.

Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs - eina toliau: skaito kitą eilutę, ją įvykdo ir t.t. Taip kompiuteris vykdo visas surašytas komandas, kol pasiekia programos pabaigą.

==== Terminologija ====
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.

Prieš tai rašydami kodą, mes naudojame „funkciją“ pavadinimu <code>print</code>. Po funkcijos pavadinimo <code>print</code> rašomi skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

funkcijai duodamas vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Programuotojai tai vadina „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme, angliškai 'string'). Kitas tekstinės reikšmės pavyzdys yra <code>"Gyveno kadaise Paryžiuj bobutė"</code>.

Užrašyta funkcija su argumentais yra komanda, kurią supranta Python'as. Sakinio pavyzdys:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

Paprasčiau tariant, komandą gali įsivaizduoti kaip vieną programos eilutę.

Kol kas terminologijos pakaks, keliaujam į kitą poskyrį ir mokomės toliau.

====Ženklo \n naudojimas====
<code>\n</code> (kaitos ženklas, angliškai - escape character), arba nauja eilutė. Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Pabandyk suprasti šią programą:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\nKą turėčiau daryti?")
</syntaxhighlight>

Kurios rezultatas yra toks:

Labas, Pasauli!
Ką turėčiau daryti?

<code>\n</code> naudojamas, kai norime tekstą perkelti į kitą eilutę, bet nenorime naudoti kelių <code>print()</code> komandų.

Spausdinimo komanda automatiškai naudoja <code>\n</code>, t.y. kiekviena komanda tekstą spausdina vis naujoje eilutėje, net jeigu pats <code>\n</code> ir neužrašai. Paprasčiau suprasti bus pamačius pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

iš tikrųjų yra:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\n")
</syntaxhighlight>

=== Aritmetinės operacijos ===
Programos pavyzdys:

<syntaxhighlight lang="python">
print("2 + 2 yra", 2 + 2)
print("3 * 4 yra", 3 * 4)
print("100 - 1 yra", 100 - 1)
# Atkreipk dėmesį, python'e aritmetikoje skaičiai po kablelio rašomi su tašku (.)
print("((33 + 2) / 5 + 11.5 yra", (33 + 2) / 5 + 11.5)
</syntaxhighlight>

Rezultatas:

2 + 2 yra 4
3 * 4 yra 12
100 - 1 yra 99
(33 + 2) / 5 + 11.5 yra 18.5

==== Aritmetinės išraiškos ====

Šiame pavyzdyje, rašymo funkcija <code>print()</code> yra su dvejais argumentais, kurie atskirti kableliu. Panagrinėkime pirmoje eilutėje užrašytą komandą:

<syntaxhighlight lang="python">
print("2 + 2 yra", 2 + 2)
</syntaxhighlight>

Pirmas argumentas yra teksto eilutė <code>"2 + 2 yra"</code> ir antras argumentas yra aritmetinė išraiška <code>2 + 2</code>, tiksliau tariant viena iš aritmetinių operacijų.

Atkreipk dėmesį, kad eilutė, kuri yra užrašyta kabutėse yra atspausdinama kaip tekstas, o išraiška užrašyta be kabučių yra apskaičiuojama ir užrašomas atsakymas.

Python'o programavimo kalba turi septynias pagrindines skaičių operacijas.

{| class="wikitable"
! Operacija
! Simbolis
! Pavyzdys
|-
|Kėlimas laipsniu
| <code>**</code>
| <code>5 ** 2 == 25</code>
|-
|Daugyba
| <code>*</code>
|<code>2 * 3 == 6</code>
|-
|Dalyba
| <code>/</code>
| <code>14 / 3 == 4.666666666666667</code>
|-
|Sveikųjų skaičių dalyba
| <code>//</code>
| <code>14 // 3 == 4</code>
|-
|Liekana
| <code>%</code>
| <code>14 % 3 == 2</code>
|-
|Sudėtis
| <code>+</code>
| <code>1 + 2 == 3</code>
|-
|Atimtis
| <code>-</code>
| <code>4 - 3 == 1</code>
|}

Atkreipk dėmesį, kad yra trys dalybos būdai: vienas grąžina dešimtainį skaičių, antras – tik dalybos sveikąją dalį, o trečias – liekaną.
Operacijų tvarka tokia pati kaip matematikoje:
* pirmiausiai atliekami veiksmai skliausteliuose <code>()</code>
* kėlimas laipsniu <code>**</code>
* iš kairės į dešinę: daugyba <code>*</code>, dalyba<code>/</code>, sveikoji dalyba <code>//</code>, dalybos liekana <code>%</code>
* iš kairės į dešinę: sudėtis <code>+</code> ir atimtis <code>-</code>

Taigi, užrašydamas formules, nepamiršk skliaustelių!

=== Komentarai ===

Rašant daug kodo, ateityje tikrai ne viską atsiminsi. Todėl programoje gali naudoti komentarus, kurie yra tiesiog pastabos/paaiškinimai sau pačiam arba kitiems programuotojams. Pavyzdžiui:

<syntaxhighlight lang="python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22 / 7)
</syntaxhighlight>

Rezultatas:

3.14285714286

Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra skirti žmonėms, pagerinti programos skaitomumą.

Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris visą šį tekstą ignoruos iki pat eilutės galo.

<syntaxhighlight lang = "python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22/7) # tokiu būdu gauname tik apytikslę PI reikšmę
</syntaxhighlight>

=== Pavyzdžiai ===
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python'o kodo redaktorių ir pažiūrėti kaip viekia. Jeigu suprasi, keliauk toliau, jeigu ne, bandyk dar kartą perskaityti skyriaus medžiagą ir suprasti pavyzdžių logiką.

'''Danija.py'''

<syntaxhighlight lang="python">
print("Būti ar nebūti, štai kur klausimas.")
print(" -- Šekspyras")
</syntaxhighlight>

Rezultatas:

Būti ar nebūti, štai kur klausimas.
-- Šekspyras

'''Mokykla.py'''

<syntaxhighlight lang="python">
print("Pirmoji klasė")
print("1 + 1 =", 1 + 1)
print("2 + 4 =", 2 + 4)
print("5 - 2 =", 5 - 2)
print()
print("Trečioji klasė")
print("243 - 23 =", 243 - 23)
print("12 * 4 =", 12 * 4)
print("12 / 3 =", 12 / 3)
print("13 / 3 =", 13 // 3, "liekana", 13 % 3)
print()
print("Penktoji klasė")
print("123.56 - 62.12 =", 123.56 - 62.12)
print("(4 + 3) * 2 =", (4 + 3) * 2)
print("4 + 3 * 2 =", 4 + 3 * 2)
print("3 ** 2 =", 3 ** 2)
</syntaxhighlight>

Rezultatas:

Pirma klasė
1 + 1 = 2
2 + 4 = 6
5 - 2 = 3

Trečia klasė
243 - 23 = 220
12 * 4 = 48
12 / 3 = 4
13 / 3 = 4 liekana 1

Penktoji klasė
123.56 - 62.12 = 61.44
(4 + 3) * 2 = 14
4 + 3 * 2 = 10
3 ** 2 = 9

=== Pratimai ===

1. Parašyk programą, kuri atspausdintų tavo vardą, pavardę ir gimtadienį kaip atskiras eilutes.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #1  
|-
|
<syntaxhighlight lang="python">
print("Ada Lovelace", "gimusi", "1815 m. gruodžio 10 d.")
</syntaxhighlight>

<syntaxhighlight lang="python">
print("Albertas Einšteinas", "gimęs", "1879 m. kovo 14 d.")
</syntaxhighlight>

<syntaxhighlight lang="python">
print(("Styvas Džobsas"), ("gimęs"), ("1955 m. vasario 24 d."))
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri parodytų visų 7 [[#Aritmetinės_išraiškos|artimetinių operacijų]] panaudojimą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #2  
|-
|
<syntaxhighlight lang="python">
print("5**5 =", 5**5)
print("6*7 =", 6*7)
print("56/8 =", 56/8)
print("14//6 =", 14//6)
print("14%6 =", 14%6)
print("5+6 =", 5+6)
print("9-0 =", 9-0)
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuri išvestų reiškinio (2023 - 2000) * (9 + 10) reikšmę.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #3  
|-
|
<syntaxhighlight lang="python">
print "(2023 - 2000) * (9 + 10) =", (2023-2000)*(9+10)
</syntaxhighlight>
|-
|}

----
==== Išnašos====

{{navigation |previous=Įvadas |next=Kas čia eina?}}