wiki.angis.net - Naudotojo indėlis [lt]

Python Vadovėlis/Ciklai For

2022-07-28T09:30:56Z

Monika: Pridėtas sąrašų rūšiavimo poskyris

{{navigation |previous=Sąrašai |next=Loginiai reiškiniai}}

{{BookCat}}

=== Ciklas <code>for</code> ===
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 ===
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>
|-
|}

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">
# sprendimas
</syntaxhighlight>
|-
|}

{{navigation |previous=Sąrašai |next=Loginiai reiškiniai}}
{{BookCat}}

Vaizdas:3 iteracija.png

2022-07-28T09:22:56Z

Monika:

Burbuliuko rūšiavimo algoritmo trečia iteracija.

Vaizdas:2 iteracija.png

2022-07-28T09:22:12Z

Monika:

Burbuliuko rūšiavimo algoritmo antra iteracija.

Vaizdas:1 iteracija.png

2022-07-28T09:20:50Z

Monika:

Burbuliuko rūšiavimo algoritmo pirma iteracija

Python Vadovėlis/Sąrašai

2022-07-28T09:14:50Z

Monika: Iškeltas rūšiavimo poskyris

{{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>
|-
|}

{{navigation |previous=Rekursinės funkcijos |next=Ciklai For}}
{{BookCat}}

Python Vadovėlis/Sąrašai

2022-07-20T06:39:39Z

Monika: Pridėtas poskyris apie rūšiavimą

{{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ą.

=== Sąrašų rūšiavimas ===

Dažai pasitaikanti užduotis su sąrašais - jų rūšiavimas. Paprastų sąrašų, kurie yra sudaryti iš skaičių ar eilučių, rūšiavimui gali naudoti funkciją <code>sort</code>, kuri buvo paminėta anksčiau šiame 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.

Pavyzdžiui, surūšiuokime jau prieš tai naudotą sąrašą [42, 7, 0, 123].

Pirma iteracija:

['''42''', '''7''', 0, 123] -> ['''7''', '''42''', 0, 123] Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.

[7, '''42''', '''0''', 123] -> [7, '''0''', '''42''', 123] Lyginami antras ir trečias elementai. Trečiasis yra didesnis už antrąjį, todėl elementai pakeičiami vietomis.

[7, 0, '''42''', '''123'''] -> [7, 0, '''42''', '''123'''] Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

Antra iteracija:

['''7''', '''0''', 42, 123] -> ['''0''', '''7''', 42, 123] Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.

[0, '''7''', '''42''', 123] -> [0, '''7''', '''42''', 123] Lyginami antras ir trečias elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

[0, 7, '''42''', '''123'''] -> [0, 7, '''42''', '''123'''] Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

Trečia iteracija:

['''0''', '''7''', 42, 123] -> ['''0''', '''7''', 42, 123] Elementai išdėstyti tinkamai.

[0, '''7''', '''42''', 123] -> [0, '''7''', '''42''', 123] Elementai išdėstyti tinkamai.

[0, 7, '''42''', '''123'''] -> [0, 7, '''42''', '''123'''] 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 >

Pogramos išvestis:

<code>
[0, 7, 42, 123]
</code>

=== 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>
|-
|}

{{navigation |previous=Rekursinės funkcijos |next=Ciklai For}}
{{BookCat}}

Python Vadovėlis/DUK

2022-04-07T11:57:03Z

Monika: Pridėta informacija apie Angis

; Kaip galiu sukurti grafinę sąsają (angl. graphical user interface, GUI) su Python? : Gali naudoti vieną iš šių bibliotekų: [https://docs.python.org/3.5/library/tkinter.html TKinter], [https://riverbankcomputing.com/software/pyqt/intro PyQt], [https://wiki.gnome.org/Projects/PyGObject PyGobject]. Itin paprastai grafikai kurti, gali naudoti vėžliuko grafikos rėžimą <code>import turtle</code>.
; Kaip galiu sukurti žaidimą su Python? : Savo žaidimą ar programėlę gali sukurti pasinaudodamas lietuviška platforma [https://angis.lrt.lt/ Angis]. Šiame puslapyje taip pat gali peržiūrėti nemokamas video pamokas ir spręsti pateiktas užduotis, taip pagerindamas savo programavimo žinias. Daugiau informacijos: https://wiki.angis.net. Kitas puikus būdas yra pasinaudoti angliška platforma [http://pygame.org PyGame].
; Kaip galiu sukurti vykdomąjį failą iš Python programos? : Trumpas atsakymas: Python yra interpretuojama kalba, todėl tai yra neįmanoma. Ilgas atsakymas: kažkas panašaus į vykdomąjį failą gali būti sukurta sujungiant Python interpretatorių su failu. Daugiau informacijos apie tai gali rasti šiame puslapyje http://www.python.org/doc/faq/programming/#how-can-i-create-a-stand-alone-binary-from-a-python-script
; Ką turėčiau daryti, jei turiu klausimų dėl vadovėlio arba radau jame klaidų? : Parašyk mums laišką elektroniniu paštu ''python.vadovelis@visma.com''.

{{navigation |previous=Pabaiga |next=Terminai}}

Python Vadovėlis/Funkcijų apibrėžimas

2022-04-06T18:24:21Z

Monika: Pataisymai pagal Martyno pastabas

{{navigation |previous=Derinimas |next=Pažangių funkcijų pavyzdys}}

=== 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

=== Užduotis ===
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=Pažangių funkcijų pavyzdys}}

Python Vadovėlis/Kas čia eina?

2022-04-06T18:10:43Z

Monika: Išverstas "Python shell"

{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}
{{BookCat}}

=== Įvestis ir 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

=== Užduotis ===
Parašyti 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>
|-
|}

{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}

Python Vadovėlis/DUK

2022-04-06T18:08:05Z

Monika: Pridėtas el. pašto adresas.

Python Vadovėlis/Kas čia eina?

2022-03-15T16:12:09Z

Monika:

{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}
{{BookCat}}

=== Įvestis ir 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 shell 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

=== Užduotis ===
Parašyti 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>
|-
|}

{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}

Python Vadovėlis/Derinimas

2022-03-15T16:05:39Z

Monika:

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

{{navigation |previous=Pasirinkimai |next=Funkcijų apibrėžimas}}

Python Vadovėlis/Derinimas

2022-03-15T16:04:55Z

Monika: Pridėta navigacija pradžioje

{{navigation |previous=Pasirinkimai |next=Funkcijų apibrėžimas}}

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

{{navigation |previous=Pasirinkimai |next=Funkcijų apibrėžimas}}

Python Vadovėlis/DUK

2022-02-28T19:18:10Z

Monika: Išversta dalis teksto

; Kaip galiu sukurti grafinę sąsają (angl. graphical user interface, GUI) su Python? : Gali naudoti vieną iš šių bibliotekų: [https://docs.python.org/3.5/library/tkinter.html TKinter], [https://riverbankcomputing.com/software/pyqt/intro PyQt], [https://wiki.gnome.org/Projects/PyGObject PyGobject]. Itin paprastai grafikai kurti, gali naudoti vėžliuko grafikos rėžimą <code>import turtle</code>
; Kaip galiu sukurti žaidimą su Python? : Geriausias būdas, greičiausiai, yra naudoti PyGame, kuris pasiekiamas šia nuoroda: http://pygame.org/
; Kaip galiu sukurti vykdomąjį failą iš Python programos? : Trumpas atsakymas: Python yra interpretuojama kalba, todėl tai yra neįmanoma. Ilgas atsakymas: kažkas panašaus į vykdomąjį failą gali būti sukuriama sujungiant Python interpretatorių ir failą. Daugiau informacijos apie tai gali rasti šiame puslapyje http://www.python.org/doc/faq/programming/#how-can-i-create-a-stand-alone-binary-from-a-python-script

; (IFAQ) Why do you use first person in this tutorial? : Once upon a time in a different millennia, (1999 to be exact), an earlier version was written entirely by Josh Cogliati, and it was up on his webpage http://www.honors.montana.edu/~jjc/easytut and it was good. Then the server rupert, like all good things than have a beginning came to an end, and Josh moved it to Wikibooks, but the first person writing stuck. If someone really wants to change it, I will not revert it, but I don't see much point. (The webpage has since moved to http://jjc.freeshell.org/easytut/ and http://jjc.freeshell.org/easytut3/ )
; My question is not answered. : Ask on the discussion page or add it to this FAQ, or email one of the [[Vadovėlis/Autoriai|Autoriai]].

For other FAQs, you may want to see the Python 2.6 version of this page [[Non-Programmer's Tutorial for Python 2.6/FAQ]], or the [https://docs.python.org/3.5/faq/ Python FAQ].

{{navigation |previous=Pabaiga |next=Terminai}}

Python Vadovėlis/Pabaiga

2022-02-28T19:03:09Z

Monika: Pirminis vertimas

Ir štai mes pasiekėme pabaigą. O gal pradžią? Šis vadovėlis parašytas Wikipedijoje, todėl gali siūlyti įvairius patobulinimus. Jei nori išmokti daugiau apie Python kalbą, šiame [http://www.python.org/~guido/ Guido van Rossum] sukurtame [http://docs.python.org/3/tutorial/index.html The Python Tutorial] puslapyje gali rasti daug papildomų temų. Jei atidžiai skaitei šį vadovėlį, turėtum suprasti daugumą ten esančios medžiagos. Dar keli naudingi puslapiai anglų kalba:

* [http://www.swaroopch.com/notes/Python A Byte of Python by Swaroop C H]
* [https://www.datacamp.com/courses/intro-to-python-for-data-science DataCamp Interactive Python 3 Tutorial - Online]
* [http://anh.cs.luc.edu/python/hands-on/3.1/handsonHtml/index.html Hands-on Python Tutorial by Dr. Andrew N. Harrington]

Tikiuosi, kad ši knyga tau suteiks pakankamai žinių, kad galėtum pradėti rašyti programinį kodą.

Tad smagaus programavimo, tegu tai pakeičia tavo gyvenimą ir pasaulį!

{{navigation |previous=Įvadas į importuotas bibliotekas ir kitas funkcijas |next=DUK}}

Python Vadovėlis/Autoriai

2022-02-28T18:41:27Z

Monika: Autorių rikiavimas

Originalaus (angliško) vadovėlio autoriai

; Josh Cogliati
: Jrincayc, jjcogliati-jan2007 AT yahoo.com

=== Angliškos versijos bendraautoriai ===
* Mitchell Aikens, LGIT, WSIT, AAS
* Kiah Morante
*Elizabeth Cogliati
*James A. Brown
*Joe Oppegaard
*Benjamin Hell

=== Lietuviškas vertimas ir modifikacija ===
* Artūras Nikončukas, Visma Lietuva
* Laura Kutovaja, Visma Lietuva
* Mantas Urbonas, Visma Lietuva
* Martynas Teleiša, Visma lietuva
* Mindaugas Pikelis, Visma Lietuva
* Modesta Jeremičienė, Visma Lietuva
* Monika Bijeikytė, Visma Lietuva
* Povilas Jeremičius, Visma Lietuva
* Rokas Cvirka, Visma Lietuva
* Živilė Bliūdžiūtė, Visma Lietuva

{{navigation |previous=BEGINNING |next=Įžanga}}
{{BookCat}}

Python Vadovėlis/Pasirinkimai

2022-02-28T18:37:31Z

Monika: Pataisymai pagal Martyno pastabas

{{navigation |previous=Suskaičiuoti iki 10 |next=Derinimas}}

=== <code>If</code> sakinys ===
Aš manau, kad kiekvieną skyrių turėčiau pradėti nuo apšilimo pratimo. Taigi, žemiau turime trumpą programą, kuri apskaičiuoja absoliučią sveikojo skaičiaus reikšmę:
<syntaxhighlight lang="python">
n = int(input("Skaičius? "))
if n < 0:
print("Absoliuti", n, "reikšmė yra", -n)
else:
print("Absoliuti", n, "reikšmė yra", n)
</syntaxhighlight>

Štai rezultatas po dviejų programos vykdymų:

Skaičius? '''-34'''
Absoliuti -34 reikšmė yra 34

Skaičius? '''1'''
Absoliuti 1 reikšmė yra 1

Taigi, ką kompiuteris daro, kai pamato šį kodą? Visų pirma, jis kviečia įvesti skaičių su šiuo sakiniu <code>n = int(input("Skaičius? "))</code>. Tada jis skaito eilutę <code>if n < 0:</code>. Jei <code>n</code> yra mažiau už nulį, Python'as vykdo eilutę <code>print("Absoliuti", n, "reikšmė yra", -n)</code>. Kitu atveju, jis vykdo eilutę <code>print("Absoliuti", n, "reikšmė yra", n)</code>.

Kalbant formaliau, Python'as tikrina, ar „reiškinio“ <code>n < 0</code> reikšmė yra teisinga (angl. true) ar klaidinga (angl. false). Sakinys <code>if</code> yra lydimas įtraukto sakinių „bloko“, kuris vykdomas tik jei reiškinio reikšmė yra teisinga. Pasirinktinai, po <code>if</code> sakinio gali būti <code>else</code> sakinys ir dar vienas įtrauktas sakinių „blokas“. Antrasis sakinių blokas yra vykdomas tik jei reiškinio reikšmė yra klaidinga.

Reiškinys gali turėti įvairių sąlygų. Žemiau yra visų jų lentelė:

{| class="wikitable"
!Operatorius
!Funkcija
|-
|<code><</code>
|mažiau nei
|-
|<code><=</code>
|mažiau nei arba lygu
|-
|<code>></code>
|daugiau nei
|-
|<code>>=</code>
|daugiau nei arba lygu
|-
|<code>==</code>
|lygu
|-
|<code>!=</code>
|nelygu
|}

Dar viena sakinio <code>if</code> ypatybė yra <code>elif</code> dalis. Tai <code>else if</code> sutrumpinimas ir reiškia, kad jei originali <code>if</code> sakinio reikšmė yra klaidinga, bet <code>elif</code> dalis yra teisinga, yra vykdoma <code>elif</code> kodo dalis. Ir jei nei <code>if</code>, nei <code>elif</code> reiškiniai nėra tiesa, tada vykdomas <code>else</code> blokas. Pavyzdžiui:
<syntaxhighlight lang="python">
a = 0
while a < 10:
a = a + 1
if a > 5:
print(a, ">", 5)
elif a <= 3:
print(a, "<=", 3)
else:
print("Nei vienas iš testų nėra teisingas")
</syntaxhighlight>

ir išvestis:

1 <= 3
2 <= 3
3 <= 3
Nei vienas iš testų nėra teisingas
Nei vienas iš testų nėra teisingas
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

Gali pastebėti, kad <code>elif a <= 3</code> dalis yra tikrinama tik tada, jei <code>if</code> reiškinio reikšmė nėra tiesa. Galima rašyti daugiau nei vieną <code>elif</code> reiškinį, tokiu būdu leidžiant tikrinti kelias sąlygas viename <code>if</code> sakinyje.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa parodo, kaip galima naudoti == operatorių
# naudojant skaičius
print(5 == 6)
# naudojant kintamuosius
x = 5
y = 8
print(x == y)
</syntaxhighlight>

Ir išvestis - dvi klaidingos (angl. false) reikšmės

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">

# Spėlionių žaidimas daugiau mažiau

# Iš tiesų, čia turėtų būti naudojami pusiau atsitiktiniai skaičiai,
# pavyzdžiui paskutinis laiko skaitmuo, ar kažkas panašaus. Bet tai
# palauks iki vėlesnės dalies. (Papildoma užduotis: po Modulių dalies, pakeisk šį kodą,
# kad būtų naudojami atsitiktiniai skaičiai)
skaicius = 7
spejimas = -1

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))

if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")
</syntaxhighlight>

Pavyzdinis vykdymas:

Atspėk skaičių!
Ar tai yra... '''2'''
Skaičius yra didesnis...
Ar tai yra... '''5'''
Skaičius yra didesnis...
Ar tai yra... '''10'''
Skaičius yra ne toks didelis.
Ar tai yra... '''7'''
Valio! Atspėjai teisingai!

'''lyginis.py'''

<syntaxhighlight lang="python">
# Prašo įvesti skaičių.
# Išveda, ar skaičius yra lyginis, ar ne

skaicius = float(input("Pasakyk man skaičių: "))
if skaicius % 2 == 0:
print(int(skaicius), "yra lyginis.")
elif skaicius % 2 == 1:
print(int(skaicius), "yra nelyginis.")
else:
print(skaicius, "yra labai keistas.")
</syntaxhighlight>

Pavyzdiniai vykdymai:

Pasakyk man skaičių: '''3'''
3 yra nelyginis.

Pasakyk man skaičių: '''2'''
2 yra lyginis.

Pasakyk man skaičių: '''3.4895'''
3.4895 yra labai keistas.

'''vidurkis1.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol įvedamas 0
# Išveda visų įvestų skaičių vidurkį

kiekis = 0
suma = 0.0
skaicius = 1 # nurodomas tam, kad nebūtų iškart išeinama iš ciklo.

print("Įvesk 0, kad sustabdytum ciklą")

while skaicius != 0:
skaicius = float(input("Įvesk skaičių: "))
if skaicius != 0:
kiekis = kiekis + 1
suma = suma + skaicius
if skaicius == 0:
print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''3'''
Įvesk skaičių: '''5'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 4.0

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''1'''
Įvesk skaičių: '''4'''
Įvesk skaičių: '''3'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 2.66666666667

'''vidurkis2.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol bus įvestas tam tikras kiekis skaičių
# Išveda visų įvestų skaičių vidurkį.

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek skaičių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui įsiminti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Pratimai ===
Parašyk programą, kuri prašo naudotojo įvesti savo vardą. Jei jis įveda tavo vardą, išvesk „Tai puikus vardas“. Jei jie įveda „Jonas Jonaitis“ arba „Petras Petraitis“, išvesk kokį nors juokingą tekstą. Kitu atveju, išvesk „Tavo vardas yra labai gražus“.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
vardas = input("Tavo vardas: ")
if vardas == 'Lukas':
print("Tai puikus vardas.")
elif vardas == 'Jonas Jonaitis':
print("... juokingas tekstas apie Joną.")
elif vardas == 'Petras Petraitis':
print("... juokingas tekstas apie Petrą.")
else:
print("Tavo vardas yra labai gražus.")
</syntaxhighlight>
|-
|}

Pakeisk aukščiau esančią „daugiau_maziau.py“ programą, kad ji papildomai skaičiuotų, kiek kartų naudotojas įvedė neteisingą skaičių. Jei taip nutiko daugiau, nei tris kartus, programos pabaigoje išvesk „Tai buvo sudėtinga.“, o kitu atveju - „Gerai padirbėjai!“

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
skaicius = 7
spejimas = -1
kiekis = 0

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))
kiekis = kiekis + 1
if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")

if kiekis > 3:
print("Tai buvo sudėtinga.")
else:
print("Gerai padirbėjai!")
</syntaxhighlight>
|-
|}

Parašyk programą, kuri prašo įvesti du skaičius. Jei skaičių suma yra didesnė nei 100, išvesk „Tai yra didelis skaičius“.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
skaicius1 = float(input("Pirmas skaičius: "))
skaicius2 = float(input("Antras skaičius: "))
if skaicius1 + skaicius2 > 100:
print("Skaičių suma yra didelis skaičius.")
</syntaxhighlight>
|-
|}

{{navigation |previous=Suskaičiuoti iki 10 |next=Derinimas}}

Python Vadovėlis/Įvadas

2022-02-15T12:34:53Z

Monika: Rašybos klaidų pataisymai

{{navigation |previous=Įžanga |next=Labas, Pasauli}}

=== Įvadas ===
Šis vadovėlis skirtas visiems norintiems išmokti Python: tiek pirmą kartą bandantiems programuoti, tiek bandžiusiems programuoti kitomis programavimo kalbomis ir norintiems išmokti Python, tiek jau pramokusiems Python, bei norintiems praplėsti žinias.

Tėra vienintelis būdas išmokti programuoti. '''Tu''' turi skaityti ''kodą'' ir rašyti ''kodą''.
Vadovėlyje parodysiu tau daug kodo. Bandyk jį vykdyti kompiuteriu ir pats išbandyti kaip jis veikia. Eksperimentuok ir bandyk daryti pakeitimus. Nebijok kažką sugandinti, blogiausiu atveju tavo kodas tiesiog neveiks. Kai aš pats rašysiu kodą knygoje, jį suformatuosiu šitaip:

<syntaxhighlight lang="python">
# Python kalbą lengva išmokti
print("Sveikas, pasauli!")
</syntaxhighlight>

