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

Python Vadovėlis/Sąrašai

2022-07-20T07:32:32Z

LauraK: /* Sąrašų rūšiavimas */

{{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žnai 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 >

Programos 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/Sąrašai

2022-07-20T07:30:15Z

LauraK: /* Sąrašų rūšiavimas */

{{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žnai 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/Sąrašai

2022-07-20T07:06:30Z

LauraK: /* Sąrašų rūšiavimas */

{{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žnai 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/Loginiai reiškiniai

2022-04-07T11:37:09Z

LauraK:

{{navigation |previous=Ciklai For |next=Žodynai}}
Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina:
<syntaxhighlight lang="python">
a = 6
b = 7
c = 42
print(1, a == 6)
print(2, a == 7)
print(3, a == 6 and b == 7)
print(4, a == 7 and b == 7)
print(5, not a == 7 and b == 7)
print(6, a == 7 or b == 7)
print(7, a == 7 or b == 6)
print(8, not (a == 7 and b == 6))
print(9, not a == 7 and b == 6)
</syntaxhighlight>

Šios programos išvestis yra:

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

Galvoje, turbūt, jau sukasi mintis: kas čia ką tik įvyko? Paaiškinsiu, kaip veikia kiekviena eilutė, kad mintys susidėliotų į savas vietas. Mano programoje gausu <code>print</code> sakinių, iš kurių kiekvienas išspausdina skaičių ir loginę reikšmę. Skaičius man padeda suprasti, kurio <code>print</code> sakinio rezultatas tai yra. Atkreipk dėmesį, kad kiekvienoje išvesties eilutėje yra žodis <code>False</code> (Klaidinga) arba <code>True</code> (Teisinga), o Python'e kiekviena loginė reikšmė <code>False</code> gali būti užrašoma skaičiumi 0, o <code>True</code> 1.

















Eilučių:

<syntaxhighlight lang="python">
print(1, a == 6)
print(2, a == 7)
</syntaxhighlight>

rezultatas atitinkamai yra <code>True</code> ir <code>False</code>, kadangi pirmasis reiškinys yra teisingas, o antrasis yra klaidingas. Trečioji eilutė: <code>print(3, a == 6 and b == 7)</code> - šiek tiek skiriasi nuo prieš tai buvusių - joje yra naudojamas operatorius <code>and</code>. Loginis operatorius <code>and</code> grąžina rezultatą <code>True</code> tik tada, kai reiškiniai iš abiejų <code>and</code> pusių yra teisingi, kitu atveju visas reiškinys bus klaidingas ir grąžins <code>False</code>. Ketvirtoje eilutėje: print(4, a == 7 and b == 7) tik vienas iš reiškinių yra teisingas, dėl to eilutės rezultatas yra <code>False</code>. Operatoriaus <code>and</code> galimi rezultatai gali būti apibrėžti tokia lentele:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>and</code> True
|True
|-
|True <code>and</code> False
|False
|-
|False <code>and</code> True
|False
|-
|False <code>and</code> False
|False
|}

Atkreipk dėmesį, jei pirmas reiškinys yra klaidingas, tai Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys yra klaidingas. Parašyk šias eilutes ir paleisk programą: <code>False and print("Labas")</code> ir palygink rezultatą su šios eilutės <code>True and print("Labas")</code> rezultatu. Techniškai tai yra vadinama sutrumpintos grandies įvertinimas (short-circuit evaluation).
Penktoje eilutėje, <code>print(5, not a == 7 and b == 7)</code>, yra naudojamas <code>not</code> operatorius. <code>not</code> suteikia priešingą reikšmę reiškiniui (reiškinys taip pat galėtų būti užrašomas taip: <code> print(5, a != 7 and b == 7)</code>). Štai lentelė apibrėžianti operatoriaus <code>not</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|<code>not</code> True
|False
|-
|<code>not</code> False
|True
|}

Dvi toliau pateiktos eilutės: <code>print(6, a == 7 or b == 7)</code> ir <code>print(7, a == 7 or b == 6)</code> naudoja operatorių <code>or</code>. Pastarasis operatorius grąžina <code>True</code> jei pirmasis reiškinys yra teisingas arba, jei antrasis reiškinys yra teisingas, arba, jei abu reiškiniai yra teisingi. Jei nei vienas iš reiškinių nėra teisingas, tuomet yra grąžinamas False. Štai lentelė apibrėžianti operatoriaus <code>or</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>or</code> True
| True
|-
|True <code>or</code> False
|True
|-
|False <code>or</code> True
|True
|-
|False <code>or</code> False
| False
|}

Turėk omeny, jei pirmasis reiškinys yra teisingas Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys bus teisingas. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code>, jei bent vienas iš reiškinių yra teisingas, tuomet viso reiškinio galutinis rezultatas bus teisingas. Pirmoji dalis yra teisinga, todėl antroji dalis gali būti klaidinga arba teisinga, tačiau visa išraiška vis dar teisinga.

Aštuntoje: <code>print(8, not (a == 7 and b == 6))</code> ir devintoje: <code>print(9, not a == 7 and b == 6)</code> eilutėse yra atvaizduojamas reiškinių grupavimo pavyzdys. Reiškinius Python’e galima sugrupuoti naudojant skliaustelius. Sugrupavę reiškinius, mes priverčiame Python’ą iš pradžių įvertinti reiškinius skliaustuose ir tik tada likusias reiškinio dalis. Atkreipk dėmesį, kad skliausteliai pakeitė reiškinį iš neteisingo į teisingą. Taip nutiko dėl to, kad operatorius <code>not</code> buvo pritaikytas reiškiniui skliausteliuose, vietoj to, kad būtų pritaikytas tik <code>a == 7</code> daliai.
Parodysiu pavyzdį, kaip rašant kodą galima pritaikyti loginius operatorius:

<syntaxhighlight lang="python">
sąrašas = ["Gyvenimas", "Visata", "Viskas", "Benas", "Liepa", "Gyvenimas", "Liepa"]

# kuriama sąrašo kopija. Peržiūrėk skyrių Daugiau apie sąrašus, kuriame sužinosi ką reiškia [:].
kopija = sąrašas[:]
# surūšiuoti sąrašą
kopija.sort()
ankstesnis = kopija[0]
del kopija[0]

kiekis = 0

# sąraše surask vienodus elementus
while kiekis < len(kopija) and kopija[kiekis] != ankstesnis:
ankstesnis = kopija[kiekis]
kiekis = kiekis + 1

# Jei nėra atitikmens tuomet kiekis negali būti < len
# kadangi ciklas kol bus vykdomas tol, kol kiekis < len
# ir nėra rastas atitikmuo

if kiekis < len(kopija):
print("Pirmasis atitikmuo:", ankstesnis)
</syntaxhighlight>

Šios programos rezultatas:
Pirmasis atitikmuo: Gyvenimas

Programa ieško vienodų elementų, tikrindama šią sąlygą: <code> while kiekis < len(kopija) and kopija[kiekis] nėra lygus ankstesnis </code>. Kai <code>kiekis</code> yra didesnis už paskutinio <code>kopija</code> sąrašo elemento indeksą arba, kai atsiranda sutampantis elementas, operatorius <code>and</code> nebėra tiesa, todėl ciklas pasibaigia. <code>if</code> sakinys patikrina ar ciklas <code>while</code> pasibaigė dėl to, kad buvo rastas sutampantis elementas.

Šioje programoje yra panaudotas dar vienas <code>and</code> operatoriaus „triukas“. Jei dar kartą pažiūrėsi į operatoriaus <code>and</code> lentelę pamatysi, jog trečioje eilutėje yra netiesa ir netiesa. Jei <code>kiekis >= len(kopija)</code> (kitais žodžiais, jei <code>kiekis < len(kopija)</code> yra <code>False</code>), tada kodo dalis <code>kopija[kiekis]</code> nebus tikrinama. Taip yra todėl, kad Python’as žino, jei pirmasis teiginys yra klaidingas, tai abu jie nebegali būti teisingi. Šis „short circuit“ triukas yra naudingas tuomet, kai antrasis <code>and</code> operatoriaus reiškinys gali sukelti klaidą. Aš panaudojau pirmąjį reiškinį (<code>kiekis < len(kopija)</code>), kad patikrinčiau ar kintamasis <code>kiekis</code> yra validus sąrašo <code>kopija</code> indeksas. Jei manimi netiki, tuomet ištrink iš sąrašo elementus „Liepa“ ir „Gyvenimas“, sukeisk vietomis sąlygas <code>kiekis < len(kopija) and kopija[kiekis] != ankstesnis</code> (rašyk: <code>kopija[kiekis] != ankstesnis and kiekis < len(kopija)</code>) ir patikrink ar programa vis dar veikia, kaip turėtų.

Loginiai operatoriai gali būti naudojami, kai mes norime patikrinti dvi arba daugiau skirtingų sąlygų vienu metu.

=== Pastaba apie loginius operatorius ===
Dažna pradedančiųjų programuotojų klaida yra neteisingas supratimas, kaip veikia loginiai operatoriai ir kaip juos „skaito“ Python'o interpretatorius. Pavyzdžiui: vos tik sužinojus apie operatorius <code>and</code> ir <code>or</code>, galima pagalvoti, kad išraiška <code>x == ('a' or 'b')</code> patikrins, ar kintamasis <code>x</code> yra lygus <code>a</code> arba kintamasis <code>x</code> lygus <code>b</code>, tačiau taip nėra. Norint suprasti, apie ką kalbu, pradėk interaktyvią sesiją su interpretatoriumi ir įvesk šias išraiškas:

>>> 'a' == ('a' or 'b')
>>> 'b' == ('a' or 'b')
>>> 'a' == ('a' and 'b')
>>> 'b' == ('a' and 'b')

Štai yra rezultatai, kurie nėra intuityvūs:

>>>''' 'a' == ('a' or 'b')'''
True
>>>''' 'b' == ('a' or 'b')'''
False
>>>''' 'a' == ('a' and 'b')'''
False
>>>''' 'b' == ('a' and 'b')'''
True

Šiuo momentu gali pasirodyti, jog operatoriai <code>and</code> ir <code>or</code> veikia klaidingai. Neatrodo logiška, jog pirmuose reiškiniuose <code>'a'</code> yra lygu <code>'a'</code> arba <code>'b'</code>, tačiau <code>'b'</code> nėra lygu <code>'a'</code> arba <code>'b'</code>. Taip pat yra ir su paskutiniu reiškiniu - jis neatrodo teisingas, nes <code>'b'</code> yra lygus <code>'a'</code> ir <code>'b'</code>. Išsiaiškinus, kaip veikia Python’o interpretatorius pasidaro aišku, kodėl gavome būtent tokius rezultatus.

Kai Python’o interpretatorius „pamato“ reiškinį, kuriame yra naudojamas <code>or</code>, jis paima pirmąjį teiginį ir patikrina ar jo rezultatas yra <code>True</code>. Jei pirmasis teiginys yra <code>True</code>, tuomet Python’as grąžina to teiginio rezultatą, netikrindamas antrojo. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code> užtenka patikrinti ar pirmasis teiginys yra teisingas, nes tada mes jau žinome, kad visas reiškinys yra teisingas ir programai nebereikia papildomai tikrinti antrojo. Iš kitos pusės, jei pirmasis teiginys grąžina <code>False</code>, tada Python’as turi patikrinti ir antrojo teiginio rezultatą bei grąžinti jo reikšmę. Antrasis teiginys nusako visos išraiškos rezultatą, kadangi pirmoji pusė buvo klaidinga. Šis interpretatoriaus „tingus“ įvertinimas vadinamas "short circuiting" ir yra įprastas būdas įvertinti logines išraiškas daugelyje programavimo kalbų.

Panašiai veikia ir operatorius <code>and</code>: Python’as naudoja, "short circuit" techniką, kad pagreitintų išraiškos įvertinimą. Jei pirmasis teiginys yra klaidingas, tada visas reiškinys yra klaidingas. Kitu atveju, jei pirmasis teiginys yra teisingas, tada Python’as patikrina antrąjį ir grąžina galutinę reikšmę.

Reiktų atkreiptį dėmesį į vieną niuansą: ne tik loginių išraiškų rezultatai gali būti apibrėžiami <code>True</code> arba <code>False</code> reikšmėmis. Norėdami patikrinti bet kurio objekto <code>x</code> loginę reikšmę, galite naudoti funkciją <code>bool(x)</code>. Žemiau yra pateikiama lentelė, kurioje yra pavyzdžiai, kokiems objektams Python’as priskiria <code>True</code> arba <code>False</code>:

{| class="wikitable"
|-
!True !!False
|-
|True ||False
|-
|1 ||0
|-
|Skaičiai kitokie nei nulis ||Tekstinė eilutė 'None'
|-
|Ne tuščios tekstinės eilutės ||Tuščios tekstinės eilutės
|-
|Sąrašai (lists) turintys elementų ||Sąrašai (lists) neturintys elementų
|-
|Žodynai (dictionaries) turintys elementų ||Žodynai (dictionaries) neturintys elementų
|}

Dabar galime suprasti gluminančius rezultatus, kuriuos gavome, kai anksčiau išbandėme logines išraiškas. Pažiūrėkime, ką Python'o interpretatorius „mato“, eidamas per šį kodą:

'''Pirmasis atvejis:'''
>>>''' 'a' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'a' == 'a' ''' # teksto eilutė 'a' yra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra True
True

'''Antrasis atvejis:'''
>>>''' 'b' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'b' == 'a' ''' # teksto eilutė 'b' nėra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra False
False

'''Trečiasis atvejis:'''
>>>''' 'a' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' and 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'a' == 'b' ''' # teksto eilutė 'a' nėra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra False
False

'''Ketvirtasis atvejis:'''
>>>''' 'b' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose:
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'b' == 'b' ''' # teksto eilutė 'b' yra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra True
True

Taigi, Python’as tikrai teisingai įvertino duotuosius reiškinius, kurių rezultatai iš pradžių neatrodė akivaizdūs. Kaip minėjau anksčiau, svarbu atpažinti, kokį rezultatą tavo loginė išraiška grąžins ir kodėl.

Grįžtant prie pradinių reiškinių, štai kaip juos turėtum aprašyti, kad jie grąžintų reikšmes, kurių tikiesi:

>>>''' 'a' == 'a' or 'a' == 'b' '''
True
>>>''' 'b' == 'a' or 'b' == 'b' '''
True
>>>''' 'a' == 'a' and 'a' == 'b' '''
False
>>>''' 'b' == 'a' and 'b' == 'b' '''
False

Įvertinus šiuos reiškinius yra gaunamos logines reikšmes <code>True</code> arba <code>False</code>, o ne teksto eilutės, kad galėtume gauti teisingus palyginimo rezultatus.

=== Pavyzdžiai ===
'''slaptazodis1.py'''
<syntaxhighlight lang="python">
## Ši programa prašo vartotojo prisijungimo vardo ir slaptažodžio.
# Kai vartotojas juos įveda, programa įvertina ar jis gali prisijungti.

vardas = input("Koks tavo vardas? ")
slaptažodis = input("Koks tavo slaptažodis? ")
if vardas == "Benas" and slaptažodis == "Penktadienis":
print("Sveikas, Benai!")
elif vardas == "Jonas" and slaptažodis == "Kietas":
print("Sveikas, Jonai!")
else:
print("Aš tavęs nepažįstu.")
</syntaxhighlight>

Pavyzdiniai rezultatai:

Koks tavo vardas? '''Benas'''

Koks tavo slaptažodis? '''Penktadienis'''

Sveikas, Benai!

Koks tavo vardas? '''Andrius'''

Koks tavo slaptažodis? '''Pinigai'''

Aš tavęs nepažįstu.

=== Užduotys ===
Parašyk programą, kurioje vartotojas turi atspėti tavo vardą, tačiau jie turės tik 3 spėjimus tai padaryti iki kol programa bus uždaryta.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
print("Pabandyk atspėti mano vardą!")
kiekis = 1
vardas = "gilbertas"
spėjimas = input("Koks mano vardas? ")
while kiekis < 3 and spėjimas.lower() != vardas: # .lower visas didžiąsias raides teksto eilutėje pakeičia į mažąsias, todėl net jei vartotojas įves Gilbertas, tai vis tiek bus teisingas atsakymas
print("Tu neteisus!")
spėjimas = input("Koks mano vardas? ")
kiekis = kiekis + 1

if spėjimas.lower() != vardas:
print("Tu neteisus!") # ši žinutė nėra atspausdinama trečiąjį bandymą, todėl mes tai padarome dabar
print("Tu nebegali spėti.")
else:
print("Taip! Mano vardas yra", vardas + "!")

</syntaxhighlight>
|-
|}

{{navigation |previous=Ciklai For |next=Žodynai}}
{{BookCat}}

Python Vadovėlis/Loginiai reiškiniai

2022-04-07T06:06:18Z

LauraK:

{{navigation |previous=Ciklai For |next=Žodynai}}
Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina:
<syntaxhighlight lang="python">
a = 6
b = 7
c = 42
print(1, a == 6)
print(2, a == 7)
print(3, a == 6 and b == 7)
print(4, a == 7 and b == 7)
print(5, not a == 7 and b == 7)
print(6, a == 7 or b == 7)
print(7, a == 7 or b == 6)
print(8, not (a == 7 and b == 6))
print(9, not a == 7 and b == 6)
</syntaxhighlight>

Šios programos išvestis yra:

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

Galvoje, turbūt, jau sukasi mintis: kas čia ką tik įvyko? Paaiškinsiu, kaip veikia kiekviena eilutė, kad mintys susidėliotų į savas vietas. Mano programoje gausu <code>print</code> sakinių, iš kurių kiekvienas išspausdina skaičių ir loginę reikšmę. Skaičius man padeda suprasti, kurio <code>print</code> sakinio rezultatas tai yra. Atkreipk dėmesį, kad kiekvienoje išvesties eilutėje yra žodis <code>False</code> (Klaidinga) arba <code>True</code> (Teisinga), o Python'e kiekviena loginė reikšmė <code>False</code> gali būti užrašoma skaičiumi 0, o <code>True</code> 1.

















Eilučių:

<syntaxhighlight lang="python">
print(1, a == 6)
print(2, a == 7)
</syntaxhighlight>

rezultatas atitinkamai yra <code>True</code> ir <code>False</code>, kadangi pirmasis reiškinys yra teisingas, o antrasis yra klaidingas. Trečioji eilutė: <code>print(3, a == 6 and b == 7)</code> - šiek tiek skiriasi nuo prieš tai buvusių - joje yra naudojamas operatorius <code>and</code>. Loginis operatorius <code>and</code> grąžina rezultatą <code>True</code> tik tada, kai reiškiniai iš abiejų <code>and</code> pusių yra teisingi, kitu atveju visas reiškinys bus klaidingas ir grąžins <code>False</code>. Ketvirtoje eilutėje: print(4, a == 7 and b == 7) tik vienas iš reiškinių yra teisingas, dėl to eilutės rezultatas yra <code>False</code>. Operatoriaus <code>and</code> galimi rezultatai gali būti apibrėžti tokia lentele:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>and</code> True
|True
|-
|True <code>and</code> False
|False
|-
|False <code>and</code> True
|False
|-
|False <code>and</code> False
|False
|}

Atkreipk dėmesį, jei pirmas reiškinys yra klaidingas, tai Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys yra klaidingas. Parašyk šias eilutes ir paleisk programą: <code>False and print("Labas")</code> ir palygink rezultatą su šios eilutės <code>True and print("Labas")</code> rezultatu. Techniškai tai yra vadinama [[w:Short-circuit evaluation|short-circuit evaluation]].
Penktoje eilutėje, <code>print(5, not a == 7 and b == 7)</code>, yra naudojamas <code>not</code> operatorius. <code>not</code> suteikia priešingą reikšmę reiškiniui (reiškinys taip pat galėtų būti užrašomas taip: <code> print(5, a != 7 and b == 7)</code>). Štai lentelė apibrėžianti operatoriaus <code>not</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|<code>not</code> True
|False
|-
|<code>not</code> False
|True
|}

Dvi toliau pateiktos eilutės: <code>print(6, a == 7 or b == 7)</code> ir <code>print(7, a == 7 or b == 6)</code> naudoja operatorių <code>or</code>. Pastarasis operatorius grąžina <code>True</code> jei pirmasis reiškinys yra teisingas arba, jei antrasis reiškinys yra teisingas, arba, jei abu reiškiniai yra teisingi. Jei nei vienas iš reiškinių nėra teisingas, tuomet yra grąžinamas False. Štai lentelė apibrėžianti operatoriaus <code>or</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>or</code> True
| True
|-
|True <code>or</code> False
|True
|-
|False <code>or</code> True
|True
|-
|False <code>or</code> False
| False
|}

Turėk omeny, jei pirmasis reiškinys yra teisingas Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys bus teisingas. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code>, jei bent vienas iš reiškinių yra teisingas, tuomet viso reiškinio galutinis rezultatas bus teisingas. Pirmoji dalis yra teisinga, todėl antroji dalis gali būti klaidinga arba teisinga, tačiau visa išraiška vis dar teisinga.

Aštuntoje: <code>print(8, not (a == 7 and b == 6))</code> ir devintoje: <code>print(9, not a == 7 and b == 6)</code> eilutėse yra atvaizduojamas reiškinių grupavimo pavyzdys. Reiškinius Python’e galima sugrupuoti naudojant skliaustelius. Sugrupavę reiškinius, mes priverčiame Python’ą iš pradžių įvertinti reiškinius skliaustuose ir tik tada likusias reiškinio dalis. Atkreipk dėmesį, kad skliausteliai pakeitė reiškinį iš neteisingo į teisingą. Taip nutiko dėl to, kad operatorius <code>not</code> buvo pritaikytas reiškiniui skliausteliuose, vietoj to, kad būtų pritaikytas tik <code>a == 7</code> daliai.
Parodysiu pavyzdį, kaip rašant kodą galima pritaikyti loginius operatorius:

<syntaxhighlight lang="python">
sąrašas = ["Gyvenimas", "Visata", "Viskas", "Benas", "Liepa", "Gyvenimas", "Liepa"]

# kuriama sąrašo kopija. Peržiūrėk skyrių Daugiau apie sąrašus, kuriame sužinosi ką reiškia [:].
kopija = sąrašas[:]
# surūšiuoti sąrašą
kopija.sort()
ankstesnis = kopija[0]
del kopija[0]

kiekis = 0

# sąraše surask vienodus elementus
while kiekis < len(kopija) and kopija[kiekis] != ankstesnis:
ankstesnis = kopija[kiekis]
kiekis = kiekis + 1

# Jei nėra atitikmens tuomet kiekis negali būti < len
# kadangi ciklas kol bus vykdomas tol, kol kiekis < len
# ir nėra rastas atitikmuo

if kiekis < len(kopija):
print("Pirmasis atitikmuo:", ankstesnis)
</syntaxhighlight>

Šios programos rezultatas:
Pirmasis atitikmuo: Gyvenimas

Programa ieško vienodų elementų, tikrindama šią sąlygą: <code> while kiekis < len(kopija) and kopija[kiekis] nėra lygus ankstesnis </code>. Kai <code>kiekis</code> yra didesnis už paskutinio <code>kopija</code> sąrašo elemento indeksą arba, kai atsiranda sutampantis elementas, operatorius <code>and</code> nebėra tiesa, todėl ciklas pasibaigia. <code>if</code> sakinys patikrina ar ciklas <code>while</code> pasibaigė dėl to, kad buvo rastas sutampantis elementas.

Šioje programoje yra panaudotas dar vienas <code>and</code> operatoriaus „triukas“. Jei dar kartą pažiūrėsi į operatoriaus <code>and</code> lentelę pamatysi, jog trečioje eilutėje yra netiesa ir netiesa. Jei <code>kiekis >= len(kopija)</code> (kitais žodžiais, jei <code>kiekis < len(kopija)</code> yra <code>False</code>), tada kodo dalis <code>kopija[kiekis]</code> nebus tikrinama. Taip yra todėl, kad Python’as žino, jei pirmasis teiginys yra klaidingas, tai abu jie nebegali būti teisingi. Šis „short circuit“ triukas yra naudingas tuomet, kai antrasis <code>and</code> operatoriaus reiškinys gali sukelti klaidą. Aš panaudojau pirmąjį reiškinį (<code>kiekis < len(kopija)</code>), kad patikrinčiau ar kintamasis <code>kiekis</code> yra validus sąrašo <code>kopija</code> indeksas. Jei manimi netiki, tuomet ištrink iš sąrašo elementus „Liepa“ ir „Gyvenimas“, sukeisk vietomis sąlygas <code>kiekis < len(kopija) and kopija[kiekis] != ankstesnis</code> (rašyk: <code>kopija[kiekis] != ankstesnis and kiekis < len(kopija)</code>) ir patikrink ar programa vis dar veikia, kaip turėtų.

Loginiai operatoriai gali būti naudojami, kai mes norime patikrinti dvi arba daugiau skirtingų sąlygų vienu metu.

=== Pastaba apie loginius operatorius ===
Dažna pradedančiųjų programuotojų klaida yra neteisingas supratimas, kaip veikia loginiai operatoriai ir kaip juos „skaito“ Python'o interpretatorius. Pavyzdžiui: vos tik sužinojus apie operatorius <code>and</code> ir <code>or</code>, galima pagalvoti, kad išraiška <code>x == ('a' or 'b')</code> patikrins, ar kintamasis <code>x</code> yra lygus <code>a</code> arba kintamasis <code>x</code> lygus <code>b</code>, tačiau taip nėra. Norint suprasti, apie ką kalbu, pradėk interaktyvią sesiją su interpretatoriumi ir įvesk šias išraiškas:

>>> 'a' == ('a' or 'b')
>>> 'b' == ('a' or 'b')
>>> 'a' == ('a' and 'b')
>>> 'b' == ('a' and 'b')

Štai yra rezultatai, kurie nėra intuityvūs:

>>>''' 'a' == ('a' or 'b')'''
True
>>>''' 'b' == ('a' or 'b')'''
False
>>>''' 'a' == ('a' and 'b')'''
False
>>>''' 'b' == ('a' and 'b')'''
True

Šiuo momentu gali pasirodyti, jog operatoriai <code>and</code> ir <code>or</code> veikia klaidingai. Neatrodo logiška, jog pirmuose reiškiniuose <code>'a'</code> yra lygu <code>'a'</code> arba <code>'b'</code>, tačiau <code>'b'</code> nėra lygu <code>'a'</code> arba <code>'b'</code>. Taip pat yra ir su paskutiniu reiškiniu - jis neatrodo teisingas, nes <code>'b'</code> yra lygus <code>'a'</code> ir <code>'b'</code>. Išsiaiškinus, kaip veikia Python’o interpretatorius pasidaro aišku, kodėl gavome būtent tokius rezultatus.

Kai Python’o interpretatorius „pamato“ reiškinį, kuriame yra naudojamas <code>or</code>, jis paima pirmąjį teiginį ir patikrina ar jo rezultatas yra <code>True</code>. Jei pirmasis teiginys yra <code>True</code>, tuomet Python’as grąžina to teiginio rezultatą, netikrindamas antrojo. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code> užtenka patikrinti ar pirmasis teiginys yra teisingas, nes tada mes jau žinome, kad visas reiškinys yra teisingas ir programai nebereikia papildomai tikrinti antrojo. Iš kitos pusės, jei pirmasis teiginys grąžina <code>False</code>, tada Python’as turi patikrinti ir antrojo teiginio rezultatą bei grąžinti jo reikšmę. Antrasis teiginys nusako visos išraiškos rezultatą, kadangi pirmoji pusė buvo klaidinga. Šis interpretatoriaus „tingus“ įvertinimas vadinamas "short circuiting" ir yra įprastas būdas įvertinti logines išraiškas daugelyje programavimo kalbų.

Panašiai veikia ir operatorius <code>and</code>: Python’as naudoja, "short circuit" techniką, kad pagreitintų išraiškos įvertinimą. Jei pirmasis teiginys yra klaidingas, tada visas reiškinys yra klaidingas. Kitu atveju, jei pirmasis teiginys yra teisingas, tada Python’as patikrina antrąjį ir grąžina galutinę reikšmę.

Reiktų atkreiptį dėmesį į vieną niuansą: ne tik loginių išraiškų rezultatai gali būti apibrėžiami <code>True</code> arba <code>False</code> reikšmėmis. Norėdami patikrinti bet kurio objekto <code>x</code> loginę reikšmę, galite naudoti funkciją <code>bool(x)</code>. Žemiau yra pateikiama lentelė, kurioje yra pavyzdžiai, kokiems objektams Python’as priskiria <code>True</code> arba <code>False</code>:

{| class="wikitable"
|-
!True !!False
|-
|True ||False
|-
|1 ||0
|-
|Skaičiai kitokie nei nulis ||Tekstinė eilutė 'None'
|-
|Ne tuščios tekstinės eilutės ||Tuščios tekstinės eilutės
|-
|Sąrašai (lists) turintys elementų ||Sąrašai (lists) neturintys elementų
|-
|Žodynai (dictionaries) turintys elementų ||Žodynai (dictionaries) neturintys elementų
|}