Prieš komentarą – paprastą tekstą – dėsiu groteles. Šitaip lengvai atskirsi kodo pavyzdžius nuo teksto. Jei skaitai internetinį knygos variantą, atkreipk dėmesį į kodo spalvą – ji kitokia, tam kad tam tikros kodo dalys išsiskirtų. Tau vedant kodą kompiuteriu redagavimo programa jį gali nuspalvinti kitokiomis spalvomis arba iš viso nenuspalvinti. Kodo nuspalvinimas gali skirtis, bet jei įvesi kodą taip, kaip nurodyta pavyzdžiuose, jis veiks taip, kaip ir aprašyta vadovėlyje.

Pavyzdžiui, vykdant anksčiau parašytą kodo pavyzdį kompiuteris ekrane išves tokį tekstą:

Sveikas, pasauli!

Šis vadovėlis skirtas Python 3 versijai. Bandant kodo pavyzdžius vykdyti su Python 2.7 ir ankstesnėmis versijomis, jis gali neveikti. Skirtumai tarp Python 2 ir 3 versijos nėra itin dideli, tad išmokęs Python 3 galėsi be didelių pastangų skaityti ir ankstesnėms versijoms skirtą kodą.

Pavyzdžiuose dažnai parodysiu programos vykdymo metu tavo įvedamą tekstą (jis bus '''paryškintas''') ir programos į ekraną išvedamą tekstą. Pavyzdžiui:

Stok!
Kas eina? '''Benas'''
Benai, gali eiti toliau

Vadovėlyje tave supažindinsiu ir su programavimo terminologiją. Tai ne tik tau padės suprasti apie ką kalba programuotojai, bet ir padės mokytis.

Kad galėtum pradėti kurti Python programas tau reikės Python 3 programinės įrangos, bei kodo redaktoriaus. Rekomenduojame naudoti "LR NŠA Python" programą, kurią gali parsisiųsti iš https://www.visma.lt/python-diegimas/. Ši diegimo programa įdiegs Python interpretatorių, Visual Studio Code kodo redaktorių, bei sukonfigūruos tavo kompiuterį, kad galėtum iš karto rašyti ir vykdyti kodą.

=== Python ir Visual Studio Code diegimas ===
==== Diegimas Windows operacinėse sistemose ====
LR NŠA Python diegimo programa yra skirta Windows operacinės sistemos naudotojams.

1. Parsisiųsk diegimo programą iš https://www.visma.lt/python-diegimas/. Rekomenduojama rinktis 64 bitų versiją, nebent naudoji 32 bitų operacinės sistemą.

2. Paleisk parsisiųstą programą

3. Atsivers diegimo programos langas. Kad pradėtum diegimą spausk mygtuką '''Next'''.

[[Vaizdas:Vadovelis 1Sk 1.jpg|frame|center]]

4. Atsivers naujas langas, kuriame galima pasirinkti kokias dalis norima įdiegti. Rekomenduojama nieko nekeisti ir spausti mygtuką '''Install'''.

[[Vaizdas:Vadovelis 1Sk 2.jpg|frame|center]]

5. Palauk kol baigsis diegimas

6. Baigus diegimą pamatysi langą su pirmo paleidimo instrukcijomis. Šiame lange paspausk mygtuką '''OK'''.

[[Vaizdas:Vadovelis 1Sk 3.jpg|frame|center]]

7. Paspausk mygtuką '''Finish''', kad užbaigtum diegimą.

[[Vaizdas:Vadovelis 1Sk 4.jpg|frame|center]]

==== Diegimas Linux, BSD, bei Unix operacinėse sistemose ====
Jei naudoji ne Windows operacinę sistemą, Python ir kodo redaktorių reikės įsidiegti atskirai.
Linux, BSD, bei Unix operacinėse sistemose Python dažnai bus įdiegtas kartu su operacine sistema. Patikrinti ar Python įdiegtas ir kuri versija įdiegta galima įvykdžius komandą:

python3 --version

Jei Python nėra įdiegtas, tai jį įsidiegti galima naudojantis instrukcija anglų kalba: https://docs.python-guide.org/starting/install3/linux/

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių Linux operacinei sistemai galima iš https://code.visualstudio.com/Download

==== Diegimas Mac operacinėse sistemose ====
Nuo Mac OS X Tiger (10.4) versijos, Python 2 yra instaliuojama kartu su operacine sistema. Tad Python 3 reikia įdiegti atskirai (Nebent vėlesnėse versijose pasikeis su operacine sistema diegiamo Python versija). Parsisiųsti Python 3 MAC operacinėms sistemoms galima iš https://www.python.org/downloads/macos/.

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download

=== Pirmas paleidimas ===
Windows operacinėse sistemose Visual Studio Code kodo redaktorių gali paleisti paspaudžiant ant darbalaukio atsiradusios ikonėlės.

[[Vaizdas:Vadovelis 1Sk 5.jpg|miniatiūra]]

Pirmo paleidimo metu programa atliks reikiamus konfigūravimo veiksmus, kad būtų galima pilnai naudotis reikiamais įskiepiais. Todėl pirmo paleidimo metu reikia palaukti kelias minutes kol konfigūravimas bus baigtas.

==== Pirmosios programos sukūrimas ====
Sukurti pirmąją programą gali vykdydamas šiuos žingsnius Visual Studio Code redaktoriuje:

1. Meniu pasirink Failas >> Atverti aplanką

2. Pasirink ar susikurk aplanką kuriame laikysi Python programų kodo failus.

3. Skyriuje '''NARŠYKLĖ''' prie aplanko paspausk ant naujo failo ikonėlės.

[[Vaizdas:Vadovelis 1Sk 6.jpg|frame|center]]

4. Pavadink failą "Sveikas.py"

5. Automatiškai atsivers failo redagavimo langas. Jame įrašyk

<syntaxhighlight lang="python">
print("Sveikas, pasauli!")
</syntaxhighlight>

6. Paspausk klavišus ctrl + F5, kad paleistum programą

7. Apatinėje skiltyje išvysi programos vykdymo langą, kur matysi ir savo programos vykdymo rezultatą:

[[Vaizdas:Vadovelis 1Sk 7.jpg|frame|kairėje]]

Tokiu pat principu galėsi kurti ir kitas programas.

==== Programų failų pavadinimai ====
Kuriant naujus Python kodo failus labai naudinga laikytis tam tikrų taisyklių, parenkant failų pavadinimus. Nesilaikant šių taisyklių gali atsitikti taip, kad programa "netikėtai" neveiks.
# Visada naudok failo plėtinį <tt>.py</tt>.
# Naudok vienintelį tašką - plėtinio atskyrimui
# Naudok tik: raides, skaičius, brūkšnį (<tt>-</tt>) ir pabraukimo simbolį (<tt>_</tt>)
# Nenaudok tarpų (žodziams atskirti galima naudoti pabraukimo simbolį (<tt>_</tt>).
# Failo pavadinimą pradėk raide
# Nenaudok standartinių Python komandų pavadinimų (pvz. <tt>print.py</tt>, <tt>math.py</tt>, <tt>list.py</tt>)

=== Python paleidimas per komandinę eilutę ===
Python programinį kodą galima vykdyti ir naudojant komandinę eilutę. Sukūrus failą su programos kodu ją įvykdyti galima komandinėj eilutėj vykdant komandą: <code>python ''failo_pavadinimas''</code>

[[Vaizdas:Vadovelis 1Sk 8.jpg|frame|kairėje]]

Python Vadovėlis/Failų tvarkymas

2021-12-08T09:09:18Z

Monika: Maži pataisymai

=== Failų I/O ===

Štai paprastas failo I/O (ang. Input/Output, lt. Įvesties/Išvesties) 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 įterpti ''n''aują eilutę toje vietoje.

Apžvelkime failų I/O:
* 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 kitą failo elementą ir grąžina jį kaip eilutę. Jei joks argumentas nepateiktas, funkcija grąžins visą failą (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 užkrauna failus. Štai dviejų programos vykdymų išvestis:

1. Spausdinti Telefono Numerius
2. Pridėti Telefono Numerį
3. Pašalinti Telefono Numerį
4. Ieškoti 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. Spausdinti Telefono Numerius
2. Pridėti Telefono Numerį
3. Pašalinti Telefono Numerį
4. Ieškoti 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ėkime į programos išsaugojimo dalį. Pirmiausia sukuriamas failo objektas su komanda <code>open(failo_pavadinimas, "wt")</code>. Toliau ji eina ir sukuria 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ė.

Užkrovimo 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 aptiktas <code>break</code> teiginys. Toliau nuskaitoma eilutė su kodu <code>skaitoma_eilutė = skaitymo_failas.readline()</code>. Pasiekus failo pabaigą, funkcija <code>readline</code> grąžins tuščią eilutę. Teiginys <code>if</code> tai patikrina ir panaudojant kodą <code>break</code> nutraukia <code>while</code> ciklą. Žinoma, jei funkcija <code>readline</code> negrąžintų naujos eilutės eilutės pabaigoje, nebūtų jokio būdo pasakyti, ar tuščia eilutė yra tuščia eilutė, ar failo pabaiga, todėl nauja eilutė įtraukiama į tai ką grąžina funckoja <code>readline</code>. Taigi turime atsikratyti tos naujos eilutės. Eilutė <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 į pavadinimą ir telefono numerį. Tada tai įtraukiama į <code>numeriai</code> žodyną

=== 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ą neatidaręs kitos programos?"

Yra keletas skirtingų būdų, kaip tai padaryti. Iš tikrųjų, lengviausias būdas atidaro kitą programą, tačiau viskuo pasirūpina Python'o kodas ir vartotojui nereikia nurodyti spausdinamo failo. Š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/Dictionaries]], kad ji naudotų failus mokinių pažymiams saugoti.

{{Solution|title=Sprendimas|text=

<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 kuri 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=Revenge of the Strings |next=Dealing with the imperfect}}
{{BookCat}}

Python Vadovėlis/Pasirinkimai

2021-11-22T14:53:16Z

Monika: Pataisytas pirmas sakinys

=== <code>If</code> sakinys ===
Aš tikiu, kad turėčiau pradėti kiekvieną skyrių nuo apšilimo pratimo. Taigi, žemiau turime trumpą programą, kuri apskaičiuoja absoliučią sveikojo skaičiaus reikšmę:
<syntaxhighlight lang="python">
n = int(input("Skaičius? "))
if n < 0:
print("Absoliuti", n, "reikšmė yra", -n)
else:
print("Absoliuti", n, "reikšmė yra", n)
</syntaxhighlight>

Štai rezultatas po dviejų programos vykdymų:

Skaičius? '''-34'''
Absoliuti -34 reikšmė yra 34

Skaičius? '''1'''
Absoliuti 1 reikšmė yra 1

Taigi, ką kompiuteris daro, kai pamato šį kodą? Visų pirma, jis kviečia įvesti skaičių su šiuo sakiniu <code>n = int(input("Skaičius? "))</code>. Tada jis skaito eilutę <code>if n < 0:</code>. Jei <code>n</code> yra mažiau už nulį, Python'as vykdo eilutę <code>print("Absoliuti", n, "reikšmė yra", -n)</code>. Kitu atveju, jis vykdo eilutę <code>print("Absoliuti", n, "reikšmė yra", n)</code>.

Kalbant formaliau, Python'as tikrina, ar „reiškinys“ <code>n < 0</code> yra teisinga ar klaidinga. Sakinys <code>if</code> yra lydimas įtraukto sakinių „bloko“, kuris vykdomas tik jei reiškinys yra tiesa. Pasirinktinai, po <code>if</code> sakinio gali būti <code>else</code> sakinys ir dar vienas įtrauktas sakinių „blokas“. Antrasis sakinių blokas yra vykdomas tik jei reiškinys yra melas.

Reiškinys gali turėti įvairių testų. Žemiau yra visų jų lentelė:

{| class="wikitable"
!operatorius
!funkcija
|-
|<code><</code>
|mažiau nei
|-
|<code><=</code>
|mažiau nei arba lygu
|-
|<code>></code>
|daugiau nei
|-
|<code>>=</code>
|daugiau nei arba lygu
|-
|<code>==</code>
|lygu
|-
|<code>!=</code>
|nelygu
|}

Dar viena sakinio <code>if</code> ypatybė yra <code>elif</code> sakinys. Tai <code>else if</code> sutrumpinimas ir reiškia, kad jei originalus <code>if</code> sakinys yra klaidinga, bet <code>elif</code> dalis yra teisinga, yra vykdoma <code>elif</code> kodo dalis. Ir jei nei <code>if</code>, nei <code>elif</code> reiškiniai nėra tiesa, tada vykdomas <code>else</code> blokas. Pavyzdžiui:
<syntaxhighlight lang="python">
a = 0
while a < 10:
a = a + 1
if a > 5:
print(a, ">", 5)
elif a <= 3:
print(a, "<=", 3)
else:
print("Nei vienas iš testų nėra teisingas")
</syntaxhighlight>

ir išvestis:

1 <= 3
2 <= 3
3 <= 3
Nei vienas iš testų nėra teisingas
Nei vienas iš testų nėra teisingas
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

Gali pastebėti, kad <code>elif a <= 3</code> dalis yra tikrinama tik tada, jei <code>if</code> sakinys nėra tiesa. Galima rašyti daugiau nei vieną <code>elif</code> reiškinį, tokiu būdu leidžiant vykdyti kelis testus viename <code>if</code> sakinyje.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa parodo, kaip galima naudoti == operatorių
# naudojant numerius
print(5 == 6)
# naudojant kintamuosius
x = 5
y = 8
print(x == y)
</syntaxhighlight>

Ir išvestis

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Žaidžia spėlionių žaidimą daugiau mažiau

# Iš tiesų, čia turėtų būti naudojami pusiau atsitiktiniai skaičiai,
# pavyzdžiui paskutinis laiko skaitmuo, ar kažkas panašaus. Bet tai
# palauks iki vėlesnės dalies. (Papildoma užduotis: po Modulių dalies, pakeisk šį kodą,
# kad būtų naudojami atsitiktiniai skaičiai)
skaicius = 7
spejimas = -1

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))

if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")
</syntaxhighlight>

Pavyzdinis vykdymas:

Atspėk skaičių!
Ar tai yra... '''2'''
Skaičius yra didesnis...
Ar tai yra... '''5'''
Skaičius yra didesnis...
Ar tai yra... '''10'''
Skaičius yra ne toks didelis.
Ar tai yra... '''7'''
Valio! Atspėjai teisingai!

'''lyginis.py'''

<syntaxhighlight lang="python">
# Prašo įvesti skaičių.
# Išveda, ar skaičius yra lyginis, ar ne

skaicius = float(input("Pasakyk man skaičių: "))
if skaicius % 2 == 0:
print(int(skaicius), "yra lyginis.")
elif skaicius % 2 == 1:
print(int(skaicius), "yra nelyginis.")
else:
print(skaicius, "yra labai keistas.")
</syntaxhighlight>

Pavyzdiniai vykdymai:

Pasakyk man skaičių: '''3'''
3 yra nelyginis.

Pasakyk man skaičių: '''2'''
2 yra lyginis.

Pasakyk man skaičių: '''3.4895'''
3.4895 yra labai keistas.

'''vidurkis1.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol įvedamas 0
# Išveda skaičių vidurkį

kiekis = 0
suma = 0.0
skaicius = 1 # nurodomas tam, kad nebūtų iškart išeinama iš ciklo.

print("Įvesk 0, kad sustabdytum ciklą")

while skaicius != 0:
skaicius = float(input("Įvesk skaičių: "))
if skaicius != 0:
kiekis = kiekis + 1
suma = suma + skaicius
if skaicius == 0:
print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''3'''
Įvesk skaičių: '''5'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 4.0

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''1'''
Įvesk skaičių: '''4'''
Įvesk skaičių: '''3'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 2.66666666667

'''vidurkis2.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol bus įvestas tam tikras kiekis skaičių
# Išveda skaičių vidurkį.

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek numerių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui sekti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Pratimai ===
Parašyk programą, kuri prašo naudotojo įvesti savo vardą. Jei jis įveda tavo vardą, išvesk „Tai puikus vardas“. Jei jie įveda "Jonas Jonaitis“ arba „Petras Petraitis“, išvesk kokį nors juokingą tekstą. Kitu atveju, išvesk „Tavo vardas yra labai gražus“.

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
vardas = input("Tavo vardas: ")
if vardas == 'Lukas':
print("Tai puikus vardas.")
elif vardas == 'Jonas Jonaitis':
print("... juokingas tekstas apie Joną.")
elif vardas == 'Petras Petraitis':
print("... juokingas tekstas apie Petrą.")
else:
print("Tavo vardas yra labai gražus.")
</syntaxhighlight>
}}

Pakeisk aukščiau esančią „daugiau_maziau.py“ programą, kad ji papildomai skaičiuotų, kiek kartų naudotojas įvedė neteisingą skaičių. Jei taip nutiko daugiau, nei tris kartus, programos pabaigoje išvesk „Tai buvo sudėtinga.“, o kitu atveju - „Gerai padirbėjai!“

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius = 7
spejimas = -1
kiekis = 0

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))
kiekis = kiekis + 1
if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")

if kiekis > 3:
print("Tai buvo sudėtinga.")
else:
print("Gerai padirbėjai!")
</syntaxhighlight>
}}

Parašyk programą, kuri prašo įvesti du skaičius. Jei skaičių suma yra didesnė nei 100, išvesk „Tai yra didelis skaičius“.

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius1 = float(input("Pirmas skaičius: "))
skaicius2 = float(input("Antras skaičius: "))
if skaicius1 + skaicius2 > 100:
print("Skaičių suma yra didelis skaičius.")
</syntaxhighlight>
}}

{{navigation |previous=Count to 10 |next=Debugging}}

Python Vadovėlis/Žodynai

2021-11-16T13:56:37Z

Monika: Maži stiliaus pataisymai

Š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 į vardų sąrašą, pateiktą prieš tai buvusiame skyriuje apie sąrašus. Štai kaip veikia programa. Pirmiausia, funkcija <code>spausdink_meniu</code> yra apibrėžiama. <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ų. Eilutės
<syntaxhighlight lang="python">
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
</syntaxhighlight>
eina per žodyną ir spausdina visą informaciją. Funkcija <code> numeriai.keys()</code> grąžina 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. Panašiai kaip sąrašai, teiginys <code>numeriai[x]</code> naudojamas norint pasiekti konkretų žodyno narį. Žinoma, šiuo atveju <code>x</code> yra eilutė. Toliau, eilutė <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 eilutės
<syntaxhighlight lang="python">
if vardas in numeriai:
del numeriai[vardas]
</syntaxhighlight>
tikrina, ar vardas yra žodyne, ir jei yra, pašalina. Operatorius <code>vardas in numeriai</code> grąžina teisinga (angl. true), jei <code>vardas</code> yra <code>numeriai</code> žodyne, bet kitu atveju grąžina neteisinga (angl. false). Eilutė <code>del numeriai[vardas]</code> pašalina raktą <code>vardas</code> ir su tuo raktu susietą reikšmę. Eilutės
<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. Raktai gali būti eilutės arba
numeriai. 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:
name = 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ų vardas, 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> (nes <code>max_taškai</code> ir buvo tai, kai priskyrimas buvo padarytas) (aš naudoju raktą <code>#Max</code>, nes <code>#</code> yra surūšiuotas prieš bet kokias abėcėlės raides). Toliau, <code>spausdink_meniu</code> yra apibrėžtas. Po to, <code>spausdink_visus_pažymius</code> funkcija yra apibrėžta žemiau esančiose
eilutėse:
<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 pirmieji raktai yra išimami iš <code>mokiniai</code> žodyno su <code>raktai</code> funkcija eilutėje <code>raktai = list(mokiniai.keys())</code>. <code>raktai</code> yra iteruojamasis ir yra paverčiamas į sąrašą, tam kad būtų 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 <code>x</code> rakte. Funkcija <code>spausdink_pažymius</code> tiesiog spausdina sąrašą ir yra apibrėžtas 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į prie savo vardo rakto. Žymėjimas <code>[0] * len(max_taškai)</code> tiesiog sukuria sąrašą 0-ių, kuris yra tokio pat ilgio kaip ir <code>max_taškai</code> sąrašas.

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 eilutėje <code>pažymiai = mokiniai[vardas]</code>, ji gauna nuorodą į mokinio <code>vardas</code> pažymius. Tada pažymys yra įrašomas eilutėje <code>pažymiai[kuris] = pažymys</code>. Tu gali pastebėti, kad <code>pažymiai</code> niekada negrąžinami į mokinių žodyną (kaip ir ne <code>mokiniai[vardas] = pažymiai</code>). Trūkstamo teiginio priežastis yra ta, kad <code>pažymiai</code> iš tiesų yra kitas pavadinimas skirtas <code>mokiniai[vardas]</code> ir dėl to keičiant <code>pažymiai</code> keičiasi ir <code>mokiniai[vardas]</code>.

Žodynai suteikia lengvą metodą susieti raktus su reikšmėmis. Tai gali būti naudojama norint lengvai sekti duomenis, pridedamus prie įvairių raktų.

{{navigation |previous=Boolean Expressions |next=Using Modules}}
{{BookCat}}

Python Vadovėlis/Rekursija

2021-11-16T13:33:16Z

Monika: Maži stiliau pataisymai

== Rekursija ==

Python'o programoje rekursinė funkcija yra funkcija, kuri iškviečia pati save.

=== Įvadas į rekursiją ===

Iki šiol Python'o programoje matėme funkcijas, kurios iškviečia kitas funkcijas. Tačiau funkcija gali iškviesti ir pati save. Pažvelkime į paprastą pavyzdį.
<syntaxhighlight lang="python">
# Program by Mitchell Aikens
# No Copyright
# 2010

sk = 0

def main():
skaitliukas(sk)

def skaitliukas(sk):
print(sk)
sk+= 1
skaitliukas(sk)

main()
</syntaxhighlight>

Jei šią programą paleistum IDLE kodo redaktoriuje, ji veiktų amžinai. Vienintelis būdas sustabdyti ciklą būtų nutraukti vykdymą paspausdami Ctrl + C klaviatūroje. Tai yra begalinės rekursijos pavyzdys. (Kai kurie naudotojai pranešė apie esamos IDLE kodo redaktoriaus sistemos gedimą, dėl kurio Ctrl + C iškelta išimtis taip pat pradeda veikti. Jei taip nutinka, paspausk Ctrl + F6 ir IDLE kodo redaktoriaus terminalas turėtų pasileisti iš naujo.)

Galima ginčytis, kad rekursija yra tik dar vienas būdas atlikti tą patį dalyką kaip ir naudojant ciklą. Kai kuriais atvejais tai yra visiškai teisinga. Tačiau yra ir kitų rekursijos naudojimo būdų, kurie yra labai tinkami, o <code>while</code> arba <code>for</code> ciklai gali būti ne pats geriausias variantas.

Rekursiją gali būti valdoma, kaip ir ciklai. Pažvelk į valdomo ciklo pavyzdį.
<syntaxhighlight lang="python">
# Program by Mitchell Aikens
# No copyright
# 2012
def main():
ciklosk= int(input("Kiek kartų norėtum paleisti ciklą?\n"))
skaitliukas = 1
recurr(ciklosk,skaitliukas)

def recurr(ciklosk,skaitliukas):
if ciklosk> 0:
print("Tai yra ciklo iteracija",skaitliukas)
recurr(ciklosk- 1,skaitliukas + 1)
else:
print("Ciklas yra pabaigtas.")

main()
</syntaxhighlight>

Aukščiau naudojami argumentai/parametrai rekursijų skaičiui valdyti. Tiesiog naudok tai, ką jau žinai apie funkcijas, ir sek programos eigą. Tai paprasta išsiaiškinti. Jei kyla problemų, grįžk į [[Non-Programmer's Tutorial for Python 3/Advanced Functions Example]].

== Praktiniai rekursijos pritaikymai ==

Dažnai rekursija yra studijuojama pažengusiu informatikos lygiu. Rekursija dažniausiai naudojama sprendžiant sudėtingas problemas, kurias galima suskirstyti į mažesnes, identiškas problemas. Norint išspręsti problemą, rekursija nebūtina. Problemos, kurias galima išspręsti naudojant rekursiją, greičiausiai gali būti išspręstos ir su ciklais. Be to, ciklas gali būti efektyvesnis nei rekursinė funkcija. Rekursinėms funkcijoms reikia daugiau atminties ir išteklių nei ciklams, todėl daugeliu atvejų jos yra mažiau efektyvios. Šis naudojimo reikalavimas kartais vadinamas overhead.
Galbūt galvoji: „Na, kam nerimauti su rekursija. Aš tiesiog naudosiu ciklą. Aš jau žinau, kaip sudaryti ciklą, ir tai yra daug daugiau darbo.“ Ši mintis suprantama, bet ne visai ideali. Sprendžiant sudėtingas problemas, rekursinę funkciją kartais lengviau, greičiau ir paprasčiau sukurti bei programuoti.

Pagalvokite apie šias dvi „taisykles“:
* Jei galiu išspręsti problemą dabar, be rekursijos, funkcija tiesiog grąžina reikšmę.
* Jei negaliu išspręsti problemos dabar be rekursijos, funkcija sumažina problemą iki mažesnio ir panašaus ir pakviečia pati save, kad išspręstų problemą.

Taikyk tai naudojant bendrą matematinę sąvoką – faktorialus. Jei nesi susipažinęs su matematikos faktoriais, skaityk: [https://lt.wikipedia.org/wiki/Faktorialas Faktorialas]

Skaičiaus faktorialas n, yra žymimas kaip n!.

Štai keletas pagrindinių faktorialų taisyklių:

Jei n = 0 tai n! = 1

Jei n > 0 tai n! = 1 x 2 x 3 x ... x n

Pavyzdžiui, pažiūrėk į skaičiaus 9 faktorialą.

9! = 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8 x 9

Pažiūrėkime į programą, kuri rekursijos metodu apskaičiuoja bet kurio vartotojo įvesto skaičiaus faktorialą.

<syntaxhighlight lang="python3">
def main():
sk = int(input("Įvesk neneigiamą sveikąjį skaičių.\n"))
fact = factorialas(sk)
print("Skaičiaus ",sk," faktorialas yra ",fact)

def factorialas(sk):
if sk== 0:
return 1
else:
return sk* factorialas(sk- 1)

main()
</syntaxhighlight>

Rekursija taip pat naudinga išplėstinėje temoje, vadinamoje generatoriais. Norint sugeneruoti serijas 1,2,1,3,1,2,1,4,1,2... reikės šio kodo:
<syntaxhighlight lang="python">
def beprotiškas(min_):
yield min_
g=beprotiškas(min_+1)
while True:
yield next(g)
yield min_

i=beprotiškas(1)
</syntaxhighlight>
norint gauti kitą elementą, iškiviestum next(i)

{{navigation |previous=Dealing with the imperfect |next=Intro to Object Oriented Programming in Python 3}}
{{BookCat}}

Python Vadovėlis/Rekursija

2021-11-16T13:29:43Z

Monika: Maži stiliau pataisymai

== Rekursija ==

Python'o programoje rekursinė funkcija yra funkcija, kuri iškviečia pati save.

=== Įvadas į rekursiją ===

Iki šiol Python'o programoje matėme funkcijas, kurios iškviečia kitas funkcijas. Tačiau funkcija gali iškviesti ir pati save. Pažvelkime į paprastą pavyzdį.
<syntaxhighlight lang="python">
# Program by Mitchell Aikens
# No Copyright
# 2010

sk = 0

def main():
skaitliukas(sk)

def skaitliukas(sk):
print(sk)
sk+= 1
skaitliukas(sk)

main()
</syntaxhighlight>

Jei šią programą paleistum IDLE kodo redaktoriuje, ji veiktų amžinai. Vienintelis būdas sustabdyti ciklą būtų nutraukti vykdymą paspausdami Ctrl + C klaviatūroje. Tai yra begalinės rekursijos pavyzdys. (Kai kurie naudotojai pranešė apie esamos IDLE kodo redaktoriaus sistemos gedimą, dėl kurio Ctrl + C iškelta išimtis taip pat pradeda veikti. Jei taip nutinka, paspausk Ctrl + F6 ir IDLE kodo redaktoriaus terminalas turėtų pasileisti iš naujo.)

Galima ginčytis, kad rekursija yra tik dar vienas būdas atlikti tą patį dalyką kaip ir naudojant ciklą. Kai kuriais atvejais tai yra visiškai teisinga. Tačiau yra ir kitų rekursijos naudojimo būdų, kurie yra labai tinkami, o <code>while</code> arba <code>for</code> ciklai gali būti ne pats geriausias variantas.

Rekursiją gali būti valdoma, kaip ir ciklai. Pažvelk į valdomo ciklo pavyzdį.
<syntaxhighlight lang="python">
# Program by Mitchell Aikens
# No copyright
# 2012
def main():
ciklosk= int(input("Kiek kartų norėtum paleisti ciklą?\n"))
skaitliukas = 1
recurr(ciklosk,skaitliukas)

def recurr(ciklosk,skaitliukas):
if ciklosk> 0:
print("Tai yra ciklo iteracija",skaitliukas)
recurr(ciklosk- 1,skaitliukas + 1)
else:
print("Ciklas yra pabaigtas.")

main()
</syntaxhighlight>

Aukščiau naudojami argumentai/parametrai rekursijų skaičiui valdyti. Tiesiog naudok tai, ką jau žinai apie funkcijas, ir sek programos eigą. Tai paprasta išsiaiškinti. Jei kyla problemų, grįžk į [[Non-Programmer's Tutorial for Python 3/Advanced Functions Example]].

== Praktiniai rekursijos pritaikymai ==

Dažnai rekursija yra studijuojama pažengusiu informatikos lygiu. Rekursija dažniausiai naudojama sprendžiant sudėtingas problemas, kurias galima suskirstyti į mažesnes, identiškas problemas. Norint išspręsti problemą, rekursija nebūtina. Problemos, kurias galima išspręsti naudojant rekursiją, greičiausiai gali būti išspręstos ir su ciklais. Be to, ciklas gali būti efektyvesnis nei rekursinė funkcija. Rekursinėms funkcijoms reikia daugiau atminties ir išteklių nei ciklams, todėl daugeliu atvejų jos yra mažiau efektyvios. Šis naudojimo reikalavimas kartais vadinamas overhead.
Galbūt galvoji: „Na, kam nerimauti su rekursija. Aš tiesiog naudosiu ciklą. Aš jau žinau, kaip sudaryti ciklą, ir tai yra daug daugiau darbo.“ Ši mintis suprantama, bet ne visai ideali. Sprendžiant sudėtingas problemas, rekursinę funkciją kartais lengviau, greičiau ir paprasčiau sukurti bei programuoti.

Pagalvokite apie šias dvi „taisykles“:
* Jei galiu išspręsti problemą dabar, be rekursijos, funkcija tiesiog grąžina reikšmę.
* Jei negaliu išspręsti problemos dabar be rekursijos, funkcija sumažina problemą iki mažesnio ir panašaus ir pakviečia pati save, kad išspręstų problemą.

Taikyk tai naudojant bendrą matematinę sąvoką – faktorialus. Jei nesi susipažinęs su matematikos faktoriais, skaityk: [https://lt.wikipedia.org/wiki/Faktorialas Faktorialas]

Skaičiaus faktorialas n, yra žymimas kaip n!.

Štai keletas pagrindinių faktorialų taisyklių.

If n = 0 then n! = 1
If n > 0 then n! = 1 x 2 x 3 x ... x n

Pavyzdžiui, pažiūrėk į skaičiaus 9 faktorialą.

9! = 1 x 2 x 3 x 4 x 5 x 6 x 7 x 8 x 9

Pažiūrėk į programą, kuri rekursijos metodu apskaičiuoja bet kurio vartotojo įvesto skaičiaus faktorialą.

<syntaxhighlight lang="python3">
def main():
sk = int(input("Įvesk neneigiamą sveikąjį skaičių.\n"))
fact = factorialas(sk)
print("Skaičiaus ",sk," faktorialas yra ",fact)

def factorialas(sk):
if sk== 0:
return 1
else:
return sk* factorialas(sk- 1)

main()
</syntaxhighlight>

Rekursija taip pat naudinga išplėstinėje temoje, vadinamoje generatoriais. Norint sugeneruoti serijas 1,2,1,3,1,2,1,4,1,2... reikės šio kodo:
<syntaxhighlight lang="python">
def beprotiškas(min_):
yield min_
g=beprotiškas(min_+1)
while True:
yield next(g)
yield min_

i=beprotiškas(1)
</syntaxhighlight>
norint gauti kitą elementą, iškiviestum next(i)

{{navigation |previous=Dealing with the imperfect |next=Intro to Object Oriented Programming in Python 3}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2021-10-20T15:22:56Z

Monika: Pataisyta nuoroda į skyrių

=== ...arba, kaip kovoti su klaidomis ===
=== Klaidų "gaudymas" su <code>try</code> ===
Tarkime, kad jau turi tobulą programą, ji vykdoma nepriekaištingai. Tik viena maža detalė: programa užstringa naudotojui įvedus klaidingą įvestį. Nepergyvenk, Pithon'as turi specialią valdymo struktūrą, kuri tau padės. Ji vadinama <code>try</code> ir ji bando kažką padaryti. Pavyzdys programos su problema:
<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
</syntaxhighlight>

Jei įvesi <code>@#&</code>, programa išves kažką tokio:

Traceback (most recent call last):
File "bandyk.py", line 4, in <module>
skaicius = int(input("Įvesk skaičių: "))
ValueError: invalid literal for int() with base 10: '\\@#&'

Kaip gali pastebėti, <code>int()</code> funkcija yra nepatenkinta skaičiumi <code>@#&</code> (kaip ir turėtų būti). Paskutinė eilutė parodo, kokia yra problema: Python'as rado <code>ValueError</code> klaidą. Kaip mūsų programa gali su tuo susitvarkyti? Visų pirma, tą kodo vietą, kurioje gali būti klaidų, turime apsupti <code>try</code> bloku. Antra, turime pasakyti Python'ui, kaip tvarkytis su <code>ValueError</code> klaidomis. Tai daro žemiau esanti programa:

<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
try:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
except ValueError:
print("Tai buvo ne skaičius.")
</syntaxhighlight>

Dabar, kai vykdome programą ir įvedame <code>@#&</code>, programa mums pasako, kad "Tai buvo ne skaičius." ir toliau vykdo tai, ką turėtų.

Kai tavo programa vis susiduria su ta pačia klaida, kodą apsupk <code>try</code> bloku ir aprašyk būdą, kaip elgtis sutikus klaidą, <code>except</code> bloke.

=== Pratimai ===
Pataisyk telefono numerių programą ([[Vadovėlis/Dictionaries|Dictionaries]] skyriuje), kad ji neužstrigtų, jei naudotojas neįrašo jokios įvesties į meniu.

{{Solution|title=Sprendimas|text=
<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:
try:
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()
except ValueError:
print("Tai buvo ne skaičius.")</syntaxhighlight>

}}
{{navigation |previous=File IO |next=Recursion}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2021-10-20T15:21:03Z

Monika: Sutvarkytas šablonas

=== ...arba, kaip kovoti su klaidomis ===
=== Klaidų "gaudymas" su <code>try</code> ===
Tarkime, kad jau turi tobulą programą, ji vykdoma nepriekaištingai. Tik viena maža detalė: programa užstringa naudotojui įvedus klaidingą įvestį. Nepergyvenk, Pithon'as turi specialią valdymo struktūrą, kuri tau padės. Ji vadinama <code>try</code> ir ji bando kažką padaryti. Pavyzdys programos su problema:
<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
</syntaxhighlight>

Jei įvesi <code>@#&</code>, programa išves kažką tokio:

Traceback (most recent call last):
File "bandyk.py", line 4, in <module>
skaicius = int(input("Įvesk skaičių: "))
ValueError: invalid literal for int() with base 10: '\\@#&'

Kaip gali pastebėti, <code>int()</code> funkcija yra nepatenkinta skaičiumi <code>@#&</code> (kaip ir turėtų būti). Paskutinė eilutė parodo, kokia yra problema: Python'as rado <code>ValueError</code> klaidą. Kaip mūsų programa gali su tuo susitvarkyti? Visų pirma, tą kodo vietą, kurioje gali būti klaidų, turime apsupti <code>try</code> bloku. Antra, turime pasakyti Python'ui, kaip tvarkytis su <code>ValueError</code> klaidomis. Tai daro žemiau esanti programa:

<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
try:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
except ValueError:
print("Tai buvo ne skaičius.")
</syntaxhighlight>

Dabar, kai vykdome programą ir įvedame <code>@#&</code>, programa mums pasako, kad "Tai buvo ne skaičius." ir toliau vykdo tai, ką turėtų.

Kai tavo programa vis susiduria su ta pačia klaida, kodą apsupk <code>try</code> bloku ir aprašyk būdą, kaip elgtis sutikus klaidą, <code>except</code> bloke.

=== Pratimai ===
Pataisyk telefono numerių programą ([[../Dictionaries|Dictionaries]] skyriuje), kad ji neužstrigtų, jei naudotojas neįrašo jokios įvesties į meniu.

{{Solution|title=Sprendimas|text=
<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:
try:
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()
except ValueError:
print("Tai buvo ne skaičius.")</syntaxhighlight>

}}
{{navigation |previous=File IO |next=Recursion}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2021-10-20T15:20:16Z

Monika: Išversta dalis "Exercises"

=== ...arba, kaip kovoti su klaidomis ===
=== Klaidų "gaudymas" su <code>try</code> ===
Tarkime, kad jau turi tobulą programą, ji vykdoma nepriekaištingai. Tik viena maža detalė: programa užstringa naudotojui įvedus klaidingą įvestį. Nepergyvenk, Pithon'as turi specialią valdymo struktūrą, kuri tau padės. Ji vadinama <code>try</code> ir ji bando kažką padaryti. Pavyzdys programos su problema:
<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
</syntaxhighlight>

Jei įvesi <code>@#&</code>, programa išves kažką tokio:

Traceback (most recent call last):
File "bandyk.py", line 4, in <module>
skaicius = int(input("Įvesk skaičių: "))
ValueError: invalid literal for int() with base 10: '\\@#&'

Kaip gali pastebėti, <code>int()</code> funkcija yra nepatenkinta skaičiumi <code>@#&</code> (kaip ir turėtų būti). Paskutinė eilutė parodo, kokia yra problema: Python'as rado <code>ValueError</code> klaidą. Kaip mūsų programa gali su tuo susitvarkyti? Visų pirma, tą kodo vietą, kurioje gali būti klaidų, turime apsupti <code>try</code> bloku. Antra, turime pasakyti Python'ui, kaip tvarkytis su <code>ValueError</code> klaidomis. Tai daro žemiau esanti programa:

<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
try:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
except ValueError:
print("Tai buvo ne skaičius.")
</syntaxhighlight>

Dabar, kai vykdome programą ir įvedame <code>@#&</code>, programa mums pasako, kad "Tai buvo ne skaičius." ir toliau vykdo tai, ką turėtų.

Kai tavo programa vis susiduria su ta pačia klaida, kodą apsupk <code>try</code> bloku ir aprašyk būdą, kaip elgtis sutikus klaidą, <code>except</code> bloke.

=== Pratimai ===
Pataisyk telefono numerių programą ([[../Dictionaries|Dictionaries]] skyriuje), kad ji neužstrigtų, jei naudotojas neįrašo jokios įvesties į meniu.

{{Sprendimas|title=Sprendimas|text=
<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:
try:
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()
except ValueError:
print("Tai buvo ne skaičius.")</syntaxhighlight>

}}
{{navigation |previous=File IO |next=Recursion}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2021-10-20T15:12:30Z

Monika: Ištrinta "Failų uždarymas with sakiniu" dalis

=== ...arba, kaip kovoti su klaidomis ===
=== Klaidų "gaudymas" su <code>try</code> ===
Tarkime, kad jau turi tobulą programą, ji vykdoma nepriekaištingai. Tik viena maža detalė: programa užstringa naudotojui įvedus klaidingą įvestį. Nepergyvenk, Pithon'as turi specialią valdymo struktūrą, kuri tau padės. Ji vadinama <code>try</code> ir ji bando kažką padaryti. Pavyzdys programos su problema:
<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
</syntaxhighlight>

Jei įvesi <code>@#&</code>, programa išves kažką tokio:

Traceback (most recent call last):
File "bandyk.py", line 4, in <module>
skaicius = int(input("Įvesk skaičių: "))
ValueError: invalid literal for int() with base 10: '\\@#&'

Kaip gali pastebėti, <code>int()</code> funkcija yra nepatenkinta skaičiumi <code>@#&</code> (kaip ir turėtų būti). Paskutinė eilutė parodo, kokia yra problema: Python'as rado <code>ValueError</code> klaidą. Kaip mūsų programa gali su tuo susitvarkyti? Visų pirma, tą kodo vietą, kurioje gali būti klaidų, turime apsupti <code>try</code> bloku. Antra, turime pasakyti Python'ui, kaip tvarkytis su <code>ValueError</code> klaidomis. Tai daro žemiau esanti programa:

<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
try:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
except ValueError:
print("Tai buvo ne skaičius.")
</syntaxhighlight>

Dabar, kai vykdome programą ir įvedame <code>@#&</code>, programa mums pasako, kad "Tai buvo ne skaičius." ir toliau vykdo tai, ką turėtų.

Kai tavo programa vis susiduria su ta pačia klaida, kodą apsupk <code>try</code> bloku ir aprašyk būdą, kaip elgtis sutikus klaidą, <code>except</code> bloke.

=== Exercises ===
Update at least the phone numbers program (in section [[../Dictionaries|Dictionaries]]) so it doesn't crash if a user doesn't enter any data at the menu.
{{Solution|title=Solution|text=
<syntaxhighlight lang="python">
def print_menu():
print('1. Print Phone Numbers')
print('2. Add a Phone Number')
print('3. Remove a Phone Number')
print('4. Lookup a Phone Number')
print('5. Quit')
print()

numbers = {}
menu_choice = 0
print_menu()
while menu_choice != 5:
try:
menu_choice = int(input("Type in a number (1-5): "))
if menu_choice == 1:
print("Telephone Numbers:")
for x in numbers.keys():
print("Name: ", x, "\tNumber:", numbers[x])
print()
elif menu_choice == 2:
print("Add Name and Number")
name = input("Name: ")
phone = input("Number: ")
numbers[name] = phone
elif menu_choice == 3:
print("Remove Name and Number")
name = input("Name: ")
if name in numbers:
del numbers[name]
else:
print(name, "was not found")
elif menu_choice == 4:
print("Lookup Number")
name = input("Name: ")
if name in numbers:
print("The number is", numbers[name])
else:
print(name, "was not found")
elif menu_choice != 5:
print_menu()
except ValueError:
print("That was not a number.")</syntaxhighlight>

}}
{{navigation |previous=File IO |next=Recursion}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2021-10-19T15:33:35Z

Monika: Išversta "catching errors with try" dalis

=== ...arba, kaip kovoti su klaidomis ===

=== Failų uždarymas <code>with</code> sakiniu ===

Mes naudojame "with" sakinį atidaryti ir uždaryti failams. Papildomai apie tai paskaityti galima šiuose angliškuose puslapiuose:
[http://docs.python.org/3.4/reference/compound_stmts.html#the-with-statement "with" sakinys]
[http://preshing.com/20110920/the-python-with-statement-by-example/ "with" sakinys su pavyzdžiais]

<syntaxhighlight lang="python">
with open("ivesties_testas.txt", "rt") as ivesties_failas:
with open("isvesties_testas.txt", "wt") as isvesties_failas:
textas = ivesties_failas.read()
duomanys = parse(textas)
rezultatas = encode(duomanys)
isvesties_failas.write(rezultatas)
print( "Baigta." )
</syntaxhighlight>

Jei kokia nors klaida įvyksta šiame kode (vienas iš failų yra nepasiekiamas, parse() funkcija užsikerta dėl netinkamų duomenų ir panašiai), <code>with</code> sakinys garantuoja, kad visi failai bus tinkamai uždaryti. Failo uždarymas šiuo atveju reiškia, kad mūsų programa failą "išvalys" ir "paleis", kad jį galėtų naudoti kitos programos.

{{todo|
Is the "closing files with with" section too much detail for a non-programmers tutorial?
If so, move it to some other Python Wikibook ([[Subject:Python programming language]])
}}

=== Klaidų "gaudymas" su <code>try</code> ===
Tarkime, kad jau turi tobulą programą, ji vykdoma nepriekaištingai. Tik viena maža detalė: programa užstringa naudotojui įvedus klaidingą įvestį. Nepergyvenk, Pithon'as turi specialią valdymo struktūrą, kuri tau padės. Ji vadinama <code>try</code> ir ji bando kažką padaryti. Pavyzdys programos su problema:
<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
</syntaxhighlight>

Jei įvesi <code>@#&</code>, programa išves kažką tokio:

Traceback (most recent call last):
File "bandyk.py", line 4, in <module>
skaicius = int(input("Įvesk skaičių: "))
ValueError: invalid literal for int() with base 10: '\\@#&'

Kaip gali pastebėti, <code>int()</code> funkcija yra nepatenkinta skaičiumi <code>@#&</code> (kaip ir turėtų būti). Paskutinė eilutė parodo, kokia yra problema: Python'as rado <code>ValueError</code> klaidą. Kaip mūsų programa gali su tuo susitvarkyti? Visų pirma, tą kodo vietą, kurioje gali būti klaidų, turime apsupti <code>try</code> bloku. Antra, turime pasakyti Python'ui, kaip tvarkytis su <code>ValueError</code> klaidomis. Tai daro žemiau esanti programa:

<syntaxhighlight lang="python">
print("Norėdamas uždaryti programą, įvesk -1")
skaicius = 1
while skaicius != -1:
try:
skaicius = int(input("Įvesk skaičių: "))
print("Tu įvedei:", skaicius)
except ValueError:
print("Tai buvo ne skaičius.")
</syntaxhighlight>

Dabar, kai vykdome programą ir įvedame <code>@#&</code>, programa mums pasako, kad "Tai buvo ne skaičius." ir toliau vykdo tai, ką turėtų.

Kai tavo programa vis susiduria su ta pačia klaida, kodą apsupk <code>try</code> bloku ir aprašyk būdą, kaip elgtis sutikus klaidą, <code>except</code> bloke.

=== Exercises ===
Update at least the phone numbers program (in section [[../Dictionaries|Dictionaries]]) so it doesn't crash if a user doesn't enter any data at the menu.
{{Solution|title=Solution|text=
<syntaxhighlight lang="python">
def print_menu():
print('1. Print Phone Numbers')
print('2. Add a Phone Number')
print('3. Remove a Phone Number')
print('4. Lookup a Phone Number')
print('5. Quit')
print()

numbers = {}
menu_choice = 0
print_menu()
while menu_choice != 5:
try:
menu_choice = int(input("Type in a number (1-5): "))
if menu_choice == 1:
print("Telephone Numbers:")
for x in numbers.keys():
print("Name: ", x, "\tNumber:", numbers[x])
print()
elif menu_choice == 2:
print("Add Name and Number")
name = input("Name: ")
phone = input("Number: ")
numbers[name] = phone
elif menu_choice == 3:
print("Remove Name and Number")
name = input("Name: ")
if name in numbers:
del numbers[name]
else:
print(name, "was not found")
elif menu_choice == 4:
print("Lookup Number")
name = input("Name: ")
if name in numbers:
print("The number is", numbers[name])
else:
print(name, "was not found")
elif menu_choice != 5:
print_menu()
except ValueError:
print("That was not a number.")</syntaxhighlight>

}}
{{navigation |previous=File IO |next=Recursion}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2021-10-19T15:16:17Z

Monika: Išversta "closing files with with" sekcija

=== ...arba, kaip kovoti su klaidomis ===

=== Failų uždarymas <code>with</code> sakiniu ===

Mes naudojame "with" sakinį atidaryti ir uždaryti failams. Papildomai apie tai paskaityti galima šiuose angliškuose puslapiuose:
[http://docs.python.org/3.4/reference/compound_stmts.html#the-with-statement "with" sakinys]
[http://preshing.com/20110920/the-python-with-statement-by-example/ "with" sakinys su pavyzdžiais]

<syntaxhighlight lang="python">
with open("ivesties_testas.txt", "rt") as ivesties_failas:
with open("isvesties_testas.txt", "wt") as isvesties_failas:
textas = ivesties_failas.read()
duomanys = parse(textas)
rezultatas = encode(duomanys)
isvesties_failas.write(rezultatas)
print( "Baigta." )
</syntaxhighlight>

Jei kokia nors klaida įvyksta šiame kode (vienas iš failų yra nepasiekiamas, parse() funkcija užsikerta dėl netinkamų duomenų ir panašiai), <code>with</code> sakinys garantuoja, kad visi failai bus tinkamai uždaryti. Failo uždarymas šiuo atveju reiškia, kad mūsų programa failą "išvalys" ir "paleis", kad jį galėtų naudoti kitos programos.

{{todo|
Is the "closing files with with" section too much detail for a non-programmers tutorial?
If so, move it to some other Python Wikibook ([[Subject:Python programming language]])
}}

=== catching errors with try ===
So you now have the perfect program, it runs flawlessly, except for one detail, it will crash on invalid user input. Have no fear, for Python has a special control structure for you. It's called <code>try</code> and it tries to do something. Here is an example of a program with a problem:
<syntaxhighlight lang="python">
print("Type Control C or -1 to exit")
number = 1
while number != -1:
number = int(input("Enter a number: "))
print("You entered:", number)
</syntaxhighlight>

Notice how when you enter <code>@#&</code> it outputs something like:

Traceback (most recent call last):
File "try_less.py", line 4, in <module>
number = int(input("Enter a number: "))
ValueError: invalid literal for int() with base 10: '\\@#&'

As you can see the <code>int()</code> function is unhappy with the number <code>@#&</code> (as well it should be). The last line shows what the problem is; Python found a <code>ValueError</code>. How can our program deal with this? What we do is first: put the place where errors may occur in a <code>try</code> block, and second: tell Python how we want <code>ValueError</code>s handled. The following program does this:
<syntaxhighlight lang="python">
print("Type Control C or -1 to exit")
number = 1
while number != -1:
try:
number = int(input("Enter a number: "))
print("You entered:", number)
except ValueError:
print("That was not a number.")
</syntaxhighlight>

Now when we run the new program and give it <code>@#&</code> it tells us "That was not a number." and continues with what it was doing before.

When your program keeps having some error that you know how to handle, put code in a <code>try</code> block, and put the way to handle the error in the <code>except</code> block.

=== Exercises ===
Update at least the phone numbers program (in section [[../Dictionaries|Dictionaries]]) so it doesn't crash if a user doesn't enter any data at the menu.
{{Solution|title=Solution|text=
<syntaxhighlight lang="python">
def print_menu():
print('1. Print Phone Numbers')
print('2. Add a Phone Number')
print('3. Remove a Phone Number')
print('4. Lookup a Phone Number')
print('5. Quit')
print()

numbers = {}
menu_choice = 0
print_menu()
while menu_choice != 5:
try:
menu_choice = int(input("Type in a number (1-5): "))
if menu_choice == 1:
print("Telephone Numbers:")
for x in numbers.keys():
print("Name: ", x, "\tNumber:", numbers[x])
print()
elif menu_choice == 2:
print("Add Name and Number")
name = input("Name: ")
phone = input("Number: ")
numbers[name] = phone
elif menu_choice == 3:
print("Remove Name and Number")
name = input("Name: ")
if name in numbers:
del numbers[name]
else:
print(name, "was not found")
elif menu_choice == 4:
print("Lookup Number")
name = input("Name: ")
if name in numbers:
print("The number is", numbers[name])
else:
print(name, "was not found")
elif menu_choice != 5:
print_menu()
except ValueError:
print("That was not a number.")</syntaxhighlight>

}}
{{navigation |previous=File IO |next=Recursion}}
{{BookCat}}

Python Vadovėlis

2021-10-19T15:04:16Z

Monika:

Tai - standartinės Python programavimo kalbos vadovėlis, 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.

==Contents==
{{print version}}
{{PDF version}}
;[[Vadovėlis/Authors]]
: Contributors to this book
;[[Vadovėlis/Front matter]]
: Initial remarks
;[[Vadovėlis/Intro]]
: Installing and using Python – where to get help
;[[Vadovėlis/Hello, World]] [Rokas]
: The famous first program – screen output – variables – numbers and calculations
;[[Vadovėlis/Who Goes There?|Vadovėlis/Who Goes There? [Modesta]]]
: Interactive input – strings
;[[Vadovėlis/Count to 10]] [Rokas]
: <tt>while</tt> loops
;[[Vadovėlis/Decisions|Vadovėlis/Decisions [Monika]]]
:<tt>if</tt> statements
;[[Vadovėlis/Debugging|Vadovėlis/Debugging [Monika]]]
:Finding out what goes wrong
;[[Vadovėlis/Defining Functions]] [Rokas]
: Structuring programs with the use of functions
;[[Vadovėlis/Advanced Functions Example]] [Rokas]
: (Almost) mind-blowing example of how programmers can think
;[[Vadovėlis/Lists|Vadovėlis/Lists [Artūras]]]
:Variables containing more than one value
;[[Vadovėlis/For Loops|Vadovėlis/For Loops [Artūras]]]
:A second kind of loop
;[[Vadovėlis/Boolean Expressions|Vadovėlis/Boolean Expressions [Laura]]]
:Computer logic – <tt>True</tt> and <tt>False</tt> – <tt>and</tt> and <tt>or</tt> – <tt>not</tt>
;[[Vadovėlis/Dictionaries|Vadovėlis/Dictionaries [zivile]]]
:Variables containing key/value pairs
;[[Vadovėlis/Using Modules |Vadovėlis/Using Modules [zivile]]]
:Extensions to the standard set of functionality
;[[Vadovėlis/More on Lists|Vadovėlis/More on Lists [Laura]]]
:Using elements or parts of lists
;[[Vadovėlis/Revenge of the Strings]] [Rokas]
:More advanced text manipulations
;[[Vadovėlis/File IO|Vadovėlis/File IO [Artūras]]]
:Reading from files and writing to files
;[[Vadovėlis/Dealing with the imperfect|Vadovėlis/Dealing with the imperfect [Monika]]]
:How to handle errors
;[[Vadovėlis/Recursion]]
:Recursive Functions
;[[Vadovėlis/Intro to Object Oriented Programming in Python 3]]
:Basics of OOP (Object Oriented Programming)
;[[Vadovėlis/Intro to Imported Libraries and other Functions|Vadovėlis/Intro to Imported Libraries and other Functions [Laura]]]
:Basic functions from various libraries.
;[[Vadovėlis/The End]]
:How to go further
;[[Vadovėlis/FAQ]]
:Some frequently asked questions
;[[Vadovėlis/Terminai]]
:Terminų žodynas

{{Alphabetical|N}}
{{status|100%}}
__NOTOC__ __NOEDITSECTION__

Python Vadovėlis/Derinimas

2021-10-11T17:12:41Z

Monika: Rašybos klaidų ištaisymas

=== Kas yra derinimas? ===
:"Kai tik pradėjome programuoti, mūsų nuostabai, supratome, kad nėra taip lengva kurti teisingai veikiančias programas, kaip manėme iš pradžių. Derinimas turėjo būti atrastas. Atsimenu tą akimirką, kai supratau, kad didelė mano gyvenimo dalis bus skirta klaidų ieškojimui savo sukurtose programose." — ''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? ===

Sekantis 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į "aukstis".
; Kuri eilutė vykdoma po to?
: Bendrai, tai yra sekanti eilutė, kuri yra <code>plotis= int(input("Plotis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Width: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį "plotis".
; Kuri eilutė vykdoma po to?
: Kai sekanti 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ėkime: 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.

Sekanti 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ėkime.
; Kuri eilutė vykdoma pirma?
: Pirmoji kodo eilutė: <code>skaicius = 5</code>
; Ką ji daro?
: Priskiria skaičių 5 kintamajam "skaicius".
; Kuri eilutė vykdoma po to?
: Sekanti 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 tiesa, vykdomas sekantis įtrauktas blokas. Jei melas - įtrauktas blokas yra praleidžiamas.
; Tai ką ji daro šiuo atveju?
: Jei <code>skaicius > 1</code> yra tiesa, bus vykdomos sekančios 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 tiesa, tai sekanti eilutė yra: <code>print(".",end=" ")</code>
; Ką daro ši eilutė?
: Spausdina vieną tašką. Kadangi funkcija turi papildomą argumentą <code>end=" "</code>, sekantis spausdinamas tekstas nebus pradedamas naujoje eilutėje.
; Kuri eilutė vykdoma po to?
: <code>skaicius = skaicius - 1</code>, nes tai yra sekanti 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 "skaicius" reikšmė. Sutrumpintai, <code>skaicius</code> vertė yra pakeičiama iš 5 į 4.
; Kuri eilutė vykdoma po to?
: Įtraukos lygis keičiasi, todėl turime žiūrėti į tai, kokią valdymo struktūrą turime. Peržiūrime <code>while</code> ciklą, taigi turime grįžti į <code>while</code> sąlygą, kuri yra <code>while skaicius > 1:</code>
; Ką ji daro?
: Eilutė žiūri į "skaicius" 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 tiesa, sekanti 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ę "skaicius" reikšmę (4), atima 1, kas yra lygu 3 ir priskiria 3 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Kadangi turime įtraukos pokytį dėl ciklo, sekanti eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę "skaicius" reikšmę (3) su 1. <code>3 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga yra tiesa, sekanti 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ę "skaicius" reikšmę (3), atima 1, kas yra lygu 2 ir priskiria 2 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Vėl grįžtame į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę "skaicius" 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ę "skaicius" reikšmę (2), atima 1, kas yra lygu 1 ir priskiria 1 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Atgal į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką daro ši eilutė?
: Ji palygina "skaicius" reikšmę (1) to 1. Kadangi <code>1 > 1</code> yra melas (vienas nėra daugiau nei vienas), ciklas baigiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo melas, vykdoma sekanti eilutė esanti už ciklo. Tai yra: <code>print()</code>
; Ką daro ši eilutė?
: Priverčia ekraną eiti į sekančią 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.

{{navigation |previous=Decisions |next=Defining Functions}}

Python Vadovėlis/Derinimas

2021-10-11T17:06:24Z

Monika: Rašybos klaidų ištaisymas

=== Kas yra derinimas? ===
:"Kai tik pradėjome programuoti, mūsų nuostabai, supratome, kad nėra taip lengva kurti teisingai veikiančias programas, kaip manėme iš pradžių. Derinimas turėjo būti atrastas. Atsimenu tą akimirką, kai supratau, kad didelė mano gyvenimo dalis bus skirta klaidų ieškojimui savo sukurtose programose." — ''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? ===

Sekantis 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į "aukstis".
; Kuri eilutė vykdoma po to?
: Bendrai, tai yra sekanti eilutė, kuri yra <code>plotis= int(input("Plotis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Width: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį "plotis".
; Kuri eilutė vykdoma po to?
: Kai sekanti eilutė nėra įtraukta daugiau ar mažiau, 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ėkime, 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.

Sekanti 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ėkime.
; Kuri eilutė vykdoma pirma?
: Pirmoji kodo eilutė: <code>skaicius = 5</code>
; Ką ji daro?
: Priskiria skaičių 5 kintamajam "skaicius".
; Kuri eilutė vykdoma po to?
: Sekanti 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 tiesa, vykdomas sekantis įtrauktas blokas. Jei melas - įtrauktas blokas yra praleidžiamas.
; Tai ką ji daro šiuo atveju?
: Jei <code>skaicius > 1</code> yra tiesa, bus vykdomos sekančios 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 tiesa, tai sekanti eilutė yra: <code>print(".",end=" ")</code>
; Ką daro ši eilutė?
: Spausdina vieną tašką. Kadangi funkcija turi papildomą argumentą <code>end=" "</code>, sekantis spausdinamas tekstas nebus pradedamas naujoje eilutėje.
; Kuri eilutė vykdoma po to?
: <code>skaicius = skaicius - 1</code>, nes tai yra sekanti 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 "skaicius" reikšmė. Sutrumpintai, <code>skaicius</code> vertė yra pakeičiama iš 5 į 4.
; Kuri eilutė vykdoma po to?
: Įtraukos lygis keičiasi, todėl turime žiūrėti į tai, kokią valdymo struktūrą turime. Peržiūrime <code>while</code> ciklą, taigi turime grįžti į <code>while</code> sąlygą, kuri yra <code>while skaicius > 1:</code>
; Ką ji daro?
: Eilutė žiūri į "skaicius" 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 tiesa, sekanti 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ę "skaicius" reikšmę (4), atima 1, kas yra lygu 3 ir priskiria 3 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Kadangi turime įtraukos pokytį dėl ciklo, sekanti eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę "skaicius" reikšmę (3) su 1. <code>3 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga yra tiesa, sekanti 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ę "skaicius" reikšmę (3), atima 1, kas yra lygu 2 ir priskiria 2 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Vėl grįžtame į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę "skaicius" 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ę "skaicius" reikšmę (2), atima 1, kas yra lygu 1 ir priskiria 1 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Atgal į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką daro ši eilutė?
: Ji palygina "skaicius" reikšmę (1) to 1. Kadangi <code>1 > 1</code> yra melas (vienas nėra daugiau nei vienas), ciklas baigiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo melas, vykdoma sekanti eilutė esanti už ciklo. Tai yra: <code>print()</code>
; Ką daro ši eilutė?
: Priverčia ekraną eiti į sekančią 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.

{{navigation |previous=Decisions |next=Defining Functions}}

Python Vadovėlis/Derinimas

2021-10-11T17:01:11Z

Monika: Išversta dalis "How do I fix my program?"

=== Kas yra derinimas? ===
:"Kai tik pradėjome programuoti, mūsų nuostabai, supratome, kad nėra taip lengva kurti teisingai veikiančias programas, kaip manėme iš pradžių. Derinimas turėjo būti atrastas. Atsimenu tą akimirką, kai supratau, kad didelė mano gyvenimo dalis bus skirta klaidų ieškojimui savo sukurtose programose." — ''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škodemas 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? ===

Sekantis 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. Progamos 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į "aukstis".
; Kuri eilutė vykdoma po to?
: Bendrai, tai yra sekanti eilutė, kuri yra <code>plotis= int(input("Plotis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Width: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį "plotis".
; Kuri eilutė vykdoma po to?
: Kai sekanti eilutė nėra įtraukta daugiau ar mažiau, 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ėkime, 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.

Sekanti programa, kurios kodo peržū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ėkime.
; Kuri eilutė vykdoma pirma?
: Pirmoji kodo eilutė: <code>skaicius = 5</code>
; Ką ji daro?
: Priskiria skaičių 5 kintamajam "skaicius".
; Kuri eilutė vykdoma po to?
: Sekanti 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 tiesa, vykdomas sekantis įtrauktas blokas. Jei melas - įtrauktas blokas yra praleidžiamas.
; Tai ką ji daro šiuo atveju?
: Jei <code>skaicius > 1</code> yra tiesa, bus vykdomos sekančios 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 tiesa, tai sekanti eilutė yra: <code>print(".",end=" ")</code>
; Ką daro ši eilutė?
: Spausdina vieną tašką. Kadangi funkcija turi papildomą argumentą <code>end=" "</code>, sekantis spausdinamas tekstas nebus pradedamas naujoje eilutėje.
; Kuri eilutė vykdoma po to?
: <code>skaicius = skaicius - 1</code>, nes tai yra sekanti 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 "skaicius" reikšmė. Sutrumpintai,<code>skaicius</code> vertė yra pakeičiama iš 5 į 4.
; Kuri eilutė vykdoma po to?
: Įtraukos lygis keičiasi, todėl turime žiūrėti į tai, kokią valdymo struktūrą turime. Peržiūrime <code>while</code> ciklą, taigi turime grįžti į <code>while</code> sąlygą, kuri yra <code>while skaicius > 1:</code>
; Ką ji daro?
: Eilutė žiūri į "skaicius" 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 tiesa, sekanti 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ę "skaicius" reikšmę (4), atima 1, kas yra lygu 3 ir priskiria 3 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Kadangi turime įtraukos pokytį dėl ciklo, sekanti eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę "skaicius" reikšmę (3) su 1. <code>3 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga yra tiesa, sekanti 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ę "skaicius" reikšmę (3), atima 1, kas yra lygu 2 ir priskiria 2 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Vėl grįžtame į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę "skaicius" 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ę "skaicius" reikšmę (2), atima 1, kas yra lygu 1 ir priskiria 1 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Atgal į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką daro ši eilutė?
: Ji palygina "skaicius" reikšmę (1) to 1. Kadangi <code>1 > 1</code> yra melas (vienas nėra daugiau nei vienas), ciklas baigiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo melas, vykdoma sekanti eilutė esanti už ciklo. Tai yra: <code>print()</code>
; Ką daro ši eilutė?
: Priverčia ekraną eiti į sekančią 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.

{{navigation |previous=Decisions |next=Defining Functions}}

Python Vadovėlis/Terminai

2021-10-06T17:38:43Z

Monika: Pridėti nauji terminai

Computer - kompiuteris

Control strukture - valdymo struktūra

Debugging - derinimas

Exercise - pratimas

Expression - reiškinys

Feature - ypatybė

Floating point - slankusis kablelis

Indent - įtrauka

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvestis/rezultatas

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Solution - sprendimas

Source code - pirminis programos tekstas

Statement - sakinys

String - eilutė

User - naudotojas

{{navigation |previous=FAQ |next=END}}

Python Vadovėlis/Derinimas

2021-10-06T17:35:54Z

Monika: Išversta dalis "What does the program do?"

=== Kas yra derinimas? ===
:"Kai tik pradėjome programuoti, mūsų nuostabai, supratome, kad nėra taip lengva kurti teisingai veikiančias programas, kaip manėme iš pradžių. Derinimas turėjo būti atrastas. Atsimenu tą akimirką, kai supratau, kad didelė mano gyvenimo dalis bus skirta klaidų ieškojimui savo sukurtose programose." — ''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škodemas 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? ===

Sekantis 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. Progamos 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į "aukstis".
; Kuri eilutė vykdoma po to?
: Bendrai, tai yra sekanti eilutė, kuri yra <code>plotis= int(input("Plotis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Width: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį "plotis".
; Kuri eilutė vykdoma po to?
: Kai sekanti eilutė nėra įtraukta daugiau ar mažiau, 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ėkime, 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.

Sekanti programa, kurios kodo peržū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ėkime.
; Kuri eilutė vykdoma pirma?
: Pirmoji kodo eilutė: <code>skaicius = 5</code>
; Ką ji daro?
: Priskiria skaičių 5 kintamajam "skaicius".
; Kuri eilutė vykdoma po to?
: Sekanti 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 tiesa, vykdomas sekantis įtrauktas blokas. Jei melas - įtrauktas blokas yra praleidžiamas.
; Tai ką ji daro šiuo atveju?
: Jei <code>skaicius > 1</code> yra tiesa, bus vykdomos sekančios 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 tiesa, tai sekanti eilutė yra: <code>print(".",end=" ")</code>
; Ką daro ši eilutė?
: Spausdina vieną tašką. Kadangi funkcija turi papildomą argumentą <code>end=" "</code>, sekantis spausdinamas tekstas nebus pradedamas naujoje eilutėje.
; Kuri eilutė vykdoma po to?
: <code>skaicius = skaicius - 1</code>, nes tai yra sekanti 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 "skaicius" reikšmė. Sutrumpintai,<code>skaicius</code> vertė yra pakeičiama iš 5 į 4.
; Kuri eilutė vykdoma po to?
: Įtraukos lygis keičiasi, todėl turime žiūrėti į tai, kokią valdymo struktūrą turime. Peržiūrime <code>while</code> ciklą, taigi turime grįžti į <code>while</code> sąlygą, kuri yra <code>while skaicius > 1:</code>
; Ką ji daro?
: Eilutė žiūri į "skaicius" 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 tiesa, sekanti 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ę "skaicius" reikšmę (4), atima 1, kas yra lygu 3 ir priskiria 3 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Kadangi turime įtraukos pokytį dėl ciklo, sekanti eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę "skaicius" reikšmę (3) su 1. <code>3 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga yra tiesa, sekanti 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ę "skaicius" reikšmę (3), atima 1, kas yra lygu 2 ir priskiria 2 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Vėl grįžtame į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę "skaicius" 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ę "skaicius" reikšmę (2), atima 1, kas yra lygu 1 ir priskiria 1 kaip naują "skaicius" reikšmę.
; Kuri eilutė vykdoma po to?
: Atgal į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką daro ši eilutė?
: Ji palygina "skaicius" reikšmę (1) to 1. Kadangi <code>1 > 1</code> yra melas (vienas nėra daugiau nei vienas), ciklas baigiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo melas, vykdoma sekanti eilutė esanti už ciklo. Tai yra: <code>print()</code>
; Ką daro ši eilutė?
: Priverčia ekraną eiti į sekančią 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ų.

=== How do I fix my program? ===

You need to figure out what the program is doing. You need to figure out what the program should do. Figure out what the difference between the two is. Debugging is a skill that has to be practiced to be learned. If you can't figure it out after an hour, take a break, talk to someone about the problem or contemplate the lint in your navel. Come back in a while and you will probably have new ideas about the problem. Good luck.

{{navigation |previous=Decisions |next=Defining Functions}}

Python Vadovėlis/Pasirinkimai

2021-10-06T16:44:50Z

Monika:

=== <code>If</code> sakinys ===
Kaip visada, aš tikiu, kad turėčiau pradėti kiekvieną skyrių su apšilimo pratimu. Taigi, žemiau turime trumpą programą, kuri apskaičiuoja absoliučią sveikojo skaičiaus reikšmę:
<syntaxhighlight lang="python">
n = int(input("Skaičius? "))
if n < 0:
print("Absoliuti", n, "reikšmė yra", -n)
else:
print("Absoliuti", n, "reikšmė yra", n)
</syntaxhighlight>

Štai rezultatas po dviejų programos vykdymų:

Skaičius? '''-34'''
Absoliuti -34 reikšmė yra 34

Skaičius? '''1'''
Absoliuti 1 reikšmė yra 1

Taigi, ką kompiuteris daro, kai pamato šį kodą? Visų pirma, jis kviečia įvesti skaičių su šiuo sakiniu "<code>n = int(input("Skaičius? "))</code>". Tada jis skaito eilutę "<code>if n < 0:</code>". Jei <code>n</code> yra mažiau už nulį, Python'as vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", -n)</code>". Kitu atveju, jis vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", n)</code>".

Kalbant formaliau, Python'as tikrina, ar ''reiškinys'' <code>n < 0</code> yra tiesa ar melas. Sakinys <code>if</code> yra lydimas įtraukto sakinių ''bloko'', kuris vykdomas tik jei reiškinys yra tiesa. Pasirinktinai, po <code>if</code> sakinio gali būti <code>else</code> sakinys ir dar vienas įtrauktas sakinių ''blokas''. Antrasis sakinių blokas yra vykdomas tik jei reiškinys yra melas.

Reiškinys gali turėti įvairių testų. Žemiau yra visų jų lentelė:

{| class="wikitable"
!operatorius
!funkcija
|-
|<code><</code>
|mažiau nei
|-
|<code><=</code>
|mažiau nei arba lygu
|-
|<code>></code>
|daugiau nei
|-
|<code>>=</code>
|daugiau nei arba lygu
|-
|<code>==</code>
|lygu
|-
|<code>!=</code>
|nelygu
|}

Dar viena sakinio <code>if</code> ypatybė yra <code>elif</code> sakinys. Tai ''else if'' sutrumpinimas ir reiškia, kad jei originalus <code>if</code> sakinys yra melas, bet <code>elif</code> dalis yra tiesa, yra vykdoma <code>elif</code> kodo dalis. Ir jei nei <code>if</code>, nei <code>elif</code> reiškiniai nėra tiesa, tada vykdomas <code>else</code> blokas. Pavyzdžiui:
<syntaxhighlight lang="python">
a = 0
while a < 10:
a = a + 1
if a > 5:
print(a, ">", 5)
elif a <= 3:
print(a, "<=", 3)
else:
print("Nei vienas iš testų nėra teisingas")
</syntaxhighlight>

ir išvestis:

1 <= 3
2 <= 3
3 <= 3
Nei vienas iš testų nėra teisingas
Nei vienas iš testų nėra teisingas
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

Gali pastebėti, kad <code>elif a <= 3</code> dalis yra tikrinama tik tada, jei <code>if</code> sakinys nėra tiesa. Galima rašyti daugiau nei vieną <code>elif</code> reiškinį, tokiu būdu leidžiant vykdyti kelis testus viename <code>if</code> sakinyje.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa parodo, kaip galima naudoti == operatorių
# naudojant numerius
print(5 == 6)
# naudojant kintamuosius
x = 5
y = 8
print(x == y)
</syntaxhighlight>

Ir išvestis

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Žaidžia spėlionių žaidimą daugiau mažiau

# Iš tiesų, čia turėtų būti naudojami pusiau atsitiktiniai skaičiai,
# pavyzdžiui paskutinis laiko skaitmuo, ar kažkas panašaus. Bet tai
# palauks iki vėlesnės dalies. (Papildoma užduotis: po Modulių dalies, pakeisk šį kodą,
# kad būtų naudojami atsitiktiniai skaičiai)
skaicius = 7
spejimas = -1

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))

if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")
</syntaxhighlight>

Pavyzdinis vykdymas:

Atspėk skaičių!
Ar tai yra... '''2'''
Skaičius yra didesnis...
Ar tai yra... '''5'''
Skaičius yra didesnis...
Ar tai yra... '''10'''
Skaičius yra ne toks didelis.
Ar tai yra... '''7'''
Valio! Atspėjai teisingai!

'''lyginis.py'''

<syntaxhighlight lang="python">
# Prašo įvesti skaičių.
# Išveda, ar skaičius yra lyginis, ar ne

skaicius = float(input("Pasakyk man skaičių: "))
if skaicius % 2 == 0:
print(int(skaicius), "yra lyginis.")
elif skaicius % 2 == 1:
print(int(skaicius), "yra nelyginis.")
else:
print(skaicius, "yra labai keistas.")
</syntaxhighlight>

Pavyzdiniai vykdymai:

Pasakyk man skaičių: '''3'''
3 yra nelyginis.

Pasakyk man skaičių: '''2'''
2 yra lyginis.

Pasakyk man skaičių: '''3.4895'''
3.4895 yra labai keistas.

'''vidurkis1.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol įvedamas 0
# Išveda skaičių vidurkį

kiekis = 0
suma = 0.0
skaicius = 1 # nurodomas tam, kad nebūtų iškart išeinama iš ciklo.

print("Įvesk 0, kad sustabdytum ciklą")

while skaicius != 0:
skaicius = float(input("Įvesk skaičių: "))
if skaicius != 0:
kiekis = kiekis + 1
suma = suma + skaicius
if skaicius == 0:
print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''3'''
Įvesk skaičių: '''5'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 4.0

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''1'''
Įvesk skaičių: '''4'''
Įvesk skaičių: '''3'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 2.66666666667

'''vidurkis2.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol bus įvestas tam tikras kiekis skaičių
# Išveda skaičių vidurkį.

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek numerių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui sekti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Pratimai ===
Parašyk programą, kuri prašo naudotojo įvesti savo vardą. Jei jis įveda tavo vardą, išvesk "Tai puikus vardas". Jei jie įveda "Jonas Jonaitis" arba "Petras Petraitis", išvesk kokį nors juokingą tekstą. Kitu atveju, išvesk "Tavo vardas yra labai gražus".

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
vardas = input('Tavo vardas: ')
if vardas == 'Lukas':
print('Tai puikus vardas.')
elif vardas == 'Jonas Jonaitis':
print('... juokingas tekstas apie Joną.')
elif vardas == 'Petras Petraitis':
print('... juokingas tekstas apie Petrą.')
else:
print('Tavo vardas yra labai gražus.')
</syntaxhighlight>
}}

Pakeisk aukščiau esančią "daugiau_maziau.py" programą, kad ji papildomai skaičiuotų, kiek kartų naudotojas įvedė neteisingą skaičių. Jei taip nutiko daugiau, nei tris kartus, programos pabaigoje išvesk "Tai buvo sudėtinga.", o kitu atveju - "Gerai padirbėjai!"

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius = 7
spejimas = -1
kiekis = 0

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))
kiekis = kiekis + 1
if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")

if kiekis > 3:
print("Tai buvo sudėtinga.")
else:
print("Gerai padirbėjai!")
</syntaxhighlight>
}}

Parašyk programą, kuri prašo įvesti du skaičius. Jei skaičių suma yra didesnė nei 100, išvesk "Tai yra didelis skaičius".

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius1 = float(input('Pirmas skaičius: '))
skaicius2 = float(input('Antras skaičius: '))
if skaicius1 + skaicius2 > 100:
print('Skaičių suma yra didelis skaičius.')
</syntaxhighlight>
}}

{{navigation |previous=Count to 10 |next=Debugging}}

Python Vadovėlis/Derinimas

2021-10-06T16:44:26Z

Monika:

=== Kas yra derinimas? ===
:"Kai tik pradėjome programuoti, mūsų nuostabai, supratome, kad nėra taip lengva kurti teisingai veikiančias programas, kaip manėme iš pradžių. Derinimas turėjo būti atrastas. Atsimenu tą akimirką, kai supratau, kad didelė mano gyvenimo dalis bus skirta klaidų ieškojimui savo sukurtose programose." — ''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škodemas 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ų.

=== What does the program do? ===

The next thing to do is to look at the source code. One of the most important things to do while programming is reading source code. The primary way to do this is code walkthroughs.

A code walkthrough starts at the first line, and works its way down until the program is done. <code>while</code> loops and <code>if</code> statements mean that some lines may never be run and some lines are run many times. At each line you figure out what Python has done.

Lets start with the simple perimeter program. Don't type it in, you are going to read it, not run it. The source code is:

<syntaxhighlight lang="python">
height = int(input("Height: "))
width = int(input("Width: "))
print("perimeter =", width + height + width + width)
</syntaxhighlight>

; ''Question:'' What is the first line Python runs?
: ''Answer:'' The first line is always run first. In this case it is: <code>height = int(input("Height: "))</code>
; What does that line do?
: Prints <code> Height: </code>, waits for the user to type a string in, and then converts the string to an integer variable height.
; What is the next line that runs?
: In general, it is the next line down which is: <code>width = int(input("Width: "))</code>
; What does that line do?
: Prints <code>Width: </code>, waits for the user to type a number in, and puts what the user types in the variable width.
; What is the next line that runs?
: When the next line is not indented more or less than the current line, it is the line right afterwards, so it is: <code>print("perimeter = ", width + height + width + width)</code> (It may also run a function in the current line, but that's a future chapter.)
; What does that line do?
: First it prints <code>perimeter = </code>, then it prints the sum of the values contained within the variables, <code>width</code> and <code>height</code>, from <code>width + height + width + width</code>.
; Does <code>width + height + width + width</code> calculate the perimeter properly?
: Let's see, perimeter of a rectangle is the bottom (width) plus the left side (height) plus the top (width) plus the right side (huh?). The last item should be the right side's length, or the height.
; Do you understand why some of the times the perimeter was calculated "correctly"?
: It was calculated correctly when the width and the height were equal.

The next program we will do a code walkthrough for is a program that is supposed to print out 5 dots on the screen. However, this is what the program is outputting:

. . . .

And here is the program:
<syntaxhighlight lang="python">
number = 5
while number > 1:
print(".",end=" ")
number = number - 1
print()
</syntaxhighlight>

This program will be more complex to walkthrough since it now has indented portions (or control structures). Let us begin.
; What is the first line to be run?
: The first line of the file: <code>number = 5</code>
; What does it do?
: Puts the number 5 in the variable number.
; What is the next line?
: The next line is: <code>while number > 1:</code>
; What does it do?
: Well, <code>while</code> statements in general look at their expression, and if it is true they do the next indented block of code, otherwise they skip the next indented block of code.
; So what does it do right now?
: If <code>number > 1</code> is true then the next two lines will be run.
; So is <code>number > 1</code>?
: The last value put into <code>number</code> was <code>5</code> and <code>5 > 1</code> so yes.
; So what is the next line?
: Since the <code> while</code> was true the next line is: <code>print(".",end=" ")</code>
; What does that line do?
: Prints one dot and since the extra argument <code>end=" "</code> exists the next printed text will not be on a different screen line.
; What is the next line?
: <code>number = number - 1</code> since that is following line and there are no indent changes.
; What does it do?
: It calculates <code>number - 1</code>, which is the current value of <code>number</code> (or 5) subtracts 1 from it, and makes that the new value of number. So basically it changes <code> number</code>'s value from 5 to 4.
; What is the next line?
: Well, the indent level decreases so we have to look at what type of control structure it is. It is a <code>while</code> loop, so we have to go back to the <code>while</code> clause which is <code>while number > 1:</code>
; What does it do?
: It looks at the value of number, which is 4, and compares it to 1 and since <code>4 > 1</code> the while loop continues.
; What is the next line?
: Since the while loop was true, the next line is: <code>print(".",end=" ")</code>
; What does it do?
: It prints a second dot on the line, ending by a space.
; What is the next line?
: No indent change so it is: <code>number = number - 1</code>
; And what does it do?
: It takes the current value of number (4), subtracts 1 from it, which gives it 3 and then finally makes 3 the new value of number.
; What is the next line?
: Since there is an indent change caused by the end of the while loop, the next line is: <code>while number > 1:</code>
; What does it do?
: It compares the current value of number (3) to 1. <code>3 > 1</code> so the while loop continues.
; What is the next line?
: Since the while loop condition was true the next line is: <code>print(".",end=" ")</code>
; And it does what?
: A third dot is printed on the line.
; What is the next line?
: It is: <code>number = number - 1</code>
; What does it do?
: It takes the current value of number (3) subtracts from it 1 and makes the 2 the new value of number.
; What is the next line?
: Back up to the start of the while loop: <code>while number > 1:</code>
; What does it do?
: It compares the current value of number (2) to 1. Since <code>2 > 1</code> the while loop continues.
; What is the next line?
: Since the while loop is continuing: <code>print(".",end=" ")</code>
; What does it do?
: It discovers the meaning of life, the universe and everything. I'm joking. (I had to make sure you were awake.) The line prints a fourth dot on the screen.
; What is the next line?
: It's: <code>number = number - 1</code>
; What does it do?
: Takes the current value of number (2) subtracts 1 and makes 1 the new value of number.
; What is the next line?
: Back up to the while loop: <code>while number > 1:</code>
; What does the line do?
: It compares the current value of number (1) to 1. Since <code>1 > 1</code> is false (one is not greater than one), the while loop exits.
; What is the next line?
: Since the while loop condition was false the next line is the line after the while loop exits, or: <code>print()</code>
; What does that line do?
: Makes the screen go to the next line.
; Why doesn't the program print 5 dots?
: The loop exits 1 dot too soon.
; How can we fix that?
: Make the loop exit 1 dot later.
; And how do we do that?
: There are several ways. One way would be to change the while loop to: <code>while number > 0:</code> Another way would be to change the conditional to: <code>number >= 1</code> There are a couple others.

=== How do I fix my program? ===

You need to figure out what the program is doing. You need to figure out what the program should do. Figure out what the difference between the two is. Debugging is a skill that has to be practiced to be learned. If you can't figure it out after an hour, take a break, talk to someone about the problem or contemplate the lint in your navel. Come back in a while and you will probably have new ideas about the problem. Good luck.

{{navigation |previous=Decisions |next=Defining Functions}}

Python Vadovėlis/Terminai

2021-10-06T16:44:04Z

Monika: Pataisytas "Output" vertimas

Computer - kompiuteris

Debugging - derinimas

Exercise - pratimas

Expression - reiškinys

Feature - ypatybė

Floating point - slankusis kablelis

Indent - įtrauka

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvestis/rezultatas

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Solution - sprendimas

Statement - sakinys

User - naudotojas

{{navigation |previous=FAQ |next=END}}

Python Vadovėlis/Autoriai

2021-10-06T12:48:25Z

Monika: Į autorius pridėta Monika Bijeikytė

Originalaus (angliško) vadovėlio autoriai

; Josh Cogliati
: Jrincayc, jjcogliati-jan2007 AT yahoo.com

=== Angliškos versijos bendraautoriai ===
* Mitchell Aikens, LGIT, WSIT, AAS
* Kiah Morante
*Elizabeth Cogliati
*James A. Brown
*Joe Oppegaard
*Benjamin Hell

=== Lietuviškas vertimas ir modifikacija ===
* Mantas Urbonas, Visma Lietuva
* Povilas Jeremičius, Visma Lietuva
* Martynas Teleiša, Visma lietuva
* Artūras Nikončukas, Visma Lietuva
* Laura Kutovaja, Visma Lietuva
* Monika Bijeikytė, Visma Lietuva
TODO

{{navigation |previous=BEGINNING |next=Front matter}}
{{BookCat}}

Python Vadovėlis/Derinimas

2021-10-04T17:44:42Z

Monika: Išversta dalis "What should the program do?"

=== Kas yra derinimas? ===
:"Kai tik pradėjome programuoti, mūsų nuostabai, supratome, kad nėra taip lengva kurti teisingai veikiančias programas, kaip manėme iš pradžių. Derinimas turėjo būti atrastas. Atsimenu tą akimirką, kai supratau, kad didelė mano gyvenimo dalis bus skirta klaidų ieškojimui savo sukurtose programose." — ''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škodemas 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švedimas (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ų.

=== What does the program do? ===

The next thing to do is to look at the source code. One of the most important things to do while programming is reading source code. The primary way to do this is code walkthroughs.

A code walkthrough starts at the first line, and works its way down until the program is done. <code>while</code> loops and <code>if</code> statements mean that some lines may never be run and some lines are run many times. At each line you figure out what Python has done.

Lets start with the simple perimeter program. Don't type it in, you are going to read it, not run it. The source code is:

<syntaxhighlight lang="python">
height = int(input("Height: "))
width = int(input("Width: "))
print("perimeter =", width + height + width + width)
</syntaxhighlight>

; ''Question:'' What is the first line Python runs?
: ''Answer:'' The first line is always run first. In this case it is: <code>height = int(input("Height: "))</code>
; What does that line do?
: Prints <code> Height: </code>, waits for the user to type a string in, and then converts the string to an integer variable height.
; What is the next line that runs?
: In general, it is the next line down which is: <code>width = int(input("Width: "))</code>
; What does that line do?
: Prints <code>Width: </code>, waits for the user to type a number in, and puts what the user types in the variable width.
; What is the next line that runs?
: When the next line is not indented more or less than the current line, it is the line right afterwards, so it is: <code>print("perimeter = ", width + height + width + width)</code> (It may also run a function in the current line, but that's a future chapter.)
; What does that line do?
: First it prints <code>perimeter = </code>, then it prints the sum of the values contained within the variables, <code>width</code> and <code>height</code>, from <code>width + height + width + width</code>.
; Does <code>width + height + width + width</code> calculate the perimeter properly?
: Let's see, perimeter of a rectangle is the bottom (width) plus the left side (height) plus the top (width) plus the right side (huh?). The last item should be the right side's length, or the height.
; Do you understand why some of the times the perimeter was calculated "correctly"?
: It was calculated correctly when the width and the height were equal.

The next program we will do a code walkthrough for is a program that is supposed to print out 5 dots on the screen. However, this is what the program is outputting:

. . . .

And here is the program:
<syntaxhighlight lang="python">
number = 5
while number > 1:
print(".",end=" ")
number = number - 1
print()
</syntaxhighlight>

This program will be more complex to walkthrough since it now has indented portions (or control structures). Let us begin.
; What is the first line to be run?
: The first line of the file: <code>number = 5</code>
; What does it do?
: Puts the number 5 in the variable number.
; What is the next line?
: The next line is: <code>while number > 1:</code>
; What does it do?
: Well, <code>while</code> statements in general look at their expression, and if it is true they do the next indented block of code, otherwise they skip the next indented block of code.
; So what does it do right now?
: If <code>number > 1</code> is true then the next two lines will be run.
; So is <code>number > 1</code>?
: The last value put into <code>number</code> was <code>5</code> and <code>5 > 1</code> so yes.
; So what is the next line?
: Since the <code> while</code> was true the next line is: <code>print(".",end=" ")</code>
; What does that line do?
: Prints one dot and since the extra argument <code>end=" "</code> exists the next printed text will not be on a different screen line.
; What is the next line?
: <code>number = number - 1</code> since that is following line and there are no indent changes.
; What does it do?
: It calculates <code>number - 1</code>, which is the current value of <code>number</code> (or 5) subtracts 1 from it, and makes that the new value of number. So basically it changes <code> number</code>'s value from 5 to 4.
; What is the next line?
: Well, the indent level decreases so we have to look at what type of control structure it is. It is a <code>while</code> loop, so we have to go back to the <code>while</code> clause which is <code>while number > 1:</code>
; What does it do?
: It looks at the value of number, which is 4, and compares it to 1 and since <code>4 > 1</code> the while loop continues.
; What is the next line?
: Since the while loop was true, the next line is: <code>print(".",end=" ")</code>
; What does it do?
: It prints a second dot on the line, ending by a space.
; What is the next line?
: No indent change so it is: <code>number = number - 1</code>
; And what does it do?
: It takes the current value of number (4), subtracts 1 from it, which gives it 3 and then finally makes 3 the new value of number.
; What is the next line?
: Since there is an indent change caused by the end of the while loop, the next line is: <code>while number > 1:</code>
; What does it do?
: It compares the current value of number (3) to 1. <code>3 > 1</code> so the while loop continues.
; What is the next line?
: Since the while loop condition was true the next line is: <code>print(".",end=" ")</code>
; And it does what?
: A third dot is printed on the line.
; What is the next line?
: It is: <code>number = number - 1</code>
; What does it do?
: It takes the current value of number (3) subtracts from it 1 and makes the 2 the new value of number.
; What is the next line?
: Back up to the start of the while loop: <code>while number > 1:</code>
; What does it do?
: It compares the current value of number (2) to 1. Since <code>2 > 1</code> the while loop continues.
; What is the next line?
: Since the while loop is continuing: <code>print(".",end=" ")</code>
; What does it do?
: It discovers the meaning of life, the universe and everything. I'm joking. (I had to make sure you were awake.) The line prints a fourth dot on the screen.
; What is the next line?
: It's: <code>number = number - 1</code>
; What does it do?
: Takes the current value of number (2) subtracts 1 and makes 1 the new value of number.
; What is the next line?
: Back up to the while loop: <code>while number > 1:</code>
; What does the line do?
: It compares the current value of number (1) to 1. Since <code>1 > 1</code> is false (one is not greater than one), the while loop exits.
; What is the next line?
: Since the while loop condition was false the next line is the line after the while loop exits, or: <code>print()</code>
; What does that line do?
: Makes the screen go to the next line.
; Why doesn't the program print 5 dots?
: The loop exits 1 dot too soon.
; How can we fix that?
: Make the loop exit 1 dot later.
; And how do we do that?
: There are several ways. One way would be to change the while loop to: <code>while number > 0:</code> Another way would be to change the conditional to: <code>number >= 1</code> There are a couple others.

=== How do I fix my program? ===

You need to figure out what the program is doing. You need to figure out what the program should do. Figure out what the difference between the two is. Debugging is a skill that has to be practiced to be learned. If you can't figure it out after an hour, take a break, talk to someone about the problem or contemplate the lint in your navel. Come back in a while and you will probably have new ideas about the problem. Good luck.

{{navigation |previous=Decisions |next=Defining Functions}}

Python Vadovėlis/Terminai

2021-10-03T15:40:33Z

Monika: Pridėti nauji terminai

Computer - kompiuteris

Debugging - derinimas

Exercise - pratimas

Expression - reiškinys

Feature - ypatybė

Floating point - slankusis kablelis

Indent - įtrauka

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvedimas/rezultatas

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Solution - sprendimas

Statement - sakinys

User - naudotojas

{{navigation |previous=FAQ |next=END}}

Python Vadovėlis/Derinimas

2021-10-03T15:40:18Z

Monika: Išversta įžanga

=== Kas yra derinimas? ===
:"Kai tik pradėjome programuoti, mūsų nuostabai, supratome, kad nėra taip lengva kurti teisingai veikiančias programas, kaip manėme iš pradžių. Derinimas turėjo būti atrastas. Atsimenu tą akimirką, kai supratau, kad didelė mano gyvenimo dalis bus skirta klaidų ieškojimui savo sukurtose programose." — ''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škodemas 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.

=== What should the program do? ===

The first thing to do (this sounds obvious) is to figure out what the
program should be doing if it is running correctly. Come up with some
test cases and see what happens. For example, let's say I have a
program to compute the perimeter of a rectangle (the sum of the length
of all the edges). I have the following test cases:

{| class="wikitable"
|-
!height !! width !!perimeter
|-
|3 ||4 ||14
|--
|2 ||3 ||10
|-
|4 ||4 ||16
|-
|2 ||2 ||8
|-
|5 ||1 ||12
|-
|}

I now run my program on all of the test cases and see if the program does what
I expect it to do. If it doesn't then I need to find out what the computer is
doing.

More commonly some of the test cases will work and some will not. If that is the case you should try and figure out what the working ones have in common.
For example here is the output for a perimeter program (you get to see the code in a minute):

Height: '''3'''
Width: '''4'''
perimeter = 15

Height: '''2'''
Width: '''3'''
perimeter = 11

Height: '''4'''
Width: '''4'''
perimeter = 16

Height: '''2'''
Width: '''2'''
perimeter = 8

Height: '''5'''
Width: '''1'''
perimeter = 8

Notice that it didn't work for the first two inputs, it worked for the next
two and it didn't work on the last one. Try and figure out what is in common
with the working ones. Once you have some idea what the problem is finding the
cause is easier. With your own programs you should try more test cases if you need them.

=== What does the program do? ===

The next thing to do is to look at the source code. One of the most important things to do while programming is reading source code. The primary way to do this is code walkthroughs.

A code walkthrough starts at the first line, and works its way down until the program is done. <code>while</code> loops and <code>if</code> statements mean that some lines may never be run and some lines are run many times. At each line you figure out what Python has done.

Lets start with the simple perimeter program. Don't type it in, you are going to read it, not run it. The source code is:

<syntaxhighlight lang="python">
height = int(input("Height: "))
width = int(input("Width: "))
print("perimeter =", width + height + width + width)
</syntaxhighlight>

; ''Question:'' What is the first line Python runs?
: ''Answer:'' The first line is always run first. In this case it is: <code>height = int(input("Height: "))</code>
; What does that line do?
: Prints <code> Height: </code>, waits for the user to type a string in, and then converts the string to an integer variable height.
; What is the next line that runs?
: In general, it is the next line down which is: <code>width = int(input("Width: "))</code>
; What does that line do?
: Prints <code>Width: </code>, waits for the user to type a number in, and puts what the user types in the variable width.
; What is the next line that runs?
: When the next line is not indented more or less than the current line, it is the line right afterwards, so it is: <code>print("perimeter = ", width + height + width + width)</code> (It may also run a function in the current line, but that's a future chapter.)
; What does that line do?
: First it prints <code>perimeter = </code>, then it prints the sum of the values contained within the variables, <code>width</code> and <code>height</code>, from <code>width + height + width + width</code>.
; Does <code>width + height + width + width</code> calculate the perimeter properly?
: Let's see, perimeter of a rectangle is the bottom (width) plus the left side (height) plus the top (width) plus the right side (huh?). The last item should be the right side's length, or the height.
; Do you understand why some of the times the perimeter was calculated "correctly"?
: It was calculated correctly when the width and the height were equal.

The next program we will do a code walkthrough for is a program that is supposed to print out 5 dots on the screen. However, this is what the program is outputting:

. . . .

And here is the program:
<syntaxhighlight lang="python">
number = 5
while number > 1:
print(".",end=" ")
number = number - 1
print()
</syntaxhighlight>

This program will be more complex to walkthrough since it now has indented portions (or control structures). Let us begin.
; What is the first line to be run?
: The first line of the file: <code>number = 5</code>
; What does it do?
: Puts the number 5 in the variable number.
; What is the next line?
: The next line is: <code>while number > 1:</code>
; What does it do?
: Well, <code>while</code> statements in general look at their expression, and if it is true they do the next indented block of code, otherwise they skip the next indented block of code.
; So what does it do right now?
: If <code>number > 1</code> is true then the next two lines will be run.
; So is <code>number > 1</code>?
: The last value put into <code>number</code> was <code>5</code> and <code>5 > 1</code> so yes.
; So what is the next line?
: Since the <code> while</code> was true the next line is: <code>print(".",end=" ")</code>
; What does that line do?
: Prints one dot and since the extra argument <code>end=" "</code> exists the next printed text will not be on a different screen line.
; What is the next line?
: <code>number = number - 1</code> since that is following line and there are no indent changes.
; What does it do?
: It calculates <code>number - 1</code>, which is the current value of <code>number</code> (or 5) subtracts 1 from it, and makes that the new value of number. So basically it changes <code> number</code>'s value from 5 to 4.
; What is the next line?
: Well, the indent level decreases so we have to look at what type of control structure it is. It is a <code>while</code> loop, so we have to go back to the <code>while</code> clause which is <code>while number > 1:</code>
; What does it do?
: It looks at the value of number, which is 4, and compares it to 1 and since <code>4 > 1</code> the while loop continues.
; What is the next line?
: Since the while loop was true, the next line is: <code>print(".",end=" ")</code>
; What does it do?
: It prints a second dot on the line, ending by a space.
; What is the next line?
: No indent change so it is: <code>number = number - 1</code>
; And what does it do?
: It takes the current value of number (4), subtracts 1 from it, which gives it 3 and then finally makes 3 the new value of number.
; What is the next line?
: Since there is an indent change caused by the end of the while loop, the next line is: <code>while number > 1:</code>
; What does it do?
: It compares the current value of number (3) to 1. <code>3 > 1</code> so the while loop continues.
; What is the next line?
: Since the while loop condition was true the next line is: <code>print(".",end=" ")</code>
; And it does what?
: A third dot is printed on the line.
; What is the next line?
: It is: <code>number = number - 1</code>
; What does it do?
: It takes the current value of number (3) subtracts from it 1 and makes the 2 the new value of number.
; What is the next line?
: Back up to the start of the while loop: <code>while number > 1:</code>
; What does it do?
: It compares the current value of number (2) to 1. Since <code>2 > 1</code> the while loop continues.
; What is the next line?
: Since the while loop is continuing: <code>print(".",end=" ")</code>
; What does it do?
: It discovers the meaning of life, the universe and everything. I'm joking. (I had to make sure you were awake.) The line prints a fourth dot on the screen.
; What is the next line?
: It's: <code>number = number - 1</code>
; What does it do?
: Takes the current value of number (2) subtracts 1 and makes 1 the new value of number.
; What is the next line?
: Back up to the while loop: <code>while number > 1:</code>
; What does the line do?
: It compares the current value of number (1) to 1. Since <code>1 > 1</code> is false (one is not greater than one), the while loop exits.
; What is the next line?
: Since the while loop condition was false the next line is the line after the while loop exits, or: <code>print()</code>
; What does that line do?
: Makes the screen go to the next line.
; Why doesn't the program print 5 dots?
: The loop exits 1 dot too soon.
; How can we fix that?
: Make the loop exit 1 dot later.
; And how do we do that?
: There are several ways. One way would be to change the while loop to: <code>while number > 0:</code> Another way would be to change the conditional to: <code>number >= 1</code> There are a couple others.

=== How do I fix my program? ===

You need to figure out what the program is doing. You need to figure out what the program should do. Figure out what the difference between the two is. Debugging is a skill that has to be practiced to be learned. If you can't figure it out after an hour, take a break, talk to someone about the problem or contemplate the lint in your navel. Come back in a while and you will probably have new ideas about the problem. Good luck.

{{navigation |previous=Decisions |next=Defining Functions}}

Python Vadovėlis

2021-10-03T15:21:32Z

Monika:

Tai - standartinės Python programavimo kalbos vadovėlis, 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.

==Contents==
{{print version}}
{{PDF version}}
;[[Vadovėlis/Authors]]
: Contributors to this book
;[[Vadovėlis/Front matter]]
: Initial remarks
;[[Vadovėlis/Intro]]
: Installing and using Python – where to get help
;[[Vadovėlis/Hello, World]]
: The famous first program – screen output – variables – numbers and calculations
;[[Vadovėlis/Who Goes There?]]
: Interactive input – strings
;[[Vadovėlis/Count to 10]]
: <tt>while</tt> loops
;[[Vadovėlis/Decisions|Vadovėlis/Decisions [Monika]]]
:<tt>if</tt> statements
;[[Vadovėlis/Debugging|Vadovėlis/Debugging [Monika]]]
:Finding out what goes wrong
;[[Vadovėlis/Defining Functions]]
: Structuring programs with the use of functions
;[[Vadovėlis/Advanced Functions Example]]
: (Almost) mind-blowing example of how programmers can think
;[[Vadovėlis/Lists|Vadovėlis/Lists [Artūras]]]
:Variables containing more than one value
;[[Vadovėlis/For Loops|Vadovėlis/For Loops [Artūras]]]
:A second kind of loop
;[[Vadovėlis/Boolean Expressions]]
:Computer logic – <tt>True</tt> and <tt>False</tt> – <tt>and</tt> and <tt>or</tt> – <tt>not</tt>
;[[Vadovėlis/Dictionaries|Vadovėlis/Dictionaries [zivile]]]
:Variables containing key/value pairs
;[[Vadovėlis/Using Modules]]
:Extensions to the standard set of functionality
;[[Vadovėlis/More on Lists]]
:Using elements or parts of lists
;[[Vadovėlis/Revenge of the Strings]]
:More advanced text manipulations
;[[Vadovėlis/File IO]]
:Reading from files and writing to files
;[[Vadovėlis/Dealing with the imperfect]]
:How to handle errors
;[[Vadovėlis/Recursion]]
:Recursive Functions
;[[Vadovėlis/Intro to Object Oriented Programming in Python 3]]
:Basics of OOP (Object Oriented Programming)
;[[Vadovėlis/Intro to Imported Libraries and other Functions]]
:Basic functions from various libraries.
;[[Vadovėlis/The End]]
:How to go further
;[[Vadovėlis/FAQ]]
:Some frequently asked questions
;[[Vadovėlis/Terminai]]
:Terminų žodynas

{{Alphabetical|N}}
{{status|100%}}
__NOTOC__ __NOEDITSECTION__

Python Vadovėlis

2021-10-03T15:21:01Z

Monika:

Tai - standartinės Python programavimo kalbos vadovėlis, 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.

==Contents==
{{print version}}
{{PDF version}}
;[[Vadovėlis/Authors]]
: Contributors to this book
;[[Vadovėlis/Front matter]]
: Initial remarks
;[[Vadovėlis/Intro]]
: Installing and using Python – where to get help
;[[Vadovėlis/Hello, World]]
: The famous first program – screen output – variables – numbers and calculations
;[[Vadovėlis/Who Goes There?]]
: Interactive input – strings
;[[Vadovėlis/Count to 10]]
: <tt>while</tt> loops
;[[Vadovėlis/Decisions|Vadovėlis/Decisions [Monika]]]
:<tt>if</tt> statements
;[[Vadovėlis/Debugging [Monika]]]
:Finding out what goes wrong
;[[Vadovėlis/Defining Functions]]
: Structuring programs with the use of functions
;[[Vadovėlis/Advanced Functions Example]]
: (Almost) mind-blowing example of how programmers can think
;[[Vadovėlis/Lists|Vadovėlis/Lists [Artūras]]]
:Variables containing more than one value
;[[Vadovėlis/For Loops|Vadovėlis/For Loops [Artūras]]]
:A second kind of loop
;[[Vadovėlis/Boolean Expressions]]
:Computer logic – <tt>True</tt> and <tt>False</tt> – <tt>and</tt> and <tt>or</tt> – <tt>not</tt>
;[[Vadovėlis/Dictionaries|Vadovėlis/Dictionaries [zivile]]]
:Variables containing key/value pairs
;[[Vadovėlis/Using Modules]]
:Extensions to the standard set of functionality
;[[Vadovėlis/More on Lists]]
:Using elements or parts of lists
;[[Vadovėlis/Revenge of the Strings]]
:More advanced text manipulations
;[[Vadovėlis/File IO]]
:Reading from files and writing to files
;[[Vadovėlis/Dealing with the imperfect]]
:How to handle errors
;[[Vadovėlis/Recursion]]
:Recursive Functions
;[[Vadovėlis/Intro to Object Oriented Programming in Python 3]]
:Basics of OOP (Object Oriented Programming)
;[[Vadovėlis/Intro to Imported Libraries and other Functions]]
:Basic functions from various libraries.
;[[Vadovėlis/The End]]
:How to go further
;[[Vadovėlis/FAQ]]
:Some frequently asked questions
;[[Vadovėlis/Terminai]]
:Terminų žodynas

{{Alphabetical|N}}
{{status|100%}}
__NOTOC__ __NOEDITSECTION__

Python Vadovėlis/Pasirinkimai

2021-10-03T15:05:31Z

Monika:

=== <code>If</code> sakinys ===
Kaip visada, aš tikiu, kad turėčiau pradėti kiekvieną skyrių su apšilimo pratimu. Taigi, žemiau turime trumpą programą, kuri apskaičiuoja absoliučią sveikojo skaičiaus reikšmę:
<syntaxhighlight lang="python">
n = int(input("Skaičius? "))
if n < 0:
print("Absoliuti", n, "reikšmė yra", -n)
else:
print("Absoliuti", n, "reikšmė yra", n)
</syntaxhighlight>

Štai rezultatas po dviejų programos vykdymų:

Skaičius? '''-34'''
Absoliuti -34 reikšmė yra 34

Skaičius? '''1'''
Absoliuti 1 reikšmė yra 1

Taigi, ką kompiuteris daro, kai pamato šį kodą? Visų pirma, jis kviečia įvesti skaičių su šiuo sakiniu "<code>n = int(input("Skaičius? "))</code>". Tada jis skaito eilutę "<code>if n < 0:</code>". Jei <code>n</code> yra mažiau už nulį, Python'as vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", -n)</code>". Kitu atveju, jis vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", n)</code>".

Kalbant formaliau, Python'as tikrina, ar ''reiškinys'' <code>n < 0</code> yra tiesa ar melas. Sakinys <code>if</code> yra lydimas įtraukto sakinių ''bloko'', kuris vykdomas tik jei reiškinys yra tiesa. Pasirinktinai, po <code>if</code> sakinio gali būti <code>else</code> sakinys ir dar vienas įtrauktas sakinių ''blokas''. Antrasis sakinių blokas yra vykdomas tik jei reiškinys yra melas.

Reiškinys gali turėti įvairių testų. Žemiau yra visų jų lentelė:

{| class="wikitable"
!operatorius
!funkcija
|-
|<code><</code>
|mažiau nei
|-
|<code><=</code>
|mažiau nei arba lygu
|-
|<code>></code>
|daugiau nei
|-
|<code>>=</code>
|daugiau nei arba lygu
|-
|<code>==</code>
|lygu
|-
|<code>!=</code>
|nelygu
|}

Dar viena sakinio <code>if</code> ypatybė yra <code>elif</code> sakinys. Tai ''else if'' sutrumpinimas ir reiškia, kad jei originalus <code>if</code> sakinys yra melas, bet <code>elif</code> dalis yra tiesa, yra vykdoma <code>elif</code> kodo dalis. Ir jei nei <code>if</code>, nei <code>elif</code> reiškiniai nėra tiesa, tada vykdomas <code>else</code> blokas. Pavyzdžiui:
<syntaxhighlight lang="python">
a = 0
while a < 10:
a = a + 1
if a > 5:
print(a, ">", 5)
elif a <= 3:
print(a, "<=", 3)
else:
print("Nei vienas iš testų nėra teisingas")
</syntaxhighlight>

ir išvedimas:

1 <= 3
2 <= 3
3 <= 3
Nei vienas iš testų nėra teisingas
Nei vienas iš testų nėra teisingas
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

Gali pastebėti, kad <code>elif a <= 3</code> dalis yra tikrinama tik tada, jei <code>if</code> sakinys nėra tiesa. Galima rašyti daugiau nei vieną <code>elif</code> reiškinį, tokiu būdu leidžiant vykdyti kelis testus viename <code>if</code> sakinyje.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa parodo, kaip galima naudoti == operatorių
# naudojant numerius
print(5 == 6)
# naudojant kintamuosius
x = 5
y = 8
print(x == y)
</syntaxhighlight>

Ir išvedimas

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Žaidžia spėlionių žaidimą daugiau mažiau

# Iš tiesų, čia turėtų būti naudojami pusiau atsitiktiniai skaičiai,
# pavyzdžiui paskutinis laiko skaitmuo, ar kažkas panašaus. Bet tai
# palauks iki vėlesnės dalies. (Papildoma užduotis: po Modulių dalies, pakeisk šį kodą,
# kad būtų naudojami atsitiktiniai skaičiai)
skaicius = 7
spejimas = -1

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))

if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")
</syntaxhighlight>

Pavyzdinis vykdymas:

Atspėk skaičių!
Ar tai yra... '''2'''
Skaičius yra didesnis...
Ar tai yra... '''5'''
Skaičius yra didesnis...
Ar tai yra... '''10'''
Skaičius yra ne toks didelis.
Ar tai yra... '''7'''
Valio! Atspėjai teisingai!

'''lyginis.py'''

<syntaxhighlight lang="python">
# Prašo įvesti skaičių.
# Išveda, ar skaičius yra lyginis, ar ne

skaicius = float(input("Pasakyk man skaičių: "))
if skaicius % 2 == 0:
print(int(skaicius), "yra lyginis.")
elif skaicius % 2 == 1:
print(int(skaicius), "yra nelyginis.")
else:
print(skaicius, "yra labai keistas.")
</syntaxhighlight>

Pavyzdiniai vykdymai:

Pasakyk man skaičių: '''3'''
3 yra nelyginis.

Pasakyk man skaičių: '''2'''
2 yra lyginis.

Pasakyk man skaičių: '''3.4895'''
3.4895 yra labai keistas.

'''vidurkis1.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol įvedamas 0
# Išveda skaičių vidurkį

kiekis = 0
suma = 0.0
skaicius = 1 # nurodomas tam, kad nebūtų iškart išeinama iš ciklo.

print("Įvesk 0, kad sustabdytum ciklą")

while skaicius != 0:
skaicius = float(input("Įvesk skaičių: "))
if skaicius != 0:
kiekis = kiekis + 1
suma = suma + skaicius
if skaicius == 0:
print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''3'''
Įvesk skaičių: '''5'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 4.0

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''1'''
Įvesk skaičių: '''4'''
Įvesk skaičių: '''3'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 2.66666666667

'''vidurkis2.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol bus įvestas tam tikras kiekis skaičių
# Išveda skaičių vidurkį.

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek numerių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui sekti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Pratimai ===
Parašyk programą, kuri prašo naudotojo įvesti savo vardą. Jei jis įveda tavo vardą, išvesk "Tai puikus vardas". Jei jie įveda "Jonas Jonaitis" arba "Petras Petraitis", išvesk kokį nors juokingą tekstą. Kitu atveju, išvesk "Tavo vardas yra labai gražus".

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
vardas = input('Tavo vardas: ')
if vardas == 'Lukas':
print('Tai puikus vardas.')
elif vardas == 'Jonas Jonaitis':
print('... juokingas tekstas apie Joną.')
elif vardas == 'Petras Petraitis':
print('... juokingas tekstas apie Petrą.')
else:
print('Tavo vardas yra labai gražus.')
</syntaxhighlight>
}}

Pakeisk aukščiau esančią "daugiau_maziau.py" programą, kad ji papildomai skaičiuotų, kiek kartų naudotojas įvedė neteisingą skaičių. Jei taip nutiko daugiau, nei tris kartus, programos pabaigoje išvesk "Tai buvo sudėtinga.", o kitu atveju - "Gerai padirbėjai!"

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius = 7
spejimas = -1
kiekis = 0

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))
kiekis = kiekis + 1
if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")

if kiekis > 3:
print("Tai buvo sudėtinga.")
else:
print("Gerai padirbėjai!")
</syntaxhighlight>
}}

Parašyk programą, kuri prašo įvesti du skaičius. Jei skaičių suma yra didesnė nei 100, išvesk "Tai yra didelis skaičius".

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius1 = float(input('Pirmas skaičius: '))
skaicius2 = float(input('Antras skaičius: '))
if skaicius1 + skaicius2 > 100:
print('Skaičių suma yra didelis skaičius.')
</syntaxhighlight>
}}

{{navigation |previous=Count to 10 |next=Debugging}}

Python Vadovėlis/Pasirinkimai

2021-10-03T14:58:01Z

Monika:

=== <code>If</code> sakinys ===
Kaip visada, aš tikiu, kad turėčiau pradėti kiekvieną skyrių su apšilimo pratimu. Taigi, žemiau turime trumpą programą, kuri apskaičiuoja absolučią sveikojo skaičiaus reikšmę:
<syntaxhighlight lang="python">
n = int(input("Skaičius? "))
if n < 0:
print("Absoliuti", n, "reikšmė yra", -n)
else:
print("Absoliuti", n, "reikšmė yra", n)
</syntaxhighlight>

Štai rezultatas po dviejų programos vykdymų:

Skaičius? '''-34'''
Absoliuti -34 reikšmė yra 34

Skaičius? '''1'''
Absoliuti 1 reikšmė yra 1

Taigi, ką kompiuteris daro, kai pamato šį kodą? Visų pirma, jis kviečia įvesti skaičių su šiuo sakiniu "<code>n = int(input("Skaičius? "))</code>". Tada jis skaito eilutę "<code>if n < 0:</code>". Jei <code>n</code> yra mažiau už nulį, Python'as vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", -n)</code>". Kitu atveju, jis vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", n)</code>".

Kalbant formaliau, Python'as tikrina, ar ''reiškinys'' <code>n < 0</code> yra tiesa ar melas. Sakinys <code>if</code> yra lydimas įtraukto sakinių ''bloko'', kuris vykdomas tik jei reikškinys yra tiesa. Pasirinktinai, po <code>if</code> sakinio gali būti <code>else</code> sakinys ir dar vienas įtrauktas sakinių ''blokas''. Antrasis sakinių blokas yra vykdomas tik jei reikškinys yra melas.

Reiškinys gali turėti įvairių testų. Žemiau yra visų jų lentelė:

{| class="wikitable"
!operatorius
!funkcija
|-
|<code><</code>
|mažiau nei
|-
|<code><=</code>
|mažiau nei arba lygu
|-
|<code>></code>
|daugiau nei
|-
|<code>>=</code>
|daugiau nei arba lygu
|-
|<code>==</code>
|lygu
|-
|<code>!=</code>
|nelygu
|}

Dar viena sakinio <code>if</code> ypatybė yra <code>elif</code> sakinys. Tai ''else if'' sutrumpinimas ir reiškia, kad jei originalus <code>if</code> sakinys yra melas, bet <code>elif</code> dalis yra tiesa, yra vykdoma <code>elif</code> kodo dalis. Ir jei nei <code>if</code>, nei <code>elif</code> reiškiniai nėra tiesa, tada vykdomas <code>else</code> blokas. Pavyzdžiui:
<syntaxhighlight lang="python">
a = 0
while a < 10:
a = a + 1
if a > 5:
print(a, ">", 5)
elif a <= 3:
print(a, "<=", 3)
else:
print("Nei vienas iš testų nėra teisingas")
</syntaxhighlight>

ir išvedimas:

1 <= 3
2 <= 3
3 <= 3
Nei vienas iš testų nėra teisingas
Nei vienas iš testų nėra teisingas
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

Gali pastebėti, kad <code>elif a <= 3</code> dalis yra tikrinama tik tada, jei <code>if</code> sakinys nėra tiesa. Galima rašyti daugiau nei vieną <code>elif</code> reiškinį, tokiu būdu leidžiant vykdyti kelis testus viename <code>if</code> sakinyje.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa parodo, kaip galima naudoti == operatorių
# naudojant numerius
print(5 == 6)
# naudojant kintamuosius
x = 5
y = 8
print(x == y)
</syntaxhighlight>

Ir išvedimas

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Žaidia spėlionių žaidimą daugiau mažiau

# Iš tiesų, čia turėtų būti naudojami pusiau atsitiktiniai skaičiai,
# pavyzdžiui paskutinis laiko skaitmuo, ar kažkas panašaus. Bet tai
# palauks iki vėlesnės dalies. (Papildoma užduotis: po Modulių dalies, pakeisk šį kodą,
# kad būtų naudojami atsitiktiniai skaičiai)
skaicius = 7
spejimas = -1

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))

if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")
</syntaxhighlight>

Pavyzdinis vykdymas:

Atspėk skaičių!
Ar tai yra... '''2'''
Skaičius yra didesnis...
Ar tai yra... '''5'''
Skaičius yra didesnis...
Ar tai yra... '''10'''
Skaičius yra ne toks didelis.
Ar tai yra... '''7'''
Valio! Atspėjai teisingai!

'''lyginis.py'''

<syntaxhighlight lang="python">
# Prašo įvesti skaičių.
# Išveda, ar skaičius yra lyginis, ar ne

skaicius = float(input("Pasakyk man skaičių: "))
if skaicius % 2 == 0:
print(int(skaicius), "yra lyginis.")
elif number % 2 == 1:
print(int(skaicius), "yra nelyginis.")
else:
print(skaicius, "yra labai keistas.")
</syntaxhighlight>

Pavyzdiniai vykdymai:

Pasakyk man skaičių: '''3'''
3 yra nelyginis.

Pasakyk man skaičių: '''2'''
2 yra lyginis.

Pasakyk man skaičių: '''3.4895'''
3.4895 yra labai keistas.

'''vidurkis1.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol įvedamas 0
# Išveda skaičių vidurkį

kiekis = 0
suma = 0.0
skaicius = 1 # nurodomas tam, kad nebūtų iškart išeinama iš ciklo.

print("Įvesk 0, kad sustabdytum ciklą")

while skaicius != 0:
skaicius = float(input("Įvesk skaičių: "))
if skaicius != 0:
kiekis = kiekis + 1
suma = suma + skaicius
if skaicius == 0:
print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''3'''
Įvesk skaičių: '''5'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 4.0

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''1'''
Įvesk skaičių: '''4'''
Įvesk skaičių: '''3'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 2.66666666667

'''vidurkis2.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol bus įvestas tam tikras kiekis skaičių
# Išveda skaičių vidurkį.

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek numerių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui sekti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Pratimai ===
Parašyk programą, kuri prašo naudotojo įvesti savo vardą. Jei jis įveda tavo vardą, išvesk "Tai puikus vardas". Jei jie įveda "Jonas Jonaitis" arba "Petras Petraitis", išvesk kokį nors juokingą tekstą. Kitu atveju, išvesk "Tavo vardas yra labai gražus".

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
vardas = input('Tavo vardas: ')
if vardas == 'Lukas':
print('Tai puikus vardas.')
elif vardas == 'Jonas Jonaitis':
print('... juokingas tekstas apie Joną.')
elif vardas == 'Petras Petraitis':
print('... juokingas tekstas apie Petrą.')
else:
print('Tavo vardas yra labai gražus.')
</syntaxhighlight>
}}

Pakeisk aukščiau esančią "daugiau_maziau.py" programą, kad ji papildomai skaičiuotų, kiek kartų naudotojas įvedė neteisingą skaičių. Jei taip nutiko daugiau, nei tris kartus, programos pabaigoje išvesk "Tai buvo sudėtinga.", o kitu atveju - "Gerai padirbėjai!"

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius = 7
spejimas = -1
kiekis = 0

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))
kiekis = kiekis + 1
if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")

if kiekis > 3:
print("Tai buvo sudėtinga.")
else:
print("Gerai padirbėjai!")
</syntaxhighlight>
}}

Parašyk programą, kuri prašo įvesti du skaičius. Jei skaičių suma yra didesnė nei 100, išvesk "Tai yra didelis skaičius".

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius1 = float(input('Pirmas skaičius: '))
skaicius2 = float(input('Antras skaičius: '))
if skaicius1 + skaicius2 > 100:
print('Skaičių suma yra didelis skaičius.')
</syntaxhighlight>
}}