Dabar galime suprasti gluminančius rezultatus, kuriuos gavome, kai anksčiau išbandėme logines išraiškas. Pažiūrėkime, ką Python'o interpretatorius „mato“, eidamas per šį kodą:

'''Pirmasis atvejis:'''
>>>''' 'a' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'a' == 'a' ''' # teksto eilutė 'a' yra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra True
True

'''Antrasis atvejis:'''
>>>''' 'b' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'b' == 'a' ''' # teksto eilutė 'b' nėra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra False
False

'''Trečiasis atvejis:'''
>>>''' 'a' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' and 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'a' == 'b' ''' # teksto eilutė 'a' nėra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra False
False

'''Ketvirtasis atvejis:'''
>>>''' 'b' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose:
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'b' == 'b' ''' # teksto eilutė 'b' yra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra True
True

Taigi, Python’as tikrai teisingai įvertino duotuosius reiškinius, kurių rezultatai iš pradžių neatrodė akivaizdūs. Kaip minėjau anksčiau, svarbu atpažinti, kokį rezultatą tavo loginė išraiška grąžins ir kodėl.

Grįžtant prie pradinių reiškinių, štai kaip juos turėtum aprašyti, kad jie grąžintų reikšmes, kurių tikiesi:

>>>''' 'a' == 'a' or 'a' == 'b' '''
True
>>>''' 'b' == 'a' or 'b' == 'b' '''
True
>>>''' 'a' == 'a' and 'a' == 'b' '''
False
>>>''' 'b' == 'a' and 'b' == 'b' '''
False

Įvertinus šiuos reiškinius yra gaunamos logines reikšmes <code>True</code> arba <code>False</code>, o ne teksto eilutės, kad galėtume gauti teisingus palyginimo rezultatus.

=== Pavyzdžiai ===
'''slaptazodis1.py'''
<syntaxhighlight lang="python">
## Ši programa prašo vartotojo prisijungimo vardo ir slaptažodžio.
# Kai vartotojas juos įveda, programa įvertina ar jis gali prisijungti.

vardas = input("Koks tavo vardas? ")
slaptažodis = input("Koks tavo slaptažodis? ")
if vardas == "Benas" and slaptažodis == "Penktadienis":
print("Sveikas, Benai!")
elif vardas == "Jonas" and slaptažodis == "Kietas":
print("Sveikas, Jonai!")
else:
print("Aš tavęs nepažįstu.")
</syntaxhighlight>

Pavyzdiniai rezultatai:

Koks tavo vardas? '''Benas'''

Koks tavo slaptažodis? '''Penktadienis'''

Sveikas, Benai!

Koks tavo vardas? '''Andrius'''

Koks tavo slaptažodis? '''Pinigai'''

Aš tavęs nepažįstu.

=== Užduotys ===
Parašyk programą, kurioje vartotojas turi atspėti tavo vardą, tačiau jie turės tik 3 spėjimus tai padaryti iki kol programa bus uždaryta.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
print("Pabandyk atspėti mano vardą!")
kiekis = 1
vardas = "gilbertas"
spėjimas = input("Koks mano vardas? ")
while kiekis < 3 and spėjimas.lower() != vardas: # .lower visas didžiąsias raides teksto eilutėje pakeičia į mažąsias, todėl net jei vartotojas įves Gilbertas, tai vis tiek bus teisingas atsakymas
print("Tu neteisus!")
spėjimas = input("Koks mano vardas? ")
kiekis = kiekis + 1

if spėjimas.lower() != vardas:
print("Tu neteisus!") # ši žinutė nėra atspausdinama trečiąjį bandymą, todėl mes tai padarome dabar
print("Tu nebegali spėti.")
else:
print("Taip! Mano vardas yra", vardas + "!")

</syntaxhighlight>
|-
|}

{{navigation |previous=Ciklai For |next=Žodynai}}
{{BookCat}}

Python Vadovėlis/Loginiai reiškiniai

2022-04-07T06:05:13Z

LauraK:

{{navigation |previous=Ciklai For |next=Žodynai}}
Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina:
<syntaxhighlight lang="python">
a = 6
b = 7
c = 42
print(1, a == 6)
print(2, a == 7)
print(3, a == 6 and b == 7)
print(4, a == 7 and b == 7)
print(5, not a == 7 and b == 7)
print(6, a == 7 or b == 7)
print(7, a == 7 or b == 6)
print(8, not (a == 7 and b == 6))
print(9, not a == 7 and b == 6)
</syntaxhighlight>

Šios programos išvestis yra:

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

Galvoje, turbūt, jau sukasi mintis: kas čia ką tik įvyko? Paaiškinsiu, kaip veikia kiekviena eilutė, kad mintys susidėliotų į savas vietas. Mano programoje gausu <code>print</code> sakinių, iš kurių kiekvienas išspausdina skaičių ir loginę reikšmę. Skaičius man padeda suprasti, kurio <code>print</code> sakinio rezultatas tai yra. Atkreipk dėmesį, kad kiekvienoje išvesties eilutėje yra žodis <code>False</code> arba <code>True</code>, o Python'e kiekviena loginė reikšmė <code>False</code> gali būti užrašoma skaičiumi 0, o <code>True</code> 1.

















Eilučių:

<syntaxhighlight lang="python">
print(1, a == 6)
print(2, a == 7)
</syntaxhighlight>

rezultatas atitinkamai yra <code>True(Teisinga)</code> ir <code>False(Klaidinga)</code>, kadangi pirmasis reiškinys yra teisingas, o antrasis yra klaidingas. Trečioji eilutė: <code>print(3, a == 6 and b == 7)</code> - šiek tiek skiriasi nuo prieš tai buvusių - joje yra naudojamas operatorius <code>and</code>. Loginis operatorius <code>and</code> grąžina rezultatą <code>True</code> tik tada, kai reiškiniai iš abiejų <code>and</code> pusių yra teisingi, kitu atveju visas reiškinys bus klaidingas ir grąžins <code>False</code>. Ketvirtoje eilutėje: print(4, a == 7 and b == 7) tik vienas iš reiškinių yra teisingas, dėl to eilutės rezultatas yra <code>False</code>. Operatoriaus <code>and</code> galimi rezultatai gali būti apibrėžti tokia lentele:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>and</code> True
|True
|-
|True <code>and</code> False
|False
|-
|False <code>and</code> True
|False
|-
|False <code>and</code> False
|False
|}

Atkreipk dėmesį, jei pirmas reiškinys yra klaidingas, tai Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys yra klaidingas. Parašyk šias eilutes ir paleisk programą: <code>False and print("Labas")</code> ir palygink rezultatą su šios eilutės <code>True and print("Labas")</code> rezultatu. Techniškai tai yra vadinama [[w:Short-circuit evaluation|short-circuit evaluation]].
Penktoje eilutėje, <code>print(5, not a == 7 and b == 7)</code>, yra naudojamas <code>not</code> operatorius. <code>not</code> suteikia priešingą reikšmę reiškiniui (reiškinys taip pat galėtų būti užrašomas taip: <code> print(5, a != 7 and b == 7)</code>). Štai lentelė apibrėžianti operatoriaus <code>not</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|<code>not</code> True
|False
|-
|<code>not</code> False
|True
|}

Dvi toliau pateiktos eilutės: <code>print(6, a == 7 or b == 7)</code> ir <code>print(7, a == 7 or b == 6)</code> naudoja operatorių <code>or</code>. Pastarasis operatorius grąžina <code>True</code> jei pirmasis reiškinys yra teisingas arba, jei antrasis reiškinys yra teisingas, arba, jei abu reiškiniai yra teisingi. Jei nei vienas iš reiškinių nėra teisingas, tuomet yra grąžinamas False. Štai lentelė apibrėžianti operatoriaus <code>or</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>or</code> True
| True
|-
|True <code>or</code> False
|True
|-
|False <code>or</code> True
|True
|-
|False <code>or</code> False
| False
|}

Turėk omeny, jei pirmasis reiškinys yra teisingas Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys bus teisingas. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code>, jei bent vienas iš reiškinių yra teisingas, tuomet viso reiškinio galutinis rezultatas bus teisingas. Pirmoji dalis yra teisinga, todėl antroji dalis gali būti klaidinga arba teisinga, tačiau visa išraiška vis dar teisinga.

Aštuntoje: <code>print(8, not (a == 7 and b == 6))</code> ir devintoje: <code>print(9, not a == 7 and b == 6)</code> eilutėse yra atvaizduojamas reiškinių grupavimo pavyzdys. Reiškinius Python’e galima sugrupuoti naudojant skliaustelius. Sugrupavę reiškinius, mes priverčiame Python’ą iš pradžių įvertinti reiškinius skliaustuose ir tik tada likusias reiškinio dalis. Atkreipk dėmesį, kad skliausteliai pakeitė reiškinį iš neteisingo į teisingą. Taip nutiko dėl to, kad operatorius <code>not</code> buvo pritaikytas reiškiniui skliausteliuose, vietoj to, kad būtų pritaikytas tik <code>a == 7</code> daliai.
Parodysiu pavyzdį, kaip rašant kodą galima pritaikyti loginius operatorius:

<syntaxhighlight lang="python">
sąrašas = ["Gyvenimas", "Visata", "Viskas", "Benas", "Liepa", "Gyvenimas", "Liepa"]

# kuriama sąrašo kopija. Peržiūrėk skyrių Daugiau apie sąrašus, kuriame sužinosi ką reiškia [:].
kopija = sąrašas[:]
# surūšiuoti sąrašą
kopija.sort()
ankstesnis = kopija[0]
del kopija[0]

kiekis = 0

# sąraše surask vienodus elementus
while kiekis < len(kopija) and kopija[kiekis] != ankstesnis:
ankstesnis = kopija[kiekis]
kiekis = kiekis + 1

# Jei nėra atitikmens tuomet kiekis negali būti < len
# kadangi ciklas kol bus vykdomas tol, kol kiekis < len
# ir nėra rastas atitikmuo

if kiekis < len(kopija):
print("Pirmasis atitikmuo:", ankstesnis)
</syntaxhighlight>

Šios programos rezultatas:
Pirmasis atitikmuo: Gyvenimas

Programa ieško vienodų elementų, tikrindama šią sąlygą: <code> while kiekis < len(kopija) and kopija[kiekis] nėra lygus ankstesnis </code>. Kai <code>kiekis</code> yra didesnis už paskutinio <code>kopija</code> sąrašo elemento indeksą arba, kai atsiranda sutampantis elementas, operatorius <code>and</code> nebėra tiesa, todėl ciklas pasibaigia. <code>if</code> sakinys patikrina ar ciklas <code>while</code> pasibaigė dėl to, kad buvo rastas sutampantis elementas.

Šioje programoje yra panaudotas dar vienas <code>and</code> operatoriaus „triukas“. Jei dar kartą pažiūrėsi į operatoriaus <code>and</code> lentelę pamatysi, jog trečioje eilutėje yra netiesa ir netiesa. Jei <code>kiekis >= len(kopija)</code> (kitais žodžiais, jei <code>kiekis < len(kopija)</code> yra <code>False</code>), tada kodo dalis <code>kopija[kiekis]</code> nebus tikrinama. Taip yra todėl, kad Python’as žino, jei pirmasis teiginys yra klaidingas, tai abu jie nebegali būti teisingi. Šis „short circuit“ triukas yra naudingas tuomet, kai antrasis <code>and</code> operatoriaus reiškinys gali sukelti klaidą. Aš panaudojau pirmąjį reiškinį (<code>kiekis < len(kopija)</code>), kad patikrinčiau ar kintamasis <code>kiekis</code> yra validus sąrašo <code>kopija</code> indeksas. Jei manimi netiki, tuomet ištrink iš sąrašo elementus „Liepa“ ir „Gyvenimas“, sukeisk vietomis sąlygas <code>kiekis < len(kopija) and kopija[kiekis] != ankstesnis</code> (rašyk: <code>kopija[kiekis] != ankstesnis and kiekis < len(kopija)</code>) ir patikrink ar programa vis dar veikia, kaip turėtų.

Loginiai operatoriai gali būti naudojami, kai mes norime patikrinti dvi arba daugiau skirtingų sąlygų vienu metu.

=== Pastaba apie loginius operatorius ===
Dažna pradedančiųjų programuotojų klaida yra neteisingas supratimas, kaip veikia loginiai operatoriai ir kaip juos „skaito“ Python'o interpretatorius. Pavyzdžiui: vos tik sužinojus apie operatorius <code>and</code> ir <code>or</code>, galima pagalvoti, kad išraiška <code>x == ('a' or 'b')</code> patikrins, ar kintamasis <code>x</code> yra lygus <code>a</code> arba kintamasis <code>x</code> lygus <code>b</code>, tačiau taip nėra. Norint suprasti, apie ką kalbu, pradėk interaktyvią sesiją su interpretatoriumi ir įvesk šias išraiškas:

>>> 'a' == ('a' or 'b')
>>> 'b' == ('a' or 'b')
>>> 'a' == ('a' and 'b')
>>> 'b' == ('a' and 'b')

Štai yra rezultatai, kurie nėra intuityvūs:

>>>''' 'a' == ('a' or 'b')'''
True
>>>''' 'b' == ('a' or 'b')'''
False
>>>''' 'a' == ('a' and 'b')'''
False
>>>''' 'b' == ('a' and 'b')'''
True

Šiuo momentu gali pasirodyti, jog operatoriai <code>and</code> ir <code>or</code> veikia klaidingai. Neatrodo logiška, jog pirmuose reiškiniuose <code>'a'</code> yra lygu <code>'a'</code> arba <code>'b'</code>, tačiau <code>'b'</code> nėra lygu <code>'a'</code> arba <code>'b'</code>. Taip pat yra ir su paskutiniu reiškiniu - jis neatrodo teisingas, nes <code>'b'</code> yra lygus <code>'a'</code> ir <code>'b'</code>. Išsiaiškinus, kaip veikia Python’o interpretatorius pasidaro aišku, kodėl gavome būtent tokius rezultatus.

Kai Python’o interpretatorius „pamato“ reiškinį, kuriame yra naudojamas <code>or</code>, jis paima pirmąjį teiginį ir patikrina ar jo rezultatas yra <code>True</code>. Jei pirmasis teiginys yra <code>True</code>, tuomet Python’as grąžina to teiginio rezultatą, netikrindamas antrojo. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code> užtenka patikrinti ar pirmasis teiginys yra teisingas, nes tada mes jau žinome, kad visas reiškinys yra teisingas ir programai nebereikia papildomai tikrinti antrojo. Iš kitos pusės, jei pirmasis teiginys grąžina <code>False</code>, tada Python’as turi patikrinti ir antrojo teiginio rezultatą bei grąžinti jo reikšmę. Antrasis teiginys nusako visos išraiškos rezultatą, kadangi pirmoji pusė buvo klaidinga. Šis interpretatoriaus „tingus“ įvertinimas vadinamas "short circuiting" ir yra įprastas būdas įvertinti logines išraiškas daugelyje programavimo kalbų.

Panašiai veikia ir operatorius <code>and</code>: Python’as naudoja, "short circuit" techniką, kad pagreitintų išraiškos įvertinimą. Jei pirmasis teiginys yra klaidingas, tada visas reiškinys yra klaidingas. Kitu atveju, jei pirmasis teiginys yra teisingas, tada Python’as patikrina antrąjį ir grąžina galutinę reikšmę.

Reiktų atkreiptį dėmesį į vieną niuansą: ne tik loginių išraiškų rezultatai gali būti apibrėžiami <code>True</code> arba <code>False</code> reikšmėmis. Norėdami patikrinti bet kurio objekto <code>x</code> loginę reikšmę, galite naudoti funkciją <code>bool(x)</code>. Žemiau yra pateikiama lentelė, kurioje yra pavyzdžiai, kokiems objektams Python’as priskiria <code>True</code> arba <code>False</code>:

{| class="wikitable"
|-
!True !!False
|-
|True ||False
|-
|1 ||0
|-
|Skaičiai kitokie nei nulis ||Tekstinė eilutė 'None'
|-
|Ne tuščios tekstinės eilutės ||Tuščios tekstinės eilutės
|-
|Sąrašai (lists) turintys elementų ||Sąrašai (lists) neturintys elementų
|-
|Žodynai (dictionaries) turintys elementų ||Žodynai (dictionaries) neturintys elementų
|}

Dabar galime suprasti gluminančius rezultatus, kuriuos gavome, kai anksčiau išbandėme logines išraiškas. Pažiūrėkime, ką Python'o interpretatorius „mato“, eidamas per šį kodą:

'''Pirmasis atvejis:'''
>>>''' 'a' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'a' == 'a' ''' # teksto eilutė 'a' yra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra True
True

'''Antrasis atvejis:'''
>>>''' 'b' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'b' == 'a' ''' # teksto eilutė 'b' nėra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra False
False

'''Trečiasis atvejis:'''
>>>''' 'a' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' and 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'a' == 'b' ''' # teksto eilutė 'a' nėra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra False
False

'''Ketvirtasis atvejis:'''
>>>''' 'b' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose:
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'b' == 'b' ''' # teksto eilutė 'b' yra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra True
True

Taigi, Python’as tikrai teisingai įvertino duotuosius reiškinius, kurių rezultatai iš pradžių neatrodė akivaizdūs. Kaip minėjau anksčiau, svarbu atpažinti, kokį rezultatą tavo loginė išraiška grąžins ir kodėl.

Grįžtant prie pradinių reiškinių, štai kaip juos turėtum aprašyti, kad jie grąžintų reikšmes, kurių tikiesi:

>>>''' 'a' == 'a' or 'a' == 'b' '''
True
>>>''' 'b' == 'a' or 'b' == 'b' '''
True
>>>''' 'a' == 'a' and 'a' == 'b' '''
False
>>>''' 'b' == 'a' and 'b' == 'b' '''
False

Įvertinus šiuos reiškinius yra gaunamos logines reikšmes <code>True</code> arba <code>False</code>, o ne teksto eilutės, kad galėtume gauti teisingus palyginimo rezultatus.

=== Pavyzdžiai ===
'''slaptazodis1.py'''
<syntaxhighlight lang="python">
## Ši programa prašo vartotojo prisijungimo vardo ir slaptažodžio.
# Kai vartotojas juos įveda, programa įvertina ar jis gali prisijungti.

vardas = input("Koks tavo vardas? ")
slaptažodis = input("Koks tavo slaptažodis? ")
if vardas == "Benas" and slaptažodis == "Penktadienis":
print("Sveikas, Benai!")
elif vardas == "Jonas" and slaptažodis == "Kietas":
print("Sveikas, Jonai!")
else:
print("Aš tavęs nepažįstu.")
</syntaxhighlight>

Pavyzdiniai rezultatai:

Koks tavo vardas? '''Benas'''

Koks tavo slaptažodis? '''Penktadienis'''

Sveikas, Benai!

Koks tavo vardas? '''Andrius'''

Koks tavo slaptažodis? '''Pinigai'''

Aš tavęs nepažįstu.

=== Užduotys ===
Parašyk programą, kurioje vartotojas turi atspėti tavo vardą, tačiau jie turės tik 3 spėjimus tai padaryti iki kol programa bus uždaryta.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
print("Pabandyk atspėti mano vardą!")
kiekis = 1
vardas = "gilbertas"
spėjimas = input("Koks mano vardas? ")
while kiekis < 3 and spėjimas.lower() != vardas: # .lower visas didžiąsias raides teksto eilutėje pakeičia į mažąsias, todėl net jei vartotojas įves Gilbertas, tai vis tiek bus teisingas atsakymas
print("Tu neteisus!")
spėjimas = input("Koks mano vardas? ")
kiekis = kiekis + 1

if spėjimas.lower() != vardas:
print("Tu neteisus!") # ši žinutė nėra atspausdinama trečiąjį bandymą, todėl mes tai padarome dabar
print("Tu nebegali spėti.")
else:
print("Taip! Mano vardas yra", vardas + "!")

</syntaxhighlight>
|-
|}

{{navigation |previous=Ciklai For |next=Žodynai}}
{{BookCat}}

Python Vadovėlis/Loginiai reiškiniai

2022-04-07T05:54:11Z

LauraK:

{{navigation |previous=Ciklai For |next=Žodynai}}
Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina:
<syntaxhighlight lang="python">
a = 6
b = 7
c = 42
print(1, a == 6)
print(2, a == 7)
print(3, a == 6 and b == 7)
print(4, a == 7 and b == 7)
print(5, not a == 7 and b == 7)
print(6, a == 7 or b == 7)
print(7, a == 7 or b == 6)
print(8, not (a == 7 and b == 6))
print(9, not a == 7 and b == 6)
</syntaxhighlight>

Šios programos išvestis yra:

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

Galvoje, turbūt, jau sukasi mintis: kas čia ką tik įvyko? Paaiškinsiu, kaip veikia kiekviena eilutė, kad mintys susidėliotų į savas vietas. Mano programoje gausu <code>print</code> sakinių, iš kurių kiekvienas išspausdina skaičių ir loginę reikšmę. Skaičius man padeda suprasti, kurio <code>print</code> sakinio rezultatas tai yra. Atkreipk dėmesį, kad kiekvienoje išvesties eilutėje yra žodis <code>False</code> arba <code>True</code>, o Python'e kiekviena loginė reikšmė <code>False</code> gali būti užrašoma skaičiumi 0, o <code>True</code> 1.

















Eilučių:

<syntaxhighlight lang="python">
print(1, a == 6)
print(2, a == 7)
</syntaxhighlight>

rezultatas atitinkamai yra <code>True</code> ir <code>False</code>, kadangi pirmasis reiškinys yra teisingas, o antrasis yra klaidingas. Trečioji eilutė: <code>print(3, a == 6 and b == 7)</code> - šiek tiek skiriasi nuo prieš tai buvusių - joje yra naudojamas operatorius <code>and</code>. Loginis operatorius <code>and</code> grąžina rezultatą <code>True</code> tik tada, kai reiškiniai iš abiejų <code>and</code> pusių yra teisingi, kitu atveju visas reiškinys bus klaidingas ir grąžins <code>False</code>. Ketvirtoje eilutėje: print(4, a == 7 and b == 7) tik vienas iš reiškinių yra teisingas, dėl to eilutės rezultatas yra <code>False</code>. Operatoriaus <code>and</code> galimi rezultatai gali būti apibrėžti tokia lentele:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>and</code> True
|True
|-
|True <code>and</code> False
|False
|-
|False <code>and</code> True
|False
|-
|False <code>and</code> False
|False
|}

Atkreipk dėmesį, jei pirmas reiškinys yra klaidingas, tai Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys yra klaidingas. Parašyk šias eilutes ir paleisk programą: <code>False and print("Labas")</code> ir palygink rezultatą su šios eilutės <code>True and print("Labas")</code> rezultatu. Techniškai tai yra vadinama [[w:Short-circuit evaluation|short-circuit evaluation]].
Penktoje eilutėje, <code>print(5, not a == 7 and b == 7)</code>, yra naudojamas <code>not</code> operatorius. <code>not</code> suteikia priešingą reikšmę reiškiniui (reiškinys taip pat galėtų būti užrašomas taip: <code> print(5, a != 7 and b == 7)</code>). Štai lentelė apibrėžianti operatoriaus <code>not</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|<code>not</code> True
|False
|-
|<code>not</code> False
|True
|}

Dvi toliau pateiktos eilutės: <code>print(6, a == 7 or b == 7)</code> ir <code>print(7, a == 7 or b == 6)</code> naudoja operatorių <code>or</code>. Pastarasis operatorius grąžina <code>True</code> jei pirmasis reiškinys yra teisingas arba, jei antrasis reiškinys yra teisingas, arba, jei abu reiškiniai yra teisingi. Jei nei vienas iš reiškinių nėra teisingas, tuomet yra grąžinamas False. Štai lentelė apibrėžianti operatoriaus <code>or</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|True <code>or</code> True
| True
|-
|True <code>or</code> False
|True
|-
|False <code>or</code> True
|True
|-
|False <code>or</code> False
| False
|}

Turėk omeny, jei pirmasis reiškinys yra teisingas Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys bus teisingas. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code>, jei bent vienas iš reiškinių yra teisingas, tuomet viso reiškinio galutinis rezultatas bus teisingas. Pirmoji dalis yra teisinga, todėl antroji dalis gali būti klaidinga arba teisinga, tačiau visa išraiška vis dar teisinga.

Aštuntoje: <code>print(8, not (a == 7 and b == 6))</code> ir devintoje: <code>print(9, not a == 7 and b == 6)</code> eilutėse yra atvaizduojamas reiškinių grupavimo pavyzdys. Reiškinius Python’e galima sugrupuoti naudojant skliaustelius. Sugrupavę reiškinius, mes priverčiame Python’ą iš pradžių įvertinti reiškinius skliaustuose ir tik tada likusias reiškinio dalis. Atkreipk dėmesį, kad skliausteliai pakeitė reiškinį iš neteisingo į teisingą. Taip nutiko dėl to, kad operatorius <code>not</code> buvo pritaikytas reiškiniui skliausteliuose, vietoj to, kad būtų pritaikytas tik <code>a == 7</code> daliai.
Parodysiu pavyzdį, kaip rašant kodą galima pritaikyti loginius operatorius:

<syntaxhighlight lang="python">
sąrašas = ["Gyvenimas", "Visata", "Viskas", "Benas", "Liepa", "Gyvenimas", "Liepa"]

# kuriama sąrašo kopija. Peržiūrėk skyrių Daugiau apie sąrašus, kuriame sužinosi ką reiškia [:].
kopija = sąrašas[:]
# surūšiuoti sąrašą
kopija.sort()
ankstesnis = kopija[0]
del kopija[0]

kiekis = 0

# sąraše surask vienodus elementus
while kiekis < len(kopija) and kopija[kiekis] != ankstesnis:
ankstesnis = kopija[kiekis]
kiekis = kiekis + 1

# Jei nėra atitikmens tuomet kiekis negali būti < len
# kadangi ciklas kol bus vykdomas tol, kol kiekis < len
# ir nėra rastas atitikmuo

if kiekis < len(kopija):
print("Pirmasis atitikmuo:", ankstesnis)
</syntaxhighlight>

Šios programos rezultatas:
Pirmasis atitikmuo: Gyvenimas

Programa ieško vienodų elementų, tikrindama šią sąlygą: <code> while kiekis < len(kopija) and kopija[kiekis] nėra lygus ankstesnis </code>. Kai <code>kiekis</code> yra didesnis už paskutinio <code>kopija</code> sąrašo elemento indeksą arba, kai atsiranda sutampantis elementas, operatorius <code>and</code> nebėra tiesa, todėl ciklas pasibaigia. <code>if</code> sakinys patikrina ar ciklas <code>while</code> pasibaigė dėl to, kad buvo rastas sutampantis elementas.

Šioje programoje yra panaudotas dar vienas <code>and</code> operatoriaus „triukas“. Jei dar kartą pažiūrėsi į operatoriaus <code>and</code> lentelę pamatysi, jog trečioje eilutėje yra netiesa ir netiesa. Jei <code>kiekis >= len(kopija)</code> (kitais žodžiais, jei <code>kiekis < len(kopija)</code> yra <code>False</code>), tada kodo dalis <code>kopija[kiekis]</code> nebus tikrinama. Taip yra todėl, kad Python’as žino, jei pirmasis teiginys yra klaidingas, tai abu jie nebegali būti teisingi. Šis „short circuit“ triukas yra naudingas tuomet, kai antrasis <code>and</code> operatoriaus reiškinys gali sukelti klaidą. Aš panaudojau pirmąjį reiškinį (<code>kiekis < len(kopija)</code>), kad patikrinčiau ar kintamasis <code>kiekis</code> yra validus sąrašo <code>kopija</code> indeksas. Jei manimi netiki, tuomet ištrink iš sąrašo elementus „Liepa“ ir „Gyvenimas“, sukeisk vietomis sąlygas <code>kiekis < len(kopija) and kopija[kiekis] != ankstesnis</code> (rašyk: <code>kopija[kiekis] != ankstesnis and kiekis < len(kopija)</code>) ir patikrink ar programa vis dar veikia, kaip turėtų.

Loginiai operatoriai gali būti naudojami, kai mes norime patikrinti dvi arba daugiau skirtingų sąlygų vienu metu.

=== Pastaba apie loginius operatorius ===
Dažna pradedančiųjų programuotojų klaida yra neteisingas supratimas, kaip veikia loginiai operatoriai ir kaip juos „skaito“ Python'o interpretatorius. Pavyzdžiui: vos tik sužinojus apie operatorius <code>and</code> ir <code>or</code>, galima pagalvoti, kad išraiška <code>x == ('a' or 'b')</code> patikrins, ar kintamasis <code>x</code> yra lygus <code>a</code> arba kintamasis <code>x</code> lygus <code>b</code>, tačiau taip nėra. Norint suprasti, apie ką kalbu, pradėk interaktyvią sesiją su interpretatoriumi ir įvesk šias išraiškas:

>>> 'a' == ('a' or 'b')
>>> 'b' == ('a' or 'b')
>>> 'a' == ('a' and 'b')
>>> 'b' == ('a' and 'b')