{{navigation |previous=Count to 10 |next=Debugging}}

Python Vadovėlis/Terminai

2021-10-03T14:54:30Z

Monika: Pridėti keli vertimai

Computer - kompiuteris

Exercise - pratimas

Expression - reiškinys

Feature - ypatybė

Floating point - slankusis kablelis

Indent - įtrauka

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvedimas/rezultatas

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Solution - sprendimas

Statement - sakinys

User - naudotojas

{{navigation |previous=FAQ |next=END}}

Python Vadovėlis/Pasirinkimai

2021-10-03T14:54:15Z

Monika: Išversti pratimai

=== <code>If</code> sakinys ===
Kaip visada, aš tikiu, kad turėčiau pradėti kiekvieną skyrių su apšilimo pratimu. Taigi, žemiau turime trumpą programą, kuri apskaičiuoja absolučią sveikojo skaičiaus reikšmę:
<syntaxhighlight lang="python">
n = int(input("Skaičius? "))
if n < 0:
print("Absoliuti", n, "reikšmė yra", -n)
else:
print("Absoliuti", n, "reikšmė yra", n)
</syntaxhighlight>

Štai rezultatas po dviejų programos vykdymų:

Skaičius? '''-34'''
Absoliuti -34 reikšmė yra 34

Skaičius? '''1'''
Absoliuti 1 reikšmė yra 1

Taigi, ką kompiuteris daro, kai pamato šį kodą? Visų pirma, jis kviečia įvesti skaičių su šiuo sakiniu "<code>n = int(input("Skaičius? "))</code>". Tada jis skaito eilutę "<code>if n < 0:</code>". Jei <code>n</code> yra mažiau už nulį, Python'as vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", -n)</code>". Kitu atveju, jis vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", n)</code>".

Kalbant formaliau, Python'as tikrina, ar ''reiškinys'' <code>n < 0</code> yra tiesa ar melas. Sakinys <code>if</code> yra lydimas įtraukto sakinių ''bloko'', kuris vykdomas tik jei reikškinys yra tiesa. Pasirinktinai, po <code>if</code> sakinio gali būti <code>else</code> sakinys ir dar vienas įtrauktas sakinių ''blokas''. Antrasis sakinių blokas yra vykdomas tik jei reikškinys yra melas.

Raikinys gali turėti įvairių testų. Žemiau yra visų jų lentelė:

{| class="wikitable"
!operatorius
!funkcija
|-
|<code><</code>
|mažiau nei
|-
|<code><=</code>
|mažiau nei arba lygu
|-
|<code>></code>
|daugiau nei
|-
|<code>>=</code>
|daugiau nei arba lygu
|-
|<code>==</code>
|lygu
|-
|<code>!=</code>
|nelygu
|}