Štai yra rezultatai, kurie nėra intuityvūs:

>>>''' 'a' == ('a' or 'b')'''
True
>>>''' 'b' == ('a' or 'b')'''
False
>>>''' 'a' == ('a' and 'b')'''
False
>>>''' 'b' == ('a' and 'b')'''
True

Šiuo momentu gali pasirodyti, jog operatoriai <code>and</code> ir <code>or</code> veikia klaidingai. Neatrodo logiška, jog pirmuose reiškiniuose <code>'a'</code> yra lygu <code>'a'</code> arba <code>'b'</code>, tačiau <code>'b'</code> nėra lygu <code>'a'</code> arba <code>'b'</code>. Taip pat yra ir su paskutiniu reiškiniu - jis neatrodo teisingas, nes <code>'b'</code> yra lygus <code>'a'</code> ir <code>'b'</code>. Išsiaiškinus, kaip veikia Python’o interpretatorius pasidaro aišku, kodėl gavome būtent tokius rezultatus.

Kai Python’o interpretatorius „pamato“ reiškinį, kuriame yra naudojamas <code>or</code>, jis paima pirmąjį teiginį ir patikrina ar jo rezultatas yra <code>True</code>. Jei pirmasis teiginys yra <code>True</code>, tuomet Python’as grąžina to teiginio rezultatą, netikrindamas antrojo. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code> užtenka patikrinti ar pirmasis teiginys yra teisingas, nes tada mes jau žinome, kad visas reiškinys yra teisingas ir programai nebereikia papildomai tikrinti antrojo. Iš kitos pusės, jei pirmasis teiginys grąžina <code>False</code>, tada Python’as turi patikrinti ir antrojo teiginio rezultatą bei grąžinti jo reikšmę. Antrasis teiginys nusako visos išraiškos rezultatą, kadangi pirmoji pusė buvo klaidinga. Šis interpretatoriaus „tingus“ įvertinimas vadinamas "short circuiting" ir yra įprastas būdas įvertinti logines išraiškas daugelyje programavimo kalbų.

Panašiai veikia ir operatorius <code>and</code>: Python’as naudoja, "short circuit" techniką, kad pagreitintų išraiškos įvertinimą. Jei pirmasis teiginys yra klaidingas, tada visas reiškinys yra klaidingas. Kitu atveju, jei pirmasis teiginys yra teisingas, tada Python’as patikrina antrąjį ir grąžina galutinę reikšmę.

Reiktų atkreiptį dėmesį į vieną niuansą: ne tik loginių išraiškų rezultatai gali būti apibrėžiami <code>True</code> arba <code>False</code> reikšmėmis. Norėdami patikrinti bet kurio objekto <code>x</code> loginę reikšmę, galite naudoti funkciją <code>bool(x)</code>. Žemiau yra pateikiama lentelė, kurioje yra pavyzdžiai, kokiems objektams Python’as priskiria <code>True</code> arba <code>False</code>:

{| class="wikitable"
|-
!True !!False
|-
|True ||False
|-
|1 ||0
|-
|Skaičiai kitokie nei nulis ||Tekstinė eilutė 'None'
|-
|Ne tuščios tekstinės eilutės ||Tuščios tekstinės eilutės
|-
|Sąrašai (lists) turintys elementų ||Sąrašai (lists) neturintys elementų
|-
|Žodynai (dictionaries) turintys elementų ||Žodynai (dictionaries) neturintys elementų
|}

Dabar galime suprasti gluminančius rezultatus, kuriuos gavome, kai anksčiau išbandėme logines išraiškas. Pažiūrėkime, ką Python'o interpretatorius „mato“, eidamas per šį kodą:

'''Pirmasis atvejis:'''
>>>''' 'a' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'a' == 'a' ''' # teksto eilutė 'a' yra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra True
True

'''Antrasis atvejis:'''
>>>''' 'b' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'b' == 'a' ''' # teksto eilutė 'b' nėra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra False
False

'''Trečiasis atvejis:'''
>>>''' 'a' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' and 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'a' == 'b' ''' # teksto eilutė 'a' nėra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra False
False

'''Ketvirtasis atvejis:'''
>>>''' 'b' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose:
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'b' == 'b' ''' # teksto eilutė 'b' yra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra True
True

Taigi, Python’as tikrai teisingai įvertino duotuosius reiškinius, kurių rezultatai iš pradžių neatrodė akivaizdūs. Kaip minėjau anksčiau, svarbu atpažinti, kokį rezultatą tavo loginė išraiška grąžins ir kodėl.

Grįžtant prie pradinių reiškinių, štai kaip juos turėtum aprašyti, kad jie grąžintų reikšmes, kurių tikiesi:

>>>''' 'a' == 'a' or 'a' == 'b' '''
True
>>>''' 'b' == 'a' or 'b' == 'b' '''
True
>>>''' 'a' == 'a' and 'a' == 'b' '''
False
>>>''' 'b' == 'a' and 'b' == 'b' '''
False

Įvertinus šiuos reiškinius yra gaunamos logines reikšmes <code>True</code> arba <code>False</code>, o ne teksto eilutės, kad galėtume gauti teisingus palyginimo rezultatus.

=== Pavyzdžiai ===
'''slaptazodis1.py'''
<syntaxhighlight lang="python">
## Ši programa prašo vartotojo prisijungimo vardo ir slaptažodžio.
# Kai vartotojas juos įveda, programa įvertina ar jis gali prisijungti.

vardas = input("Koks tavo vardas? ")
slaptažodis = input("Koks tavo slaptažodis? ")
if vardas == "Benas" and slaptažodis == "Penktadienis":
print("Sveikas, Benai!")
elif vardas == "Jonas" and slaptažodis == "Kietas":
print("Sveikas, Jonai!")
else:
print("Aš tavęs nepažįstu.")
</syntaxhighlight>

Pavyzdiniai rezultatai:

Koks tavo vardas? '''Benas'''

Koks tavo slaptažodis? '''Penktadienis'''

Sveikas, Benai!

Koks tavo vardas? '''Andrius'''

Koks tavo slaptažodis? '''Pinigai'''

Aš tavęs nepažįstu.

=== Užduotys ===
Parašyk programą, kurioje vartotojas turi atspėti tavo vardą, tačiau jie turės tik 3 spėjimus tai padaryti iki kol programa bus uždaryta.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
print("Pabandyk atspėti mano vardą!")
kiekis = 1
vardas = "gilbertas"
spėjimas = input("Koks mano vardas? ")
while kiekis < 3 and spėjimas.lower() != vardas: # .lower visas didžiąsias raides teksto eilutėje pakeičia į mažąsias, todėl net jei vartotojas įves Gilbertas, tai vis tiek bus teisingas atsakymas
print("Tu neteisus!")
spėjimas = input("Koks mano vardas? ")
kiekis = kiekis + 1

if spėjimas.lower() != vardas:
print("Tu neteisus!") # ši žinutė nėra atspausdinama trečiąjį bandymą, todėl mes tai padarome dabar
print("Tu nebegali spėti.")
else:
print("Taip! Mano vardas yra", vardas + "!")

</syntaxhighlight>
|-
|}

{{navigation |previous=Ciklai For |next=Žodynai}}
{{BookCat}}

Python Vadovėlis/Rekursinės funkcijos

2022-03-14T09:27:05Z

LauraK:

{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Vieniems šis skyrius gali pasirodyti naudingas, o kitiems - painus. Jeigu tau informacija pasirodys paini, tai nesuk galvos ir praleisk, prie šio skyriaus galėsi grįžti šiek tiek vėliau. O dabar pabandom pasižiūrėti į mūsų parašytą programą:
<syntaxhighlight lang="python">
def daug(a, b): # daug reiškia daugybą
if b == 0:
return 0
lik = daug(a, b - 1) #lik reiškia likutį
reikšmė = a + lik
return reikšmė
rezultatas = daug(3, 2)
print("3 * 2 = ", rezultatas)
</syntaxhighlight>

Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reikia atkreipti dėmesį į tai, kad Python'o programavimo kalboje jau yra integruota funkcija dauginimui, čia mes patys parašėme lengvai suprantamą pavyzdį (jeigu kurtume tokią funkciją patys), kuris parodo kaip atrodo daugybos veiksmas. Šioje programoje gali pamatyti rekursijos naudojimą, tai yra iteracijos (kartojimo) forma, kai funkcija yra pakartotinai iškviečiama, kol bus įvykdyta sukurta išvesties sąlyga. Programa naudoja pakartotinius papildymus, kad gautų tą patį rezultatą kaip ir daugyba: pavyzdžiui 3 + 3 (sudėtis) duoda tą patį rezultatą kaip ir 3 * 2 (daugyba).

; ''Klausimas:'' Ką pirmiausia daro programa?
: ''Atsakymas:'' Pirmiausia yra aprašyta daugybos funkcija:
<syntaxhighlight lang="python">
def daug(a, b):
if b == 0:
return 0
lik = daug(a, b - 1)
reikšmė = a + lik
return reikšmė
</syntaxhighlight>
: Ši funkcija paima du parametrus ir grąžina reikšmę. Vėliau šią funkciją galima bus iškviesti.
; Kas nutinka toliau?
: Vykdoma kita eilutė einanti po funkcijos <code>rezultatas = daug(3, 2)</code>
; Ką daro ši eilutė?
: Ši eilutė priskiria funkcijos <code>daug(3, 2)</code> grąžinamą reikšmę kintamajam <code>rezultatas</code>.
; Ką grąžina <code>daug(3, 2)</code>?
: Norėdami tai išsiaiškinti, turime peržiūrėti funkciją <code>daug()</code>.
; Kas vyksta su kodu?
: Kintamasis <code>a</code> gauna jam priskirtą reikšmę 3, o kintamasis <code>b</code> - jam priskirtą reikšmę 2.
; Kas nutinka tada?
: Vykdoma eilutė <code>if b == 0:</code>. Kadangi <code>b</code> reikšmė yra 2, todėl eilutė <code>return 0</code> praleidžiama.
; Kas vyksta toliau?
: Vykdoma eilutė <code>lik = daug(a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>lik</code> reikšmę į <code>daug(a, b - 1)</code> reikšmę. <code>a</code> reikšmė yra 3, o <code>b</code> - 2, todėl funkcija kviečia funkciją <code>daug(3, 1)</code>
; Taigi kokia yra <code>daug(3, 1)</code> reikšmė?
: Turime paleisti funkciją <code>daug()</code> su parametrais, kurie yra 3 ir 1.
; Kas nutinka toliau?
: Lokalūs kintamieji vėl pasileidus kodui jau yra nustatyti, todėl <code>a</code> reikšmė būtų 3, o <code>b</code> reikšmė – 1. Kadangi jie yra lokalūs kintamieji, todėl jie neturi įtakos ankstesnėms <code>a</code> ir <code>b</code> reikšmėms.
; Kas įvyksta toliau?
: Kadangi <code>b</code> turi reikšmę 1, if sąlygos rezultatas yra neigiamas, todėl vykdoma kita eilutė <code>lik = daug(a, b - 1)</code>.
; Ką daro ši eilutė?
: Dabar kintamajam <code>lik</code> priskiriam funkcijos <code>daug(3, 0)</code> reikšmė.
; Kokia ši reikšmė?
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> – 0.
; Kas vyksta toliau?
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code>
; Ką daro <code>return 0</code> eilutė?
: Ši eilutė grąžina funkcijos reikšmę lygią 0 į tą vietą, kur ji buvo iškviesta.
; Kas iš to?
: Dabar mes žinome, kad <code>daug(3, 0)</code> grąžina reikšmę 0. Dar žinome, ką daro eilutė <code>lik = daug(a, b - 1)</code>, nes paleidžiame funkciją <code>daug()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>daug(3, 0)</code> ir dabar vėl pradedame vykdyti <code>daug(3, 1)</code>. Kintamajam <code>lik</code> priskiriama reikšmė yra 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>reikšmė = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reikšmė = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return reikšmė</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.
; Kur yra <code>daug(3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reikšmė = a + lik</code> priskiria kintamajam <code>reikšmė</code> reikšmę <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradedama vykdyti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>rezultatas = daug(3, 2)</code>, kur kintamajam <code>rezultatas</code> dabar priskiriama reikšmė 6
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", rezultatas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>rezultatas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmo skaičiaus ir pirmo bei vienetu mažesnio už antrąjį sandaugos sumai <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Kai viskas surašoma vienoje eilutėje, gauname <code>3 + 3 + 0 </code>

Štai kaip viskas veikia:

daug(3, 2)
3 + daug(3, 1)
3 + 3 + daug(3, 0)
3 + 3 + 0
3 + 3
6

==== Rekursija ====
Funkcijos, kurios kreipiasi pačios į save yra vadinamos rekursinėmis funkcijomis. Šio skyriaus pavyzdžiuose panagrinėsime tokias funkcijas. Tai palengvina programavimo užduočių spendimų įgyvendinimą, nes kartais pakanka apsvarstyti tik vieną problemos žingsnį, o ne visą problemą iš karto. Be to tai leidžia išreikšti kai kurias matematines sąvokas paprastu, lengvai skaitomu kodu.

Bet kokią problemą, kurią galime išspręsti naudojant rekursiją, gali būti išspręsta naudojant ciklus. Jie veikia greičiau, bet kartais ciklus sunku atlikti teisingai.

Turbūt intuityviausias „rekursijos“ apibrėžimas yra toks:
REKURSIJA
Jei vis dar nesupranti, tai skaityk: REKURSIJA.
Pabandyk perskaityti dar kelis pavyzdžius.

=== Pavyzdžiai ===
'''faktorialas.py'''
<syntaxhighlight lang="python">
#apibrėžia funkciją, kuri apskaičiuoja koeficientą

def faktorialas(n):
if n == 0:
return 1
if n < 0:
return "Klaida, neigiami skaičiai neturi faktorialo reikšmių!!"
return n * faktorialas(n - 1)

print("2! =", faktorialas(2))
print("3! =", faktorialas(3))
print("4! =", faktorialas(4))
print("5! =", faktorialas(5))
print("-3! =", faktorialas(-3))
</syntaxhighlight>

Rezultatas:

2! = 2
3! = 6
4! = 24
5! = 120
-3! = Klaida, neigiami skaičiai neturi faktorialo reikšmių!!

'''atgalinis_skaičiavimas.py'''
<syntaxhighlight lang="python">
def atgalinis_skaičiavimas(n):
print(n)
if n > 0:
return atgalinis_skaičiavimas(n-1)

atgalinis_skaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Python Vadovėlis/Įvadas į importuotas bibliotekas ir kitas funkcijas

2022-03-09T08:37:55Z

LauraK:

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Pabaiga}}

Šiame skyriuje apžvelgsime kai kurias funkcijas iš įvairių importuotų bibliotekų, kurios yra dažniausiai naudojamos Python'e. Šis skyrius nėra būtinas norint visiškai suprasti Python'o pagrindus. Šis skyrius skirtas parodyti tolesnes Python'o galimybes, kurias galima panaudoti su tuo, ką jau žinote apie kalbą.

=== math ===

:Matematikos biblioteka aprėpia daug naudingų ir programoms reikalingų funkcijų, kurios atlieka įvarias matematines operacijas (kai neužtenka Python'o operatorių).

:Šiame skyriuje daroma prielaida, kad turi matematikos žinias iki trigonometrijos kurso imtinai.

Šiame sąraše išvardintos visos matematikos bibliotekos funkcijos:
*math.ceil (Suapvalina skaičių iki artimiausio skaičiaus po kablelio)
*math.copysign (Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>)
*math.fabs (Grąžina absoliučią skaičiaus reikšmę, kaip slankiojo kablelio reikšmę)
*math.factorial (Grąžina skaičiaus faktorialą)
*math.floor (Grąžina didžiausią sveikąjį skaičių, mažesnį arba lygų duotajam skaičiui)
*math.fmod (Nėra pati idealiausia funkcija su kuria galima pasiekti nurodytą tikslą. Šiame skyriuje nebus detaliau paaiškinta.)
*math.frexp (Už šios pamokos ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.fsum (Grąžina visų skliausteliuose esančių skaičių sumą)
*math.isfinite (Patikrina ar skaičius yra baigtinis)
*math.isinf (Patikrina ar skaičius yra begalinis ar ne)
*math.isnan (Patikrina, ar reikšmė yra NaN (ne skaičius), ar ne)
*math.modf (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.trunc (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.exp (Apskaičiuoja eksponentinę funkciją e^x, kur e yra matematinė konstanta)
*math.expm1 (Grąžina E^x - 1)
*math.log (Grąžina natūralųjį skaičiaus logaritmą)
*math.log1p (Grąžina log(1+skaičius))
*math.log10 (Grąžina skaičiaus 10 bazinį logaritmą)
*math.pow (Grąžina x reikšmę, pakeltą laipsniu y)
*math.sqrt (Grąžina skaičiaus kvadratinę šaknį)
*math.acos (Grąžina arccos(x))
*math.asin (Grąžina arcsin(x))
*math.atan (Grąžina arctan(x))
*math.cos (Grąžina reikšmės kosinusą)
*math.hypot (Grąžina Euklido normą)
*math.sin (Grąžina reikšmės sinusą)
*math.tan (Grąžina reikšmės tangentą)
*math.degrees (Paverčia radianus į laipsnius)
*math.radians (Paverčia laipsnius į radianus)
*math.pi (Grąžina π reikšmę)
*math.e (Grąžina e reikšmę)

:Žinoma, neapimsime visų šių funkcijų, bet padengsime didelę jų dalį.

Pradėkime nuo dviejų konstantų matematikos bibliotekoje. <code>math.pi</code> yra matematinė konstanta „π“, tavo kompiuteryje pasiekiamu tikslumu. <code>math.e</code> yra matematinė konstanta „e“, tavo kompiuteryje pasiekiamu tikslumu.
Štai yra abiejų konstantų, įvestų interaktyviuoju režimu Python'o terminale, pavyzdys:
>>> import math
>>> math.e
2.718281828459045
>>> math.pi
3.141592653589793

Šios konstantos gali būti saugomos kintamajame, kaip ir bet kuris kitas skaičius. Žemiau pateikiamas būtent toks pavyzdys ir parodytos paprastos šių kintamųjų operacijos:
>>> conste = math.e
>>> (conste + 5 / 2) * 2.21
11.532402840894488
>>> constpi = math.pi
>>> (((7 /2.1) % constpi) * 2)
0.38348135948707984
>>>

Dabar pažvelk į funkcijas: pradėk nuo sąrašo viršaus ir judėk žemyn (kai kurios funkcijos bus praleistos).
Kai žiūrėsi kiekvieną iš pavyzdžių, pabandyk išsiaiškinti, ką kiekviena funkcija daro. Šalia bus pateiktas sakinys ar du, kurie turėtų tau padėti.

Žemiau pateikiamas kiekvienos <code>math</code> modulio funkcijos pavyzdys ir kaip ji naudojama (išskyrus anksčiau nurodytas funkcijas, kurių nereikia paaiškinti)

>>> import math
>>> math.ceil(4.5) ** Suapvalina skaičių iki artimiausio skaičiaus po kablelio **
5
>>> math.ceil(4.1)
5
>>> math.copysign(4, -.4) ** Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>
-4.0
>>> math.copysign(-4, 4)
4.0
>>> math.fabs(-44) ** Grąžina absoliučią skaičiaus reikšmę, kaip slankiojo kablelio reikšmę **
44.0
>>> math.factorial(4) ** Grąžina skaičiaus faktorialą **
24
>>> math.floor(4.3) ** Grąžina didžiausią sveikąjį skaičių, mažesnį arba lygų duotajam skaičiui **
4
>>> math.floor(4.99999)
4
>>> math.fsum([.1,.2,5,45.2,-.054,.4]) ** Grąžina visų skliausteliuose esančių skaičių sumą. Funkcija ne visada tiksli **
50.846000000000004
>>> math.isfinite(3) ** Grąžina <code>True</code>, jei reikšmė nėra begalinė ar NaN. Kitu atveju, grąžina <code>False</code>. **
True

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Pabaiga}}
{{BookCat}}

Python Vadovėlis/Įvadas į importuotas bibliotekas ir kitas funkcijas

2022-03-09T08:37:20Z

LauraK:

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Pabaiga}}

Šiame skyriuje apžvelgsime kai kurias funkcijas iš įvairių importuotų bibliotekų, kurios yra dažniausiai naudojamos Python'e. Šis skyrius nėra būtinas norint visiškai suprasti Python'o pagrindus. Šis skyrius skirtas parodyti tolesnes Python'o galimybes, kurias galima panaudoti su tuo, ką jau žinote apie kalbą.

=== math ===

:Matematikos biblioteka aprėpia daug naudingų ir programoms reikalingų funkcijų, kurios atlieka įvarias matematines operacijas (kai neužtenka Python'o operatorių).

:Šiame skyriuje daroma prielaida, kad turi matematikos žinias iki trigonometrijos kurso imtinai.

Šiame sąraše išvardintos visos matematikos bibliotekos funkcijos:
*math.ceil (Suapvalina skaičių iki artimiausio skaičiaus po kablelio)
*math.copysign (Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>)
*math.fabs (Grąžina absoliučią skaičiaus reikšmę, kaip slankiojo kablelio reikšmę)
*math.factorial (Grąžina skaičiaus faktorialą)
*math.floor (Grąžina didžiausią sveikąjį skaičių, mažesnį arba lygų duotajam skaičiui)
*math.fmod (Nėra pati idealiausia funkcija su kuria galima pasiekti nurodytą tikslą. Šiame skyriuje nebus detaliau paaiškinta.)
*math.frexp (Už šios pamokos ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.fsum (Grąžina visų skliausteliuose esančių skaičių sumą)
*math.isfinite (Patikrina ar skaičius yra baigtinis)
*math.isinf (Patikrina ar skaičius yra begalinis ar ne)
*math.isnan (Patikrina, ar reikšmė yra NaN (ne skaičius), ar ne)
*math.ldexp (Grąžina x * (2 ** i) iš pateiktų skaičių x ir i)
*math.modf (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.trunc (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.exp (Apskaičiuoja eksponentinę funkciją e^x, kur e yra matematinė konstanta)
*math.expm1 (Grąžina E^x - 1)
*math.log (Grąžina natūralųjį skaičiaus logaritmą)
*math.log1p (Grąžina log(1+skaičius))
*math.log10 (Grąžina skaičiaus 10 bazinį logaritmą)
*math.pow (Grąžina x reikšmę, pakeltą laipsniu y)
*math.sqrt (Grąžina skaičiaus kvadratinę šaknį)
*math.acos (Grąžina arccos(x))
*math.asin (Grąžina arcsin(x))
*math.atan (Grąžina arctan(x))
*math.cos (Grąžina reikšmės kosinusą)
*math.hypot (Grąžina Euklido normą)
*math.sin (Grąžina reikšmės sinusą)
*math.tan (Grąžina reikšmės tangentą)
*math.degrees (Paverčia radianus į laipsnius)
*math.radians (Paverčia laipsnius į radianus)
*math.pi (Grąžina π reikšmę)
*math.e (Grąžina e reikšmę)

:Žinoma, neapimsime visų šių funkcijų, bet padengsime didelę jų dalį.

Pradėkime nuo dviejų konstantų matematikos bibliotekoje. <code>math.pi</code> yra matematinė konstanta „π“, tavo kompiuteryje pasiekiamu tikslumu. <code>math.e</code> yra matematinė konstanta „e“, tavo kompiuteryje pasiekiamu tikslumu.
Štai yra abiejų konstantų, įvestų interaktyviuoju režimu Python'o terminale, pavyzdys:
>>> import math
>>> math.e
2.718281828459045
>>> math.pi
3.141592653589793

Šios konstantos gali būti saugomos kintamajame, kaip ir bet kuris kitas skaičius. Žemiau pateikiamas būtent toks pavyzdys ir parodytos paprastos šių kintamųjų operacijos:
>>> conste = math.e
>>> (conste + 5 / 2) * 2.21
11.532402840894488
>>> constpi = math.pi
>>> (((7 /2.1) % constpi) * 2)
0.38348135948707984
>>>

Dabar pažvelk į funkcijas: pradėk nuo sąrašo viršaus ir judėk žemyn (kai kurios funkcijos bus praleistos).
Kai žiūrėsi kiekvieną iš pavyzdžių, pabandyk išsiaiškinti, ką kiekviena funkcija daro. Šalia bus pateiktas sakinys ar du, kurie turėtų tau padėti.

Žemiau pateikiamas kiekvienos <code>math</code> modulio funkcijos pavyzdys ir kaip ji naudojama (išskyrus anksčiau nurodytas funkcijas, kurių nereikia paaiškinti)

>>> import math
>>> math.ceil(4.5) ** Suapvalina skaičių iki artimiausio skaičiaus po kablelio **
5
>>> math.ceil(4.1)
5
>>> math.copysign(4, -.4) ** Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>
-4.0
>>> math.copysign(-4, 4)
4.0
>>> math.fabs(-44) ** Grąžina absoliučią skaičiaus reikšmę, kaip slankiojo kablelio reikšmę **
44.0
>>> math.factorial(4) ** Grąžina skaičiaus faktorialą **
24
>>> math.floor(4.3) ** Grąžina didžiausią sveikąjį skaičių, mažesnį arba lygų duotajam skaičiui **
4
>>> math.floor(4.99999)
4
>>> math.fsum([.1,.2,5,45.2,-.054,.4]) ** Grąžina visų skliausteliuose esančių skaičių sumą. Funkcija ne visada tiksli **
50.846000000000004
>>> math.isfinite(3) ** Grąžina <code>True</code>, jei reikšmė nėra begalinė ar NaN. Kitu atveju, grąžina <code>False</code>. **
True

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Pabaiga}}
{{BookCat}}

Python Vadovėlis/Įvadas į importuotas bibliotekas ir kitas funkcijas

2022-03-09T08:13:46Z

LauraK:

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Pabaiga}}

Šiame skyriuje apžvelgsime kai kurias funkcijas iš įvairių importuotų bibliotekų, kurios yra dažniausiai naudojamos Python'e. Šis skyrius nėra būtinas norint visiškai suprasti Python'o pagrindus. Šis skyrius skirtas parodyti tolesnes Python'o galimybes, kurias galima panaudoti su tuo, ką jau žinote apie kalbą.

=== math ===

:Matematikos biblioteka aprėpia daug naudingų ir programoms reikalingų funkcijų, kurios atlieka įvarias matematines operacijas (kai neužtenka Python'o operatorių).

:Šiame skyriuje daroma prielaida, kad turi matematikos žinias iki trigonometrijos kurso imtinai.

Šiame sąraše išvardintos visos matematikos bibliotekos funkcijos:
*math.ceil (Suapvalina skaičių iki artimiausio skaičiaus po kablelio)
*math.copysign (Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>)
*math.fabs
*math.factorial
*math.floor
*math.fmod (Nėra pati idealiausia funkcija su kuria galima pasiekti nurodytą tikslą. Šiame skyriuje nebus detaliau paaiškinta.)
*math.frexp (Už šios pamokos ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.fsum
*math.isfinite
*math.isinf
*math.isnan
*math.ldexp
*math.modf (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.trunc (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.exp
*math.expm1
*math.log
*math.log1p
*math.log10
*math.pow
*math.sqrt
*math.acos
*math.asin
*math.atan
*math.atan2
*math.cos
*math.hypot
*math.sin
*math.tan
*math.degrees
*math.radians
*math.acosh
*math.asinh
*math.atanh
*math.cosh
*math.sinh
*math.tanh
*math.erf
*math.erfc
*math.gamma
*math.lgamma
*math.pi
*math.e

:Žinoma, neapimsime visų šių funkcijų, bet padengsime didelę jų dalį.

Pradėkime nuo dviejų konstantų matematikos bibliotekoje. <code>math.pi</code> yra matematinė konstanta „π“, tavo kompiuteryje pasiekiamu tikslumu. <code>math.e</code> yra matematinė konstanta „e“, tavo kompiuteryje pasiekiamu tikslumu.
Štai yra abiejų konstantų, įvestų interaktyviuoju režimu Python'o terminale, pavyzdys:
>>> import math
>>> math.e
2.718281828459045
>>> math.pi
3.141592653589793

Šios konstantos gali būti saugomos kintamajame, kaip ir bet kuris kitas skaičius. Žemiau pateikiamas būtent toks pavyzdys ir parodytos paprastos šių kintamųjų operacijos:
>>> conste = math.e
>>> (conste + 5 / 2) * 2.21
11.532402840894488
>>> constpi = math.pi
>>> (((7 /2.1) % constpi) * 2)
0.38348135948707984
>>>

Dabar pažvelk į funkcijas: pradėk nuo sąrašo viršaus ir judėk žemyn (kai kurios funkcijos bus praleistos).
Kai žiūrėsi kiekvieną iš pavyzdžių, pabandyk išsiaiškinti, ką kiekviena funkcija daro. Šalia bus pateiktas sakinys ar du, kurie turėtų tau padėti.

Žemiau pateikiamas kiekvienos <code>math</code> modulio funkcijos pavyzdys ir kaip ji naudojama (išskyrus anksčiau nurodytas funkcijas, kurių nereikia paaiškinti)

>>> import math
>>> math.ceil(4.5) ** Suapvalina skaičių iki artimiausio skaičiaus po kablelio **
5
>>> math.ceil(4.1)
5
>>> math.copysign(4, -.4) ** Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>
-4.0
>>> math.copysign(-4, 4)
4.0
>>> math.fabs(-44) ** Grąžina absoliučią skaičiaus reikšmę, kaip slankiojo kablelio reikšmę **
44.0
>>> math.factorial(4) ** Grąžina skaičiaus faktorialą **
24
>>> math.floor(4.3) ** Grąžina didžiausią sveikąjį skaičių, mažesnį arba lygų duotajam skaičiui **
4
>>> math.floor(4.99999)
4
>>> math.fsum([.1,.2,5,45.2,-.054,.4]) ** Grąžina visų skliausteliuose esančių skaičių sumą. Funkcija ne visada tiksli **
50.846000000000004
>>> math.isfinite(3) ** Grąžina <code>True</code>, jei reikšmė nėra begalinė ar NaN. Kitu atveju, grąžina <code>False</code>. **
True

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Pabaiga}}
{{BookCat}}

Python Vadovėlis/Įvadas į importuotas bibliotekas ir kitas funkcijas

2022-03-09T08:10:36Z

LauraK:

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Pabaiga}}

Šiame skyriuje apžvelgsime kai kurias funkcijas iš įvairių importuotų bibliotekų, kurios yra dažniausiai naudojamos Python'e. Šis skyrius nėra būtinas norint visiškai suprasti Python'o pagrindus. Šis skyrius skirtas parodyti tolesnes Python'o galimybes, kurias galima panaudoti su tuo, ką jau žinote apie kalbą.

=== math ===

:Matematikos biblioteka aprėpia daug naudingų ir programoms reikalingų funkcijų, kurios atlieka įvarias matematines operacijas (kai neužtenka Python'o operatorių).

:Šiame skyriuje daroma prielaida, kad turi matematikos žinias iki trigonometrijos kurso imtinai.

Šiame sąraše išvardintos visos matematikos bibliotekos funkcijos:
*math.ceil
*math.copysign
*math.fabs
*math.factorial
*math.floor
*math.fmod (Nėra pati idealiausia funkcija su kuria galima pasiekti nurodytą tikslą. Šiame skyriuje nebus detaliau paaiškinta.)
*math.frexp (Už šios pamokos ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.fsum
*math.isfinite
*math.isinf
*math.isnan
*math.ldexp
*math.modf (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.trunc (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.exp
*math.expm1
*math.log
*math.log1p
*math.log10
*math.pow
*math.sqrt
*math.acos
*math.asin
*math.atan
*math.atan2
*math.cos
*math.hypot
*math.sin
*math.tan
*math.degrees
*math.radians
*math.acosh
*math.asinh
*math.atanh
*math.cosh
*math.sinh
*math.tanh
*math.erf
*math.erfc
*math.gamma
*math.lgamma
*math.pi
*math.e

:Žinoma, neapimsime visų šių funkcijų, bet padengsime didelę jų dalį.

Pradėkime nuo dviejų konstantų matematikos bibliotekoje. <code>math.pi</code> yra matematinė konstanta „π“, tavo kompiuteryje pasiekiamu tikslumu. <code>math.e</code> yra matematinė konstanta „e“, tavo kompiuteryje pasiekiamu tikslumu.
Štai yra abiejų konstantų, įvestų interaktyviuoju režimu Python'o terminale, pavyzdys:
>>> import math
>>> math.e
2.718281828459045
>>> math.pi
3.141592653589793

Šios konstantos gali būti saugomos kintamajame, kaip ir bet kuris kitas skaičius. Žemiau pateikiamas būtent toks pavyzdys ir parodytos paprastos šių kintamųjų operacijos:
>>> conste = math.e
>>> (conste + 5 / 2) * 2.21
11.532402840894488
>>> constpi = math.pi
>>> (((7 /2.1) % constpi) * 2)
0.38348135948707984
>>>

Dabar pažvelk į funkcijas: pradėk nuo sąrašo viršaus ir judėk žemyn (kai kurios funkcijos bus praleistos).
Kai žiūrėsi kiekvieną iš pavyzdžių, pabandyk išsiaiškinti, ką kiekviena funkcija daro. Šalia bus pateiktas sakinys ar du, kurie turėtų tau padėti.

Žemiau pateikiamas kiekvienos <code>math</code> modulio funkcijos pavyzdys ir kaip ji naudojama (išskyrus anksčiau nurodytas funkcijas, kurių nereikia paaiškinti)

>>> import math
>>> math.ceil(4.5) ** Suapvalina skaičių iki artimiausio skaičiaus po kablelio **
5
>>> math.ceil(4.1)
5
>>> math.copysign(4, -.4) ** Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>
-4.0
>>> math.copysign(-4, 4)
4.0
>>> math.fabs(-44) ** Grąžina absoliučią skaičiaus reikšmę, kaip slankiojo kablelio reikšmę **
44.0
>>> math.factorial(4) ** Grąžina skaičiaus faktorialą **
24
>>> math.floor(4.3) ** Grąžina didžiausią sveikąjį skaičių, mažesnį arba lygų duotajam skaičiui **
4
>>> math.floor(4.99999)
4
>>> math.fsum([.1,.2,5,45.2,-.054,.4]) ** Grąžina visų skliausteliuose esančių skaičių sumą. Funkcija ne visada tiksli **
50.846000000000004
>>> math.isfinite(3) ** Grąžina <code>True</code>, jei reikšmė nėra begalinė ar NaN. Kitu atveju, grąžina <code>False</code>. **
True

{{navigation |previous=Įvadas į objektinį programavimą Python 3 |next=Pabaiga}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2022-03-09T08:09:39Z

LauraK:

{{navigation |previous=Failų IO |next=Rekursija}}

=== ...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į. Nesijaudink, Pithon'as turi specialią valdymo struktūrą, kuri tau padės. Ji vadinama <code>try</code> ir ji bando kažką padaryti. Programos su problema pavyzdys:
<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> funkcijai netinka įvestis <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 įrašyti į <code>try</code> bloką. 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 <code>Tai buvo ne skaičius.</code> 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>.

=== Pratimai ===
Pataisyk telefono numerių programą ([[Vadovėlis/Žodynai|Žodynai]] skyriuje), kad ji neužstrigtų, jei naudotojas neįrašo jokios įvesties į meniu.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<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=Failų IO |next=Rekursija}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2022-03-03T11:43:43Z

LauraK:

{{navigation |previous=Modulių naudojimas|next=Daugiau apie tekstines eilutes}}

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementais ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina elementų kiekį + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį – pjaustymas (slicing). Štai pavyzdys, leidžiantis suprasti, kaip jis gali būti naudojamas:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poema = ["", "Ta", "liga", "nelimpa", "", "net", "ir", "prie",
"savų.", "Pats", "", "žiopliukas", "būdamas,", "neapkrės", "kitų.", "",
"Žiopliškumas", "buvo", "ir", "", "visad", "jis", "bus.",
"", "Jei", "skandinsi", "pelkėj,", "", "jis", "ir",
"", "ten", "nežus."]

def gauk_pastorintą(tekstas):
true = 1
false = 0
## ar_pastorintas pasako ar mes dabar tikriname
## pastorintą teksto dalį.
ar_pastorintas = false
## pradinis_blokas yra indeksas arba nepastorinta
## teksto dalis arba pastorinta.
pradinis_blokas = 0
for indeksas in range(len(tekstas)):
## Apdorojama pastorinto teksto pradžia
if tekstas[indeksas] == "":
if ar_pastorintas:
print("Klaida: Papildoma pastorinimo atidarymo žyma")
## print "Nepastorintas:", tekstas[pradinis_blokas:indeksas]
ar_pastorintas = true
pradinis_blokas = indeksas + 1
## Apdorojama pastorinto teksto pabaiga
## Atsimink, kad paskutinis skaičius atliekant pjūvį yra indeksas
## po to, kai paskutinis indeksas yra panaudotas.
if tekstas[indeksas] == "":
if not ar_pastorintas:
print("Klaida: papildoma pastorinimo uždarymo žyma")
print("Pastorintas [", pradinis_blokas, ":", indeksas, "]", tekstas[pradinis_blokas:indeksas])
ar_pastorintas = false
pradinis_blokas = indeksas + 1

gauk_pastorintą(poema)
</syntaxhighlight>

šios programos išvestis yra:

Pastorinta [ 1 : 4 ] ['Ta', 'liga', 'nelimpa']
Pastorinta [ 11 : 15 ] ['žiopliukas', 'būdamas,', 'neapkrės', 'kitų.']
Pastorinta [ 20 : 23 ] ['visad', 'jis', 'bus.']
Pastorinta [ 28 : 30 ] ['jis', 'ir']

Funkcija <code>gauk_pastorintą()</code> pasiima sau į sąrašą tai, kas buvo padalinta į žodžius ir žymas. Žymos, kurį ši funkcija ieško - <code></code>, nes ji pradeda pastorintą tekstą ir <code></code>, kuris užbaigia pastorintą tekstą. Funkcija <code>gauk_pastorintą()</code> eina per tekstą ir ieško pradžios ir pabaigos žymų.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

Šis pavyzdys turėtų nustebinti, kadangi pakeitus <code>b</code> pasikeitė ir <code>a</code>. Taip yra todėl, kad teiginys <code>b = a</code> sukūrė ''nuorodą (reference)'' iš <code>b</code> į <code>a</code>, o tai reiškia, jog <code>b</code> dabar yra dar vienas <code>a</code> vardas.
Taigi, bet koks <code>b</code> pakeitimas, keičia ir <code>a</code>. Tačiau kai kurie priskyrimai nesukuria dviejų pavadinimų vienam sąrašui, pažvelk į dar vieną pavyzdį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

Šiuo atveju <code>b</code> nėra nuoroda į <code>a</code>, nes išraiška <code>a * 2</code> sukuria naują sąrašą vietoje nuorodos į <code>a</code>. Beveik visos priskyrimo operacijos sukuria nuorodą, pavyzdžiui: kai perduodi sąrašą, kaip funkcijos argumentą, tu sukuri nuorodą.
Visgi, dažniau mums programoje reikia kopijų, o ne nuorodų. Kai norime pakeisti vieną sąrašą, nekeisdami kito sąrašo, mes turime įsitikinti, kad sukūrėme sąrašo kopiją.

Yra keli būdai, kaip gali sukurti sąrašo kopiją. Vienas iš paprasčiausių būdų yra pjaustymo operatorius, kadangi jis visuomet sukuria naują sąrašą, net tada, kai su pjūviu apimame viso sąrašo ilgį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Panaudoję pjūvio operatorių <code>[:]</code> mes sukuriame naują sąrašo kopiją. Turėk omeny, kad nukopijuojamas yra tik išorinis sąrašas. Bet koks vidinis sąrašas turi nuorodą į pirminį sąrašą. Todėl, kai sąraše yra sąrašų, reikia nukopijuoti ir vidinius sąrašus. Tu tai gali padaryti pats, tačiau Python'as savyje jau turi modulį, kuris tai padaro už tave. Gali panaudoti funkciją <code>deepcopy</code> iš <code>copy</code> modulio:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

Iš pradžių atkreipk dėmesį į tai, kad <code>a</code> sąrašų sąrašas. Toliau, kai kodo eilutė <code>b[0][1] = 10</code> yra vykdoma, tuomet <code>a</code> ir <code>b</code> pasikeičia, bet <code>c</code> ne. Taip nutiko todėl, kad vidiniai masyvai vis dar yra nuorodos, kai naudojamas pjūvio operatorius. Iš kitos pusės, <code>deepcopy</code> <code>c</code> buvo visiškai nukopijuotas.

Taigi, ar turėčiau nerimauti dėl nuorodų kiekvieną kartą, kai naudoju funkciją ar <code>=</code>? Geros naujienos yra tos, kad tau reikia nerimauti apie nuorodas tik naudojant žodynus ir sąrašus. Priskiriant skaičiaus ar teksto eilutės reikšmes turinčius kintamuosius nuorodos nesukuriamos ir tau nereikia sukti galvos ar netikėtai pasikeis reikšmė. Tačiau tau reikia turėt omeny nuorodas, kai keiti sąrašus ir žodynus.

Turbūt susimąstei, kam išvis yra reikalingos nuorodos? Pagrindinė priežastis – greitis. Sukurti nuorodą sąrašo tūkstančiui elementų yra daug greičiau nei sukurti jų kopijas. Dar viena priežastis – tai, kad tu gali turėti funkciją, kuri leidžia modifikuoti sąrašus arba žodynus. Jei kada nors susidursi su keistomis problemomis, kai duomenys pasikeičia, nors neturėtų, tai prisimink apie nuorodas.

































{{navigation |previous=Modulių naudojimas|next=Daugiau apie tekstines eilutes}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2022-03-03T08:21:31Z

LauraK:

{{navigation |previous=Modulių naudojimas|next=Daugiau apie tekstines eilutes}}

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementais ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina elementų kiekį + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį – pjaustymas (slicing). Štai pavyzdys, leidžiantis suprasti, kaip jis gali būti naudojamas:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poema = ["", "Ta", "liga", "nelimpa", "", "net", "ir", "prie",
"savų.", "Pats", "", "žiopliukas", "būdamas,", "neapkrės", "kitų.", "",
"Žiopliškumas", "buvo", "ir", "", "visad", "jis", "bus.",
"", "Jei", "skandinsi", "pelkėj,", "", "jis", "ir",
"", "ten", "nežus."]

def gauk_pastorintą(tekstas):
true = 1
false = 0
## ar_pastorintas pasako ar mes dabar tikriname
## pastorintą teksto dalį.
ar_pastorintas = false
## pradinis_blokas yra indeksas arba nepastorinta
## teksto dalis arba pastorinta.
pradinis_blokas = 0
for indeksas in range(len(tekstas)):
## Apdorojama pastorinto teksto pradžia
if tekstas[indeksas] == "":
if ar_pastorintas:
print("Klaida: Papildoma pastorinimo atidarymo žyma")
## print "Nepastorintas:", tekstas[pradinis_blokas:indeksas]
ar_pastorintas = true
pradinis_blokas = indeksas + 1
## Apdorojama pastorinto teksto pabaiga
## Atsimink, kad paskutinis skaičius atliekant pjūvį yra indeksas
## po to, kai paskutinis indeksas yra panaudotas.
if tekstas[indeksas] == "":
if not ar_pastorintas:
print("Klaida: papildoma pastorinimo uždarymo žyma")
print("Pastorintas [", pradinis_blokas, ":", indeksas, "]", tekstas[pradinis_blokas:indeksas])
ar_pastorintas = false
pradinis_blokas = indeksas + 1

gauk_pastorintą(poema)
</syntaxhighlight>

šios programos išvestis yra:

Pastorinta [ 1 : 4 ] ['Ta', 'liga', 'nelimpa']
Pastorinta [ 11 : 15 ] ['žiopliukas', 'būdamas,', 'neapkrės', 'kitų.']
Pastorinta [ 20 : 23 ] ['visad', 'jis', 'bus.']
Pastorinta [ 28 : 30 ] ['jis', 'ir']

Funkcija <code>gauk_pastorintą()</code> pasiima sau į sąrašą tai, kas buvo padalinta į žodžius ir žymas. Žymos, kurį ši funkcija ieško - <code></code>, nes ji pradeda pastorintą tekstą ir <code></code>, kuris užbaigia pastorintą tekstą. Funkcija <code>gauk_pastorintą()</code> eina per tekstą ir ieško pradžios ir pabaigos žymų.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

Šis pavyzdys turėtų nustebinti, kadangi pakeitus <code>b</code> pasikeitė ir <code>a</code>. Taip yra todėl, kad teiginys <code>b = a</code> sukūrė ''nuorodą (reference)'' iš <code>b</code> į <code>a</code>, o tai reiškia, jog <code>b</code> dabar yra dar vienas <code>a</code> vardas.
Taigi, bet koks <code>b</code> pakeitimas, keičia ir <code>a</code>. Tačiau kai kurie priskyrimai nesukuria dviejų pavadinimų vienam sąrašui, pažvelk į dar vieną pavyzdį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

Šiuo atveju <code>b</code> nėra nuoroda į <code>a</code>, nes išraiška <code>a * 2</code> sukuria naują sąrašą vietoje nuorodos į <code>a</code>. Beveik visos priskyrimo operacijos sukuria nuorodą, pavyzdžiui: kai perduodi sąrašą, kaip funkcijos argumentą, tu sukuri nuorodą.
Visgi, dažniau mums programoje reikia kopijų, o ne nuorodų. Kai norime pakeisti vieną sąrašą, nekeisdami kito sąrašo, mes turime įsitikinti, kad sukūrėme sąrašo kopiją.

Yra keli būdai, kaip gali sukurti sąrašo kopiją. Vienas iš paprasčiausių būdų yra pjaustymo operatorius, kadangi jis visuomet sukuria naują sąrašą, net tada, kai su pjūviu apimame viso sąrašo ilgį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Panaudoję pjūvio operatorių <code>[:]</code> mes sukuriame naują sąrašo kopiją. Turėk omeny, kad nukopijuojamas yra tik išorinis sąrašas. Bet koks vidinis sąrašas turi nuorodą į pirminį sąrašą. Todėl, kai sąraše yra sąrašų, reikia nukopijuoti ir vidinius sąrašus. Tu tai gali padaryti pats, tačiau Python'as savyje jau turi modulį, kuris tai padaro už tave. Gali panaudoti funkciją <code>deepcopy</code> iš <code>copy</code> modulio:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

Iš pradžių atkreipk dėmesį į tai, kad <code>a</code> sąrašų sąrašas. Toliau, kai kodo eilutė <code>b[0][1] = 10</code> yra vykdoma, tuomet <code>a</code> ir <code>b</code> pasikeičia, bet <code>c</code> ne. Taip nutiko todėl, kad vidiniai masyvai vis dar yra nuorodos, kai naudojamas pjūvio operatorius. Iš kitos pusės, <code>deepcopy</code> <code>c</code> buvo visiškai nukopijuotas.

Taigi, ar turėčiau nerimauti dėl nuorodų kiekvieną kartą, kai naudoju funkciją ar <code>=</code>? Geros naujienos yra tos, kad tau reikia nerimauti apie nuorodas tik naudojant žodynus ir sąrašus. Priskiriant skaičiaus ar teksto eilutės reikšmes turinčius kintamuosius nuorodos nesukuriamos ir tau nereikia sukti galvos ar netikėtai pasikeis reikšmė. Tačiau tau reikia turėt omeny nuorodas, kai keiti sąrašus ir žodynus.

Turbūt susimąstei, kam išvis yra reikalingos nuorodos? Pagrindinė priežastis – greitis. Sukurti nuorodą sąrašo tūkstančiui elementų yra daug greičiau nei sukurti jų kopijas. Dar viena priežastis – tai, kad tu gali turėti funkciją, kuri leidžia modifikuoti sąrašus arba žodynus. Jei kada nors susidursi su keistomis problemomis, kai duomenys pasikeičia, nors neturėtų, tai prisimink apie nuorodas.

































{{navigation |previous=Modulių naudojimas|next=Daugiau apie tekstines eilutes}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2022-03-03T08:20:11Z

LauraK:

{{navigation |previous=Modulių naudojimas|next=Daugiau apie tekstines eilutes}}

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementais ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį – pjaustymas (slicing). Štai pavyzdys, leidžiantis suprasti, kaip jis gali būti naudojamas:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poema = ["", "Ta", "liga", "nelimpa", "", "net", "ir", "prie",
"savų.", "Pats", "", "žiopliukas", "būdamas,", "neapkrės", "kitų.", "",
"Žiopliškumas", "buvo", "ir", "", "visad", "jis", "bus.",
"", "Jei", "skandinsi", "pelkėj,", "", "jis", "ir",
"", "ten", "nežus."]

def gauk_pastorintą(tekstas):
true = 1
false = 0
## ar_pastorintas pasako ar mes dabar tikriname
## pastorintą teksto dalį.
ar_pastorintas = false
## pradinis_blokas yra indeksas arba nepastorinta
## teksto dalis arba pastorinta.
pradinis_blokas = 0
for indeksas in range(len(tekstas)):
## Apdorojama pastorinto teksto pradžia
if tekstas[indeksas] == "":
if ar_pastorintas:
print("Klaida: Papildoma pastorinimo atidarymo žyma")
## print "Nepastorintas:", tekstas[pradinis_blokas:indeksas]
ar_pastorintas = true
pradinis_blokas = indeksas + 1
## Apdorojama pastorinto teksto pabaiga
## Atsimink, kad paskutinis skaičius atliekant pjūvį yra indeksas
## po to, kai paskutinis indeksas yra panaudotas.
if tekstas[indeksas] == "":
if not ar_pastorintas:
print("Klaida: papildoma pastorinimo uždarymo žyma")
print("Pastorintas [", pradinis_blokas, ":", indeksas, "]", tekstas[pradinis_blokas:indeksas])
ar_pastorintas = false
pradinis_blokas = indeksas + 1

gauk_pastorintą(poema)
</syntaxhighlight>

šios programos išvestis yra:

Pastorinta [ 1 : 4 ] ['Ta', 'liga', 'nelimpa']
Pastorinta [ 11 : 15 ] ['žiopliukas', 'būdamas,', 'neapkrės', 'kitų.']
Pastorinta [ 20 : 23 ] ['visad', 'jis', 'bus.']
Pastorinta [ 28 : 30 ] ['jis', 'ir']

Funkcija <code>gauk_pastorintą()</code> pasiima sau į sąrašą tai, kas buvo padalinta į žodžius ir žymas. Žymos, kurį ši funkcija ieško - <code></code>, nes ji pradeda pastorintą tekstą ir <code></code>, kuris užbaigia pastorintą tekstą. Funkcija <code>gauk_pastorintą()</code> eina per tekstą ir ieško pradžios ir pabaigos žymų.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

Šis pavyzdys turėtų nustebinti, kadangi pakeitus <code>b</code> pasikeitė ir <code>a</code>. Taip yra todėl, kad teiginys <code>b = a</code> sukūrė ''nuorodą (reference)'' iš <code>b</code> į <code>a</code>, o tai reiškia, jog <code>b</code> dabar yra dar vienas <code>a</code> vardas.
Taigi, bet koks <code>b</code> pakeitimas, keičia ir <code>a</code>. Tačiau kai kurie priskyrimai nesukuria dviejų pavadinimų vienam sąrašui, pažvelk į dar vieną pavyzdį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

Šiuo atveju <code>b</code> nėra nuoroda į <code>a</code>, nes išraiška <code>a * 2</code> sukuria naują sąrašą vietoje nuorodos į <code>a</code>. Beveik visos priskyrimo operacijos sukuria nuorodą, pavyzdžiui: kai perduodi sąrašą, kaip funkcijos argumentą, tu sukuri nuorodą.
Visgi, dažniau mums programoje reikia kopijų, o ne nuorodų. Kai norime pakeisti vieną sąrašą, nekeisdami kito sąrašo, mes turime įsitikinti, kad sukūrėme sąrašo kopiją.

Yra keli būdai, kaip gali sukurti sąrašo kopiją. Vienas iš paprasčiausių būdų yra pjaustymo operatorius, kadangi jis visuomet sukuria naują sąrašą, net tada, kai su pjūviu apimame viso sąrašo ilgį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Panaudoję pjūvio operatorių <code>[:]</code> mes sukuriame naują sąrašo kopiją. Turėk omeny, kad nukopijuojamas yra tik išorinis sąrašas. Bet koks vidinis sąrašas turi nuorodą į pirminį sąrašą. Todėl, kai sąraše yra sąrašų, reikia nukopijuoti ir vidinius sąrašus. Tu tai gali padaryti pats, tačiau Python'as savyje jau turi modulį, kuris tai padaro už tave. Gali panaudoti funkciją <code>deepcopy</code> iš <code>copy</code> modulio:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

Iš pradžių atkreipk dėmesį į tai, kad <code>a</code> sąrašų sąrašas. Toliau, kai kodo eilutė <code>b[0][1] = 10</code> yra vykdoma, tuomet <code>a</code> ir <code>b</code> pasikeičia, bet <code>c</code> ne. Taip nutiko todėl, kad vidiniai masyvai vis dar yra nuorodos, kai naudojamas pjūvio operatorius. Iš kitos pusės, <code>deepcopy</code> <code>c</code> buvo visiškai nukopijuotas.

Taigi, ar turėčiau nerimauti dėl nuorodų kiekvieną kartą, kai naudoju funkciją ar <code>=</code>? Geros naujienos yra tos, kad tau reikia nerimauti apie nuorodas tik naudojant žodynus ir sąrašus. Priskiriant skaičiaus ar teksto eilutės reikšmes turinčius kintamuosius nuorodos nesukuriamos ir tau nereikia sukti galvos ar netikėtai pasikeis reikšmė. Tačiau tau reikia turėt omeny nuorodas, kai keiti sąrašus ir žodynus.

Turbūt susimąstei, kam išvis yra reikalingos nuorodos? Pagrindinė priežastis – greitis. Sukurti nuorodą sąrašo tūkstančiui elementų yra daug greičiau nei sukurti jų kopijas. Dar viena priežastis – tai, kad tu gali turėti funkciją, kuri leidžia modifikuoti sąrašus arba žodynus. Jei kada nors susidursi su keistomis problemomis, kai duomenys pasikeičia, nors neturėtų, tai prisimink apie nuorodas.

































{{navigation |previous=Modulių naudojimas|next=Daugiau apie tekstines eilutes}}
{{BookCat}}

Python Vadovėlis/Ciklai For

2022-01-04T07:56:22Z

LauraK:

And here is the new typing exercise for this chapter:
<source lang="python">
onetoten = range(1, 11)
for count in onetoten:
print(count)
</source>

and the ever-present output:

1
2
3
4
5
6
7
8
9
10

The output looks awfully familiar but the program code looks different. The first line uses the <code>range</code> function. The <code>range</code> function uses two arguments like this <code>range(start, finish)</code>. <code>start</code> is the first number that is produced. <code>finish</code> is one larger than the last number. Note that this program could have been done in a shorter way:
<source lang="python">
for count in range(1, 11):
print(count)
</source>

The range function returns an iterable. This can be converted into a list with the <code>list</code> function.
Here are some examples to show what happens with the <code>range</code> command:

>>> '''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))'''
[]

The next line <code>for count in onetoten:</code> uses the <code>for</code> control structure. A <code>for</code> control structure looks like <code>for variable in list:</code>. <code>list</code> is gone through starting with the first element of the list and going to the last. As <code>for</code> goes through each element in a list it puts each into <code>variable</code>. That allows <code>variable</code> to be used in each successive time the <code>for</code> loop is run through. Here is another example (you don't have to type this) to demonstrate:
<source lang="python">
demolist = ['life', 42, 'the universe', 6, 'and', 7, 'everything']
for item in demolist:
print("The Current item is:",item)
</source>

The output is:

The Current item is: life
The Current item is: 42
The Current item is: the universe
The Current item is: 6
The Current item is: and
The Current item is: 7
The Current item is: everything

Notice how the <code>for</code> loop goes through and sets item to each element in the list. So, what is <code>for</code> good for? The first use is to go through all the elements of a list and do something with each of them. Here's a quick way to add up all the elements:

<source lang="python">
list = [2, 4, 6, 8]
sum = 0
for num in list:
sum = sum + num

print("The sum is:", sum)
</source>

with the output simply being:

The sum is: 20

Or you could write a program to find out if there are any duplicates in a list like this program does:

<source lang="python">
list = [4, 5, 7, 8, 9, 1, 0, 7, 10]
list.sort()
prev = list[0]
del list[0]
for item in list:
if prev == item:
print("Duplicate of", prev, "found")
prev = item
</source>

and for good measure:

Duplicate of 7 Found

Okay, so how does it work? Here is a special debugging version to help you understand (you don't need to type this in):

<source 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)
prev = l[0]
print("prev = l[0]", "\t\tprev:", prev)
del l[0]
print("del l[0]", "\t\tl:", l)
for item in l:
if prev == item:
print("Duplicate of", prev, "found")
print("if prev == item:", "\t\tprev:", prev, "\titem:", item)
prev = item
print("prev = item", "\t\tprev:", prev, "\titem:", item)
</source>

with the output being:

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]
prev = l[0] prev: 0
del l[0] l: [1, 4, 5, 7, 7, 8, 9, 10]
if prev == item: prev: 0 item: 1
prev = item prev: 1 item: 1
if prev == item: prev: 1 item: 4
prev = item prev: 4 item: 4
if prev == item: prev: 4 item: 5
prev = item prev: 5 item: 5
if prev == item: prev: 5 item: 7
prev = item prev: 7 item: 7
Duplicate of 7 found
if prev == item: prev: 7 item: 7
prev = item prev: 7 item: 7
if prev == item: prev: 7 item: 8
prev = item prev: 8 item: 8
if prev == item: prev: 8 item: 9
prev = item prev: 9 item: 9
if prev == item: prev: 9 item: 10
prev = item prev: 10 item: 10

The reason I put so many <code>print</code> statements in the code was so that you can see what is happening in each line. (By the way, if you can't figure out why a program is not working, try putting in lots of print statements in places where you want to know what is happening.) First the program starts with a boring old list. Next the program sorts the list. This is so that any duplicates get put next to each other. The program then initializes a <code>prev</code>(ious) variable. Next the first element of the list is deleted so that the first item is not incorrectly thought to be a duplicate. Next a <code>for</code> loop is gone into. Each item of the list is checked to see if it is the same as the previous. If it is a duplicate was found. The value of <code>prev</code> is then changed so that the next time the <code>for</code> loop is run through <code>prev</code> is the previous item to the current. Sure enough, the 7 is found to be a duplicate. (Notice how <code>\t</code> is used to print a tab.)

The other way to use <code>for</code> loops is to do something a certain number of times. Here is some code to print out the first 9 numbers of the Fibonacci series:
<source lang="python">
a = 1
b = 1
for c in range(1, 10):
print(a," ")
n = a + b
a = b
b = n
</source>

with the surprising output:

1 1 2 3 5 8 13 21 34

Everything that can be done with <code>for</code> loops can also be done with <code>while</code> loops but <code>for</code> loops give an easy way to go through all the elements in a list or to do something a certain number of times.

{{../Navigation|Lists|Boolean Expressions}}
[[Category:Non-Programmer's Tutorial for Python 3.0]]

Python Vadovėlis/Ciklai For

2022-01-04T07:34:41Z

LauraK:

Ir štai naujas šio skyriaus 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>. <code>pradžia</code> yra pirmasis atkuriamas skaičius. <code>pabaiga</code> yra vienu didesnis nei paskutinis atkuriamas 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ą. 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 (tau nereikia šito įvesti), 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> teiginių, 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 daug spausdintų teiginių 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 inicijuoja kintamąjį <code>praeitas</code>. Tada pirmasis sąrašo elementas ištrinamas, kad pirmasis elementas nebūtų klaidingai laikomas dublikatu. Toliau inicijuojamas <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ų.

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

Python Vadovėlis/Loginiai reiškiniai

2022-01-04T07:16:49Z

LauraK:

Šiame skyriuje padėsiu tau išsiaiškinti, kas yra loginiai reiškiniai. Sugalvojau nedidelį programos pavyzdį, kurio tau įvedinėti nebūtina:
<syntaxhighlight lang="python">
a = 6
b = 7
c = 42
print(1, a == 6)
print(2, a == 7)
print(3, a == 6 and b == 7)
print(4, a == 7 and b == 7)
print(5, not a == 7 and b == 7)
print(6, a == 7 or b == 7)
print(7, a == 7 or b == 6)
print(8, not (a == 7 and b == 6))
print(9, not a == 7 and b == 6)
</syntaxhighlight>

Šios programos išvestis yra:

1 True
2 False
3 True
4 False
5 True
6 True
7 False
8 True
9 False

Galvoje, turbūt, jau sukasi mintis: kas čia ką tik įvyko? Paaiškinsiu, kaip veikia kiekviena eilutė, kad mintys susidėliotų į savas vietas. Mano programoje gausu <code>print</code> sakinių, iš kurių kiekvienas išspausdina skaičių ir loginę reikšmę. Skaičius man padeda suprasti, kurio <code>print</code> sakinio rezultatas tai yra. Atkreipk dėmesį, kad kiekvienoje išvesties eilutėje yra žodis <code>False</code> arba <code>True</code>, o Python'e kiekviena loginė reikšmė <code>false</code> gali būti užrašoma skaičiumi 0, o <code>true</code> 1.

















Eilučių:

<syntaxhighlight lang="python">
print(1, a == 6)
print(2, a == 7)
</syntaxhighlight>

rezultatas atitinkamai yra <code>True</code> ir <code>False</code>, kadangi pirmasis reiškinys yra teisingas, o antrasis yra klaidingas. Trečioji eilutė: <code>print(3, a == 6 and b == 7)</code> - šiek tiek skiriasi nuo prieš tai buvusių - joje yra naudojamas operatorius <code>and</code>. Loginis operatorius <code>and</code> grąžina rezultatą <code>True</code> tik tada, kai reiškiniai iš abiejų <code>and</code> pusių yra teisingi, kitu atveju visas reiškinys bus klaidingas ir grąžins <code>False</code>. Ketvirtoje eilutėje: print(4, a == 7 and b == 7) tik vienas iš reiškinių yra teisingas, dėl to eilutės rezultatas yra <code>False</code>. Operatoriaus <code>and</code> galimi rezultatai gali būti apibrėžti tokia lentele:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|true <code>and</code> true
|true
|-
|true <code>and</code> false
|false
|-
|false <code>and</code> true
|false
|-
|false <code>and</code> false
|false
|}

Atkreipk dėmesį, jei pirmas reiškinys yra klaidingas, tai Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys yra klaidingas. Parašyk šias eilutes ir paleisk programą: <code>False and print("Labas")</code> ir palygink rezultatą su šios eilutės <code>True and print("Labas")</code> rezultatu. Techniškai tai yra vadinama [[w:Short-circuit evaluation|short-circuit evaluation]].
Penktoje eilutėje, <code>print(5, not a == 7 and b == 7)</code>, yra naudojamas <code>not</code> operatorius. <code>not</code> suteikia priešingą reikšmę reiškiniui (reiškinys taip pat galėtų būti užrašomas taip: <code> print(5, a != 7 and b == 7)</code>). Štai lentelė apibrėžianti operatoriaus <code>not</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|<code>not</code> true
|false
|-
|<code>not</code> false
|true
|}

Dvi toliau pateiktos eilutės: <code>print(6, a == 7 or b == 7)</code> ir <code>print(7, a == 7 or b == 6)</code> naudoja operatorių <code>or</code>. Pastarasis operatorius grąžina <code>True</code> jei pirmasis reiškinys yra teisingas arba, jei antrasis reiškinys yra teisingas, arba, jei abu reiškiniai yra teisingi. Jei nei vienas iš reiškinių nėra teisingas, tuomet yra grąžinamas false. Štai lentelė apibrėžianti operatoriaus <code>or</code> rezultatus:

{| class="wikitable"
!Reiškinys
!Rezultatas
|-
|true <code>or</code> true
| true
|-
|true <code>or</code> false
|true
|-
|false <code>or</code> true
| true
|-
|false <code>or</code> false
| false
|}

Turėk omeny, jei pirmasis reiškinys yra teisingas Python’as nebetikrins antrojo, kadangi jis žino, jog visas reiškinys bus teisingas. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code>, jei bent vienas iš reiškinių yra teisingas, tuomet viso reiškinio galutinis rezultatas bus teisingas. Pirmoji dalis yra teisinga, todėl antroji dalis gali būti klaidinga arba teisinga, tačiau visa išraiška vis dar teisinga.

Aštuntoje: <code>print(8, not (a == 7 and b == 6))</code> ir devintoje: <code>print(9, not a == 7 and b == 6)</code> eilutėse yra atvaizduojamas reiškinių grupavimo pavyzdys. Reiškinius Python’e galima sugrupuoti naudojant skliaustelius. Sugrupavę reiškinius, mes priverčiame Python’ą iš pradžių įvertinti reiškinius skliaustuose ir tik tada likusias reiškinio dalis. Atkreipk dėmesį, kad skliausteliai pakeitė reiškinį iš neteisingo į teisingą. Taip nutiko dėl to, kad operatorius <code>not</code> buvo pritaikytas reiškiniui skliausteliuose, vietoj to, kad būtų pritaikytas tik <code>a == 7</code> daliai.
Parodysiu pavyzdį, kaip rašant kodą galima pritaikyti loginius operatorius:

<syntaxhighlight lang="python">
sąrašas = ["Gyvenimas", "Visata", "Viskas", "Benas", "Liepa", "Gyvenimas", "Liepa"]

# kuriama sąrašo kopija. Peržiūrėk skyrių Daugiau apie sąrašus, kuriame sužinosi ką reiškia [:].
kopija = sąrašas[:]
# surūšiuoti sąrašą
kopija.sort()
ankstesnis = kopija[0]
del kopija[0]

kiekis = 0

# sąraše surask vienodus elementus
while kiekis < len(kopija) and kopija[kiekis] != ankstesnis:
ankstesnis = kopija[kiekis]
kiekis = kiekis + 1

# Jei nėra atitikmens tuomet kiekis negali būti < len
# kadangi ciklas kol bus vykdomas tol, kol kiekis < len
# ir nėra rastas atitikmuo

if kiekis < len(kopija):
print("Pirmasis atitikmuo:", ankstesnis)
</syntaxhighlight>

Šios programos rezultatas:
Pirmasis atitikmuo: Gyvenimas

Programa ieško vienodų elementų, tikrindama šią sąlygą: <code> while kiekis < len(kopija) ir kopija[kiekis] nėra lygus ankstesnis </code>. Kai <code>kiekis</code> yra didesnis už paskutinio <code>kopija</code> sąrašo elemento indeksą arba, kai atsiranda sutampantis elementas, operatorius <code>and</code> nebėra tiesa, todėl ciklas pasibaigia. <code>if</code> sakinys patikrina ar ciklas <code>while</code> pasibaigė dėl to, kad buvo rastas sutampantis elementas.

Šioje programoje yra panaudotas dar vienas <code>and</code> operatoriaus „triukas“. Jei dar kartą pažiūrėsi į operatoriaus <code>and</code> lentelę pamatysi, jog trečioje eilutėje yra netiesa ir netiesa. Jei <code>kiekis >= len(kopija)</code> (kitais žodžiais, jei <code>kiekis < len(kopija)</code> yra <code>False</code>), tada kodo dalis <code>kopija[kiekis]</code> nebus tikrinama. Taip yra todėl, kad Python’as žino, jei pirmasis teiginys yra klaidingas, tai abu jie nebegali būti teisingi. Šis „short circuit“ triukas yra naudingas tuomet, kai antrasis <code>and</code> operatoriaus teiginys gali sukelti klaidą. Aš panaudojau pirmąjį teiginį (<code>kiekis < len(kopija)</code>), kad patikrinčiau ar kintamasis <code>kiekis</code> yra validus sąrašo <code>kopija</code> indeksas. Jei manimi netiki, tuomet ištrink iš sąrašo elementus „Liepa“ ir „Gyvenimas“, sukeisk vietomis sąlygas <code>kiekis < len(kopija) and kopija[kiekis] != ankstesnis</code> (rašyk: <code>kopija[kiekis] != ankstesnis and kiekis < len(kopija)</code>) ir patikrink ar programa vis dar veikia, kaip turėtų.

Loginės išraiškos gali būti naudojamos, kai mes norime patikrinti dvi arba daugiau skirtingų sąlygų vienu metu.

=== Pastaba apie loginius operatorius ===
Dažna pradedančiųjų programuotojų klaida yra neteisingas supratimas, kaip veikia loginiai operatoriai ir kaip juos „skaito“ Python'o interpretatorius. Pavyzdžiui: vos tik sužinojus apie operatorius <code>and</code> ir <code>or</code>, galima pagalvoti, kad išraiška <code>x == ('a' or 'b')</code> patikrins, ar kintamasis <code>x</code> yra lygus <code>a</code> arba kintamasis <code>x</code> lygus <code>b</code>, tačiau taip nėra. Norint suprasti, apie ką kalbu, pradėk interaktyvią sesiją su interpretatoriumi ir įvesk šias išraiškas:

>>> 'a' == ('a' or 'b')
>>> 'b' == ('a' or 'b')
>>> 'a' == ('a' and 'b')
>>> 'b' == ('a' and 'b')

Štai yra rezultatai, kurie nėra intuityvūs:

>>>''' 'a' == ('a' or 'b')'''
True
>>>''' 'b' == ('a' or 'b')'''
False
>>>''' 'a' == ('a' and 'b')'''
False
>>>''' 'b' == ('a' and 'b')'''
True

Šiuo momentu gali pasirodyti, jog operatoriai <code>and</code> ir <code>or</code> veikia klaidingai. Neatrodo logiška, jog pirmuose reiškiniuose <code>'a'</code> yra lygu <code>'a'</code> arba <code>'b'</code>, tačiau <code>'b'</code> nėra lygu <code>'a'</code> arba <code>'b'</code>. Taip pat yra ir su paskutiniu reiškiniu - jis neatrodo teisingas, nes <code>'b'</code> yra lygus <code>'a'</code> ir <code>'b'</code>. Išsiaiškinus, kaip veikia Python’o interpretatorius pasidaro aišku, kodėl gavome būtent tokius rezultatus.

Kai Python’o interpretatorius „pamato“ reiškinį, kuriame yra naudojamas <code>or</code>, jis paima pirmąjį teiginį ir patikrina ar jo rezultatas yra <code>True</code>. Jei pirmasis teiginys yra <code>True</code>, tuomet Python’as grąžina to teiginio rezultatą, netikrindamas antrojo. Kaip jau minėjau anksčiau, naudojant operatorių <code>or</code> užtenka patikrinti ar pirmasis teiginys yra teisingas, nes tada mes jau žinome, kad visas reiškinys yra teisingas ir programai nebereikia papildomai tikrinti antrojo. Iš kitos pusės, jei pirmasis teiginys grąžina <code>False</code>, tada Python’as turi patikrinti ir antrojo teiginio rezultatą bei grąžinti jo reikšmę. Antrasis teiginys nusako visos išraiškos rezultatą, kadangi pirmoji pusė buvo klaidinga. Šis interpretatoriaus „tingus“ įvertinimas vadinamas "short circuiting" ir yra įprastas būdas įvertinti logines išraiškas daugelyje programavimo kalbų.

Panašiai veikia ir operatorius <code>and</code>: Python’as naudoja, "short circuit" techniką, kad pagreitintų išraiškos įvertinimą. Jei pirmasis teiginys yra klaidingas, tada visas reiškinys yra klaidingas. Kitu atveju, jei pirmasis teiginys yra teisingas, tada Python’as patikrina antrąjį ir grąžina galutinę reikšmę.

Reiktų atkreiptį dėmesį į vieną niuansą: ne tik loginių išraiškų rezultatai gali būti apibrėžiami <code>True</code> arba <code>False</code> reikšmėmis. Norėdami patikrinti bet kurio objekto <code>x</code> loginę reikšmę, galite naudoti funkciją <code>bool(x)</code>. Žemiau yra pateikiama lentelė, kurioje yra pavyzdžiai, kokiems objektams Python’as priskiria <code>True</code> arba <code>False</code>:

{| class="wikitable"
|-
!True !!False
|-
|True ||False
|-
|1 ||0
|-
|Skaičiai kitokie nei nulis ||Tekstinė eilutė 'None'
|-
|Ne tuščios tekstinės eilutės ||Tuščios tekstinės eilutės
|-
|Sąrašai (lists) turintys elementų ||Sąrašai (lists) neturintys elementų
|-
|Žodynai (dictionaries) turintys elementų ||Žodynai (dictionaries) neturintys elementų
|}

Dabar galime suprasti gluminančius rezultatus, kuriuos gavome, kai anksčiau išbandėme logines išraiškas. Pažiūrėkime, ką Python'o interpretatorius „mato“, eidamas per šį kodą:

'''Pirmasis atvejis:'''
>>>''' 'a' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'a' == 'a' ''' # teksto eilutė 'a' yra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra True
True

'''Antrasis atvejis:'''
>>>''' 'b' == ('a' or 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' or 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True
# Grąžink tą pirmą reikšmę: 'a'
>>>''' 'b' == 'a' ''' # teksto eilutė 'b' nėra lygi teksto eilutei 'a', todėl reiškinio rezultatas yra False
False

'''Trečiasis atvejis:'''
>>>''' 'a' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose: "('a' and 'b')"
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'a' == 'b' ''' # teksto eilutė 'a' nėra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra False
False

'''Ketvirtasis atvejis:'''
>>>''' 'b' == ('a' and 'b')''' # Iš pradžių žiūrėk į reiškinį skliaustuose:
# 'a' yra netuščia teksto eilutė, todėl reiškinio rezultatas yra True, patikrinkime antrąją reikšmę
# 'b' yra netuščia teksto eilutė, todėl antrojo reiškinio rezultatas yra True
# Grąžink antrąją reikšmę kaip viso reiškinio rezultatą: 'b'
>>>''' 'b' == 'b' ''' # teksto eilutė 'b' yra lygi teksto eilutei 'b', todėl reiškinio rezultatas yra True
True

Taigi, Python’as tikrai teisingai įvertino duotuosius reiškinius, kurių rezultatai iš pradžių neatrodė akivaizdūs. Kaip minėjau anksčiau, svarbu atpažinti, kokį rezultatą tavo loginė išraiška grąžins ir kodėl.

Grįžtant prie pradinių reiškinių, štai kaip juos turėtum aprašyti, kad jie grąžintų reikšmes, kurių tikiesi:

>>>''' 'a' == 'a' or 'a' == 'b' '''
True
>>>''' 'b' == 'a' or 'b' == 'b' '''
True
>>>''' 'a' == 'a' and 'a' == 'b' '''
False
>>>''' 'b' == 'a' and 'b' == 'b' '''
False

Įvertinus šiuos reiškinius yra gaunamos logines reikšmes <code>True</code> arba <code>False</code>, o ne teksto eilutės, kad galėtume gauti teisingus palyginimo rezultatus.

=== Pavyzdžiai ===
'''slaptazodis1.py'''
<syntaxhighlight lang="python">
## Ši programa prašo vartotojo prisijungimo vardo ir slaptažodžio.
# Kai vartotojas juos įveda, programa įvertina ar jis gali prisijungti.

vardas = input("Koks tavo vardas? ")
slaptažodis = input("Koks tavo slaptažodis? ")
if vardas == "Benas" and slaptažodis == "Penktadienis":
print("Sveikas, Benai!")
elif vardas == "Jonas" and slaptažodis == "Kietas":
print("Sveikas, Jonai!")
else:
print("Aš tavęs nepažįstu.")
</syntaxhighlight>

Pavyzdiniai rezultatai:

Koks tavo vardas? '''Benas'''

Koks tavo slaptažodis? '''Penktadienis'''

Sveikas, Benai!

Koks tavo vardas? '''Andrius'''

Koks tavo slaptažodis? '''Pinigai'''

Aš tavęs nepažįstu.

=== Užduotys ===
Parašyk programą, kurioje vartotojas turi atspėti tavo vardą, tačiau jie turės tik 3 spėjimus tai padaryti iki kol programa bus uždaryta.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
print("Pabandyk atspėti mano vardą!")
kiekis = 1
vardas = "gilbertas"
spėjimas = input("Koks mano vardas? ")
while kiekis < 3 and spėjimas.lower() != vardas: # .lower visas didžiąsias raides teksto eilutėje pakeičia į mažąsias, todėl net jei vartotojas įves Gilbertas, tai vis tiek bus teisingas atsakymas
print("Tu neteisus!")
spėjimas = input("Koks mano vardas? ")
kiekis = kiekis + 1

if spėjimas.lower() != vardas:
print("Tu neteisus!") # ši žinutė nėra atspausdinama trečiąjį bandymą, todėl mes tai padarome dabar
print("Tu nebegali spėti.")
else:
print("Taip! Mano vardas yra", vardas + "!")

</syntaxhighlight>
|-
|}

{{navigation |previous=Ciklai For |next=Žodynai}}
{{BookCat}}

Python Vadovėlis/Sąrašai

2021-12-15T14:26:25Z

LauraK:

=== 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 šiomis eilutėmis <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 ilgai eilutei atskirti gali būti naudojamas simbolis <code>\</code>, tačiau šiuo atveju jis nėra būtinas, nes Python'as supranta, kad viskas, kas yra laužtiniuose skliaustuose priklauso 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.

Teiginys <code> if 1 <= kuris <= 12:</code> bus teisingas tik tuo atveju, kai <code>kuris</code> yra tarp vieno ir dvylikos imtinai (kitaip tariant, to ir tikėtumeis, jeigu matytum tai matematikoje).

Sąrašai gali būti laikomi blokų serija. Kiekvienas blokas turi vis kitą reikšmę. Pavyzdžiui, blokai sukurti šiuo kodu: <code>demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]</code> atrodytų taip:

{| class="wikitable"
!bloko numeris
!0
!1
!2
!3
!4
!5
|-
|demoSąrašas
|"gyvybė"
|42
|"visata"
|6
|"ir"
|9
|}

Kiekvienas blokas nurodomas jo numeriu - indeksu, todėl teiginys <code>demoSąrašas[0]</code> gautų <code>"gyvybė"</code>, <code>demoSąrašas[1]</code> gautų <code>42</code> ir taip toliau iki kol <code>demoSąrašas[5]</code> gauna <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ą susivesi į programą, 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 naudojama visa krūva 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ų, įvesk <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 iškarto 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, kol pasiekia paskutinį sąrašo indeksą. Tuo tarpu <code>print</code> teiginys 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>
|pasiekia elementą ties indeksu 2
|-
|<code>demoSąrašas[2] = 3</code>
|nustato elementą ties indeksu 2 kaip 3
|-
|<code>del demoSąrašas[2]</code>
|pašalina elementą, esantį 2 indekse
|-
|<code>len(demoSąrašas)</code>
|grąžina <code>demoSąrašas</code> ilgį
|-
|<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 reišme iš <code>demoSąrašas</code> (taip pat, kaip <code>del demoSąrašas[demoSąrašas.index("reikšmė")]</code>)
|}

Šiame kitame pavyzdyje šios funkcijos naudojamos naudingiau:
<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 teiginį <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=Pažangių funkcijų pavyzdys |next=Ciklai For}}
{{BookCat}}

Python Vadovėlis/Rekursinės funkcijos

2021-12-15T12:49:56Z

LauraK:

Vieniems šis skyrius gali pasirodyti naudingas, o kitiems - painus. Jeigu tau informacija pasirodys paini, tai nesuk galvos ir praleisk, prie šio skyriaus galėsi grįžti šiek tiek vėliau. O dabar pabandom pasižiūrėti į mūsų parašytą programą:
<syntaxhighlight lang="python">
def daug(a, b): # daug reiškia daugybą
if b == 0:
return 0
lik = daug(a, b - 1) #lik reiškia likutį
reiksme = a + lik
return reiksme
rezultatas = daug(3, 2)
print("3 * 2 = ", rezultatas)
</syntaxhighlight>

Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reikia atkreipti dėmesį į tai, kad Python'o programavimo kalboje jau yra integruota funkcija dauginimui, čia mes patys parašėme lengvai suprantamą pavyzdį (jeigu kurtume tokią funkciją patys), kuris parodo kaip atrodo daugybos veiksmas. Šioje programoje gali pamatyti rekursijos naudojimą, tai yra iteracijos (kartojimo) forma, kai funkcija yra pakartotinai iškviečiama, kol bus įvykdyta sukurta išvesties sąlyga. Programa naudoja pakartotinius papildymus, kad gautų tą patį rezultatą kaip ir daugyba: pavyzdžiui 3 + 3 (sudėtis) duoda tą patį rezultatą kaip ir 3 * 2 (daugyba).

; ''Klausimas:'' Ką pirmiausia daro programa?
: ''Atsakymas:'' Pirmiausia yra aprašyta daugybos funkcija:
<syntaxhighlight lang="python">
def daug(a, b):
if b == 0:
return 0
lik = daug(a, b - 1)
reiksme = a + lik
return reiksme
</syntaxhighlight>
: Tai sukuria funkciją, kuri paima du parametrus ir grąžina reikšmę, kai ji atitinka reikiamą rezultatą. Vėliau šią funkciją galima paleisti.
; Kas nutinka toliau?
: Vykdoma kita eilutė einanti po funkcijos <code>rezultatas = daug(3, 2)</code>
; Ką daro ši eilutė?
: Ši eilutė priskiria grąžinimo reikšmę <code>daug(3, 2)</code> kintamajam <code>rezultatas</code>.
; Ką grąžina <code>daug(3, 2)</code>?
: Norėdami tai išsiaiškinti, turime peržiūrėti funkciją <code>daug()</code>.
; Kas vyksta su kodu?
: Kintamasis <code>a</code> gauna jam priskirtą reikšmę 3, o kintamasis <code>b</code> - jam priskirtą reikšmę 2.
; Kas nutinka tada?
: Vykdoma eilutė <code>if b == 0:</code>. Kadangi <code>b</code> reikšmė yra 2, todėl eilutė <code>return 0</code> praleidžiama.
; Kas vyksta toliau?
: Vykdoma eilutė <code>lik = daug(a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>lik</code> reikšmę į <code>daug(a, b - 1)</code> reikšmę. <code>a</code> reikšmė yra 3, o <code>b</code> - 2, todėl funkcija kviečia funkciją<code>daug(3,1)</code>
; Taigi kokia yra <code>daug(3, 1)</code> reikšmė?
: Turime paleisti funkciją <code>daug()</code> su parametrais, kurie yra 3 ir 1.
; Kas nutinka toliau?
: Lokalūs kintamieji vėl pasileidus kodui jau yra nustatyti, todėl <code>a</code> reikšmė būtų 3, o <code>b</code> reikšmė -1. Kadangi jie yra lokalūs kintamieji, todėl jie neturi įtakos ankstesnėms <code>a</code> ir <code>b</code> reikšmėms.
; Kas įvyksta toliau?
: Kadangi <code>b</code> turi reikšmę 1, if teiginys yra neigiamas, todėl vykdoma kita eilutė <code>lik = daug(a, b - 1)</code>.
; Ką daro ši eilutė?
: Ši eilutė <code>daug(3, 0)</code> reikšmę priskiria kitiems.
; Ką daro ši reikšmė?
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> - 0.
; Kas vyksta toliau?
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code>
; Ką daro <code>return 0</code> eilutė?
: Ši eilutė grąžina funkcijos reikšmę lygią 0.
; Kas iš to?
: Dabar mes žinome, kad <code>daug(3, 0)</code> turi reikšmę 0. Dar žinome, ką daro eilutė <code>lik = daug(a, b - 1)</code>, nes paleidžiame funkciją <code>daug()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>daug(3, 0)</code> ir dabar vėl pradedame vykdyti <code>daug(3, 1)</code>. Kintamajam <code>lik</code> priskiriama vertė 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>reiksme = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reiksme = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return reiksme</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.
; Kur yra <code>daug(3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reiksme = a + lik</code> nustato <code>reiksme</code> į <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradeda veikti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>rezultatas = daug(3, 2)</code>, kuriai dabar galima priskirti reikšmę 6 kintamajam <code>rezultatas</code>
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", rezultatas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>rezultatas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmam skaičiui ir pirmas skaičius yra vienu skaitmeniu mažesnis už antrajį skaičių <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Tuomet galime apskaičiuoti, kad <code>3 + 3 * 0</code> yra <code>3 + 0</code> arba kitaip tariant tiesiog <code>3</code>. Tuomet mes žinome, kas yra <code>3 * 1</code>, todėl galime apskaičiuoti, kad <code>3 + 3 * 1</code> yra <code>3 + 3</code> arba kitaip tariant <code>6</code>.

Štai kaip viskas veikia:

daug(3, 2)
3 + daug(3, 1)
3 + 3 + daug(3, 0)
3 + 3 + 0
3 + 3
6

==== Rekursija ====
Programavimo konstrukcijos, išsprendžiančios problemą išsprendžiant mažesnę tos pačios problemos versiją, vadinamos „rekursyviomis“. Šio skyriaus pavyzdžiuose rekursija realizuojama apibrėžiant funkciją, kuri pati save iškviečia. Tai palengvina programavimo užduočių spendimų įgyvendinimą, nes kartais pakanka apsvarstyti tik vieną problemos žingsnį, o ne visą problemą iš karto. Be to tai leidžia išreikšti kai kurias matematines sąvokas paprastu, lengvai skaitomu kodu.

Bet kokią problemą, kurią galime išspręsti naudojant rekursiją, gali būti išspręsta naudojant ciklus. Jie veikia greičiau, bet kartais ciklus sunku atlikti teisingai.

Turbūt intuityviausias „rekursijos“ apibrėžimas yra toks:
; Rekursija
: Jei vis dar nesupranti, tai skaityk: REKURSIJA.
Pabandyk perskaityti faktinį pavyzdį, jei nesupratai daugybos pavyzdžio.

=== Pavyzdžiai ===
'''faktorialas.py'''
<syntaxhighlight lang="python">
#apibrėžia funkciją, kuri apskaičiuoja koeficientą

def faktorialas(n):
if n == 0:
return 1
if n<0:
return "Klaida, neigiami skaičiai neturi faktorialo reikšmių!!"
return n * faktorialas(n - 1)

print("2! =", faktorialas(2))
print("3! =", faktorialas(3))
print("4! =", faktorialas(4))
print("5! =", faktorialas(5))
print("-3! =", faktorialas(-3))
</syntaxhighlight>

Rezultatas:

2! = 2
3! = 6
4! = 24
5! = 120
-3! = Klaida, neigiami skaičiai neturi faktorialo reikšmių!!

'''atgalinis_kaičiavimas.py'''
<syntaxhighlight lang="python">
def atgalinis_kaičiavimas(n):
print(n)
if n > 0:
return atgalinis_kaičiavimas(n-1)

atgalinis_kaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Python Vadovėlis/Rekursinės funkcijos

2021-12-15T12:46:57Z

LauraK:

Vieniems šis skyrius gali pasirodyti naudingas, o kitiems - painus. Jeigu tau informacija pasirodys paini, tai nesuk galvos ir praleisk, prie šio skyriaus galėsi grįžti šiek tiek vėliau. O dabar pabandom pasižiūrėti į mūsų parašytą programą:
<syntaxhighlight lang="python">
def daug(a, b): # daug reiškia daugybą
if b == 0:
return 0
lik = daug(a, b - 1) #lik reiškia likutį
reiksme = a + lik
return reiksme
rezultatas = daug(3, 2)
print("3 * 2 = ", rezultatas)
</syntaxhighlight>

Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reikia atkreipti dėmesį į tai, kad Python'o programavimo kalboje jau yra integruota funkcija dauginimui, čia mes patys parašėme lengvai suprantamą pavyzdį (jeigu kurtume tokią funkciją patys), kuris parodo kaip atrodo daugybos veiksmas. Šioje programoje gali pamatyti rekursijos naudojimą, tai yra iteracijos (kartojimo) forma, kai funkcija yra pakartotinai iškviečiama, kol bus įvykdyta sukurta išvesties sąlyga. Programa naudoja pakartotinius papildymus, kad gautų tą patį rezultatą kaip ir daugyba: pavyzdžiui 3 + 3 (sudėtis) duoda tą patį rezultatą kaip ir 3 * 2 (daugyba).

; ''Klausimas:'' Ką pirmiausia daro programa?
: ''Atsakymas:'' Pirmiausia yra aprašyta daugybos funkcija:
<syntaxhighlight lang="python">
def daug(a, b):
if b == 0:
return 0
lik = daug(a, b - 1)
reiksme = a + lik
return reiksme
</syntaxhighlight>
: Tai sukuria funkciją, kuri paima du parametrus ir grąžina reikšmę, kai ji atitinka reikiamą rezultatą. Vėliau šią funkciją galima paleisti.
; Kas nutinka toliau?
: Vykdoma kita eilutė einanti po funkcijos <code>rezultatas = daug(3, 2)</code>
; Ką daro ši eilutė?
: Ši eilutė priskiria grąžinimo reikšmę <code>daug(3, 2)</code> kintamajam <code>rezultatas</code>.
; Ką grąžina <code>daug(3, 2)</code>?
: Norėdami tai išsiaiškinti, turime peržiūrėti funkciją <code>daug()</code>.
; Kas vyksta su kodu?
: Kintamasis <code>a</code> gauna jam priskirtą reikšmę 3, o kintamasis <code>b</code> - jam priskirtą reikšmę 2.
; Kas nutinka tada?
: Vykdoma eilutė <code>if b == 0:</code>. Kadangi <code>b</code> reikšmė yra 2, todėl eilutė <code>return 0</code> praleidžiama.
; Kas vyksta toliau?
: Vykdoma eilutė <code>lik = daug(a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>lik</code> reikšmę į <code>daug(a, b - 1)</code> reikšmę. <code>a</code> reikšmė yra 3, o <code>b</code> - 2, todėl funkcija kviečia funkciją<code>daug(3,1)</code>
; Taigi kokia yra <code>daug(3, 1)</code> reikšmė?
: Turime paleisti funkciją <code>daug()</code> su parametrais, kurie yra 3 ir 1.
; Kas nutinka toliau?
: Lokalūs kintamieji vėl pasileidus kodui jau yra nustatyti, todėl <code>a</code> reikšmė būtų 3, o <code>b</code> reikšmė -1. Kadangi jie yra lokalūs kintamieji, todėl jie neturi įtakos ankstesnėms <code>a</code> ir <code>b</code> reikšmėms.
; Kas įvyksta toliau?
: Kadangi <code>b</code> turi reikšmę 1, if teiginys yra neigiamas, todėl vykdoma kita eilutė <code>lik = daug(a, b - 1)</code>.
; Ką daro ši eilutė?
: Ši eilutė <code>daug(3, 0)</code> reikšmę priskiria kitiems.
; Ką daro ši reikšmė?
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> - 0.
; Kas vyksta toliau?
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code>
; Ką daro <code>return 0</code> eilutė?
: Ši eilutė grąžina funkcijos reikšmę lygią 0.
; Kas iš to?
: Dabar mes žinome, kad <code>daug(3, 0)</code> turi reikšmę 0. Dar žinome, ką daro eilutė <code>lik = daug(a, b - 1)</code>, nes paleidžiame funkciją <code>daug()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>daug(3, 0)</code> ir dabar vėl pradedame vykdyti <code>daug(3, 1)</code>. Kintamajam <code>lik</code> priskiriama vertė 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>reiksme = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reiksme = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return reiksme</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.
; Kur yra <code>daug(3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reiksme = a + lik</code> nustato <code>reiksme</code> į <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradeda veikti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>resultas = daug(3, 2)</code>, kuriai dabar galima priskirti reikšmę 6 kintamajam <code>resultas</code>
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", resultas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>resultas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmam skaičiui ir pirmas skaičius yra vienu skaitmeniu mažesnis už antrajį skaičių <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Tuomet galime apskaičiuoti, kad <code>3 + 3 * 0</code> yra <code>3 + 0</code> arba kitaip tariant tiesiog <code>3</code>. Tuomet mes žinome, kas yra <code>3 * 1</code>, todėl galime apskaičiuoti, kad <code>3 + 3 * 1</code> yra <code>3 + 3</code> arba kitaip tariant <code>6</code>.

Štai kaip viskas veikia:

daug(3, 2)
3 + daug(3, 1)
3 + 3 + daug(3, 0)
3 + 3 + 0
3 + 3
6

==== Rekursija ====
Programavimo konstrukcijos, išsprendžiančios problemą išsprendžiant mažesnę tos pačios problemos versiją, vadinamos „rekursyviomis“. Šio skyriaus pavyzdžiuose rekursija realizuojama apibrėžiant funkciją, kuri pati save iškviečia. Tai palengvina programavimo užduočių spendimų įgyvendinimą, nes kartais pakanka apsvarstyti tik vieną problemos žingsnį, o ne visą problemą iš karto. Be to tai leidžia išreikšti kai kurias matematines sąvokas paprastu, lengvai skaitomu kodu.

Bet kokią problemą, kurią galime išspręsti naudojant rekursiją, gali būti išspręsta naudojant ciklus. Jie veikia greičiau, bet kartais ciklus sunku atlikti teisingai.

Turbūt intuityviausias „rekursijos“ apibrėžimas yra toks:
; Rekursija
: Jei vis dar nesupranti, tai skaityk: REKURSIJA.
Pabandyk perskaityti faktinį pavyzdį, jei nesupratai daugybos pavyzdžio.

=== Pavyzdžiai ===
'''faktorialas.py'''
<syntaxhighlight lang="python">
#apibrėžia funkciją, kuri apskaičiuoja koeficientą

def faktorialas(n):
if n == 0:
return 1
if n<0:
return "Klaida, neigiami skaičiai neturi faktorialo reikšmių!!"
return n * faktorialas(n - 1)

print("2! =", faktorialas(2))
print("3! =", faktorialas(3))
print("4! =", faktorialas(4))
print("5! =", faktorialas(5))
print("-3! =", faktorialas(-3))
</syntaxhighlight>

Rezultatas:

2! = 2
3! = 6
4! = 24
5! = 120
-3! = Klaida, neigiami skaičiai neturi faktorialo reikšmių!!

'''atgalinis_kaičiavimas.py'''
<syntaxhighlight lang="python">
def atgalinis_kaičiavimas(n):
print(n)
if n > 0:
return atgalinis_kaičiavimas(n-1)

atgalinis_kaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Python Vadovėlis/Rekursinės funkcijos

2021-12-15T12:46:08Z

LauraK:

Vieniems šis skyrius gali pasirodyti naudingas, o kitiems - painus. Jeigu tau informacija pasirodys paini, tai nesuk galvos ir praleisk, prie šio skyriaus galėsi grįžti šiek tiek vėliau. O dabar pabandom pasižiūrėti į mūsų parašytą programą:
<syntaxhighlight lang="python">
def daug(a, b): # daug reiškia daugybą
if b == 0:
return 0
lik = daug(a, b - 1) #lik reiškia likutį
reiksme = a + lik
return reiksme
rezultatas = daug(3, 2)
print("3 * 2 = ", rezultatas)
</syntaxhighlight>

Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reikia atkreipti dėmesį į tai, kad Python'o programavimo kalboje jau yra integruota funkcija dauginimui, čia mes patys parašėme lengvai suprantamą pavyzdį (jeigu kurtume tokią funkciją patys), kuris parodo kaip atrodo daugybos veiksmas. Šioje programoje gali pamatyti rekursijos naudojimą, tai yra iteracijos (kartojimo) forma, kai funkcija yra pakartotinai iškviečiama, kol bus įvykdyta sukurta išvesties sąlyga. Programa naudoja pakartotinius papildymus, kad gautų tą patį rezultatą kaip ir daugyba: pavyzdžiui 3 + 3 (sudėtis) duoda tą patį rezultatą kaip ir 3 * 2 (daugyba).

; ''Klausimas:'' Ką pirmiausia daro programa?
: ''Atsakymas:'' Pirmiausia yra aprašyta daugybos funkcija:
<syntaxhighlight lang="python">
def daug(a, b):
if b == 0:
return 0
lik = daug(a, b - 1)
reiksme = a + lik
return reiksme
</syntaxhighlight>
: Tai sukuria funkciją, kuri paima du parametrus ir grąžina reikšmę, kai ji atitinka reikiamą rezultatą. Vėliau šią funkciją galima paleisti.
; Kas nutinka toliau?
: Vykdoma kita eilutė einanti po funkcijos <code>resultas = daug(3, 2)</code>
; Ką daro ši eilutė?
: Ši eilutė priskiria grąžinimo reikšmę <code>daug(3, 2)</code> kintamajam <code>resultas</code>.
; Ką grąžina <code>daug(3, 2)</code>?
: Norėdami tai išsiaiškinti, turime peržiūrėti funkciją <code>daug()</code>.
; Kas vyksta su kodu?
: Kintamasis <code>a</code> gauna jam priskirtą reikšmę 3, o kintamasis <code>b</code> - jam priskirtą reikšmę 2.
; Kas nutinka tada?
: Vykdoma eilutė <code>if b == 0:</code>. Kadangi <code>b</code> reikšmė yra 2, todėl eilutė <code>return 0</code> praleidžiama.
; Kas vyksta toliau?
: Vykdoma eilutė <code>lik = daug(a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>lik</code> reikšmę į <code>daug(a, b - 1)</code> reikšmę. <code>a</code> reikšmė yra 3, o <code>b</code> - 2, todėl funkcija kviečia funkciją<code>daug(3,1)</code>
; Taigi kokia yra <code>daug(3, 1)</code> reikšmė?
: Turime paleisti funkciją <code>daug()</code> su parametrais, kurie yra 3 ir 1.
; Kas nutinka toliau?
: Lokalūs kintamieji vėl pasileidus kodui jau yra nustatyti, todėl <code>a</code> reikšmė būtų 3, o <code>b</code> reikšmė -1. Kadangi jie yra lokalūs kintamieji, todėl jie neturi įtakos ankstesnėms <code>a</code> ir <code>b</code> reikšmėms.
; Kas įvyksta toliau?
: Kadangi <code>b</code> turi reikšmę 1, if teiginys yra neigiamas, todėl vykdoma kita eilutė <code>lik = daug(a, b - 1)</code>.
; Ką daro ši eilutė?
: Ši eilutė <code>daug(3, 0)</code> reikšmę priskiria kitiems.
; Ką daro ši reikšmė?
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> - 0.
; Kas vyksta toliau?
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code>
; Ką daro <code>return 0</code> eilutė?
: Ši eilutė grąžina funkcijos reikšmę lygią 0.
; Kas iš to?
: Dabar mes žinome, kad <code>daug(3, 0)</code> turi reikšmę 0. Dar žinome, ką daro eilutė <code>lik = daug(a, b - 1)</code>, nes paleidžiame funkciją <code>daug()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>daug(3, 0)</code> ir dabar vėl pradedame vykdyti <code>daug(3, 1)</code>. Kintamajam <code>lik</code> priskiriama vertė 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>reiksme = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reiksme = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return reiksme</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.
; Kur yra <code>daug(3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reiksme = a + lik</code> nustato <code>reiksme</code> į <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradeda veikti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>resultas = daug(3, 2)</code>, kuriai dabar galima priskirti reikšmę 6 kintamajam <code>resultas</code>
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", resultas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>resultas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmam skaičiui ir pirmas skaičius yra vienu skaitmeniu mažesnis už antrajį skaičių <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Tuomet galime apskaičiuoti, kad <code>3 + 3 * 0</code> yra <code>3 + 0</code> arba kitaip tariant tiesiog <code>3</code>. Tuomet mes žinome, kas yra <code>3 * 1</code>, todėl galime apskaičiuoti, kad <code>3 + 3 * 1</code> yra <code>3 + 3</code> arba kitaip tariant <code>6</code>.

Štai kaip viskas veikia:

daug(3, 2)
3 + daug(3, 1)
3 + 3 + daug(3, 0)
3 + 3 + 0
3 + 3
6

==== Rekursija ====
Programavimo konstrukcijos, išsprendžiančios problemą išsprendžiant mažesnę tos pačios problemos versiją, vadinamos „rekursyviomis“. Šio skyriaus pavyzdžiuose rekursija realizuojama apibrėžiant funkciją, kuri pati save iškviečia. Tai palengvina programavimo užduočių spendimų įgyvendinimą, nes kartais pakanka apsvarstyti tik vieną problemos žingsnį, o ne visą problemą iš karto. Be to tai leidžia išreikšti kai kurias matematines sąvokas paprastu, lengvai skaitomu kodu.

Bet kokią problemą, kurią galime išspręsti naudojant rekursiją, gali būti išspręsta naudojant ciklus. Jie veikia greičiau, bet kartais ciklus sunku atlikti teisingai.

Turbūt intuityviausias „rekursijos“ apibrėžimas yra toks:
; Rekursija
: Jei vis dar nesupranti, tai skaityk: REKURSIJA.
Pabandyk perskaityti faktinį pavyzdį, jei nesupratai daugybos pavyzdžio.

=== Pavyzdžiai ===
'''faktorialas.py'''
<syntaxhighlight lang="python">
#apibrėžia funkciją, kuri apskaičiuoja koeficientą

def faktorialas(n):
if n == 0:
return 1
if n<0:
return "Klaida, neigiami skaičiai neturi faktorialo reikšmių!!"
return n * faktorialas(n - 1)

print("2! =", faktorialas(2))
print("3! =", faktorialas(3))
print("4! =", faktorialas(4))
print("5! =", faktorialas(5))
print("-3! =", faktorialas(-3))
</syntaxhighlight>

Rezultatas:

2! = 2
3! = 6
4! = 24
5! = 120
-3! = Klaida, neigiami skaičiai neturi faktorialo reikšmių!!

'''atgalinis_kaičiavimas.py'''
<syntaxhighlight lang="python">
def atgalinis_kaičiavimas(n):
print(n)
if n > 0:
return atgalinis_kaičiavimas(n-1)

atgalinis_kaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Python Vadovėlis/Rekursinės funkcijos

2021-12-15T12:44:34Z

LauraK:

Vieniems šis skyrius gali pasirodyti naudingas, o kitiems - painus. Jeigu tau informacija pasirodys paini, tai nesuk galvos ir praleisk, prie šio skyriaus galėsi grįžti šiek tiek vėliau. O dabar pabandom pasižiūrėti į mūsų parašytą programą:
<syntaxhighlight lang="python">
def daug(a, b): # daug reiškia daugybą
if b == 0:
return 0
lik = daug(a, b - 1) #lik reiškia likutį
reiksme = a + lik
return reiksme
rezultatas = daug(3, 2)
print("3 * 2 = ", rezultatas)
</syntaxhighlight>

Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reikia atkreipti dėmesį į tai, kad Python'o programavimo kalboje jau yra integruota funkcija dauginimui, čia mes patys parašėme lengvai suprantamą pavyzdį (jeigu kurtume tokią funkciją patys), kuris parodo kaip atrodo daugybos veiksmas. Šioje programoje gali pamatyti rekursijos naudojimą, tai yra iteracijos (kartojimo) forma, kai funkcija yra pakartotinai iškviečiama, kol bus įvykdyta sukurta išvesties sąlyga. Programa naudoja pakartotinius papildymus, kad gautų tą patį rezultatą kaip ir daugyba: pavyzdžiui 3 + 3 (sudėtis) duoda tą patį rezultatą kaip ir 3 * 2 (daugyba).

; ''Klausimas:'' Ką pirmiausia daro programa?
: ''Atsakymas:'' Pirmiausia yra aprašyta funkcija daugink:
<syntaxhighlight lang="python">
def daug(a, b):
if b == 0:
return 0
lik = daug(a, b - 1)
reiksme = a + lik
return reiksme
</syntaxhighlight>
: Tai sukuria funkciją, kuri paima du parametrus ir grąžina reikšmę, kai ji atitinka reikiamą rezultatą. Vėliau šią funkciją galima paleisti.
; Kas nutinka toliau?
: Vykdoma kita eilutė einanti po funkcijos <code>resultas = daug(3, 2)</code>
; Ką daro ši eilutė?
: Ši eilutė priskiria grąžinimo reikšmę <code>daug(3, 2)</code> kintamajam <code>resultas</code>.
; Ką grąžina <code>daug(3, 2)</code>?
: Norėdami tai išsiaiškinti, turime peržiūrėti funkciją <code>daug()</code>.
; Kas vyksta su kodu?
: Kintamasis <code>a</code> gauna jam priskirtą reikšmę 3, o kintamasis <code>b</code> - jam priskirtą reikšmę 2.
; Kas nutinka tada?
: Vykdoma eilutė <code>if b == 0:</code>. Kadangi <code>b</code> reikšmė yra 2, todėl eilutė <code>return 0</code> praleidžiama.
; Kas vyksta toliau?
: Vykdoma eilutė <code>lik = daug(a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>lik</code> reikšmę į <code>daug(a, b - 1)</code> reikšmę. <code>a</code> reikšmė yra 3, o <code>b</code> - 2, todėl funkcija kviečia funkciją<code>daug(3,1)</code>
; Taigi kokia yra <code>daug(3, 1)</code> reikšmė?
: Turime paleisti funkciją <code>daug()</code> su parametrais, kurie yra 3 ir 1.
; Kas nutinka toliau?
: Lokalūs kintamieji vėl pasileidus kodui jau yra nustatyti, todėl <code>a</code> reikšmė būtų 3, o <code>b</code> reikšmė -1. Kadangi jie yra lokalūs kintamieji, todėl jie neturi įtakos ankstesnėms <code>a</code> ir <code>b</code> reikšmėms.
; Kas įvyksta toliau?
: Kadangi <code>b</code> turi reikšmę 1, if teiginys yra neigiamas, todėl vykdoma kita eilutė <code>lik = daug(a, b - 1)</code>.
; Ką daro ši eilutė?
: Ši eilutė <code>daug(3, 0)</code> reikšmę priskiria kitiems.
; Ką daro ši reikšmė?
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> - 0.
; Kas vyksta toliau?
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code>
; Ką daro <code>return 0</code> eilutė?
: Ši eilutė grąžina funkcijos reikšmę lygią 0.
; Kas iš to?
: Dabar mes žinome, kad <code>daug(3, 0)</code> turi reikšmę 0. Dar žinome, ką daro eilutė <code>lik = daug(a, b - 1)</code>, nes paleidžiame funkciją <code>daug()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>daug(3, 0)</code> ir dabar vėl pradedame vykdyti <code>daug(3, 1)</code>. Kintamajam <code>lik</code> priskiriama vertė 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>reiksme = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reiksme = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return reiksme</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.
; Kur yra <code>daug(3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reiksme = a + lik</code> nustato <code>reiksme</code> į <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradeda veikti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>resultas = daug(3, 2)</code>, kuriai dabar galima priskirti reikšmę 6 kintamajam <code>resultas</code>
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", resultas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>resultas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmam skaičiui ir pirmas skaičius yra vienu skaitmeniu mažesnis už antrajį skaičių <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Tuomet galime apskaičiuoti, kad <code>3 + 3 * 0</code> yra <code>3 + 0</code> arba kitaip tariant tiesiog <code>3</code>. Tuomet mes žinome, kas yra <code>3 * 1</code>, todėl galime apskaičiuoti, kad <code>3 + 3 * 1</code> yra <code>3 + 3</code> arba kitaip tariant <code>6</code>.

Štai kaip viskas veikia:

daug(3, 2)
3 + daug(3, 1)
3 + 3 + daug(3, 0)
3 + 3 + 0
3 + 3
6

==== Rekursija ====
Programavimo konstrukcijos, išsprendžiančios problemą išsprendžiant mažesnę tos pačios problemos versiją, vadinamos „rekursyviomis“. Šio skyriaus pavyzdžiuose rekursija realizuojama apibrėžiant funkciją, kuri pati save iškviečia. Tai palengvina programavimo užduočių spendimų įgyvendinimą, nes kartais pakanka apsvarstyti tik vieną problemos žingsnį, o ne visą problemą iš karto. Be to tai leidžia išreikšti kai kurias matematines sąvokas paprastu, lengvai skaitomu kodu.

Bet kokią problemą, kurią galime išspręsti naudojant rekursiją, gali būti išspręsta naudojant ciklus. Jie veikia greičiau, bet kartais ciklus sunku atlikti teisingai.

Turbūt intuityviausias „rekursijos“ apibrėžimas yra toks:
; Rekursija
: Jei vis dar nesupranti, tai skaityk: REKURSIJA.
Pabandyk perskaityti faktinį pavyzdį, jei nesupratai daugybos pavyzdžio.

=== Pavyzdžiai ===
'''faktorialas.py'''
<syntaxhighlight lang="python">
#apibrėžia funkciją, kuri apskaičiuoja koeficientą

def faktorialas(n):
if n == 0:
return 1
if n<0:
return "Klaida, neigiami skaičiai neturi faktorialo reikšmių!!"
return n * faktorialas(n - 1)

print("2! =", faktorialas(2))
print("3! =", faktorialas(3))
print("4! =", faktorialas(4))
print("5! =", faktorialas(5))
print("-3! =", faktorialas(-3))
</syntaxhighlight>

Rezultatas:

2! = 2
3! = 6
4! = 24
5! = 120
-3! = Klaida, neigiami skaičiai neturi faktorialo reikšmių!!

'''atgalinis_kaičiavimas.py'''
<syntaxhighlight lang="python">
def atgalinis_kaičiavimas(n):
print(n)
if n > 0:
return atgalinis_kaičiavimas(n-1)

atgalinis_kaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}

Python Vadovėlis/Kas čia eina?

2021-12-08T13:28:17Z

LauraK: /* Pavyzdžiai */

=== Įvestis ir kintamieji ===
Aš 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? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

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 yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos.
Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
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 Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji talpina 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>Jonas</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 == Op!
reikšmė2 == "Op!"
</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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų 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 = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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 <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir grąžino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> 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>, 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 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>)

Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus 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 (paskutinis veiksmas):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operation
!Symbol
!Example
|-
|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("Temperatura Farenheitais: "))
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)
print("Temperatura Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatura Farenheitais: '''32'''
Temperatura Celsijaus laipsniais: 0.0

Temperatura Farenheitais: '''-40'''
Temperatura Celsijaus laipsniais: -40.0

Temperatura Farenheitais: '''212'''
Temperatura Celsijaus laipsniais: 100.0

Temperatura Farenheitais: '''98.6'''
Temperatura Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programa, kuri priima 2 tekstines reikšmes, 2 skaičius ir vartotojo įvestį, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

=== 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=Hello, World |next=Count to 10}}

Python Vadovėlis/Kas čia eina?

2021-12-08T13:26:30Z

LauraK: /* Pavyzdžiai */

=== Įvestis ir kintamieji ===
Aš 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? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

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 yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos.
Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
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 Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji talpina 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>Jonas</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 == Op!
reikšmė2 == "Op!"
</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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų 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 = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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 <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir grąžino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> 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>, 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 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>)

Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus 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 (paskutinis veiksmas):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operation
!Symbol
!Example
|-
|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 koncertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatura Farenheitais: "))
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)
print("Temperatura Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatura Farenheitais: '''32'''
Temperatura Celsijaus laipsniais: 0.0

Temperatura Farenheitais: '''-40'''
Temperatura Celsijaus laipsniais: -40.0

Temperatura Farenheitais: '''212'''
Temperatura Celsijaus laipsniais: 100.0

Temperatura Farenheitais: '''98.6'''
Temperatura Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programa, kuri priima 2 tekstines reikšmes, 2 skaičius ir vartotojo įvestį, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

=== 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=Hello, World |next=Count to 10}}

Python Vadovėlis/Kas čia eina?

2021-12-08T13:26:07Z

LauraK: /* Pavyzdžiai */

=== Įvestis ir kintamieji ===
Aš 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? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

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 yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos.
Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
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 Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji talpina 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>Jonas</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 == Op!
reikšmė2 == "Op!"
</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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų 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 = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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 <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir grąžino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> 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>, 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 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>)

Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus 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 (paskutinis veiksmas):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operation
!Symbol
!Example
|-
|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("Įvestike 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 koncertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatura Farenheitais: "))
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)
print("Temperatura Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatura Farenheitais: '''32'''
Temperatura Celsijaus laipsniais: 0.0

Temperatura Farenheitais: '''-40'''
Temperatura Celsijaus laipsniais: -40.0

Temperatura Farenheitais: '''212'''
Temperatura Celsijaus laipsniais: 100.0

Temperatura Farenheitais: '''98.6'''
Temperatura Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programa, kuri priima 2 tekstines reikšmes, 2 skaičius ir vartotojo įvestį, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

=== 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=Hello, World |next=Count to 10}}

Python Vadovėlis/Kas čia eina?

2021-12-08T13:15:15Z

LauraK: /* Priskyrimai */

=== Įvestis ir kintamieji ===
Aš 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? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

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 yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos.
Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
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 Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji talpina 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>Jonas</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 == Op!
reikšmė2 == "Op!"
</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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų 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 = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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 <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir grąžino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> 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>, 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 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>)

Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus 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 (paskutinis veiksmas):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operation
!Symbol
!Example
|-
|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("Įvestike 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:

Įvestike stačiakampio informaciją
Ilgis: '''4'''
Plotis: '''3'''
Plotas: 12.0
Perimetras: 14.0

Įvestike stačiakampio informaciją
Ilgis: '''2.53'''
Plotis: '''5.2'''
Plotas: 13.156
Perimetras: 15.46

'''Temperatura.py'''
<syntaxhighlight lang="python">
# Ši programa koncertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatura Farenheitais: "))
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)
print("Temperatura Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatura Farenheitais: '''32'''
Temperatura Celsijaus laipsniais: 0.0

Temperatura Farenheitais: '''-40'''
Temperatura Celsijaus laipsniais: -40.0

Temperatura Farenheitais: '''212'''
Temperatura Celsijaus laipsniais: 100.0

Temperatura Farenheitais: '''98.6'''
Temperatura Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programa, kuri priima 2 tekstines reikšmes, 2 skaičius ir vartotojo įvestį, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

=== 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=Hello, World |next=Count to 10}}

Python Vadovėlis/Kas čia eina?

2021-12-08T13:11:12Z

LauraK: /* Priskyrimai */

=== Įvestis ir kintamieji ===
Aš 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? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

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 yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos.
Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
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 Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji talpina 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>Jonas</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 == Op!
reikšmė2 == "Op!"
</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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų 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 = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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 <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir gražino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> graž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>, 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'' (virvelė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas - ne. Atkreipk dėmesį, kai python 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>)

Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus ir duos klaidą, jei bus bandoma panaudoti tesktą. Štai keleta 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 (paskutinis veiksmas):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operation
!Symbol
!Example
|-
|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("Įvestike 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:

Įvestike stačiakampio informaciją
Ilgis: '''4'''
Plotis: '''3'''
Plotas: 12.0
Perimetras: 14.0

Įvestike stačiakampio informaciją
Ilgis: '''2.53'''
Plotis: '''5.2'''
Plotas: 13.156
Perimetras: 15.46

'''Temperatura.py'''
<syntaxhighlight lang="python">
# Ši programa koncertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatura Farenheitais: "))
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)
print("Temperatura Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatura Farenheitais: '''32'''
Temperatura Celsijaus laipsniais: 0.0

Temperatura Farenheitais: '''-40'''
Temperatura Celsijaus laipsniais: -40.0

Temperatura Farenheitais: '''212'''
Temperatura Celsijaus laipsniais: 100.0

Temperatura Farenheitais: '''98.6'''
Temperatura Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programa, kuri priima 2 tekstines reikšmes, 2 skaičius ir vartotojo įvestį, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

=== 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=Hello, World |next=Count to 10}}

Python Vadovėlis/Kas čia eina?

2021-12-08T13:09:01Z

LauraK: /* Įvestis ir kintamieji */

=== Įvestis ir kintamieji ===
Aš 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? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

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 yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos.
Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
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 Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji talpina 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>Jonas</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 == Op!
reikšmė2 == "Op!"
</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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų apie tekstą ir <code>==</code>).

=== Priskyrimai ===

Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kuri gali būti kintamajame. Komputeris pamatys tokią eilutę <code>vardas = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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), komputeris 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 <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir gražino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> graž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>, 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'' (virvelė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas - ne. Atkreipk dėmesį, kai python 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>)

Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus ir duos klaidą, jei bus bandoma panaudoti tesktą. Štai keleta 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 (paskutinis veiksmas):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operation
!Symbol
!Example
|-
|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("Įvestike 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:

Įvestike stačiakampio informaciją
Ilgis: '''4'''
Plotis: '''3'''
Plotas: 12.0
Perimetras: 14.0

Įvestike stačiakampio informaciją
Ilgis: '''2.53'''
Plotis: '''5.2'''
Plotas: 13.156
Perimetras: 15.46

'''Temperatura.py'''
<syntaxhighlight lang="python">
# Ši programa koncertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatura Farenheitais: "))
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)
print("Temperatura Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatura Farenheitais: '''32'''
Temperatura Celsijaus laipsniais: 0.0

Temperatura Farenheitais: '''-40'''
Temperatura Celsijaus laipsniais: -40.0

Temperatura Farenheitais: '''212'''
Temperatura Celsijaus laipsniais: 100.0

Temperatura Farenheitais: '''98.6'''
Temperatura Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programa, kuri priima 2 tekstines reikšmes, 2 skaičius ir vartotojo įvestį, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

=== 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=Hello, World |next=Count to 10}}

Python Vadovėlis/Kas čia eina?

2021-12-08T13:08:33Z

LauraK: /* Įvestis ir kintamieji */

=== Įvestis ir kintamieji ===
Aš 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? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

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 yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos.
Šai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
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 Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji talpina 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>Jonas</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 == Op!
reikšmė2 == "Op!"
</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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų apie tekstą ir <code>==</code>).

=== Priskyrimai ===

Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kuri gali būti kintamajame. Komputeris pamatys tokią eilutę <code>vardas = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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), komputeris 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 <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir gražino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> graž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>, 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'' (virvelė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas - ne. Atkreipk dėmesį, kai python 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>)

Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus ir duos klaidą, jei bus bandoma panaudoti tesktą. Štai keleta 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 (paskutinis veiksmas):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operation
!Symbol
!Example
|-
|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("Įvestike 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:

Įvestike stačiakampio informaciją
Ilgis: '''4'''
Plotis: '''3'''
Plotas: 12.0
Perimetras: 14.0

Įvestike stačiakampio informaciją
Ilgis: '''2.53'''
Plotis: '''5.2'''
Plotas: 13.156
Perimetras: 15.46

'''Temperatura.py'''
<syntaxhighlight lang="python">
# Ši programa koncertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatura Farenheitais: "))
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)
print("Temperatura Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatura Farenheitais: '''32'''
Temperatura Celsijaus laipsniais: 0.0

Temperatura Farenheitais: '''-40'''
Temperatura Celsijaus laipsniais: -40.0

Temperatura Farenheitais: '''212'''
Temperatura Celsijaus laipsniais: 100.0

Temperatura Farenheitais: '''98.6'''
Temperatura Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programa, kuri priima 2 tekstines reikšmes, 2 skaičius ir vartotojo įvestį, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

=== 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=Hello, World |next=Count to 10}}

Python Vadovėlis/Kas čia eina?

2021-12-08T13:07:58Z

LauraK: /* Įvestis ir kintamieji */

=== Įvestis ir kintamieji ===
Aš 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? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

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 yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos.
Šai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
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 Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji talpina 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>Jonas</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 == Op!
reikšmė2 == "Op!"
</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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų apie tekstą ir <code>==</code>).

=== Priskyrimai ===

Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kuri gali būti kintamajame. Komputeris pamatys tokią eilutę <code>vardas = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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), komputeris 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 <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir gražino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> graž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>, 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'' (virvelė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas - ne. Atkreipk dėmesį, kai python 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>)

Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus ir duos klaidą, jei bus bandoma panaudoti tesktą. Štai keleta 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 (paskutinis veiksmas):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operation
!Symbol
!Example
|-
|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("Įvestike 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:

Įvestike stačiakampio informaciją
Ilgis: '''4'''
Plotis: '''3'''
Plotas: 12.0
Perimetras: 14.0

Įvestike stačiakampio informaciją
Ilgis: '''2.53'''
Plotis: '''5.2'''
Plotas: 13.156
Perimetras: 15.46

'''Temperatura.py'''
<syntaxhighlight lang="python">
# Ši programa koncertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatura Farenheitais: "))
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)
print("Temperatura Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatura Farenheitais: '''32'''
Temperatura Celsijaus laipsniais: 0.0

Temperatura Farenheitais: '''-40'''
Temperatura Celsijaus laipsniais: -40.0

Temperatura Farenheitais: '''212'''
Temperatura Celsijaus laipsniais: 100.0

Temperatura Farenheitais: '''98.6'''
Temperatura Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programa, kuri priima 2 tekstines reikšmes, 2 skaičius ir vartotojo įvestį, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

=== 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=Hello, World |next=Count to 10}}

Python Vadovėlis/Įvadas į importuotas bibliotekas ir kitas funkcijas

2021-10-24T17:39:05Z

LauraK: /* Intro to Imported Libraries and other Functions */

== Įvadas į importuotas bibliotekas ir kitas funkcijas ==

Šiame skyriuje apžvelgsime kai kurias funkcijas iš įvairių importuotų bibliotekų, kurios yra dažniausiai naudojamos Python'e. Šis skyrius nėra būtinas norint visiškai suprasti Python pagrindus. Šis skyrius skirtas parodyti tolesnes Python galimybes, kurias galima panaudoti su tuo, ką jau žinote apie kalbą.

=== math ===

:Matematikos biblioteka aprėpia daug naudingų funkcijų, kurių prireikia programoms, kurios atlieka įvarias matematines operacijas (kurioms neužtenka Python'o operatorių).

:Šiame skyriuje daroma prielaida, kad turi matematikos žinias iki trigonometrijos kurso imtinai.

Šiame sąraše išvardintos visos matematikos bibliotekos funkcijos:
*math.ceil
*math.copysign
*math.fabs
*math.factorial
*math.floor
*math.fmod (Nėra pati idealiausia funkcija su kuria galima pasiekti nurodytą tikslą. Šiame skyriuje nebus detaliau paaiškinta.)
*math.frexp (Už šios pamokos ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.fsum
*math.isfinite
*math.isinf
*math.isnan
*math.ldexp
*math.modf (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.trunc (Už šios pamokos srities ribų. Šiame skyriuje nebus detaliau paaiškinta.)
*math.exp
*math.expm1
*math.log
*math.log1p
*math.log10
*math.pow
*math.sqrt
*math.acos
*math.asin
*math.atan
*math.atan2
*math.cos
*math.hypot
*math.sin
*math.tan
*math.degrees
*math.radians
*math.acosh
*math.asinh
*math.atanh
*math.cosh
*math.sinh
*math.tanh
*math.erf
*math.erfc
*math.gamma
*math.lgamma
*math.pi
*math.e

:Žinoma, neapimsime visų šių funkcijų, bet padengsime didelę jų dalį.

Pradėkime nuo dviejų konstantų matematikos bibliotekoje. <code>math.pi</code> yra matematinė konstanta "π", tavo kompiuteryje pasiekiamu tikslumu. <code>math.e</code> yra matematinė konstanta "e", tavo kompiuteryje pasiekiamu tikslumu.
Štai yra abiejų konstantų, įvestų interaktyviuoju režimu Python apvalkale, pavyzdys:
>>> import math
>>> math.e
2.718281828459045
>>> math.pi
3.141592653589793

Šios konstantos gali būti saugomos kintamajame, kaip ir bet kuris kitas skaičius. Žemiau pateikiamas būtent toks pavyzdys ir parodytos paprastos šių kintamųjų operacijos:
>>> conste = math.e
>>> (conste + 5 / 2) * 2.21
11.532402840894488
>>> constpi = math.pi
>>> (((7 /2.1) % constpi) * 2)
0.38348135948707984
>>>

Dabar pažvelk į funkcijas: pradėk nuo sąrašo viršaus ir judėk žemyn (kai kurios funkcijos bus praleistos).
Kai peržiūrinėsi kiekvieną iš pavyzdžių, pabandyk išsiaiškinti, ką kiekviena funkcija daro. Šalia bus pateiktas sakinys ar du, kurie turėtų tau padėti.

Žemiau pateikiamas kiekvienos <code> math </code> modulio funkcijos pavyzdys ir kaip ji naudojama (išskyrus anksčiau nurodytas funkcijas, kurių nereikia paaiškinti)

>>> import math
>>> math.ceil(4.5) ** Suapvalina skaičių iki artimiausio skaičiaus po kablelio **
5
>>> math.ceil(4.1)
5
>>> math.copysign(4, -.4) ** Grąžina absoliučią reikšmę <code>x</code> su ženklu, kurį turi skaičius <code>y</code>. <code>(x, y)</code>
-4.0
>>> math.copysign(-4, 4)
4.0
>>> math.fabs(-44) ** Grąžina absoliučią skaičiaus reikšmę, kaip slankiojo kablelio reikšmę **
44.0
>>> math.factorial(4) ** Grąžina skaičiaus faktorialą **
24
>>> math.floor(4.3) ** Grąžina didžiausią sveikąjį skaičių, mažesnį arba lygų duotajam skaičiui **
4
>>> math.floor(4.99999)
4
>>> math.fsum([.1,.2,5,45.2,-.054,.4]) ** Grąžina visų skliausteliuose esančių skaičių sumą. Funkcija ne visada tiksli **
50.846000000000004
>>> math.isfinite(3) ** Grąžina <code>True</code>, jei reikšmė nėra begalinė ar NaN. Kitu atveju, grąžina <code>False</code>. **
True

{{navigation |previous=Intro to Object Oriented Programming in Python 3 |next=The End}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-19T07:22:38Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poema = ["", "Ta", "liga", "nelimpa", "", "net", "ir", "prie",
"savų.", "Pats", "", "žiopliukas", "būdams,", "neapkrės", "kitų.", "",
"Žiopliškumas", "buvo", ir", "", "visad", "jis", "bus",
"", "Jei", "skandinsi", "pelkėj,", "", "jis", "ir",
"", "ten", "nežus"]

def gauk_pastorintą(tekstas):
true = 1
false = 0
## ar_pastorintas pasako ar mes dabar tikriname
## pastorintą teksto dalį.
ar_pastorintas = false
## pradinis_blokas yra indeksas arba nepastorinta
## teksto dalis arba pastorinta.
pradinis_blokas = 0
for indeksas in range(len(tekstas)):
## Apdorojama pastorinto teksto pradžia
if tekstas[indeksas] == "":
if ar_pastorintas:
print("Klaida: Papildoma pastorinimo atidarymo žyma")
## print "Nepastorintas:", tekstas[pradinis_blokas:indeksas]
ar_pastorintas = true
pradinis_blokas = indeksas + 1
## Apdorojama pastorinto teksto pabaiga
## Atsimink, kad paskutinis skaičius atliekant pjūvį yra indeksas
## po to, kai paskutinis indeksas yra panaudotas.
if tekstas[indeksas] == "":
if not ar_pastorintas:
print("Klaida: papildoma pastorinimo uždarymo žyma")
print("Pastorintas [", pradinis_blokas, ":", indeksas, "]", tekstas[pradinis_blokas:indeksas])
ar_pastorintas = false
pradinis_blokas = indeksas + 1

gauk_pastorintą(poema)
</syntaxhighlight>

šios programos išvestis yra:

Pastorinta [ 1 : 4 ] ['Ta', 'liga', 'nelimpa']
Pastorinta [ 11 : 15 ] ['žiopliukas', 'būdams,', 'neapkrės', 'kitų.']
Pastorinta [ 20 : 23 ] ['visad', 'jis', 'bus.']
Pastorinta [ 28 : 30 ] ['jis', 'ir']

Funkcija <code>gauk_pastorintą()</code> pasiima sau į sąrašą tai, kas buvo padalinta į žodžius ir žymas. Žymos, kurį ši funkcija ieško - <code></code>, nes ji pradeda pastorintą tekstą ir <code></code>, kuris užbaigia pastorintą tekstą. Funkcija <code>gauk_pastorintą()</code> eina per tekstą ir ieško pradžios ir pabaigos žymų.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

Šis pavyzdys turėtų nustebinti, kadangi pakeitus <code>b</code> pasikeitė ir <code>a</code>. Taip yra todėl, kad teiginys <code>b = a</code> sukūrė ''nuorodą(reference)'' iš <code>b</code> į <code>a</code>, o tai reiškia, jog <code>b</code> dabar yra dar vienas <code>a</code> vardas.
Taigi, bet koks <code>b</code> pakeitimas, keičia ir <code>a</code>. Tačiau kai kurie priskyrimai nesukuria dviejų pavadinimų vienam sąrašui, pažvelk į dar vieną pavyzdį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

Šiuo atveju <code>b</code> nėra nuoroda į <code>a</code>, nes išraiška <code>a * 2</code> sukuria naują sąrašą vietoje nuorodos į <code>a</code>. Visos priskyrimo operacijos sukuria nuorodą, pavyzdžiui: kai perduodi sąrašą kaip funkcijos argumentą, tu sukuri nuorodą.
Visgi, dažniau kuriame kopijas, o ne nuorodas, todėl svarbu įsitikinti, kas buvo sukurta, pavyzdžiui: kai norime pakeisti vieną sąrašą, nekeisdami kito sąrašo pavadinimo, mes turime įsitikinti, kad sukūrėme sąrašo kopiją.

Yra keli būdai, kaip gali sukurti sąrašo kopiją. Vienas iš paprasčiausių būdų yra pjaustymo operatorius, kadangi jis visuomet sukuria naują sąrašą, net tada, kai su pjūviu apimame viso sąrašo ilgį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Panaudoję pjūvio operatorių <code>[:]</code> mes sukuriame naujo sąrašo kopiją. Turėk omeny, kad nukopijuojamas yra tik išorinis sąrašas. Bet koks vidinis sąrašas turi nuorodą į pirminį sąrašą. Todėl, kai sąraše yra sąrašų, reikia nukopijuoti ir vidinius sąrašus. Tu tai gali padaryti pats, tačiau Python'as savy jau turi modulį, kuris tai padaro už tave. Gali panaudoti funkciją <code>deepcopy</code> iš <code>copy</code> modulio:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

Iš pradžių atkreipk dėmesį į tai, kad <code>a</code> sąrašų sąrašas. Tada pastebėk, kad, kai kodo eilutė <code>b[0][1] = 10</code> yra vykdoma, tuomet <code>a</code> ir <code>b</code> pasikeičia, bet <code>c</code> ne. Taip nutiko todėl, kad vidiniai masyvai vis dar yra nuorodos, kai naudojamas pjūvio operatorius. Iš kitos pusės, <code>deepcopy</code> <code>c</code> buvo visiškai nukopijuotas.

Taigi, ar turėčiau nerimauti dėl nuorodų kiekvieną kartą, kai naudoju funkciją ar
<code>=</code>? Geros naujienos yra tos, kad tau reikia nerimauti apie nuorodas tik naudojant žodynus ir sąrašus. Skaičiai ir teksto eilutės sukuria nuorodas tik tada, kai yra vykdoma priskyrimo operacija, tačiau, kitos operacijos sukuria kopija ir tau nereikia sukti galvos ar netikėtai pasikeis reikšmė. Tačiau tau reikia turėt omeny nuorodas, kai keiti sąrašus ir žodynus.

Turbūt susimąstei, kam išvis yra reikalingos nuorodos? Pagrindinė priežastis - greitis. Sukurti nuorodą sąrašo tūkstančiui elementų yra yra daug greičiau nei sukurti jų kopijas. Dar viena priežastis - tai, kad tu gali turėti funkciją, kuri leidžia modifikuoti sąrašus arba žodynus. Jei kada nors susidursi su keistomis problemomis, kai duomenys pasikeičia, nors neturėtų, tai prisimink apie nuorodas.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-19T06:23:59Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poema = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def gauk_pastorintą(tekstas):
true = 1
false = 0
## ar_pastorintas pasako ar mes dabar tikriname
## pastorintą teksto dalį.
ar_pastorintas = false
## pradinis_blokas yra indeksas arba nepastorinta
## teksto dalis arba pastorinta.
pradinis_blokas = 0
for indeksas in range(len(tekstas)):
## Apdorojama pastorinto teksto pradžia
if tekstas[indeksas] == "":
if ar_pastorintas:
print("Klaida: Papildoma pastorinimo atidarymo žyma")
## print "Nepastorintas:", tekstas[pradinis_blokas:indeksas]
ar_pastorintas = true
pradinis_blokas = indeksas + 1
## Apdorojama pastorinto teksto pabaiga
## Atsimink, kad paskutinis skaičius atliekant pjūvį yra indeksas
## po to, kai paskutinis indeksas yra panaudotas.
if tekstas[indeksas] == "":
if not ar_pastorintas:
print("Klaida: papildoma pastorinimo uždarymo žyma")
print("Pastorintas [", pradinis_blokas, ":", indeksas, "]", tekstas[pradinis_blokas:indeksas])
ar_pastorintas = false
pradinis_blokas = indeksas + 1

gauk_pastorintą(poema)
</syntaxhighlight>

šios programos išvestis yra:

Pastorinta [ 1 : 4 ] ['Jack', 'and', 'Jill']
Pastorinta [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Pastorinta [ 20 : 23 ] ['down', 'and', 'broke']
Pastorinta [ 28 : 30 ] ['Jill', 'came']

Funkcija <code>gauk_pastorintą()</code> pasiima sau į sąrašą tai, kas buvo padalinta į žodžius ir žymas. Žymos, kurį ši funkcija ieško - <code></code>, nes ji pradeda pastorintą tekstą ir <code></code>, kuris užbaigia pastorintą tekstą. Funkcija <code>gauk_pastorintą()</code> eina per tekstą ir ieško pradžios ir pabaigos žymų.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

Šis pavyzdys turėtų nustebinti, kadangi pakeitus <code>b</code> pasikeitė ir <code>a</code>. Taip yra todėl, kad teiginys <code>b = a</code> sukūrė ''nuorodą(reference)'' iš <code>b</code> į <code>a</code>, o tai reiškia, jog <code>b</code> dabar yra dar vienas <code>a</code> vardas.
Taigi, bet koks <code>b</code> pakeitimas, keičia ir <code>a</code>. Tačiau kai kurie priskyrimai nesukuria dviejų pavadinimų vienam sąrašui, pažvelk į dar vieną pavyzdį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

Šiuo atveju <code>b</code> nėra nuoroda į <code>a</code>, nes išraiška <code>a * 2</code> sukuria naują sąrašą vietoje nuorodos į <code>a</code>. Visos priskyrimo operacijos sukuria nuorodą, pavyzdžiui: kai perduodi sąrašą kaip funkcijos argumentą, tu sukuri nuorodą.
Visgi, dažniau kuriame kopijas, o ne nuorodas, todėl svarbu įsitikinti, kas buvo sukurta, pavyzdžiui: kai norime pakeisti vieną sąrašą, nekeisdami kito sąrašo pavadinimo, mes turime įsitikinti, kad sukūrėme sąrašo kopiją.

Yra keli būdai, kaip gali sukurti sąrašo kopiją. Vienas iš paprasčiausių būdų yra pjaustymo operatorius, kadangi jis visuomet sukuria naują sąrašą, net tada, kai su pjūviu apimame viso sąrašo ilgį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Panaudoję pjūvio operatorių <code>[:]</code> mes sukuriame naujo sąrašo kopiją. Turėk omeny, kad nukopijuojamas yra tik išorinis sąrašas. Bet koks vidinis sąrašas turi nuorodą į pirminį sąrašą. Todėl, kai sąraše yra sąrašų, reikia nukopijuoti ir vidinius sąrašus. Tu tai gali padaryti pats, tačiau Python'as savy jau turi modulį, kuris tai padaro už tave. Gali panaudoti funkciją <code>deepcopy</code> iš <code>copy</code> modulio:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

Iš pradžių atkreipk dėmesį į tai, kad <code>a</code> sąrašų sąrašas. Tada pastebėk, kad, kai kodo eilutė <code>b[0][1] = 10</code> yra vykdoma, tuomet <code>a</code> ir <code>b</code> pasikeičia, bet <code>c</code> ne. Taip nutiko todėl, kad vidiniai masyvai vis dar yra nuorodos, kai naudojamas pjūvio operatorius. Iš kitos pusės, <code>deepcopy</code> <code>c</code> buvo visiškai nukopijuotas.

Taigi, ar turėčiau nerimauti dėl nuorodų kiekvieną kartą, kai naudoju funkciją ar
<code>=</code>? Geros naujienos yra tos, kad tau reikia nerimauti apie nuorodas tik naudojant žodynus ir sąrašus. Skaičiai ir teksto eilutės sukuria nuorodas tik tada, kai yra vykdoma priskyrimo operacija, tačiau, kitos operacijos sukuria kopija ir tau nereikia sukti galvos ar netikėtai pasikeis reikšmė. Tačiau tau reikia turėt omeny nuorodas, kai keiti sąrašus ir žodynus.

Turbūt susimąstei, kam išvis yra reikalingos nuorodos? Pagrindinė priežastis - greitis. Sukurti nuorodą sąrašo tūkstančiui elementų yra yra daug greičiau nei sukurti jų kopijas. Dar viena priežastis - tai, kad tu gali turėti funkciją, kuri leidžia modifikuoti sąrašus arba žodynus. Jei kada nors susidursi su keistomis problemomis, kai duomenys pasikeičia, nors neturėtų, tai prisimink apie nuorodas.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2021-10-18T18:34:03Z

LauraK:

=== ...or how to handle errors ===

=== closing files with with ===

We use the "with" statement to open and close files.<ref>
[http://docs.python.org/3.4/reference/compound_stmts.html#the-with-statement "The 'with' statement"]
</ref><ref>
[http://preshing.com/20110920/the-python-with-statement-by-example/ 'The Python "with" Statement by Example']
</ref>

<syntaxhighlight lang="python">
with open("in_test.txt", "rt") as in_file:
with open("out_test.txt", "wt") as out_file:
text = in_file.read()
data = parse(text)
results = encode(data)
out_file.write(results)
print( "All done." )
</syntaxhighlight>

If some sort of error happens anywhere in this code
(one of the files is inaccessible,
the parse() function chokes on corrupt data,
etc.)
the "with" statements guarantee that all the files will eventually be properly closed. Closing a file just means that the file is "cleaned up" and "released" by our program so that it can be used in another program.

{{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-18T18:32:37Z

LauraK:

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]]
: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

2021-10-18T18:31:39Z

LauraK:

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]]
:How to handle errors
;[[Vadovėlis/Recursion]]
:Recursive Functions
;[[Vadovėlis/Intro to Object Oriented Programming in Python 3|Vadovėlis/Intro to Object Oriented Programming in Python 3 [Laura]]]
: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/Daugiau apie sąrašus

2021-10-18T18:28:01Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poema = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def gauk_pastorintą(tekstas):
true = 1
false = 0
## ar_pastorintas pasako ar mes dabar tikriname
## pastorintą teksto dalį.
ar_pastorintas = false
## pradinis_blokas yra indeksas arba nepastorinta
## teksto dalis arba pastorinta.
pradinis_blokas = 0
for indeksas in range(len(tekstas)):
## Apdorojama pastorinto teksto pradžia
if tekstas[indeksas] == "":
if ar_pastorintas:
print("Klaida: Papildoma pastorinimo atidarymo žyma")
## print "Nepastorintas:", tekstas[pradinis_blokas:indeksas]
ar_pastorintas = true
pradinis_blokas = indeksas + 1
## Apdorojama pastorinto teksto pabaiga
## Atsimink, kad paskutinis skaičius atliekant pjūvį yra indeksas
## po to, kai paskutinis indeksas yra panaudotas.
if tekstas[indeksas] == "":
if not ar_pastorintas:
print("Klaida: papildoma pastorinimo uždarymo žyma")
print("Pastorintas [", pradinis_blokas, ":", indeksas, "]", tekstas[pradinis_blokas:indeksas])
ar_pastorintas = false
pradinis_blokas = indeksas + 1

gauk_pastorintą(poema)
</syntaxhighlight>

šios programos išvestis yra:

Pastorinta [ 1 : 4 ] ['Jack', 'and', 'Jill']
Pastorinta [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Pastorinta [ 20 : 23 ] ['down', 'and', 'broke']
Pastorinta [ 28 : 30 ] ['Jill', 'came']

Funkcija <code>get_bold()</code> pasiima sau į sąrašą tai, kas buvo padalinta į žodžius ir žymas. Žymos, kurį ši funkcija ieško - <code></code>, nes ji pradeda pastorintą tekstą ir <code></code>, kuris užbaigia pastorintą tekstą. Funkcija <code>get_bold()</code> eina per tekstą ir ieško pradžios ir pabaigos žymų.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

Šis pavyzdys turėtų nustebinti, kadangi pakeitus <code>b</code> pasikeitė ir <code>a</code>. Taip yra todėl, kad teiginys <code>b = a</code> sukūrė ''nuorodą(reference)'' iš <code>b</code> į <code>a</code>, o tai reiškia, jog <code>b</code> dabar yra dar vienas <code>a</code> vardas.
Taigi, bet koks <code>b</code> pakeitimas, keičia ir <code>a</code>. Tačiau kai kurie priskyrimai nesukuria dviejų pavadinimų vienam sąrašui, pažvelk į dar vieną pavyzdį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

Šiuo atveju <code>b</code> nėra nuoroda į <code>a</code>, nes išraiška <code>a * 2</code> sukuria naują sąrašą vietoje nuorodos į <code>a</code>. Visos priskyrimo operacijos sukuria nuorodą, pavyzdžiui: kai perduodi sąrašą kaip funkcijos argumentą, tu sukuri nuorodą.
Visgi, dažniau kuriame kopijas, o ne nuorodas, todėl svarbu įsitikinti, kas buvo sukurta, pavyzdžiui: kai norime pakeisti vieną sąrašą, nekeisdami kito sąrašo pavadinimo, mes turime įsitikinti, kad sukūrėme sąrašo kopiją.

Yra keli būdai, kaip gali sukurti sąrašo kopiją. Vienas iš paprasčiausių būdų yra pjaustymo operatorius, kadangi jis visuomet sukuria naują sąrašą, net tada, kai su pjūviu apimame viso sąrašo ilgį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Panaudoję pjūvio operatorių <code>[:]</code> mes sukuriame naujo sąrašo kopiją. Turėk omeny, kad nukopijuojamas yra tik išorinis sąrašas. Bet koks vidinis sąrašas turi nuorodą į pirminį sąrašą. Todėl, kai sąraše yra sąrašų, reikia nukopijuoti ir vidinius sąrašus. Tu tai gali padaryti pats, tačiau Python'as savy jau turi modulį, kuris tai padaro už tave. Gali panaudoti funkciją <code>deepcopy</code> iš <code>copy</code> modulio:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

Iš pradžių atkreipk dėmesį į tai, kad <code>a</code> sąrašų sąrašas. Tada pastebėk, kad, kai kodo eilutė <code>b[0][1] = 10</code> yra vykdoma, tuomet <code>a</code> ir <code>b</code> pasikeičia, bet <code>c</code> ne. Taip nutiko todėl, kad vidiniai masyvai vis dar yra nuorodos, kai naudojamas pjūvio operatorius. Iš kitos pusės, <code>deepcopy</code> <code>c</code> buvo visiškai nukopijuotas.

Taigi, ar turėčiau nerimauti dėl nuorodų kiekvieną kartą, kai naudoju funkciją ar
<code>=</code>? Geros naujienos yra tos, kad tau reikia nerimauti apie nuorodas tik naudojant žodynus ir sąrašus. Skaičiai ir teksto eilutės sukuria nuorodas tik tada, kai yra vykdoma priskyrimo operacija, tačiau, kitos operacijos sukuria kopija ir tau nereikia sukti galvos ar netikėtai pasikeis reikšmė. Tačiau tau reikia turėt omeny nuorodas, kai keiti sąrašus ir žodynus.

Turbūt susimąstei, kam išvis yra reikalingos nuorodos? Pagrindinė priežastis - greitis. Sukurti nuorodą sąrašo tūkstančiui elementų yra yra daug greičiau nei sukurti jų kopijas. Dar viena priežastis - tai, kad tu gali turėti funkciją, kuri leidžia modifikuoti sąrašus arba žodynus. Jei kada nors susidursi su keistomis problemomis, kai duomenys pasikeičia, nors neturėtų, tai prisimink apie nuorodas.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-18T18:01:20Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

šios programos išvestis yra:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

Šis pavyzdys turėtų nustebinti, kadangi pakeitus <code>b</code> pasikeitė ir <code>a</code>. Taip yra todėl, kad teiginys <code>b = a</code> sukūrė ''nuorodą(reference)'' iš <code>b</code> į <code>a</code>, o tai reiškia, jog <code>b</code> dabar yra dar vienas <code>a</code> vardas.
Taigi, bet koks <code>b</code> pakeitimas, keičia ir <code>a</code>. Tačiau kai kurie priskyrimai nesukuria dviejų pavadinimų vienam sąrašui, pažvelk į dar vieną pavyzdį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

Šiuo atveju <code>b</code> nėra nuoroda į <code>a</code>, nes išraiška <code>a * 2</code> sukuria naują sąrašą vietoje nuorodos į <code>a</code>. Visos priskyrimo operacijos sukuria nuorodą, pavyzdžiui: kai perduodi sąrašą kaip funkcijos argumentą, tu sukuri nuorodą.
Visgi, dažniau kuriame kopijas, o ne nuorodas, todėl svarbu įsitikinti, kas buvo sukurta, pavyzdžiui: kai norime pakeisti vieną sąrašą, nekeisdami kito sąrašo pavadinimo, mes turime įsitikinti, kad sukūrėme sąrašo kopiją.

Yra keli būdai, kaip gali sukurti sąrašo kopiją. Vienas iš paprasčiausių būdų yra pjaustymo operatorius, kadangi jis visuomet sukuria naują sąrašą, net tada, kai su pjūviu apimame viso sąrašo ilgį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Panaudoję pjūvio operatorių <code>[:]</code> mes sukuriame naujo sąrašo kopiją. Turėk omeny, kad nukopijuojamas yra tik išorinis sąrašas. Bet koks vidinis sąrašas turi nuorodą į pirminį sąrašą. Todėl, kai sąraše yra sąrašų, reikia nukopijuoti ir vidinius sąrašus. Tu tai gali padaryti pats, tačiau Python'as savy jau turi modulį, kuris tai padaro už tave. Gali panaudoti funkciją <code>deepcopy</code> iš <code>copy</code> modulio:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

Iš pradžių atkreipk dėmesį į tai, kad <code>a</code> sąrašų sąrašas. Tada pastebėk, kad, kai kodo eilutė <code>b[0][1] = 10</code> yra vykdoma, tuomet <code>a</code> ir <code>b</code> pasikeičia, bet <code>c</code> ne. Taip nutiko todėl, kad vidiniai masyvai vis dar yra nuorodos, kai naudojamas pjūvio operatorius. Iš kitos pusės, <code>deepcopy</code> <code>c</code> buvo visiškai nukopijuotas.

Taigi, ar turėčiau nerimauti dėl nuorodų kiekvieną kartą, kai naudoju funkciją ar
<code>=</code>? Geros naujienos yra tos, kad tau reikia nerimauti apie nuorodas tik naudojant žodynus ir sąrašus. Skaičiai ir teksto eilutės sukuria nuorodas tik tada, kai yra vykdoma priskyrimo operacija, tačiau, kitos operacijos sukuria kopija ir tau nereikia sukti galvos ar netikėtai pasikeis reikšmė. Tačiau tau reikia turėt omeny nuorodas, kai keiti sąrašus ir žodynus.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-18T14:40:47Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

šios programos išvestis yra:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

Šis pavyzdys turėtų nustebinti, kadangi pakeitus <code>b</code> pasikeitė ir <code>a</code>. Taip yra todėl, kad teiginys <code>b = a</code> sukūrė ''nuorodą(reference)'' iš <code>b</code> į <code>a</code>, o tai reiškia, jog <code>b</code> dabar yra dar vienas <code>a</code> vardas.
Taigi, bet koks <code>b</code> pakeitimas, keičia ir <code>a</code>. Tačiau kai kurie priskyrimai nesukuria dviejų pavadinimų vienam sąrašui, pažvelk į dar vieną pavyzdį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

Šiuo atveju <code>b</code> nėra nuoroda į <code>a</code>, nes išraiška <code>a * 2</code> sukuria naują sąrašą vietoje nuorodos į <code>a</code>. Visos priskyrimo operacijos sukuria nuorodą, pavyzdžiui: kai perduodi sąrašą kaip funkcijos argumentą, tu sukuri nuorodą.
Visgi, dažniau kuriame kopijas, o ne nuorodas, todėl svarbu įsitikinti, kas buvo sukurta, pavyzdžiui: kai norime pakeisti vieną sąrašą, nekeisdami kito sąrašo pavadinimo, mes turime įsitikinti, kad sukūrėme sąrašo kopiją.

Yra keli būdai, kaip gali sukurti sąrašo kopiją. Vienas iš paprasčiausių būdų yra pjaustymo operatorius, kadangi jis visuomet sukuria naują sąrašą, net tada, kai su pjūviu apimame viso sąrašo ilgį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Panaudoję pjūvio operatorių <code>[:]</code> mes sukuriame naujo sąrašo kopiją. Turėk omeny, kad nukopijuojamas yra tik išorinis sąrašas. Bet koks vidinis sąrašas yra nuorodos į pirminę sąraš Any sublist inside is still a references to the sublist in the original list. Todėl, kai sąraše yra sąrašų, reikia nukopijuoti ir vidinius sąrašus. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-18T13:52:19Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

šios programos išvestis yra:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

Šis pavyzdys turėtų nustebinti, kadangi pakeitus <code>b</code> pasikeitė ir <code>a</code>. Taip yra todėl, kad teiginys <code>b = a</code> sukūrė ''nuorodą(reference)'' iš <code>b</code> į <code>a</code>, o tai reiškia, jog <code>b</code> dabar yra dar vienas <code>a</code> vardas.
Taigi, bet koks <code>b</code> pakeitimas, keičia ir <code>a</code>. Tačiau kai kurie priskyrimai nesukuria dviejų pavadinimų vienam sąrašui, pažvelk į dar vieną pavyzdį:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

In this case <code>b</code> is not a reference to <code>a</code> since the expression <code>a * 2</code> creates a new list. Then the statement
<code>b = a * 2</code> gives <code>b</code> a reference to <code>a * 2</code> rather than a reference to <code>a</code>. All assignment operations create a reference.
When you pass a list as an argument to a function you create a
reference as well. Most of the time you don't have to worry about
creating references rather than copies. However when you need to make
modifications to one list without changing another name of the list
you have to make sure that you have actually created a copy.

There are several ways to make a copy of a list. The simplest that
works most of the time is the slice operator since it always makes a
new list even if it is a slice of a whole list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Taking the slice <code>[:]</code> creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-15T12:24:21Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok ir išbandyk šios programos kodą):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

šios programos išvestis yra:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

This probably looks surprising since a modification to <code>b</code>
resulted in <code>a</code> being changed as well. What happened is that the
statement <code>b = a</code> makes <code>b</code> a ''reference'' to <code>a</code>.
This means that <code>b</code> can be thought of as another name for <code>a</code>.
Hence any modification to <code>b</code> changes <code>a</code> as well. However
some assignments don't create two names for one list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

In this case <code>b</code> is not a reference to <code>a</code> since the expression <code>a * 2</code> creates a new list. Then the statement
<code>b = a * 2</code> gives <code>b</code> a reference to <code>a * 2</code> rather than a reference to <code>a</code>. All assignment operations create a reference.
When you pass a list as an argument to a function you create a
reference as well. Most of the time you don't have to worry about
creating references rather than copies. However when you need to make
modifications to one list without changing another name of the list
you have to make sure that you have actually created a copy.

There are several ways to make a copy of a list. The simplest that
works most of the time is the slice operator since it always makes a
new list even if it is a slice of a whole list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Taking the slice <code>[:]</code> creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-15T12:23:47Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Štai (HTML įkvėptas) programos pavyzdys (jei nori, nukopijuok šios programos kodą ir išbandyk):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

šios programos išvestis yra:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

Kitas dalykas, kurį gali daryti su sąrašais - juos kopijuoti, pavyzdžiui:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

This probably looks surprising since a modification to <code>b</code>
resulted in <code>a</code> being changed as well. What happened is that the
statement <code>b = a</code> makes <code>b</code> a ''reference'' to <code>a</code>.
This means that <code>b</code> can be thought of as another name for <code>a</code>.
Hence any modification to <code>b</code> changes <code>a</code> as well. However
some assignments don't create two names for one list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

In this case <code>b</code> is not a reference to <code>a</code> since the expression <code>a * 2</code> creates a new list. Then the statement
<code>b = a * 2</code> gives <code>b</code> a reference to <code>a * 2</code> rather than a reference to <code>a</code>. All assignment operations create a reference.
When you pass a list as an argument to a function you create a
reference as well. Most of the time you don't have to worry about
creating references rather than copies. However when you need to make
modifications to one list without changing another name of the list
you have to make sure that you have actually created a copy.

There are several ways to make a copy of a list. The simplest that
works most of the time is the slice operator since it always makes a
new list even if it is a slice of a whole list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Taking the slice <code>[:]</code> creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-12T10:39:50Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Dar vienas dalykas, kurį turėtum žinoti apie sąrašo pjaustymą - neapibrėžtas indeksas. Jei <code>pirmas_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra pirmojo elemento sąraše indeksas. Jei paskutinis <code>paskutinis_indeksas</code> nenurodytas, tuomet numatytoji reikšmė yra paskutiniojo elemento sąraše indeksas. Štai keli pavyzdžiai:

>>> '''dalykai[:2]'''
[0, 'Jonas']
>>> '''dalykai[-2:]'''
['Benas', 'Liepa']
>>> '''dalykai[:3]'''
[0, 'Jonas', 2]
>>> '''dalykai[:-5]'''
[0, 'Jonas', 2]

Here is a (HTML inspired) program example (copy and paste in the poem definition if you want):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

with the output being:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

The next feature of lists is copying them. If you try something simple like:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

This probably looks surprising since a modification to <code>b</code>
resulted in <code>a</code> being changed as well. What happened is that the
statement <code>b = a</code> makes <code>b</code> a ''reference'' to <code>a</code>.
This means that <code>b</code> can be thought of as another name for <code>a</code>.
Hence any modification to <code>b</code> changes <code>a</code> as well. However
some assignments don't create two names for one list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

In this case <code>b</code> is not a reference to <code>a</code> since the expression <code>a * 2</code> creates a new list. Then the statement
<code>b = a * 2</code> gives <code>b</code> a reference to <code>a * 2</code> rather than a reference to <code>a</code>. All assignment operations create a reference.
When you pass a list as an argument to a function you create a
reference as well. Most of the time you don't have to worry about
creating references rather than copies. However when you need to make
modifications to one list without changing another name of the list
you have to make sure that you have actually created a copy.

There are several ways to make a copy of a list. The simplest that
works most of the time is the slice operator since it always makes a
new list even if it is a slice of a whole list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Taking the slice <code>[:]</code> creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-12T09:25:24Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą ir gauti konkrečią jo dalį - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas „perpjauna“ sąrašą ties <code>pirmas_indeksas</code> ir <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Another trick with slicing is the unspecified index. If the first index is not specified the beginning of the list is assumed. If the last index is not specified the whole rest of the list is assumed. Here are some examples:

>>> '''things[:2]'''
[0, 'Fred']
>>> '''things[-2:]'''
['Jack', 'Jill']
>>> '''things[:3]'''
[0, 'Fred', 2]
>>> '''things[:-5]'''
[0, 'Fred', 2]

Here is a (HTML inspired) program example (copy and paste in the poem definition if you want):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

with the output being:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

The next feature of lists is copying them. If you try something simple like:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

This probably looks surprising since a modification to <code>b</code>
resulted in <code>a</code> being changed as well. What happened is that the
statement <code>b = a</code> makes <code>b</code> a ''reference'' to <code>a</code>.
This means that <code>b</code> can be thought of as another name for <code>a</code>.
Hence any modification to <code>b</code> changes <code>a</code> as well. However
some assignments don't create two names for one list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

In this case <code>b</code> is not a reference to <code>a</code> since the expression <code>a * 2</code> creates a new list. Then the statement
<code>b = a * 2</code> gives <code>b</code> a reference to <code>a * 2</code> rather than a reference to <code>a</code>. All assignment operations create a reference.
When you pass a list as an argument to a function you create a
reference as well. Most of the time you don't have to worry about
creating references rather than copies. However when you need to make
modifications to one list without changing another name of the list
you have to make sure that you have actually created a copy.

There are several ways to make a copy of a list. The simplest that
works most of the time is the slice operator since it always makes a
new list even if it is a slice of a whole list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Taking the slice <code>[:]</code> creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-12T09:14:28Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą į kelias dalis - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą(slicing) naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo(slicing) operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas(slicing) „perpjauna“ sąrašą prieš <code>pirmas_indeksas</code> ir po <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Another trick with slicing is the unspecified index. If the first index is not specified the beginning of the list is assumed. If the last index is not specified the whole rest of the list is assumed. Here are some examples:

>>> '''things[:2]'''
[0, 'Fred']
>>> '''things[-2:]'''
['Jack', 'Jill']
>>> '''things[:3]'''
[0, 'Fred', 2]
>>> '''things[:-5]'''
[0, 'Fred', 2]

Here is a (HTML inspired) program example (copy and paste in the poem definition if you want):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

with the output being:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

The next feature of lists is copying them. If you try something simple like:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

This probably looks surprising since a modification to <code>b</code>
resulted in <code>a</code> being changed as well. What happened is that the
statement <code>b = a</code> makes <code>b</code> a ''reference'' to <code>a</code>.
This means that <code>b</code> can be thought of as another name for <code>a</code>.
Hence any modification to <code>b</code> changes <code>a</code> as well. However
some assignments don't create two names for one list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

In this case <code>b</code> is not a reference to <code>a</code> since the expression <code>a * 2</code> creates a new list. Then the statement
<code>b = a * 2</code> gives <code>b</code> a reference to <code>a * 2</code> rather than a reference to <code>a</code>. All assignment operations create a reference.
When you pass a list as an argument to a function you create a
reference as well. Most of the time you don't have to worry about
creating references rather than copies. However when you need to make
modifications to one list without changing another name of the list
you have to make sure that you have actually created a copy.

There are several ways to make a copy of a list. The simplest that
works most of the time is the slice operator since it always makes a
new list even if it is a slice of a whole list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Taking the slice <code>[:]</code> creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-12T09:13:47Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Kitas naudingas būdas, kaip gali padalinti sąrašą į kelias dalis - pjaustymas(slicing). Štai dar vienas pavyzdys, leidžiantis suprasti, kam jie gali būti naudojami:

>>> '''dalykai = [0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, "Benas", "Liepa"]'''
>>> '''dalykai[0]'''
0
>>> '''dalykai[7]'''
'Liepa'
>>> '''dalykai[0:8]'''
[0, 'Jonas', 2, 'S.P.A.M.', 'Kojinė', 42, 'Benas', 'Liepa']
>>> '''dalykai[2:4]'''
[2, 'S.P.A.M.']
>>> '''dalykai[4:7]'''
['Kojinė', 42, 'Benas']
>>> '''dalykai[1:5]'''
['Jonas', 2, 'S.P.A.M.', 'Kojinė']

Pjaustymą(slicing) naudoju tada, kai noriu gauti konkrečią sąrašo dalį. Pjaustymo(slicing) operatorius yra aprašomas taip: <code>dalykai[pirmas_indeksas:paskutinis_indeksas]</code>. Pjaustymas(slicing) „perpjauna“ sąrašą prieš <code>pirmas_indeksas</code> ir po <code>paskutinis_indeksas</code> ir tuomet grąžina tą sarašo dalį, kuri yra tarp pirmo indekso ir paskutinio indekso rėžių. Gali naudoti abiejų tipų indeksavimą:

>>> '''dalykai[-4:-2]'''
['Kojinė', 42]
>>> '''dalykai[-4]'''
'Kojinė'
>>> '''dalykai[-4:6]'''
['Kojinė', 42]

Another trick with slicing is the unspecified index. If the first index is not specified the beginning of the list is assumed. If the last index is not specified the whole rest of the list is assumed. Here are some examples:

>>> '''things[:2]'''
[0, 'Fred']
>>> '''things[-2:]'''
['Jack', 'Jill']
>>> '''things[:3]'''
[0, 'Fred', 2]
>>> '''things[:-5]'''
[0, 'Fred', 2]

Here is a (HTML inspired) program example (copy and paste in the poem definition if you want):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

with the output being:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

The next feature of lists is copying them. If you try something simple like:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

This probably looks surprising since a modification to <code>b</code>
resulted in <code>a</code> being changed as well. What happened is that the
statement <code>b = a</code> makes <code>b</code> a ''reference'' to <code>a</code>.
This means that <code>b</code> can be thought of as another name for <code>a</code>.
Hence any modification to <code>b</code> changes <code>a</code> as well. However
some assignments don't create two names for one list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

In this case <code>b</code> is not a reference to <code>a</code> since the expression <code>a * 2</code> creates a new list. Then the statement
<code>b = a * 2</code> gives <code>b</code> a reference to <code>a * 2</code> rather than a reference to <code>a</code>. All assignment operations create a reference.
When you pass a list as an argument to a function you create a
reference as well. Most of the time you don't have to worry about
creating references rather than copies. However when you need to make
modifications to one list without changing another name of the list
you have to make sure that you have actually created a copy.

There are several ways to make a copy of a list. The simplest that
works most of the time is the slice operator since it always makes a
new list even if it is a slice of a whole list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Taking the slice <code>[:]</code> creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-12T08:51:09Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Another useful way to get into parts of lists is using slicing. Here is another example to give you an idea what they can be used for:

>>> '''things = [0, 'Fred', 2, 'S.P.A.M.', 'Stocking', 42, "Jack", "Jill"]'''
>>> '''things[0]'''
0
>>> '''things[7]'''
'Jill'
>>> '''things[0:8]'''
[0, 'Fred', 2, 'S.P.A.M.', 'Stocking', 42, 'Jack', 'Jill']
>>> '''things[2:4]'''
[2, 'S.P.A.M.']
>>> '''things[4:7]'''
['Stocking', 42, 'Jack']
>>> '''things[1:5]'''
['Fred', 2, 'S.P.A.M.', 'Stocking']

Slicing is used to return part of a list. The slicing operator is in the form <code>things[first_index:last_index]</code>. Slicing cuts the list before the <code>first_index</code> and before the <code>last_index</code> and returns the parts in between. You can use both types of indexing:

>>> '''things[-4:-2]'''
['Stocking', 42]
>>> '''things[-4]'''
'Stocking'
>>> '''things[-4:6]'''
['Stocking', 42]

Another trick with slicing is the unspecified index. If the first index is not specified the beginning of the list is assumed. If the last index is not specified the whole rest of the list is assumed. Here are some examples:

>>> '''things[:2]'''
[0, 'Fred']
>>> '''things[-2:]'''
['Jack', 'Jill']
>>> '''things[:3]'''
[0, 'Fred', 2]
>>> '''things[:-5]'''
[0, 'Fred', 2]

Here is a (HTML inspired) program example (copy and paste in the poem definition if you want):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

with the output being:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

The next feature of lists is copying them. If you try something simple like:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

This probably looks surprising since a modification to <code>b</code>
resulted in <code>a</code> being changed as well. What happened is that the
statement <code>b = a</code> makes <code>b</code> a ''reference'' to <code>a</code>.
This means that <code>b</code> can be thought of as another name for <code>a</code>.
Hence any modification to <code>b</code> changes <code>a</code> as well. However
some assignments don't create two names for one list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

In this case <code>b</code> is not a reference to <code>a</code> since the expression <code>a * 2</code> creates a new list. Then the statement
<code>b = a * 2</code> gives <code>b</code> a reference to <code>a * 2</code> rather than a reference to <code>a</code>. All assignment operations create a reference.
When you pass a list as an argument to a function you create a
reference as well. Most of the time you don't have to worry about
creating references rather than copies. However when you need to make
modifications to one list without changing another name of the list
you have to make sure that you have actually created a copy.

There are several ways to make a copy of a list. The simplest that
works most of the time is the slice operator since it always makes a
new list even if it is a slice of a whole list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Taking the slice <code>[:]</code> creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}

Python Vadovėlis/Daugiau apie sąrašus

2021-10-12T08:46:53Z

LauraK:

Apie sąrašus ir jų panaudojimą jau girdėjai praėjusiame skyriuje. Dabar, kai turi daugiau žinių, aš išsamiau aprašysiu sąrašus. Iš pradžių parodysiu, kaip dirbti su sąrašo elementai ir tuomet papasakosiu, kaip juos galima kopijuoti.

Parašiau pavyzdį, kuriame naudoju indeksus, kad pasiimčiau vieną konkretų elementą iš sąrašo:

>>> '''skaičiai = ['nulis', 'vienas', 'du', 'trys', 'keturi', 'penki']'''
>>> '''skaičiai[0]'''
'nulis'
>>> '''skaičiai[4]'''
'keturi'
>>> '''skaičiai[5]'''
'penki'

Visi šie pavyzdžiai tau turėtų atrodyti pažįstami. Jei nori gauti pirmąjį sąrašo elementą, tu žiūri į indeksą 0, jei nori antrojo, tuomet imi indeksą 1 ir taip toliau judi per visą sąrašą. Tačiau ką daryti, jei nori paskutinio sąrašo elemento? Vienas iš būdų galėtų būti funkcijos <code>len()</code> panaudojimas: <code>skaičiai[len(skaičiai) - 1]</code>. Funkcija <code>len()</code> visada grąžina paskutinį indeksą + 1. Šiuo būdu gali eiti per sąrašą iš kitos pusės, pavyzdžiui: antrasis sąrašo elementas nuo galo yra gaunamas taip: <code>skaičiai[len(skaičiai) - 2]</code>. Kaip jau minėjau, yra dar vienas lengvesnis būdas, kaip galėtum pasiekti tą patį rezultatą. Python'e paskutinis elementas sąraše visada turi indeksą -1, antrojo elemento nuo sąrašo pabaigos indeksas yra -2 ir taip toliau. Štai daugiau pavyzdžių:

>>> '''skaičiai[len(skaičiai) - 1]'''
'penki'
>>> '''skaičiai[len(skaičiai) - 2]'''
'keturi'
>>> '''skaičiai[-1]'''
'penki'
>>> '''skaičiai[-2]'''
'keturi'
>>> '''skaičiai[-6]'''
'nulis'

Taigi, bet kuris sąrašo elementas gali būti indeksuojamas dviem būdais: iš priekio ir iš galo.

Another useful way to get into parts of lists is using slicing. Here is another example to give you an idea what they can be used for:

>>> '''things = [0, 'Fred', 2, 'S.P.A.M.', 'Stocking', 42, "Jack", "Jill"]'''
>>> '''things[0]'''
0
>>> '''things[7]'''
'Jill'
>>> '''things[0:8]'''
[0, 'Fred', 2, 'S.P.A.M.', 'Stocking', 42, 'Jack', 'Jill']
>>> '''things[2:4]'''
[2, 'S.P.A.M.']
>>> '''things[4:7]'''
['Stocking', 42, 'Jack']
>>> '''things[1:5]'''
['Fred', 2, 'S.P.A.M.', 'Stocking']

Slicing is used to return part of a list. The slicing operator is in the form <code>things[first_index:last_index]</code>. Slicing cuts the list before the <code>first_index</code> and before the <code>last_index</code> and returns the parts in between. You can use both types of indexing:

>>> '''things[-4:-2]'''
['Stocking', 42]
>>> '''things[-4]'''
'Stocking'
>>> '''things[-4:6]'''
['Stocking', 42]

Another trick with slicing is the unspecified index. If the first index is not specified the beginning of the list is assumed. If the last index is not specified the whole rest of the list is assumed. Here are some examples:

>>> '''things[:2]'''
[0, 'Fred']
>>> '''things[-2:]'''
['Jack', 'Jill']
>>> '''things[:3]'''
[0, 'Fred', 2]
>>> '''things[:-5]'''
[0, 'Fred', 2]

Here is a (HTML inspired) program example (copy and paste in the poem definition if you want):
<syntaxhighlight lang="python">
poem = ["", "Jack", "and", "Jill", "", "went", "up", "the",
"hill", "to", "", "fetch", "a", "pail", "of", "",
"water.", "Jack", "fell", "", "down", "and", "broke",
"", "his", "crown", "and", "", "Jill", "came",
"", "tumbling", "after"]

def get_bold(text):
true = 1
false = 0
## is_bold tells whether or not we are currently looking at
## a bold section of text.
is_bold = false
## start_block is the index of the start of either an unbolded
## segment of text or a bolded segment.
start_block = 0
for index in range(len(text)):
## Handle a starting of bold text
if text[index] == "":
if is_bold:
print("Error: Extra Bold")
## print "Not Bold:", text[start_block:index]
is_bold = true
start_block = index + 1
## Handle end of bold text
## Remember that the last number in a slice is the index
## after the last index used.
if text[index] == "":
if not is_bold:
print("Error: Extra Close Bold")
print("Bold [", start_block, ":", index, "]", text[start_block:index])
is_bold = false
start_block = index + 1

get_bold(poem)
</syntaxhighlight>

with the output being:

Bold [ 1 : 4 ] ['Jack', 'and', 'Jill']
Bold [ 11 : 15 ] ['fetch', 'a', 'pail', 'of']
Bold [ 20 : 23 ] ['down', 'and', 'broke']
Bold [ 28 : 30 ] ['Jill', 'came']

The <code>get_bold()</code> function takes in a list that is broken into words and tokens. The tokens that it looks for are <code></code> which starts the bold text and <code></code> which ends bold text. The function <code>get_bold()</code> goes through and searches for the start and end tokens.

The next feature of lists is copying them. If you try something simple like:

>>> '''a = [1, 2, 3]'''
>>> '''b = a'''
>>> '''print(b)'''
[1, 2, 3]
>>> '''b[1] = 10'''
>>> '''print(b)'''
[1, 10, 3]
>>> '''print(a)'''
[1, 10, 3]

This probably looks surprising since a modification to <code>b</code>
resulted in <code>a</code> being changed as well. What happened is that the
statement <code>b = a</code> makes <code>b</code> a ''reference'' to <code>a</code>.
This means that <code>b</code> can be thought of as another name for <code>a</code>.
Hence any modification to <code>b</code> changes <code>a</code> as well. However
some assignments don't create two names for one list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a * 2'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]
>>> '''a[1] = 10'''
>>> '''print(a)'''
[1, 10, 3]
>>> '''print(b)'''
[1, 2, 3, 1, 2, 3]

In this case <code>b</code> is not a reference to <code>a</code> since the expression <code>a * 2</code> creates a new list. Then the statement
<code>b = a * 2</code> gives <code>b</code> a reference to <code>a * 2</code> rather than a reference to <code>a</code>. All assignment operations create a reference.
When you pass a list as an argument to a function you create a
reference as well. Most of the time you don't have to worry about
creating references rather than copies. However when you need to make
modifications to one list without changing another name of the list
you have to make sure that you have actually created a copy.

There are several ways to make a copy of a list. The simplest that
works most of the time is the slice operator since it always makes a
new list even if it is a slice of a whole list:

>>> '''a = [1, 2, 3]'''
>>> '''b = a[:]'''
>>> '''b[1] = 10'''
>>> '''print(a)'''
[1, 2, 3]
>>> '''print(b)'''
[1, 10, 3]

Taking the slice <code>[:]</code> creates a new copy of the list. However it only copies the outer list. Any sublist inside is still a references to the sublist in the original list. Therefore, when the list contains lists, the inner lists have to be copied as well. You could do that manually but Python already contains a module to do it. You use the <code>deepcopy</code> function of the <code>copy</code> module:

>>> '''import copy'''
>>> '''a = [[1, 2, 3], [4, 5, 6]]'''
>>> '''b = a[:]'''
>>> '''c = copy.deepcopy(a)'''
>>> '''b[0][1] = 10'''
>>> '''c[1][1] = 12'''
>>> '''print(a)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(b)'''
[[1, 10, 3], [4, 5, 6]]
>>> '''print(c)'''
[[1, 2, 3], [4, 12, 6]]

First of all notice that <code>a</code> is a list of lists. Then notice
that when <code>b[0][1] = 10</code> is run both <code>a</code> and <code>b</code> are changed, but <code>c</code> is not. This happens because the inner arrays are still references when the slice operator is used. However with <code>deepcopy</code> <code>c</code> was fully copied.

So, should I worry about references every time I use a function or
<code>=</code>? The good news is that you only have to worry about
references when using dictionaries and lists. Numbers and strings
create references when assigned but every operation on numbers and
strings that modifies them creates a new copy so you can never modify
them unexpectedly. You do have to think about references when you are
modifying a list or a dictionary.

By now you are probably wondering why are references used at all? The
basic reason is speed. It is much faster to make a reference to a
thousand element list than to copy all the elements. The other reason
is that it allows you to have a function to modify the inputed list
or dictionary. Just remember about references if you ever have some
weird problem with data being changed when it shouldn't be.

































{{navigation |previous=Using Modules|next=Revenge of the Strings}}
{{BookCat}}