Dar viena sakinio <code>if</code> ypatybė yra <code>elif</code> sakinys. Tai ''else if'' sutrumpinimas ir reiškia, kad jei originalus <code>if</code> sakinys yra melas, bet <code>elif</code> dalis yra tiesa, yra vykdoma <code>elif</code> kodo dalis. Ir jei nei <code>if</code>, nei <code>elif</code> reiškiniai nėra tiesa, tada vykdomas <code>else</code> blokas. Pavyzdžiui:
<syntaxhighlight lang="python">
a = 0
while a < 10:
a = a + 1
if a > 5:
print(a, ">", 5)
elif a <= 3:
print(a, "<=", 3)
else:
print("Nei vienas iš testų nėra teisingas")
</syntaxhighlight>

ir išvedimas:

1 <= 3
2 <= 3
3 <= 3
Nei vienas iš testų nėra teisingas
Nei vienas iš testų nėra teisingas
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

Gali pastebėti, kad <code>elif a <= 3</code> dalis yra tikrinama tik tada, jei <code>if</code> sakinys nėra tiesa. Galima rašyti daugiau nei vieną <code>elif</code> reiškinį, tokiu būdu leidžiant vykdyti kelis testus viename <code>if</code> sakinyje.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa parodo, kaip galima naudoti == operatorių
# naudojant numerius
print(5 == 6)
# naudojant kintamuosius
x = 5
y = 8
print(x == y)
</syntaxhighlight>

Ir išvedimas

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Žaidia spėlionių žaidimą daugiau mažiau

# Iš tiesų, čia turėtų būti naudojami pusiau atsitiktiniai skaičiai,
# pavyzdžiui paskutinis laiko skaitmuo, ar kažkas panašaus. Bet tai
# palauks iki vėlesnės dalies. (Papildoma užduotis: po Modulių dalies, pakeisk šį kodą,
# kad būtų naudojami atsitiktiniai skaičiai)
skaicius = 7
spejimas = -1

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))

if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")
</syntaxhighlight>

Pavyzdinis vykdymas:

Atspėk skaičių!
Ar tai yra... '''2'''
Skaičius yra didesnis...
Ar tai yra... '''5'''
Skaičius yra didesnis...
Ar tai yra... '''10'''
Skaičius yra ne toks didelis.
Ar tai yra... '''7'''
Valio! Atspėjai teisingai!

'''lyginis.py'''

<syntaxhighlight lang="python">
# Prašo įvesti skaičių.
# Išveda, ar skaičius yra lyginis, ar ne

skaicius = float(input("Pasakyk man skaičių: "))
if skaicius % 2 == 0:
print(int(skaicius), "yra lyginis.")
elif number % 2 == 1:
print(int(skaicius), "yra nelyginis.")
else:
print(skaicius, "yra labai keistas.")
</syntaxhighlight>

Pavyzdiniai vykdymai:

Pasakyk man skaičių: '''3'''
3 yra nelyginis.

Pasakyk man skaičių: '''2'''
2 yra lyginis.

Pasakyk man skaičių: '''3.4895'''
3.4895 yra labai keistas.

'''vidurkis1.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol įvedamas 0
# Išveda skaičių vidurkį

kiekis = 0
suma = 0.0
skaicius = 1 # nurodomas tam, kad nebūtų iškart išeinama iš ciklo.

print("Įvesk 0, kad sustabdytum ciklą")

while skaicius != 0:
skaicius = float(input("Įvesk skaičių: "))
if skaicius != 0:
kiekis = kiekis + 1
suma = suma + skaicius
if skaicius == 0:
print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''3'''
Įvesk skaičių: '''5'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 4.0

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''1'''
Įvesk skaičių: '''4'''
Įvesk skaičių: '''3'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 2.66666666667

'''vidurkis2.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol bus įvestas tam tikras kiekis skaičių
# Išveda skaičių vidurkį.

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek numerių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui sekti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Pratimai ===
Parašyk programą, kuri prašo naudotojo įvesti savo vardą. Jei jis įveda tavo vardą, išvesk "Tai puikus vardas". Jei jie įveda "Jonas Jonaitis" arba "Petras Petraitis", išvesk kokį nors juokingą tekstą. Kitu atveju, išvesk "Tavo vardas yra labai gražus".

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
vardas = input('Tavo vardas: ')
if vardas == 'Lukas':
print('Tai puikus vardas.')
elif vardas == 'Jonas Jonaitis':
print('... juokingas tekstas apie Joną.')
elif vardas == 'Petras Petraitis':
print('... juokingas tekstas apie Petrą.')
else:
print('Tavo vardas yra labai gražus.')
</syntaxhighlight>
}}

Pakeisk aukščiau esančią "daugiau_maziau.py" programą, kad ji papildomai skaičiuotų, kiek kartų naudotojas įvedė neteisingą skaičių. Jei taip nutiko daugiau, nei tris kartus, programos pabaigoje išvesk "Tai buvo sudėtinga.", o kitu atveju - "Gerai padirbėjai!"

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius = 7
spejimas = -1
kiekis = 0

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))
kiekis = kiekis + 1
if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")

if kiekis > 3:
print("Tai buvo sudėtinga.")
else:
print("Gerai padirbėjai!")
</syntaxhighlight>
}}

Parašyk programą, kuri prašo įvesti du skaičius. Jei skaičių suma yra didesnė nei 100, išvesk "Tai yra didelis skaičius".

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
skaicius1 = float(input('Pirmas skaičius: '))
skaicius2 = float(input('Antras skaičius: '))
if skaicius1 + skaicius2 > 100:
print('Skaičių suma yra didelis skaičius.')
</syntaxhighlight>
}}

{{navigation |previous=Count to 10 |next=Debugging}}

Python Vadovėlis/Pasirinkimai

2021-10-03T14:39:44Z

Monika:

=== <code>If</code> sakinys ===
Kaip visada, aš tikiu, kad turėčiau pradėti kiekvieną skyrių su apšilimo pratimu. Taigi, žemiau turime trumpą programą, kuri apskaičiuoja absolučią sveikojo skaičiaus reikšmę:
<syntaxhighlight lang="python">
n = int(input("Skaičius? "))
if n < 0:
print("Absoliuti", n, "reikšmė yra", -n)
else:
print("Absoliuti", n, "reikšmė yra", n)
</syntaxhighlight>

Štai rezultatas po dviejų programos vykdymų:

Skaičius? '''-34'''
Absoliuti -34 reikšmė yra 34

Skaičius? '''1'''
Absoliuti 1 reikšmė yra 1

Taigi, ką kompiuteris daro, kai pamato šį kodą? Visų pirma, jis kviečia įvesti skaičių su šiuo sakiniu "<code>n = int(input("Skaičius? "))</code>". Tada jis skaito eilutę "<code>if n < 0:</code>". Jei <code>n</code> yra mažiau už nulį, Python'as vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", -n)</code>". Kitu atveju, jis vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", n)</code>".

Kalbant formaliau, Python'as tikrina, ar ''reiškinys'' <code>n < 0</code> yra tiesa ar melas. Sakinys <code>if</code> yra lydimas įtraukto sakinių ''bloko'', kuris vykdomas tik jei reikškinys yra tiesa. Pasirinktinai, po <code>if</code> sakinio gali būti <code>else</code> sakinys ir dar vienas įtrauktas sakinių ''blokas''. Antrasis sakinių blokas yra vykdomas tik jei reikškinys yra melas.

Raikinys gali turėti įvairių testų. Žemiau yra visų jų lentelė:

{| class="wikitable"
!operatorius
!funkcija
|-
|<code><</code>
|mažiau nei
|-
|<code><=</code>
|mažiau nei arba lygu
|-
|<code>></code>
|daugiau nei
|-
|<code>>=</code>
|daugiau nei arba lygu
|-
|<code>==</code>
|lygu
|-
|<code>!=</code>
|nelygu
|}

Dar viena sakinio <code>if</code> ypatybė yra <code>elif</code> sakinys. Tai ''else if'' sutrumpinimas ir reiškia, kad jei originalus <code>if</code> sakinys yra melas, bet <code>elif</code> dalis yra tiesa, yra vykdoma <code>elif</code> kodo dalis. Ir jei nei <code>if</code>, nei <code>elif</code> reiškiniai nėra tiesa, tada vykdomas <code>else</code> blokas. Pavyzdžiui:
<syntaxhighlight lang="python">
a = 0
while a < 10:
a = a + 1
if a > 5:
print(a, ">", 5)
elif a <= 3:
print(a, "<=", 3)
else:
print("Nei vienas iš testų nėra teisingas")
</syntaxhighlight>

ir išvedimas:

1 <= 3
2 <= 3
3 <= 3
Nei vienas iš testų nėra teisingas
Nei vienas iš testų nėra teisingas
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

Gali pastebėti, kad <code>elif a <= 3</code> dalis yra tikrinama tik tada, jei <code>if</code> sakinys nėra tiesa. Galima rašyti daugiau nei vieną <code>elif</code> reiškinį, tokiu būdu leidžiant vykdyti kelis testus viename <code>if</code> sakinyje.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa parodo, kaip galima naudoti == operatorių
# naudojant numerius
print(5 == 6)
# naudojant kintamuosius
x = 5
y = 8
print(x == y)
</syntaxhighlight>

Ir išvedimas

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Žaidia spėlionių žaidimą daugiau mažiau

# Iš tiesų, čia turėtų būti naudojami pusiau atsitiktiniai skaičiai,
# pavyzdžiui paskutinis laiko skaitmuo, ar kažkas panašaus. Bet tai
# palauks iki vėlesnės dalies. (Papildoma užduotis: po Modulių dalies, pakeisk šį kodą,
# kad būtų naudojami atsitiktiniai skaičiai)
skaicius = 7
spejimas = -1

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))

if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")
</syntaxhighlight>

Pavyzdinis vykdymas:

Atspėk skaičių!
Ar tai yra... '''2'''
Skaičius yra didesnis...
Ar tai yra... '''5'''
Skaičius yra didesnis...
Ar tai yra... '''10'''
Skaičius yra ne toks didelis.
Ar tai yra... '''7'''
Valio! Atspėjai teisingai!

'''lyginis.py'''

<syntaxhighlight lang="python">
# Prašo įvesti skaičių.
# Išveda, ar skaičius yra lyginis, ar ne

skaicius = float(input("Pasakyk man skaičių: "))
if skaicius % 2 == 0:
print(int(skaicius), "yra lyginis.")
elif number % 2 == 1:
print(int(skaicius), "yra nelyginis.")
else:
print(skaicius, "yra labai keistas.")
</syntaxhighlight>

Pavyzdiniai vykdymai:

Pasakyk man skaičių: '''3'''
3 yra nelyginis.

Pasakyk man skaičių: '''2'''
2 yra lyginis.

Pasakyk man skaičių: '''3.4895'''
3.4895 yra labai keistas.

'''vidurkis1.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol įvedamas 0
# Išveda skaičių vidurkį

kiekis = 0
suma = 0.0
skaicius = 1 # nurodomas tam, kad nebūtų iškart išeinama iš ciklo.

print("Įvesk 0, kad sustabdytum ciklą")

while skaicius != 0:
skaicius = float(input("Įvesk skaičių: "))
if skaicius != 0:
kiekis = kiekis + 1
suma = suma + skaicius
if skaicius == 0:
print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''3'''
Įvesk skaičių: '''5'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 4.0

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''1'''
Įvesk skaičių: '''4'''
Įvesk skaičių: '''3'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 2.66666666667

'''vidurkis2.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol bus įvestas tam tikras kiekis skaičių
# Išveda skaičių vidurkį.

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek numerių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui sekti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Exercises ===
Write a program that asks the user their name, if they enter your name
say "That is a nice name", if they enter "John Cleese" or "Michael
Palin", tell them how you feel about them ;), otherwise tell them "You
have a nice name."

{{Solution|title=Solution|text=
<syntaxhighlight lang="python">
name = input('Your name: ')
if name == 'Bryn':
print('That is a nice name.')
elif name == 'John Cleese':
print('... some funny text.')
elif name == 'Michael Palin':
print('... some funny text.')
else:
print('You have a nice name.')
</syntaxhighlight>
}}

Modify the higher or lower program from this section to keep track of how many times the user has entered the wrong number. If it is more than 3 times, print "That must have been complicated." at the end, otherwise print "Good job!"

{{Solution|title=Solution|text=
<syntaxhighlight lang="python">
number = 7
guess = -1
count = 0

print("Guess the number!")
while guess != number:
guess = int(input("Is it... "))
count = count + 1
if guess == number:
print("Hooray! You guessed it right!")
elif guess < number:
print("It's bigger...")
elif guess > number:
print("It's not so big.")

if count > 3:
print("That must have been complicated.")
else:
print("Good job!")
</syntaxhighlight>
}}

Write a program that asks for two numbers. If the sum of the numbers
is greater than 100, print "That is a big number."

{{Solution|title=Solution|text=
<syntaxhighlight lang="python">
number1 = float(input('1st number: '))
number2 = float(input('2nd number: '))
if number1 + number2 > 100:
print('That is a big number.')
</syntaxhighlight>
}}

{{navigation |previous=Count to 10 |next=Debugging}}

Python Vadovėlis/Pasirinkimai

2021-10-03T14:38:55Z

Monika: Išversti pavyzdžiai

=== <code>If</code> sakinys ===
Kaip visada, aš tikiu, kad turėčiau pradėti kiekvieną skyrių su apšilimo pratimu. Taigi, žemiau turime trumpą programą, kuri apskaičiuoja absolučią sveikojo skaičiaus reikšmę:
<syntaxhighlight lang="python">
n = int(input("Skaičius? "))
if n < 0:
print("Absoliuti", n, "reikšmė yra", -n)
else:
print("Absoliuti", n, "reikšmė yra", n)
</syntaxhighlight>

Štai rezultatas po dviejų programos vykdymų:

Skaičius? '''-34'''
Absoliuti -34 reikšmė yra 34

Skaičius? '''1'''
Absoliuti 1 reikšmė yra 1

Taigi, ką kompiuteris daro, kai pamato šį kodą? Visų pirma, jis kviečia įvesti skaičių su šiuo sakiniu "<code>n = int(input("Skaičius? "))</code>". Tada jis skaito eilutę "<code>if n < 0:</code>". Jei <code>n</code> yra mažiau už nulį, Python'as vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", -n)</code>". Kitu atveju, jis vykdo eilutę "<code>print("Absoliuti", n, "reikšmė yra", n)</code>".

Kalbant formaliau, Python'as tikrina, ar ''reiškinys'' <code>n < 0</code> yra tiesa ar melas. Sakinys <code>if</code> yra lydimas įtraukto sakinių ''bloko'', kuris vykdomas tik jei reikškinys yra tiesa. Pasirinktinai, po <code>if</code> sakinio gali būti <code>else</code> sakinys ir dar vienas įtrauktas sakinių ''blokas''. Antrasis sakinių blokas yra vykdomas tik jei reikškinys yra melas.

Raikinys gali turėti įvairių testų. Žemiau yra visų jų lentelė:

{| class="wikitable"
!operatorius
!funkcija
|-
|<code><</code>
|mažiau nei
|-
|<code><=</code>
|mažiau nei arba lygu
|-
|<code>></code>
|daugiau nei
|-
|<code>>=</code>
|daugiau nei arba lygu
|-
|<code>==</code>
|lygu
|-
|<code>!=</code>
|nelygu
|}

Dar viena sakinio <code>if</code> ypatybė yra <code>elif</code> sakinys. Tai ''else if'' sutrumpinimas ir reiškia, kad jei originalus <code>if</code> sakinys yra melas, bet <code>elif</code> dalis yra tiesa, yra vykdoma <code>elif</code> kodo dalis. Ir jei nei <code>if</code>, nei <code>elif</code> reiškiniai nėra tiesa, tada vykdomas <code>else</code> blokas. Pavyzdžiui:
<syntaxhighlight lang="python">
a = 0
while a < 10:
a = a + 1
if a > 5:
print(a, ">", 5)
elif a <= 3:
print(a, "<=", 3)
else:
print("Nei vienas iš testų nėra teisingas")
</syntaxhighlight>

ir išvedimas:

1 <= 3
2 <= 3
3 <= 3
Nei vienas iš testų nėra teisingas
Nei vienas iš testų nėra teisingas
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

Gali pastebėti, kad <code>elif a <= 3</code> dalis yra tikrinama tik tada, jei <code>if</code> sakinys nėra tiesa. Galima rašyti daugiau nei vieną <code>elif</code> reiškinį, tokiu būdu leidžiant vykdyti kelis testus viename <code>if</code> sakinyje.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa parodo, kaip galima naudoti == operatorių
# naudojant numerius
print(5 == 6)
# naudojant kintamuosius
x = 5
y = 8
print(x == y)
</syntaxhighlight>

Ir išvedimas

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Žaidia spėlionių žaidimą daugiau mažiau

# Iš tiesų, čia turėtų būti naudojami pusiau atsitiktiniai skaičiai,
# pavyzdžiui paskutinis laiko skaitmuo, ar kažkas panašaus. Bet tai
# palauks iki vėlesnės dalies. (Papildoma užduotis: po Modulių dalies, pakeisk šį kodą,
# kad būtų naudojami atsitiktiniai skaičiai)
skaicius = 7
spejimas = -1

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))

if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")
</syntaxhighlight>

Pavyzdinis vykdymas:

Atspėk skaičių!
Ar tai yra... '''2'''
Skaičius yra didesnis...
Ar tai yra... '''5'''
Skaičius yra didesnis...
Ar tai yra... '''10'''
Skaičius yra ne toks didelis.
Ar tai yra... '''7'''
Valio! Atspėjai teisingai!

'''lyginis.py'''

<syntaxhighlight lang="python">
# Prašo įvesti skaičių.
# Išveda, ar skaičius yra lyginis, ar ne

skaicius = float(input("Pasakyk man skaičių: "))
if skaicius % 2 == 0:
print(int(skaicius), "yra lyginis.")
elif number % 2 == 1:
print(int(skaicius), "yra nelyginis.")
else:
print(skaicius, "yra labai keistas.")
</syntaxhighlight>

Pavyzdiniai vykdymai:

Pasakyk man skaičių: '''3'''
3 yra nelyginis.

Pasakyk man skaičių: '''2'''
2 yra lyginis.

Pasakyk man skaičių: '''3.4895'''
3.4895 yra labai keistas.

'''vidurkis1.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol įvedamas 0
# Išveda skaičių vidurkį

kiekis = 0
suma = 0.0
skaicius = 1 # nurodomas tam, kad nebūtų iškart išeinama iš ciklo.

print("Įvesk 0, kad sustabdytum ciklą")

while skaicius != 0:
skaicius = float(input("Įvesk skaičių: "))
if skaicius != 0:
kiekis = kiekis + 1
suma = suma + skaicius
if skaicius == 0:
print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''3'''
Įvesk skaičių: '''5'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 4.0

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''1'''
Įvesk skaičių: '''4'''
Įvesk skaičių: '''3'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 2.66666666667

'''vidurkis2.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol bus įvestas tam tikras kiekis skaičių
# Išveda skaičių vidurkį.

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek numerių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui sekti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Sample runs:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Exercises ===
Write a program that asks the user their name, if they enter your name
say "That is a nice name", if they enter "John Cleese" or "Michael
Palin", tell them how you feel about them ;), otherwise tell them "You
have a nice name."

{{Solution|title=Solution|text=
<syntaxhighlight lang="python">
name = input('Your name: ')
if name == 'Bryn':
print('That is a nice name.')
elif name == 'John Cleese':
print('... some funny text.')
elif name == 'Michael Palin':
print('... some funny text.')
else:
print('You have a nice name.')
</syntaxhighlight>
}}

Modify the higher or lower program from this section to keep track of how many times the user has entered the wrong number. If it is more than 3 times, print "That must have been complicated." at the end, otherwise print "Good job!"

{{Solution|title=Solution|text=
<syntaxhighlight lang="python">
number = 7
guess = -1
count = 0

print("Guess the number!")
while guess != number:
guess = int(input("Is it... "))
count = count + 1
if guess == number:
print("Hooray! You guessed it right!")
elif guess < number:
print("It's bigger...")
elif guess > number:
print("It's not so big.")

if count > 3:
print("That must have been complicated.")
else:
print("Good job!")
</syntaxhighlight>
}}

Write a program that asks for two numbers. If the sum of the numbers
is greater than 100, print "That is a big number."

{{Solution|title=Solution|text=
<syntaxhighlight lang="python">
number1 = float(input('1st number: '))
number2 = float(input('2nd number: '))
if number1 + number2 > 100:
print('That is a big number.')
</syntaxhighlight>
}}

{{navigation |previous=Count to 10 |next=Debugging}}