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

Python Vadovėlis/Rekursija

2022-04-12T15:24:09Z

ZivileB:

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

== Rekursija ==

Programavime rekursine funkcija vadinama funkcija, kuri iškviečia pati save.

=== Įvadas į rekursiją ===

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

sk = 0

def main():
skaitliukas(sk)

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

main()
</syntaxhighlight>

Jei šią programą paleistum VS Code kodo redaktoriuje, ji veiktų amžinai. Vienintelis būdas sustabdyti ciklą būtų nutraukti vykdymą paspaudžiant Ctrl + C klaviatūroje. Tai yra begalinės rekursijos pavyzdys.

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

Rekursija gali būti valdoma, kaip ir ciklai. Pažvelk į rekursinio ciklo pavyzdį.
<syntaxhighlight lang="python">
# Mitchell Aikens programa
# Nėra autorinių teisių
# 2010
def main():
ciklosk= int(input("Kiek kartų norėtum paleisti ciklą?\n"))
skaitliukas = 1
recurr(ciklosk,skaitliukas)

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

main()
</syntaxhighlight>

Programoje naudojami argumentai/parametrai rekursijų skaičiui valdyti. Tiesiog naudok tai, ką jau žinai apie funkcijas, ir sek programos eigą. Tai paprasta išsiaiškinti. Jei kyla problemų, grįžk į [[Vadovėlis/Pažangių funkcijų pavyzdys|Pažangių funkcijų pavyzdys]].

== Praktiniai rekursijos pritaikymai ==

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

Pagalvokite apie šias dvi „taisykles“:
* Jei galiu išspręsti problemą su ciklu, be rekursijos, funkcija tiesiog grąžina reikšmę.
* Jei negaliu išspręsti problemos su cilku, be rekursijos, funkcija sumažina problemą iki mažesnės analogiškos problemos ir iškviečia pati save.

Pabandyk pritaikyti rekursinę funkciją faktorialui apskaičiuoti. Jei nesi susipažinęs su faktoriais, skaityk: [https://lt.wikipedia.org/wiki/Faktorialas Faktorialas]

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

Štai keletas pagrindinių faktorialo taisyklių:

Jei n = 0 tai n! = 1

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

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

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

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

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

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

main()
</syntaxhighlight>

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

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

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

Python Vadovėlis/Žodynai

2022-04-11T17:40:22Z

ZivileB:

{{navigation |previous=Loginiai reiškiniai |next=Modulių naudojimas}}

Šis skyrius yra apie žodynus. Žodynai turi raktus ir reikšmes. Raktai naudojami reikšmėms rasti. Štai žodyno pavyzdys:
<syntaxhighlight lang="python">
def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu ()
while meniu_pasirinkimas != 5:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-5): "))
if meniu_pasirinkimas == 1:
print("Telefono numeriai: ")
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
print()
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
numeriai[vardas] = numeris
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas != 5:
print_menu()

</syntaxhighlight>

O čia - mano išvestis:

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

Įvesk skaičių (1-5): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Benas'''
Telefono numeris: '''869935951'''
Įvesk skaičių (1-5): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Liepa'''
Telefono numeris: '''869935952'''
Įvesk skaičių (1-5): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Markas'''
Telefono numeris: '''869935957'''
Įvesk skaičių (1-5): '''1'''
Telefono numeriai:
Vardas: Benas Telefono numeris: 869935951
Vardas: Liepa Telefono numeris: 869935952
Vardas: Markas Telefono numeris: 869935957

Įvesk skaičių (1-5): '''4'''
Ieškok telefono numerio
Vardas: '''Benas'''
Telefono numeris yra 869935951
Įvesk skaičių (1-5): '''3'''
Pašalink telefono numerį
Vardas: '''Markas'''
Įvesk skaičių (1-5): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 869935952
Vardas: Benas Telefono numeris: 869935951

Įvesk skaičių (1-5): '''5'''

Ši programa yra panaši į programą su vardų sąrašu, pateiktu prieš tai buvusiame skyriuje apie sąrašus. Štai kaip veikia programa. Pirmiausiai yra aprašoma funkcija <code>spausdink_meniu</code>. <code>spausdink_meniu</code> tiesiog spausdina meniu, kuris vėliau du kartus naudojamas programoje. Po to, pateikiama keistai atrodanti eilutė <code>numeriai = {}</code>. Ši eilutė Python'ui pasako, kad <code>numeriai</code> yra žodynas. Kitos kelios eilutės tiesiog padaro taip, kad meniu veiktų. Vykdydant ciklą:
<syntaxhighlight lang="python">
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
</syntaxhighlight>
einama per žodyną ir spausdinami žodyne esantys elementai. Funkcija <code> numeriai.keys()</code> grąžina žodyno elementų raktų sąrašą, kuris yra vėliau naudojamas <code>for</code> cikle. Sąrašas grąžinamas <code>keys()</code> metodo pagalba neturi jokio eiliškumo, todėl, jei tu nori, kad jis būtų abėcėlės tvarka, jis turi būti surūšiuotas. Taigi, šiuo atveju <code>x</code> yra tekstinė eilutė – vardai. Panašiai kaip sąrašai, komanda <code>numeriai[x]</code> naudojama norint pasiekti konkretų žodyno elementą. Šiuo atveju tai yra telefonų numeriai. Komanda <code>print</code> visa tai atspausdina.
<syntaxhighlight lang="python">
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
numeriai[vardas] = numeris
</syntaxhighlight>
Padarius kitą pasirinkimą, pirmiausiai paklausiamas vardas – tai bus žodyno elemento raktas, ir paklausiamas numeris. Toliau, komanda <code>numeriai[vardas] = telefonas</code> prideda vardą ir telefono numerį į žodyną. Jei <code>vardas</code> jau būtų buvęs žodyne, <code>telefonas</code> pakeistų prieš tai buvusią reikšmę.
Toliau sąlyginis sakinys
<syntaxhighlight lang="python">
if vardas in numeriai:
del numeriai[vardas]
</syntaxhighlight>
tikrina, ar vardas yra žodyne, ir jei yra, jį pašalina. Komanda <code>vardas in numeriai</code> grąžina loginę reikšmę <code>True</code>, jei <code>vardas</code> yra <code>numeriai</code> žodyne, bet kitu atveju grąžina <code>False</code>. Komanda <code>del numeriai[vardas]</code> pašalina raktą <code>vardas</code> ir su tuo raktu susietą reikšmę.
Sąlyginis sakinys
<syntaxhighlight lang="python">
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
</syntaxhighlight>
patikrina, ar žodynas turi tam tikrą raktą ir jei žodynas turi tą raktą, išspausdina su juo susietą numerį. Galiausiai, jei meniu pasirinkimas negalioja, pagrindinis meniu yra atspausdinamas, kad tu galėtum juo pasigrožėti.


Apibendrinimas: žodynai turi raktus ir reikšmes. Raktu gali būti tekstinė eilutė arba
skaičius. Raktai nurodo reikšmes. Reikšmės gali būti bet kokio tipo kintamieji
(įskaitant sąrašus ar net žodynus (žinoma, tuose žodynuose ar sąrašuose
gali būti patys žodynai ar sąrašai (baisu, ane? :-)
))). Štai yra pavyzdys, kai naudojamas sąrašas žodyne:

<syntaxhighlight lang="python">
max_taškai = [25, 25, 50, 25, 100]
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = {'#Max': max_taškai}

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

def spausdink_visus_pažymius():
print('\t', end=' ')
for i in range(len(užduotys)):
print(užduotys[i], '\t', end=' ')
print()
raktai = list(mokiniai.keys())
raktai.sort()
for x in raktai:
print(x, '\t', end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)

def spausdink_pažymius(pažymiai):
for i in range(len(pažymiai)):
print(pažymiai[i], '\t', end=' ')
print()

spausdink_meniu()
meniu_pasirinkimas = 0
while meniu_pasirinkimas != 6:
print()
meniu_pasirinkimas = int(input("Meniu pasirinkimas (1-6): "))
if meniu_pasirinkimas == 1:
vardas = input("Pridėk mokinį: ")
mokiniai[vardas] = [0] * len(max_taškai)
elif meniu_pasirinkimas == 2:
vardas = input("Pašalink mokinį: ")
if vardas in mokiniai:
del mokiniai[vardas]
else:
print("Vardas: ", vardas, " nebuvo rastas")
elif meniu_pasirinkimas == 3:
spausdink_visus_pažymius()
elif meniu_pasirinkimas == 4:
print("Įrašyk pažymį")
vardas = input("Mokinys: ")
if vardas in mokiniai:
pažymiai = mokiniai[vardas]
print("Įrašyk mokinio pažymį")
print("Įrašyk 0 (nulį), kad išeitum")
for i in range(len(užduotys)):
print(i + 1, užduotys[i], '\t', end=' ')
print()
spausdink_pažymius(pažymiai)
kuris = 1234
while kuris != -1:
kuris = int(input("Pakeisk kuris pažymį: "))
kuris -= 1 #tas pats kaip ir: kuris = kuris - 1
if 0 <= kuris < len(pažymiai):
pažymys = int(input("Pažymys: "))
pažymiai[kuris] = pažymys
elif kuris != -1:
print("Klaidingas pažymys")
else:
print("Mokinys nerastas")
elif meniu_pasirinkimas != 6:
spausdink_meniu()
</syntaxhighlight>

O štai čia yra išvestis:

1. Pridėk mokinį
2. Pašalink mokinį
3. Spausdink pažymius
4. Įrašyk pažymį
5. Spausdink meniu
6. Išeik

Meniu pasirinkimas (1-6): '''3'''
nd sk 1 nd sk 2 viktorina nd sk 3 testas
#Max 25 25 50 25 100

Meniu pasirinkimas (1-6): '''5'''
1. Pridėk mokinį
2. Pašalink mokinį
3. Spausdink pažymius
4. Įrašyk pažymį
5. Spausdink meniu
6. Išeik

Meniu pasirinkimas (1-6): '''1'''
Pridėk mokinį: '''Markas'''

Meniu pasirinkimas (1-6): '''4'''
Įrašyk pažymį
Mokinys: '''Markas'''
Įrašyk mokinio pažymį
Įrašyk 0 (nulį), kad išeitum
1 nd sk 1 2 nd sk 2 3 viktorina 4 nd sk 3 5 testas
0 0 0 0 0
Pakeisk kuris pažymį: '''1'''
Pažymys: '''25'''
Pakeisk kuris pažymį: '''2'''
Pažymys: '''24'''
Pakeisk kuris pažymį: '''3'''
Pažymys: '''45'''
Pakeisk kuris pažymį: '''4'''
Pažymys: '''23'''
Pakeisk kuris pažymį: '''5'''
Pažymys: '''95'''
Pakeisk kuris pažymį: '''0'''

Meniu pasirinkimas (1-6): '''3'''
nd sk 1 nd sk 2 viktorina nd sk 3 testas
#Max 25 25 50 25 100
Markas 25 24 45 23 95

Meniu pasirinkimas (1-6): '''6'''

Štai kaip veikia programa. Iš esmės, kintamasis <code>mokiniai</code> yra žodynas, kurio raktai yra mokinių vardai, o reikšmės – jų pažymiai. Pirmosios dvi eilutės tik sukuria du sąrašus.
Kita eilutė <code>mokiniai = {'#Max': max_taškai}</code> sukuria naują
žodyną su raktu {<code>#Max</code>}, o reikšmė yra <code>[25, 25, 50, 25, 100]</code> (pirmame sakinyje <code>max_taškai</code> buvo padarytas priskyrimas) (aš naudoju raktą <code>#Max</code>, nes rūšiuojant simolis <code>#</code> patenka prieš bet kokias abėcėlės raides). Toliau aprašoma funkcija <code>spausdink_meniu</code>. Kaip jau žinai, ji spausdina meniu.
Po to aprašoma funkcija <code>spausdink_visus_pažymius</code>:
<syntaxhighlight lang="python">
def spausdink_visus_pažymius():
print('\t',end=" ")
for i in range(len(užduotys)):
print(užduotys[i], '\t',end=" ")
print()
raktai = list(mokiniai.keys())
keys.sort()
for x in raktai:
print(x, '\t',end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
</syntaxhighlight>

Atkreipk dėmesį, į tai, kaip žodyno <code>mokiniai</code> raktai yra išimami į kintamąjį <code>raktai</code> su komanda <code>raktai = list(mokiniai.keys())</code>. Kintamasis <code>raktai</code> turės būti rūšiuojamas, todėl yra paverčiamas į sąrašą. Taip bus galima naudoti visas sąrašų funkcijas. Toliau raktai yra surūšiuojami eilutėje <code>raktai.sort()</code>. <code>for</code> yra naudojamas pereiti per visus raktus. Pažymiai yra saugomi kaip sąrašas žodyno viduje, todėl priskyrimas <code>pažymiai = mokiniai[x]</code> duoda <code>pažymiai</code> sąrašą, kuris yra saugomas su <code>x</code> raktu. Funkcija <code>spausdink_pažymius</code> tiesiog spausdina sąrašą ir yra aprašyta keliomis eilutėmis žemiau.

Tolimesnės programos eilutės įgyvendina įvairius meniu pasirinkimus. Eilutė <code>mokiniai[vardas] = [0] * len(max_taškai)</code> prideda mokinį į žodyną: <code>vardas</code> yra naujas raktas. Komanda <code>[0] * len(max_taškai)</code> tiesiog sukuria žodyno elementą – 0-ių sąrašą, kuris yra tokio pat ilgio kaip ir <code>max_taškai</code> sąrašas, kuriame vėliau bus sukelti pažymiai.

Pašalinti mokinį pasirinkimas tiesiog ištrina mokinį, panašiai kaip ir telefonų knygutės pavyzdyje.
Įrašyti mokinį pasirinkimas yra šiek tiek sudėtingesnis. Pažymiai yra gaunami komandinėje eilutėje
<code>pažymiai = mokiniai[vardas]</code>, ji gauna nuorodą į mokinio <code>vardas</code> pažymius. Tada pažymys yra įrašomas komanda <code>pažymiai[kuris] = pažymys</code>. Tu gali pastebėti, kad <code>pažymiai</code> niekada negrąžinami į mokinių žodyną (tokios komandos niekada nerašome: <code>mokiniai[vardas] = pažymiai</code>). Pakeisto pažymių sąrašo į žodyną grąžinti nereikia todėl, kad komanda <code>pažymiai[kuris] = pažymys</code> mes gauname ne realų sąrašą, o nuorodą į tą sąrašą, tada <code>pažymiai</code> iš tiesų yra tik kitas <code>mokiniai[vardas]</code> pavadinimas. Dėl to, keičiant <code>pažymiai</code> keičiasi ir <code>mokiniai[vardas]</code>.

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

{{navigation |previous=Loginiai reiškiniai |next=Modulių naudojimas}}
{{BookCat}}

Python Vadovėlis/Modulių naudojimas

2022-03-17T06:11:21Z

ZivileB:

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Štai šio skyriaus pratimas. Failas, kuriame yra ši užduotis, geriausia būtų pavadinti kalendorius.py, kad nesimaišytų su importuojamu calendar.py moduliu. Modulis iš tiesų yra failas su priesaga .py, kuriame yra papildomų funkcijų rinkinys, kurį norite įtraukti ir naudoti savo programoje. Eilutė <code>import calendar</code> iš tikrųjų ieško failo pavadinimu calendar.py ir jį su jo funkcijomis įtraukia į savo kodą, kad galėtume naudoti funkciją <code>prcal</code> funkciją, kuri atspausdins visų metų kalendorių. Jei failas būtų pavadintas calendar.py ir matytų <code>import calendar</code>, jis bandytų skaityti pats save, ir kodas tada neveiktų tinkamai.

<syntaxhighlight lang="python">
import calendar
metai = int(input("Įvesk metų skaičių: "))
calendar.prcal(metai)
</syntaxhighlight>

Ir čia yra gautos programos išvestis:

Įvesk metų skaičių: 2001

2001

Sausis Vasaris Kovas

Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se
1 2 3 4 5 6 7 1 2 3 4 1 2 3 4
8 9 10 11 12 13 14 5 6 7 8 9 10 11 5 6 7 8 9 10 11
15 16 17 18 19 20 21 12 13 14 15 16 17 18 12 13 14 15 16 17 18
22 23 24 25 26 27 28 19 20 21 22 23 24 25 19 20 21 22 23 24 25
29 30 31 26 27 28 26 27 28 29 30 31

(Aš praleidau kai kurias išvesties dalis, bet manau, kad principas aiškus.) Taigi, ką daro programa? Pirma eilutė <code>import calendar</code> naudoja naują komandą <code>import</code>. Komanda <code>import</code> įkelia modulį (šiuo atveju <code>calendar</code> modulį). Norint pamatyti standartiniuose moduliuose esančias funkcijas, ieškok Python'o bibliotekos nuorodos (jei atsisiuntei biblioteką) arba eik į http://docs.python.org/3/library/. Jei pažvelsi į kalendoriaus modulio dokumentaciją, jame yra funkcija, vadinama <code>prcal</code>, kuri spausdina metų kalendorių. Komanda <code>calendar.prcal(metai)</code> naudoja šią funkciją. Apskritai, norint naudoti modulį, reikia naudoti raktažodį <code>import</code> ir kartu panaudoti <code>modulio_pavadinimas.function</code>, kreipiantis į funkcijas esančias modulyje. Yra ir kitas būdas parašyti analogišką programą:

<syntaxhighlight lang="python">
from calendar import prcal

metai = int(input("Įveskite metų skaičių: "))
prcal(metai)
</syntaxhighlight>

Šis variantas importuoja konkrečią funkciją iš modulio.
Panagrinėkime dar vieną programą, kuri naudoja Python'o biblioteką (pavadink ją clock.py) (tuo pačiu metu paspausk Ctrl ir klavišą c, kad nutrauktum darbą):

<syntaxhighlight lang="python">
from time import time, ctime

ankstesnis_laikas = ""
while True:
laikas = ctime(time())
if ankstesnis_laikas != laikas:
print("Laikas:", ctime(time()))
ankstesnis_laikas = laikas
</syntaxhighlight>

Dalis išvesties yra:

Laikas: Tue Dec 21 13:14:20 2021
Laikas: Tue Dec 21 13:14:21 2021
Laikas: Tue Dec 21 13:14:22 2021
Laikas: Tue Dec 21 13:14:23 2021

Traceback (most recent call last):
File "laikas.py", line 5, in <module>
laikas = ctime(time())
KeyboardInterrupt

Kadangi išvestis yra begalinė, todėl ją atšaukiu (kitu atveju, išvestis tęstųsi bent jau tol, kol būtų paspaustas Ctrl+C). Programa atlieka nesibaigiantį ciklą (<code>True</code> yra visada tiesa, taigi <code>while True:</code> vykdoma amžinai). Kiekvieną kartą patikrina, ar laikas nepasikeitė, ir išspausdina, jei pasikeitė. Atkreipk dėmesį, kaip naudojami keli funkcijų pavadinimai po ''import'' sakinyje <code>from time import time, ctime</code>.

Python'o bibliotekoje yra daug naudingų funkcijų. Šios funkcijos suteikia Tavo programoms daugiau galimybių ir daugelis jų gali supaprastinti programavimą Python'u.

=== Pratimai ===
Perrašyk <code>daugiau_maziau.py</code> programą iš skyriaus [[Vadovėlis/Pasirinkimai#Pavyzdžiai|Pasirinkimai]], kad naudotų atsitiktinį sveikąjį skaičių nuo 0 iki 99, o ne įkoduotą 7. Naudok <code>random</code> modulį ir <code>randint</code> funkciją.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
from random import randint

skaičius = randint(0, 99)
spėjimas = -1
while spėjimas != skaičius:
spėjimas = int(input ("Atspėk skaičių: "))
if spėjimas > skaičius:
print("Per didelis")
elif spėjimas < skaičius:
print("Per mažas")

print("Būtent tas")

</syntaxhighlight>
|-
|}

==Kiti moduliai==
Kartais Tu gali norėti naudoti Python'o modulį, kurio nėra standatinėje Python versijoje. Tu gali juos importuoti, tačiau pirmiau turėsi juos įsidiegti savo kompiuterį.

===Kuriant savo modulį===
Kai Python'as skaito importavimo komandą, jis pirmiausia patikrina Tavo katalogo failus, po to svetainės paketus ir iš anksto įdiegtus modulius. Norint sukurti savo modulį, tiesiog sukurk .py failą dabartiniame kataloge ir parašyk komandą:
<syntaxhighlight lang="python3">
import modulis
</syntaxhighlight>

Taip bus bandoma importuoti failą modulis.py iš dabartinio katalogo, o jei modulis bus nerastas, iš svetainių paketų ir iš anksto paruoštų modulių. Pakeitus modulį į Tavo sukurto .py failo pavadinimą, jis bus importuotas.

Tačiau kai jis importuoja modulį, jis iš esmės paleidžia failą kaip programą, todėl bet koks jame esantis kodas bus paleistas. Patartina visą kodą sugrupuoti į funkcijas.
====__name__ == __main__ triukas====
Python'e kintamasis <code>__name__</code> suteiks dabartinį programos pavadinimą. Jei importuojamas modulis spausdina <code>__name__</code> kintamąjį, tada jis atspausdins modulio pavadinimą. Jei dabartinis failas spausdina <code>__name__</code> kintamąjį, jis atspausdins <code>__main__</code>, tam, kad parodytų, kad tai yra pagrindinė programa.

Sąlyginis sakinys patikrina vardo kintamąjį ir paleidžia kodą, jei programa yra pagrindinė. Taip ji gali apeiti netyčinio paleidimo problemą, sukuriamą importuojant modulį. Tarkime, kad turi failą, kuriame veikia tam tikras kodas. Jis taip pat turi funkciją, kurią nori naudoti kitoje programoje. Tačiau nori tik funkcijos, esančios faile, o ne paleisti vykdyti kodą. Parašius žemiau pateiktą kodą, programa bus vykdoma tik tuo atveju, jei bus spustelėtas ar paleistas vykdyti esamas failas, o ne importuotas.
<syntaxhighlight lang="python3">
if __name__ == '__main__':
pass
</syntaxhighlight>
Šiuo atveju, jei failas paleidžiamas, bet neimportuojamas, jis vykdys komandą pass. Pass komandą galite pakeisti kodu, kurį norite paleisti, kai jis nėra importuotas. Tiesiog nepamiršk to kodo parašyti.
===pip modulis===
Pip modulis yra įdiegtas kartu su Python'u ir veikia kaip modulio atsisiuntėjas/tvarkytojas. Kitus modulius galima atsisiųsti iš interneto naudojant pip.

Pip modulis nenaudojamas Python'o interpretatoriuje, bet yra vykdomas per komandinę eilutę. Norint jį naudoti, atidaryk komandų eilutės programėlę (Windows tai yra komandinė eilutė, Mac/Linux – terminalas) ir įvesk šį kodą:
<syntaxhighlight lang="bash">
py3 -m pip install modulis
</syntaxhighlight>

arba alternatyvus kodas

<syntaxhighlight lang="bash">
pip install modulis
</syntaxhighlight>

Ši komandų eilutė bandys atsisiųsti ir įdiegti modulį iš vartotojo pateiktos Python'o modulių duomenų bazės. Modulis gali būti pakeistas į konkretaus modulio pavadinimą.

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Python Vadovėlis/Modulių naudojimas

2022-03-17T06:08:05Z

ZivileB:

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Štai šio skyriaus pratimas. Failas, kuriame yra ši užduotis, geriausia būtų pavadinti cal.py, kad nesimaišytų su importuojamu calendar.py moduliu. Modulis iš tiesų yra failas su priesaga .py, kuriame yra papildomų funkcijų rinkinys, kurį norite įtraukti ir naudoti savo programoje. Eilutė <code>import calendar</code> iš tikrųjų ieško failo pavadinimu calendar.py ir jį įtraukią į savo kodą. Jei failas būtų pavadintas calendar.py ir matytų <code>import calendar</code>, jis bandytų skaityti pats save, ir kodas tada neveiktų tinkamai.

<syntaxhighlight lang="python">
import calendar
metai = int(input("Įvesk metų skaičių: "))
calendar.prcal(metai)
</syntaxhighlight>

Ir čia yra gautos programos išvestis:

Įvesk metų skaičių: 2001

2001

Sausis Vasaris Kovas

Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se
1 2 3 4 5 6 7 1 2 3 4 1 2 3 4
8 9 10 11 12 13 14 5 6 7 8 9 10 11 5 6 7 8 9 10 11
15 16 17 18 19 20 21 12 13 14 15 16 17 18 12 13 14 15 16 17 18
22 23 24 25 26 27 28 19 20 21 22 23 24 25 19 20 21 22 23 24 25
29 30 31 26 27 28 26 27 28 29 30 31

(Aš praleidau kai kurias išvesties dalis, bet manau, kad principas aiškus.) Taigi, ką daro programa? Pirma eilutė <code>import calendar</code> naudoja naują komandą <code>import</code>. Komanda <code>import</code> įkelia modulį (šiuo atveju <code>calendar</code> modulį). Norint pamatyti standartiniuose moduliuose esančias funkcijas, ieškok Python'o bibliotekos nuorodos (jei atsisiuntei biblioteką) arba eik į http://docs.python.org/3/library/. Jei pažvelsi į kalendoriaus modulio dokumentaciją, jame yra funkcija, vadinama <code>prcal</code>, kuri spausdina metų kalendorių. Komanda <code>calendar.prcal(metai)</code> naudoja šią funkciją. Apskritai, norint naudoti modulį, reikia naudoti raktažodį <code>import</code> ir kartu panaudoti <code>modulio_pavadinimas.function</code>, kreipiantis į funkcijas esančias modulyje. Yra ir kitas būdas parašyti analogišką programą:

<syntaxhighlight lang="python">
from calendar import prcal

metai = int(input("Įveskite metų skaičių: "))
prcal(metai)
</syntaxhighlight>

Šis variantas importuoja konkrečią funkciją iš modulio.
Panagrinėkime dar vieną programą, kuri naudoja Python'o biblioteką (pavadink ją clock.py) (tuo pačiu metu paspausk Ctrl ir klavišą c, kad nutrauktum darbą):

<syntaxhighlight lang="python">
from time import time, ctime

ankstesnis_laikas = ""
while True:
laikas = ctime(time())
if ankstesnis_laikas != laikas:
print("Laikas:", ctime(time()))
ankstesnis_laikas = laikas
</syntaxhighlight>

Dalis išvesties yra:

Laikas: Tue Dec 21 13:14:20 2021
Laikas: Tue Dec 21 13:14:21 2021
Laikas: Tue Dec 21 13:14:22 2021
Laikas: Tue Dec 21 13:14:23 2021

Traceback (most recent call last):
File "laikas.py", line 5, in <module>
laikas = ctime(time())
KeyboardInterrupt

Kadangi išvestis yra begalinė, todėl ją atšaukiu (kitu atveju, išvestis tęstųsi bent jau tol, kol būtų paspaustas Ctrl+C). Programa atlieka nesibaigiantį ciklą (<code>True</code> yra visada tiesa, taigi <code>while True:</code> vykdoma amžinai). Kiekvieną kartą patikrina, ar laikas nepasikeitė, ir išspausdina, jei pasikeitė. Atkreipk dėmesį, kaip naudojami keli funkcijų pavadinimai po ''import'' sakinyje <code>from time import time, ctime</code>.

Python'o bibliotekoje yra daug naudingų funkcijų. Šios funkcijos suteikia Tavo programoms daugiau galimybių ir daugelis jų gali supaprastinti programavimą Python'u.

=== Pratimai ===
Perrašyk <code>daugiau_maziau.py</code> programą iš skyriaus [[Vadovėlis/Pasirinkimai#Pavyzdžiai|Pasirinkimai]], kad naudotų atsitiktinį sveikąjį skaičių nuo 0 iki 99, o ne įkoduotą 7. Naudok <code>random</code> modulį ir <code>randint</code> funkciją.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
from random import randint

skaičius = randint(0, 99)
spėjimas = -1
while spėjimas != skaičius:
spėjimas = int(input ("Atspėk skaičių: "))
if spėjimas > skaičius:
print("Per didelis")
elif spėjimas < skaičius:
print("Per mažas")

print("Būtent tas")

</syntaxhighlight>
|-
|}

==Kiti moduliai==
Kartais Tu gali norėti naudoti Python'o modulį, kurio nėra standatinėje Python versijoje. Tu gali juos importuoti, tačiau pirmiau turėsi juos įsidiegti savo kompiuterį.

===Kuriant savo modulį===
Kai Python'as skaito importavimo komandą, jis pirmiausia patikrina Tavo katalogo failus, po to svetainės paketus ir iš anksto įdiegtus modulius. Norint sukurti savo modulį, tiesiog sukurk .py failą dabartiniame kataloge ir parašyk komandą:
<syntaxhighlight lang="python3">
import modulis
</syntaxhighlight>

Taip bus bandoma importuoti failą modulis.py iš dabartinio katalogo, o jei modulis bus nerastas, iš svetainių paketų ir iš anksto paruoštų modulių. Pakeitus modulį į Tavo sukurto .py failo pavadinimą, jis bus importuotas.

Tačiau kai jis importuoja modulį, jis iš esmės paleidžia failą kaip programą, todėl bet koks jame esantis kodas bus paleistas. Patartina visą kodą sugrupuoti į funkcijas.
====__name__ == __main__ triukas====
Python'e kintamasis <code>__name__</code> suteiks dabartinį programos pavadinimą. Jei importuojamas modulis spausdina <code>__name__</code> kintamąjį, tada jis atspausdins modulio pavadinimą. Jei dabartinis failas spausdina <code>__name__</code> kintamąjį, jis atspausdins <code>__main__</code>, tam, kad parodytų, kad tai yra pagrindinė programa.

Sąlyginis sakinys patikrina vardo kintamąjį ir paleidžia kodą, jei programa yra pagrindinė. Taip ji gali apeiti netyčinio paleidimo problemą, sukuriamą importuojant modulį. Tarkime, kad turi failą, kuriame veikia tam tikras kodas. Jis taip pat turi funkciją, kurią nori naudoti kitoje programoje. Tačiau nori tik funkcijos, esančios faile, o ne paleisti vykdyti kodą. Parašius žemiau pateiktą kodą, programa bus vykdoma tik tuo atveju, jei bus spustelėtas ar paleistas vykdyti esamas failas, o ne importuotas.
<syntaxhighlight lang="python3">
if __name__ == '__main__':
pass
</syntaxhighlight>
Šiuo atveju, jei failas paleidžiamas, bet neimportuojamas, jis vykdys komandą pass. Pass komandą galite pakeisti kodu, kurį norite paleisti, kai jis nėra importuotas. Tiesiog nepamiršk to kodo parašyti.
===pip modulis===
Pip modulis yra įdiegtas kartu su Python'u ir veikia kaip modulio atsisiuntėjas/tvarkytojas. Kitus modulius galima atsisiųsti iš interneto naudojant pip.

Pip modulis nenaudojamas Python'o interpretatoriuje, bet yra vykdomas per komandinę eilutę. Norint jį naudoti, atidaryk komandų eilutės programėlę (Windows tai yra komandinė eilutė, Mac/Linux – terminalas) ir įvesk šį kodą:
<syntaxhighlight lang="bash">
py3 -m pip install modulis
</syntaxhighlight>

arba alternatyvus kodas

<syntaxhighlight lang="bash">
pip install modulis
</syntaxhighlight>

Ši komandų eilutė bandys atsisiųsti ir įdiegti modulį iš vartotojo pateiktos Python'o modulių duomenų bazės. Modulis gali būti pakeistas į konkretaus modulio pavadinimą.

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Python Vadovėlis/Modulių naudojimas

2022-03-17T06:03:29Z

ZivileB:

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Štai šio skyriaus pratimas. Failas, kuriame yra ši užduotis, geriausia būtų pavadinti cal.py, kad nesimaišytų su importuojamu calendar.py. Eilutė <code>import calendar</code> iš tikrųjų ieško failo pavadinimu calendar.py ir jį įtraukią į savo kodą. Jei failas būtų pavadintas calendar.py ir matytų <code>import calendar</code>, jis bandytų skaityti pats save, ir kodas tada neveiktų tinkamai.

<syntaxhighlight lang="python">
import calendar
metai = int(input("Įvesk metų skaičių: "))
calendar.prcal(metai)
</syntaxhighlight>

Ir čia yra gautos programos išvestis:

Įvesk metų skaičių: 2001

2001

Sausis Vasaris Kovas

Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se
1 2 3 4 5 6 7 1 2 3 4 1 2 3 4
8 9 10 11 12 13 14 5 6 7 8 9 10 11 5 6 7 8 9 10 11
15 16 17 18 19 20 21 12 13 14 15 16 17 18 12 13 14 15 16 17 18
22 23 24 25 26 27 28 19 20 21 22 23 24 25 19 20 21 22 23 24 25
29 30 31 26 27 28 26 27 28 29 30 31

(Aš praleidau kai kurias išvesties dalis, bet manau, kad principas aiškus.) Taigi, ką daro programa? Pirma eilutė <code>import calendar</code> naudoja naują komandą <code>import</code>. Komanda <code>import</code> įkelia modulį (šiuo atveju <code>calendar</code> modulį). Norint pamatyti standartiniuose moduliuose esančias funkcijas, ieškok Python'o bibliotekos nuorodos (jei atsisiuntei biblioteką) arba eik į http://docs.python.org/3/library/. Jei pažvelsi į kalendoriaus modulio dokumentaciją, jame yra funkcija, vadinama <code>prcal</code>, kuri spausdina metų kalendorių. Komanda <code>calendar.prcal(metai)</code> naudoja šią funkciją. Apskritai, norint naudoti modulį, reikia naudoti raktažodį <code>import</code> ir kartu panaudoti <code>modulio_pavadinimas.function</code>, kreipiantis į funkcijas esančias modulyje. Yra ir kitas būdas parašyti analogišką programą:

<syntaxhighlight lang="python">
from calendar import prcal

metai = int(input("Įveskite metų skaičių: "))
prcal(metai)
</syntaxhighlight>

Šis variantas importuoja konkrečią funkciją iš modulio.
Panagrinėkime dar vieną programą, kuri naudoja Python'o biblioteką (pavadink ją clock.py) (tuo pačiu metu paspausk Ctrl ir klavišą c, kad nutrauktum darbą):

<syntaxhighlight lang="python">
from time import time, ctime

ankstesnis_laikas = ""
while True:
laikas = ctime(time())
if ankstesnis_laikas != laikas:
print("Laikas:", ctime(time()))
ankstesnis_laikas = laikas
</syntaxhighlight>

Dalis išvesties yra:

Laikas: Tue Dec 21 13:14:20 2021
Laikas: Tue Dec 21 13:14:21 2021
Laikas: Tue Dec 21 13:14:22 2021
Laikas: Tue Dec 21 13:14:23 2021

Traceback (most recent call last):
File "laikas.py", line 5, in <module>
laikas = ctime(time())
KeyboardInterrupt

Kadangi išvestis yra begalinė, todėl ją atšaukiu (kitu atveju, išvestis tęstųsi bent jau tol, kol būtų paspaustas Ctrl+C). Programa atlieka nesibaigiantį ciklą (<code>True</code> yra visada tiesa, taigi <code>while True:</code> vykdoma amžinai). Kiekvieną kartą patikrina, ar laikas nepasikeitė, ir išspausdina, jei pasikeitė. Atkreipk dėmesį, kaip naudojami keli funkcijų pavadinimai po ''import'' sakinyje <code>from time import time, ctime</code>.

Python'o bibliotekoje yra daug naudingų funkcijų. Šios funkcijos suteikia Tavo programoms daugiau galimybių ir daugelis jų gali supaprastinti programavimą Python'u.

=== Pratimai ===
Perrašyk <code>daugiau_maziau.py</code> programą iš skyriaus [[Vadovėlis/Pasirinkimai#Pavyzdžiai|Pasirinkimai]], kad naudotų atsitiktinį sveikąjį skaičių nuo 0 iki 99, o ne įkoduotą 7. Naudok <code>random</code> modulį ir <code>randint</code> funkciją.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
from random import randint

skaičius = randint(0, 99)
spėjimas = -1
while spėjimas != skaičius:
spėjimas = int(input ("Atspėk skaičių: "))
if spėjimas > skaičius:
print("Per didelis")
elif spėjimas < skaičius:
print("Per mažas")

print("Būtent tas")

</syntaxhighlight>
|-
|}

==Kiti moduliai==
Kartais Tu gali norėti naudoti Python'o modulį, kurio nėra standatinėje Python versijoje. Tu gali juos importuoti, tačiau pirmiau turėsi juos įsidiegti savo kompiuterį.

===Kuriant savo modulį===
Kai Python'as skaito importavimo komandą, jis pirmiausia patikrina Tavo katalogo failus, po to svetainės paketus ir iš anksto įdiegtus modulius. Norint sukurti savo modulį, tiesiog sukurk .py failą dabartiniame kataloge ir parašyk komandą:
<syntaxhighlight lang="python3">
import modulis
</syntaxhighlight>

Taip bus bandoma importuoti failą modulis.py iš dabartinio katalogo, o jei modulis bus nerastas, iš svetainių paketų ir iš anksto paruoštų modulių. Pakeitus modulį į Tavo sukurto .py failo pavadinimą, jis bus importuotas.

Tačiau kai jis importuoja modulį, jis iš esmės paleidžia failą kaip programą, todėl bet koks jame esantis kodas bus paleistas. Patartina visą kodą sugrupuoti į funkcijas.
====__name__ == __main__ triukas====
Python'e kintamasis <code>__name__</code> suteiks dabartinį programos pavadinimą. Jei importuojamas modulis spausdina <code>__name__</code> kintamąjį, tada jis atspausdins modulio pavadinimą. Jei dabartinis failas spausdina <code>__name__</code> kintamąjį, jis atspausdins <code>__main__</code>, tam, kad parodytų, kad tai yra pagrindinė programa.

Sąlyginis sakinys patikrina vardo kintamąjį ir paleidžia kodą, jei programa yra pagrindinė. Taip ji gali apeiti netyčinio paleidimo problemą, sukuriamą importuojant modulį. Tarkime, kad turi failą, kuriame veikia tam tikras kodas. Jis taip pat turi funkciją, kurią nori naudoti kitoje programoje. Tačiau nori tik funkcijos, esančios faile, o ne paleisti vykdyti kodą. Parašius žemiau pateiktą kodą, programa bus vykdoma tik tuo atveju, jei bus spustelėtas ar paleistas vykdyti esamas failas, o ne importuotas.
<syntaxhighlight lang="python3">
if __name__ == '__main__':
pass
</syntaxhighlight>
Šiuo atveju, jei failas paleidžiamas, bet neimportuojamas, jis vykdys komandą pass. Pass komandą galite pakeisti kodu, kurį norite paleisti, kai jis nėra importuotas. Tiesiog nepamiršk to kodo parašyti.
===pip modulis===
Pip modulis yra įdiegtas kartu su Python'u ir veikia kaip modulio atsisiuntėjas/tvarkytojas. Kitus modulius galima atsisiųsti iš interneto naudojant pip.

Pip modulis nenaudojamas Python'o interpretatoriuje, bet yra vykdomas per komandinę eilutę. Norint jį naudoti, atidaryk komandų eilutės programėlę (Windows tai yra komandinė eilutė, Mac/Linux – terminalas) ir įvesk šį kodą:
<syntaxhighlight lang="bash">
py3 -m pip install modulis
</syntaxhighlight>

arba alternatyvus kodas

<syntaxhighlight lang="bash">
pip install modulis
</syntaxhighlight>

Ši komandų eilutė bandys atsisiųsti ir įdiegti modulį iš vartotojo pateiktos Python'o modulių duomenų bazės. Modulis gali būti pakeistas į konkretaus modulio pavadinimą.

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Python Vadovėlis/Modulių naudojimas

2022-03-17T05:59:55Z

ZivileB:

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Štai šio skyriaus pratimas. Failas, kuriame yra ši užduotis, geriausia būtų pavadinti cal.py, kad nesimaišytų su importuojamu calendar.py. Eilutė <code>import calendar</code> iš tikrųjų ieško failo pavadinimu calendar.py ir jį įtraukią į savo kodą. Jei failas būtų pavadintas calendar.py ir matytų <code>import calendar</code>, jis bandytų skaityti pats save, ir kodas tada neveiktų tinkamai.

<syntaxhighlight lang="python">
import calendar
metai = int(input("Įvesk metų skaičių: "))
calendar.prcal(metai)
</syntaxhighlight>

Ir čia yra gautos programos išvestis:

Įvesk metų skaičių: 2001

2001

Sausis Vasaris Kovas

Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se
1 2 3 4 5 6 7 1 2 3 4 1 2 3 4
8 9 10 11 12 13 14 5 6 7 8 9 10 11 5 6 7 8 9 10 11
15 16 17 18 19 20 21 12 13 14 15 16 17 18 12 13 14 15 16 17 18
22 23 24 25 26 27 28 19 20 21 22 23 24 25 19 20 21 22 23 24 25
29 30 31 26 27 28 26 27 28 29 30 31

(Aš praleidau kai kurias išvesties dalis, bet manau, kad principas aiškus.) Taigi, ką daro programa? Pirma eilutė <code>import calendar</code> naudoja naują komandą <code>import</code>. Komanda <code>import</code> įkelia modulį (šiuo atveju <code>calendar</code> modulį). Norint pamatyti standartiniuose moduliuose esančias funkcijas, ieškok Python'o bibliotekos nuorodos (jei atsisiuntei biblioteką) arba eik į http://docs.python.org/3/library/. Jei pažvelsi į kalendoriaus modulio dokumentaciją, jame yra funkcija, vadinama <code>prcal</code>, kuri spausdina metų kalendorių. Komanda <code>calendar.prcal(metai)</code> naudoja šią funkciją. Apskritai, norint naudoti modulį, reikia naudoti raktažodį <code>import</code> ir kartu panaudoti <code>modulio_pavadinimas.function</code>, kreipiantis į funkcijas esančias modulyje. Yra ir kitas būdas parašyti analogišką programą:

<syntaxhighlight lang="python">
from calendar import prcal

metai = int(input("Įveskite metų skaičių: "))
prcal(metai)
</syntaxhighlight>

Šis variantas importuoja konkrečią funkciją iš modulio.
Panagrinėkime dar vieną programą, kuri naudoja Python'o biblioteką (pavadink ją clock.py) (tuo pačiu metu paspausk Ctrl ir klavišą c, kad nutrauktum darbą):

<syntaxhighlight lang="python">
from time import time, ctime

ankstesnis_laikas = ""
while True:
laikas = ctime(time())
if ankstesnis_laikas != laikas:
print("Laikas:", ctime(time()))
ankstesnis_laikas = laikas
</syntaxhighlight>

Dalis išvesties yra:

Laikas: Tue Dec 21 13:14:20 2021
Laikas: Tue Dec 21 13:14:21 2021
Laikas: Tue Dec 21 13:14:22 2021
Laikas: Tue Dec 21 13:14:23 2021

Traceback (most recent call last):
File "laikas.py", line 5, in <module>
laikas = ctime(time())
KeyboardInterrupt

Kadangi išvestis yra begalinė, todėl ją atšaukiu (kitu atveju, išvestis tęstųsi bent jau tol, kol būtų paspaustas Ctrl+C). Programa atlieka nesibaigiantį ciklą (<code>True</code> yra visada tiesa, taigi <code>while True:</code> vykdoma amžinai). Kiekvieną kartą patikrina, ar laikas nepasikeitė, ir išspausdina, jei pasikeitė. Atkreipk dėmesį, kaip naudojami keli funkcijų pavadinimai po ''import'' sakinyje <code>from time import time, ctime</code>.

Python'o bibliotekoje yra daug naudingų funkcijų. Šios funkcijos suteikia Tavo programoms daugiau galimybių ir daugelis jų gali supaprastinti programavimą Python'u.

=== Pratimai ===
Perrašyk <code>daugiau_maziau.py</code> programą iš skyriaus [[Vadovėlis/Pasirinkimai#Pavyzdžiai|Pasirinkimai]], kad naudotų atsitiktinį sveikąjį skaičių nuo 0 iki 99, o ne įkoduotą 7. Naudok Python'o dokumentaciją, kad surastum tinkamą modulį ir funkciją.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
from random import randint

skaičius = randint(0, 99)
spėjimas = -1
while spėjimas != skaičius:
spėjimas = int(input ("Atspėk skaičių: "))
if spėjimas > skaičius:
print("Per didelis")
elif spėjimas < skaičius:
print("Per mažas")

print("Būtent tas")

</syntaxhighlight>
|-
|}

==Kiti moduliai==
Kartais Tu gali norėti naudoti Python'o modulį, kurio nėra standatinėje Python versijoje. Tu gali juos importuoti, tačiau pirmiau turėsi juos įsidiegti savo kompiuterį.

===Kuriant savo modulį===
Kai Python'as skaito importavimo komandą, jis pirmiausia patikrina Tavo katalogo failus, po to svetainės paketus ir iš anksto įdiegtus modulius. Norint sukurti savo modulį, tiesiog sukurk .py failą dabartiniame kataloge ir parašyk komandą:
<syntaxhighlight lang="python3">
import modulis
</syntaxhighlight>

Taip bus bandoma importuoti failą modulis.py iš dabartinio katalogo, o jei modulis bus nerastas, iš svetainių paketų ir iš anksto paruoštų modulių. Pakeitus modulį į Tavo sukurto .py failo pavadinimą, jis bus importuotas.

Tačiau kai jis importuoja modulį, jis iš esmės paleidžia failą kaip programą, todėl bet koks jame esantis kodas bus paleistas. Patartina visą kodą sugrupuoti į funkcijas.
====__name__ == __main__ triukas====
Python'e kintamasis <code>__name__</code> suteiks dabartinį programos pavadinimą. Jei importuojamas modulis spausdina <code>__name__</code> kintamąjį, tada jis atspausdins modulio pavadinimą. Jei dabartinis failas spausdina <code>__name__</code> kintamąjį, jis atspausdins <code>__main__</code>, tam, kad parodytų, kad tai yra pagrindinė programa.

Sąlyginis sakinys patikrina vardo kintamąjį ir paleidžia kodą, jei programa yra pagrindinė. Taip ji gali apeiti netyčinio paleidimo problemą, sukuriamą importuojant modulį. Tarkime, kad turi failą, kuriame veikia tam tikras kodas. Jis taip pat turi funkciją, kurią nori naudoti kitoje programoje. Tačiau nori tik funkcijos, esančios faile, o ne paleisti vykdyti kodą. Parašius žemiau pateiktą kodą, programa bus vykdoma tik tuo atveju, jei bus spustelėtas ar paleistas vykdyti esamas failas, o ne importuotas.
<syntaxhighlight lang="python3">
if __name__ == '__main__':
pass
</syntaxhighlight>
Šiuo atveju, jei failas paleidžiamas, bet neimportuojamas, jis vykdys komandą pass. Pass komandą galite pakeisti kodu, kurį norite paleisti, kai jis nėra importuotas. Tiesiog nepamiršk to kodo parašyti.
===pip modulis===
Pip modulis yra įdiegtas kartu su Python'u ir veikia kaip modulio atsisiuntėjas/tvarkytojas. Kitus modulius galima atsisiųsti iš interneto naudojant pip.

Pip modulis nenaudojamas Python'o interpretatoriuje, bet yra vykdomas per komandinę eilutę. Norint jį naudoti, atidaryk komandų eilutės programėlę (Windows tai yra komandinė eilutė, Mac/Linux – terminalas) ir įvesk šį kodą:
<syntaxhighlight lang="bash">
py3 -m pip install modulis
</syntaxhighlight>

arba alternatyvus kodas

<syntaxhighlight lang="bash">
pip install modulis
</syntaxhighlight>

Ši komandų eilutė bandys atsisiųsti ir įdiegti modulį iš vartotojo pateiktos Python'o modulių duomenų bazės. Modulis gali būti pakeistas į konkretaus modulio pavadinimą.

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Python Vadovėlis/Modulių naudojimas

2022-03-05T14:36:51Z

ZivileB:

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Štai šio skyriaus pratimas (pavadink failą cal.py (<code>import</code> iš tikrųjų ieško failo pavadinimu calendar.py ir jį įtraukią į savo kodą. Jei failas būtų pavadintas calendar.py ir matytų "import calendar", jis bandytų skaityti pats save, o tai neveiktų tinkamai.)):

<syntaxhighlight lang="python">
import calendar
metai = int(input("Įvesk metų skaičių: "))
calendar.prcal(metai)
</syntaxhighlight>

Ir čia yra gautos programos išvestis:

Įvesk metų skaičių: 2001

2001

Sausis Vasaris Kovas

Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se Pr An Tr Ke Pe Še Se
1 2 3 4 5 6 7 1 2 3 4 1 2 3 4
8 9 10 11 12 13 14 5 6 7 8 9 10 11 5 6 7 8 9 10 11
15 16 17 18 19 20 21 12 13 14 15 16 17 18 12 13 14 15 16 17 18
22 23 24 25 26 27 28 19 20 21 22 23 24 25 19 20 21 22 23 24 25
29 30 31 26 27 28 26 27 28 29 30 31

(Aš praleidau kai kurias išvesties dalis, bet manau, kad principas aiškus.) Taigi, ką daro programa? Pirma eilutė <code>import calendar</code> naudoja naują komandą <code>import</code>. Komanda <code>import</code> įkelia modulį (šiuo atveju <code>calendar</code> modulį). Norint pamatyti standartiniuose moduliuose esančias funkcijas, ieškok Python'o bibliotekos nuorodos (jei atsisiuntei biblioteką) arba eik į http://docs.python.org/3/library/. Jei pažvelsi į kalendoriaus modulio dokumentaciją, jame yra funkcija, vadinama <code>prcal</code>, kuri spausdina metų kalendorių. Komanda <code>calendar.prcal(metai)</code> naudoja šią funkciją. Apskritai, norint naudoti modulį, reikia naudoti raktažodį <code>import</code> ir kartu panaudoti <code>modulio_pavadinimas.function</code>, kreipiantis į funkcijas esančias modulyje. Yra ir kitas būdas parašyti analogišką programą:

<syntaxhighlight lang="python">
from calendar import prcal

metai = int(input("Įveskite metų skaičių: "))
prcal(metai)
</syntaxhighlight>

Šis variantas importuoja konkrečią funkciją iš modulio.
Panagrinėkime dar vieną programą, kuri naudoja Python'o biblioteką (pavadink ją clock.py) (tuo pačiu metu paspausk Ctrl ir klavišą c, kad nutrauktum darbą):

<syntaxhighlight lang="python">
from time import time, ctime

ankstesnis_laikas = ""
while True:
laikas = ctime(time())
if ankstesnis_laikas != laikas:
print("Laikas:", ctime(time()))
ankstesnis_laikas = laikas
</syntaxhighlight>

Dalis išvesties yra:

Laikas: Tue Dec 21 13:14:20 2021
Laikas: Tue Dec 21 13:14:21 2021
Laikas: Tue Dec 21 13:14:22 2021
Laikas: Tue Dec 21 13:14:23 2021

Traceback (most recent call last):
File "laikas.py", line 5, in <module>
laikas = ctime(time())
KeyboardInterrupt

Kadangi išvestis yra begalinė, todėl ją atšaukiu (kitu atveju, išvestis tęstųsi bent jau tol, kol būtų paspaustas Ctrl+C). Programa atlieka nesibaigiantį ciklą (<code>True</code> yra visada tiesa, taigi <code>while True:</code> vykdoma amžinai). Kiekvieną kartą patikrina, ar laikas nepasikeitė, ir išspausdina, jei pasikeitė. Atkreipk dėmesį, kaip naudojami keli funkcijų pavadinimai po ''import'' sakinyje <code>from time import time, ctime</code>.

Python'o bibliotekoje yra daug naudingų funkcijų. Šios funkcijos suteikia Tavo programoms daugiau galimybių ir daugelis jų gali supaprastinti programavimą Python'u.

=== Pratimai ===
Perrašyk <code>daugiau_maziau.py</code> programą iš skyriaus [[Vadovėlis/Pasirinkimai#Pavyzdžiai|Pasirinkimai]], kad naudotų atsitiktinį sveikąjį skaičių nuo 0 iki 99, o ne įkoduotą 7. Naudok Python'o dokumentaciją, kad surastum tinkamą modulį ir funkciją.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
from random import randint

skaičius = randint(0, 99)
spėjimas = -1
while spėjimas != skaičius:
spėjimas = int(input ("Atspėk skaičių: "))
if spėjimas > skaičius:
print("Per didelis")
elif spėjimas < skaičius:
print("Per mažas")

print("Būtent tas")

</syntaxhighlight>
|-
|}

==Kiti moduliai==
Kartais Tu gali norėti naudoti Python'o modulį, kurio nėra standatinėje Python versijoje. Tu gali juos importuoti, tačiau pirmiau turėsi juos įsidiegti savo kompiuterį.

===Kuriant savo modulį===
Kai Python'as skaito importavimo komandą, jis pirmiausia patikrina Tavo katalogo failus, po to svetainės paketus ir iš anksto įdiegtus modulius. Norint sukurti savo modulį, tiesiog sukurk .py failą dabartiniame kataloge ir parašyk komandą:
<syntaxhighlight lang="python3">
import modulis
</syntaxhighlight>

Taip bus bandoma importuoti failą modulis.py iš dabartinio katalogo, o jei modulis bus nerastas, iš svetainių paketų ir iš anksto paruoštų modulių. Pakeitus modulį į Tavo sukurto .py failo pavadinimą, jis bus importuotas.

Tačiau kai jis importuoja modulį, jis iš esmės paleidžia failą kaip programą, todėl bet koks jame esantis kodas bus paleistas. Patartina visą kodą sugrupuoti į funkcijas.
====__name__ == __main__ triukas====
Python'e kintamasis <code>__name__</code> suteiks dabartinį programos pavadinimą. Jei importuojamas modulis spausdina <code>__name__</code> kintamąjį, tada jis atspausdins modulio pavadinimą. Jei dabartinis failas spausdina <code>__name__</code> kintamąjį, jis atspausdins <code>__main__</code>, tam, kad parodytų, kad tai yra pagrindinė programa.

Sąlyginis sakinys patikrina vardo kintamąjį ir paleidžia kodą, jei programa yra pagrindinė. Taip ji gali apeiti netyčinio paleidimo problemą, sukuriamą importuojant modulį. Tarkime, kad turi failą, kuriame veikia tam tikras kodas. Jis taip pat turi funkciją, kurią nori naudoti kitoje programoje. Tačiau nori tik funkcijos, esančios faile, o ne paleisti vykdyti kodą. Parašius žemiau pateiktą kodą, programa bus vykdoma tik tuo atveju, jei bus spustelėtas ar paleistas vykdyti esamas failas, o ne importuotas.
<syntaxhighlight lang="python3">
if __name__ == '__main__':
pass
</syntaxhighlight>
Šiuo atveju, jei failas paleidžiamas, bet neimportuojamas, jis vykdys komandą pass. Pass komandą galite pakeisti kodu, kurį norite paleisti, kai jis nėra importuotas. Tiesiog nepamiršk to kodo parašyti.
===pip modulis===
Pip modulis yra įdiegtas kartu su Python'u ir veikia kaip modulio atsisiuntėjas/tvarkytojas. Kitus modulius galima atsisiųsti iš interneto naudojant pip.

Pip modulis nenaudojamas Python'o interpretatoriuje, bet yra vykdomas per komandinę eilutę. Norint jį naudoti, atidaryk komandų eilutės programėlę (Windows tai yra komandinė eilutė, Mac/Linux – terminalas) ir įvesk šį kodą:
<syntaxhighlight lang="bash">
py3 -m pip install modulis
</syntaxhighlight>

arba alternatyvus kodas

<syntaxhighlight lang="bash">
pip install modulis
</syntaxhighlight>

Ši komandų eilutė bandys atsisiųsti ir įdiegti modulį iš vartotojo pateiktos Python'o modulių duomenų bazės. Modulis gali būti pakeistas į konkretaus modulio pavadinimą.

{{navigation |previous=Žodynai |next=Daugiau apie sąrašus}}

Python Vadovėlis/Rekursija

2022-03-02T15:20:41Z

ZivileB:

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

== Rekursija ==

Programavime rekursine funkcija vadinama funkcija, kuri iškviečia pati save.

=== Įvadas į rekursiją ===

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

sk = 0

def main():
skaitliukas(sk)

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

main()
</syntaxhighlight>

Jei šią programą paleistum VS Code kodo redaktoriuje, ji veiktų amžinai. Vienintelis būdas sustabdyti ciklą būtų nutraukti vykdymą paspaudžiant Ctrl + C klaviatūroje. Tai yra begalinės rekursijos pavyzdys.

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

Rekursija gali būti valdoma, kaip ir ciklai. Pažvelk į rekursinio ciklo pavyzdį.
<syntaxhighlight lang="python">
# Mitchell Aikens programa
# Nėra autorinių teisių
# 2010
def main():
ciklosk= int(input("Kiek kartų norėtum paleisti ciklą?\n"))
skaitliukas = 1
recurr(ciklosk,skaitliukas)

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

main()
</syntaxhighlight>

Programoje naudojami argumentai/parametrai rekursijų skaičiui valdyti. Tiesiog naudok tai, ką jau žinai apie funkcijas, ir sek programos eigą. Tai paprasta išsiaiškinti. Jei kyla problemų, grįžk į [[Vadovėlis/Pažangių funkcijų pavyzdys|Pažangių funkcijų pavyzdys]].

== Praktiniai rekursijos pritaikymai ==

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

Pagalvokite apie šias dvi „taisykles“:
* Jei galiu išspręsti problemą su ciklu, be rekursijos, funkcija tiesiog grąžina reikšmę.
* Jei negaliu išspręsti problemos su cilku, be rekursijos, funkcija sumažina problemą iki mažesnės analogiškos problemos ir iškviečia pati save.

Pabandyk pritaikyti rekursinę funkciją faktorialui apskaičiuoti. Jei nesi susipažinęs su faktoriais, skaityk: [https://lt.wikipedia.org/wiki/Faktorialas Faktorialas]

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

Štai keletas pagrindinių faktorialo taisyklių:

Jei n = 0 tai n! = 1

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

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

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

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

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

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

main()
</syntaxhighlight>

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

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

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

Python Vadovėlis/Žodynai

2022-03-02T15:19:45Z

ZivileB:

{{navigation |previous=Loginiai reiškiniai |next=Modulių naudojimas}}

Šis skyrius yra apie žodynus. Žodynai turi raktus ir reikšmes. Raktai naudojami reikšmėms rasti. Štai žodyno pavyzdys:
<syntaxhighlight lang="python">
def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu ()
while meniu_pasirinkimas != 5:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-5): "))
if meniu_pasirinkimas == 1:
print("Telefono numeriai: ")
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
print()
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
numeriai[vardas] = numeris
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas != 5:
print_menu()

</syntaxhighlight>

O čia - mano išvestis:

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

Įvesk skaičių (1-5): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Benas'''
Telefono numeris: '''869935951'''
Įvesk skaičių (1-5): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Liepa'''
Telefono numeris: '''869935952'''
Įvesk skaičių (1-5): '''2'''
Pridėk vardą ir telefono numerį
Vardas: '''Markas'''
Telefono numeris: '''869935957'''
Įvesk skaičių (1-5): '''1'''
Telefono numeriai:
Vardas: Benas Telefono numeris: 869935951
Vardas: Liepa Telefono numeris: 869935952
Vardas: Markas Telefono numeris: 869935957

Įvesk skaičių (1-5): '''4'''
Ieškok telefono numerio
Vardas: '''Benas'''
Telefono numeris yra 869935951
Įvesk skaičių (1-5): '''3'''
Pašalink telefono numerį
Vardas: '''Markas'''
Įvesk skaičių (1-5): '''1'''
Telefono numeriai:
Vardas: Liepa Telefono numeris: 869935952
Vardas: Benas Telefono numeris: 869935951

Įvesk skaičių (1-5): '''5'''

Ši programa yra panaši į į programą su vardų sąrašu, pateiktą prieš tai buvusiame skyriuje apie sąrašus. Štai kaip veikia programa. Pirmiausiai yra aprašoma funkcija <code>spausdink_meniu</code>. <code>spausdink_meniu</code> tiesiog spausdina meniu, kuris vėliau du kartus naudojamas programoje. Po to, pateikiama keistai atrodanti eilutė <code>numeriai = {}</code>. Ši eilutė Python'ui pasako, kad <code>numeriai</code> yra žodynas. Kitos kelios eilutės tiesiog padaro taip, kad meniu veiktų. Vykdydant ciklą:
<syntaxhighlight lang="python">
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
</syntaxhighlight>
einama per žodyną ir spausdinami žodyne esantys elementai. Funkcija <code> numeriai.keys()</code> grąžina žodyno elementų raktų sąrašą, kuris yra vėliau naudojamas <code>for</code> cikle. Sąrašas grąžinamas <code>keys()</code> metodo pagalba neturi jokio eiliškumo, todėl, jei tu nori, kad jis būtų abėcėlės tvarka, jis turi būti surūšiuotas. Taigi, šiuo atveju <code>x</code> yra tekstinė eilutė – vardai. Panašiai kaip sąrašai, komanda <code>numeriai[x]</code> naudojama norint pasiekti konkretų žodyno elementą. Šiuo atveju tai yra telefonų numeriai. Komanda <code>print</code> visa tai atspausdina.
<syntaxhighlight lang="python">
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
numeriai[vardas] = numeris
</syntaxhighlight>
Padarius kitą pasirinkimą, pirmiausiai paklausiamas Vardas – tai bus žodyno elemento raktas, ir paklausiamas numeris. Toliau, komanda <code>numeriai[vardas] = telefonas</code> prideda vardą ir telefono numerį į žodyną. Jei <code>vardas</code> jau būtų buvęs žodyne, <code>telefonas</code> pakeistų prieš tai buvusią reikšmę.
Toliau sąlyginis sakinys
<syntaxhighlight lang="python">
if vardas in numeriai:
del numeriai[vardas]
</syntaxhighlight>
tikrina, ar vardas yra žodyne, ir jei yra, jį pašalina. Komanda <code>vardas in numeriai</code> grąžina loginę reikšmę <code>True</code>, jei <code>vardas</code> yra <code>numeriai</code> žodyne, bet kitu atveju grąžina <code>False</code>. Komanda <code>del numeriai[vardas]</code> pašalina raktą <code>vardas</code> ir su tuo raktu susietą reikšmę.
Sąlyginis sakinys
<syntaxhighlight lang="python">
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
</syntaxhighlight>
patikrina, ar žodynas turi tam tikrą raktą ir jei žodynas turi tą raktą, išspausdina su juo susietą numerį. Galiausiai, jei meniu pasirinkimas negalioja, pagrindinis meniu yra atspausdinamas, kad tu galėtum juo pasigrožėti.


Apibendrinimas: žodynai turi raktus ir reikšmes. Raktu gali būti tekstinė eilutė arba
skaičius. Raktai nurodo reikšmes. Reikšmės gali būti bet kokio tipo kintamieji
(įskaitant sąrašus ar net žodynus (žinoma, tuose žodynuose ar sąrašuose
gali būti patys žodynai ar sąrašai (baisu, ane? :-)
))). Štai yra pavyzdys, kai naudojamas sąrašas žodyne:

<syntaxhighlight lang="python">
max_taškai = [25, 25, 50, 25, 100]
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = {'#Max': max_taškai}

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

def spausdink_visus_pažymius():
print('\t', end=' ')
for i in range(len(užduotys)):
print(užduotys[i], '\t', end=' ')
print()
raktai = list(mokiniai.keys())
raktai.sort()
for x in raktai:
print(x, '\t', end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)

def spausdink_pažymius(pažymiai):
for i in range(len(pažymiai)):
print(pažymiai[i], '\t', end=' ')
print()

spausdink_meniu()
meniu_pasirinkimas = 0
while meniu_pasirinkimas != 6:
print()
meniu_pasirinkimas = int(input("Meniu pasirinkimas (1-6): "))
if meniu_pasirinkimas == 1:
vardas = input("Pridėk mokinį: ")
mokiniai[vardas] = [0] * len(max_taškai)
elif meniu_pasirinkimas == 2:
vardas = input("Pašalink mokinį: ")
if vardas in mokiniai:
del mokiniai[vardas]
else:
print("Vardas: ", vardas, " nebuvo rastas")
elif meniu_pasirinkimas == 3:
spausdink_visus_pažymius()
elif meniu_pasirinkimas == 4:
print("Įrašyk pažymį")
vardas = input("Mokinys: ")
if vardas in mokiniai:
pažymiai = mokiniai[vardas]
print("Įrašyk mokinio pažymį")
print("Įrašyk 0 (nulį), kad išeitum")
for i in range(len(užduotys)):
print(i + 1, užduotys[i], '\t', end=' ')
print()
spausdink_pažymius(pažymiai)
kuris = 1234
while kuris != -1:
kuris = int(input("Pakeisk kuris pažymį: "))
kuris -= 1 #tas pats kaip ir: kuris = kuris - 1
if 0 <= kuris < len(pažymiai):
pažymys = int(input("Pažymys: "))
pažymiai[kuris] = pažymys
elif kuris != -1:
print("Klaidingas pažymys")
else:
print("Mokinys nerastas")
elif meniu_pasirinkimas != 6:
spausdink_meniu()
</syntaxhighlight>

O štai čia yra išvestis:

1. Pridėk mokinį
2. Pašalink mokinį
3. Spausdink pažymius
4. Įrašyk pažymį
5. Spausdink meniu
6. Išeik

Meniu pasirinkimas (1-6): '''3'''
nd sk 1 nd sk 2 viktorina nd sk 3 testas
#Max 25 25 50 25 100

Meniu pasirinkimas (1-6): '''5'''
1. Pridėk mokinį
2. Pašalink mokinį
3. Spausdink pažymius
4. Įrašyk pažymį
5. Spausdink meniu
6. Išeik

Meniu pasirinkimas (1-6): '''1'''
Pridėk mokinį: '''Markas'''

Meniu pasirinkimas (1-6): '''4'''
Įrašyk pažymį
Mokinys: '''Markas'''
Įrašyk mokinio pažymį
Įrašyk 0 (nulį), kad išeitum
1 nd sk 1 2 nd sk 2 3 viktorina 4 nd sk 3 5 testas
0 0 0 0 0
Pakeisk kuris pažymį: '''1'''
Pažymys: '''25'''
Pakeisk kuris pažymį: '''2'''
Pažymys: '''24'''
Pakeisk kuris pažymį: '''3'''
Pažymys: '''45'''
Pakeisk kuris pažymį: '''4'''
Pažymys: '''23'''
Pakeisk kuris pažymį: '''5'''
Pažymys: '''95'''
Pakeisk kuris pažymį: '''0'''

Meniu pasirinkimas (1-6): '''3'''
nd sk 1 nd sk 2 viktorina nd sk 3 testas
#Max 25 25 50 25 100
Markas 25 24 45 23 95

Meniu pasirinkimas (1-6): '''6'''

Štai kaip veikia programa. Iš esmės, kintamasis <code>mokiniai</code> yra žodynas, kurio raktai yra mokinių vardai, o reikšmės – jų pažymiai. Pirmosios dvi eilutės tik sukuria du sąrašus.
Kita eilutė <code>mokiniai = {'#Max': max_taškai}</code> sukuria naują
žodyną su raktu {<code>#Max</code>}, o reikšmė yra <code>[25, 25, 50, 25, 100]</code> (pirmame sakinyje <code>max_taškai</code> buvo padarytas priskyrimas) (aš naudoju raktą <code>#Max</code>, nes rūšiuojant simolis <code>#</code> patenka prieš bet kokias abėcėlės raides). Toliau aprašoma funkcija <code>spausdink_meniu</code>. Kaip jau žinai, ji spausdina meniu.
Po to aprašoma funkcija <code>spausdink_visus_pažymius</code>:
<syntaxhighlight lang="python">
def spausdink_visus_pažymius():
print('\t',end=" ")
for i in range(len(užduotys)):
print(užduotys[i], '\t',end=" ")
print()
raktai = list(mokiniai.keys())
keys.sort()
for x in raktai:
print(x, '\t',end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
</syntaxhighlight>

Atkreipk dėmesį, į tai, kaip žodyno <code>mokiniai</code> raktai yra išimami į kintamąjį <code>raktai</code> su komanda <code>raktai = list(mokiniai.keys())</code>. Kintamasis <code>raktai</code> turės būti rūšiuojamas, todėl yra paverčiamas į sąrašą. Taip bus galima naudoti visas sąrašų funkcijas. Toliau raktai yra surūšiuojami eilutėje <code>raktai.sort()</code>. <code>for</code> yra naudojamas pereiti per visus raktus. Pažymiai yra saugomi kaip sąrašas žodyno viduje, todėl priskyrimas <code>pažymiai = mokiniai[x]</code> duoda <code>pažymiai</code> sąrašą, kuris yra saugomas su <code>x</code> raktu. Funkcija <code>spausdink_pažymius</code> tiesiog spausdina sąrašą ir yra aprašyta keliomis eilutėmis žemiau.

Tolimesnės programos eilutės įgyvendina įvairius meniu pasirinkimus. Eilutė <code>mokiniai[vardas] = [0] * len(max_taškai)</code> prideda mokinį į žodyną: <code>vardas</code> yra naujas raktas. Komanda <code>[0] * len(max_taškai)</code> tiesiog sukuria žodyno elementą – 0-ių sąrašą, kuris yra tokio pat ilgio kaip ir <code>max_taškai</code> sąrašas, kuriame vėliau bus sukelti pažymiai.

Pašalinti mokinį pasirinkimas tiesiog ištrina mokinį, panašiai kaip ir telefonų knygutės pavyzdyje.
Įrašyti mokinį pasirinkimas yra šiek tiek sudėtingesnis. Pažymiai yra gaunami komandinėje eilutėje
<code>pažymiai = mokiniai[vardas]</code>, ji gauna nuorodą į mokinio <code>vardas</code> pažymius. Tada pažymys yra įrašomas komanda <code>pažymiai[kuris] = pažymys</code>. Tu gali pastebėti, kad <code>pažymiai</code> niekada negrąžinami į mokinių žodyną (tokios komandos niekada nerašome: <code>mokiniai[vardas] = pažymiai</code>). Pakeisto pažymių sąrašo į žodyną grąžinti nereikia todėl,kad komanda <code>pažymiai[kuris] = pažymys</code> mes gauname ne realų sąrašą, o nuorodą į tą sąrašą, tada <code>pažymiai</code> iš tiesų yra tik kitas <code>mokiniai[vardas]</code> pavadinimas. Dėl to, keičiant <code>pažymiai</code> keičiasi ir <code>mokiniai[vardas]</code>.

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

{{navigation |previous=Loginiai reiškiniai |next=Modulių naudojimas}}
{{BookCat}}

Python Vadovėlis/Rekursija

2022-03-02T15:14:01Z

ZivileB:

== Rekursija ==

Programavime rekursine funkcija vadinama funkcija, kuri iškviečia pati save.

=== Įvadas į rekursiją ===

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

sk = 0

def main():
skaitliukas(sk)

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

main()
</syntaxhighlight>

Jei šią programą paleistum VS Code kodo redaktoriuje, ji veiktų amžinai. Vienintelis būdas sustabdyti ciklą būtų nutraukti vykdymą paspaudžiant Ctrl + C klaviatūroje. Tai yra begalinės rekursijos pavyzdys.

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

Rekursija gali būti valdoma, kaip ir ciklai. Pažvelk į rekursinio ciklo pavyzdį.
<syntaxhighlight lang="python">
# Mitchell Aikens programa
# Nėra autorinių teisių
# 2010
def main():
ciklosk= int(input("Kiek kartų norėtum paleisti ciklą?\n"))
skaitliukas = 1
recurr(ciklosk,skaitliukas)

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

main()
</syntaxhighlight>

Programoje naudojami argumentai/parametrai rekursijų skaičiui valdyti. Tiesiog naudok tai, ką jau žinai apie funkcijas, ir sek programos eigą. Tai paprasta išsiaiškinti. Jei kyla problemų, grįžk į [[Vadovėlis/Pažangių funkcijų pavyzdys|Pažangių funkcijų pavyzdys]].

== Praktiniai rekursijos pritaikymai ==

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

Pagalvokite apie šias dvi „taisykles“:
* Jei galiu išspręsti problemą su ciklu, be rekursijos, funkcija tiesiog grąžina reikšmę.
* Jei negaliu išspręsti problemos su cilku, be rekursijos, funkcija sumažina problemą iki mažesnės analogiškos problemos ir iškviečia pati save.

Pabandyk pritaikyti rekursinę funkciją faktorialui apskaičiuoti. Jei nesi susipažinęs su faktoriais, skaityk: [https://lt.wikipedia.org/wiki/Faktorialas Faktorialas]

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

Štai keletas pagrindinių faktorialo taisyklių:

Jei n = 0 tai n! = 1

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

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

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

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

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

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

main()
</syntaxhighlight>

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

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

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

Python Vadovėlis/Įvadas į objektinį programavimą Python 3

2021-12-27T17:43:58Z

ZivileB:

==Objektinis programavimas==

Iki šiol rašei kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios parašytos pagal objektinio programavimo taisykles. Žinoti abu programavimo tipus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų, tokių kaip C++ ar Java, dažnai naudoja objektinio programavimo taisykles.

Pradedantiesiems ir mokiniams, neturintiems programavimo žinių, objektinis programavimas dažnai gali atrodyti painus ir tai yra visiškai normalu. Nesijausk blogai, jei nesiseka suprasti iš pat pradžių. Jei šis skyrius nepadės tau suprasti, yra ir daugiau informatyvių šaltinių, kurie padės atsakyti į visus klausimus.

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka - skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti jas visas. Nepamiršk prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvok apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Paprastai, procedūros manipuliuoja duomenis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos procedūros į kitą. Ir kai programa pasidaro per didelė, tai padaro duomenų perdavimą komplikuotą.
Pavyzdžiui, parašei programą, kuri kintamuosiuose išsaugo produkto duomenis. Kai klientas paprašo informacijos apie produktą, kintamieji, kurie turi visą informaciją, yra perduodami įvairioms funkcijoms su skirtingomis paskirtimis. Laikui bėgant ir saugant vis daugiau duomenų apie turimus produktus, tu sugalvoji išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog tavo programa veiktų, tu dabar turi redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduok kiek laiko tau reikėtų norint peržiūrėti ir pakeisti šimtus failų. Tu išprotėtum! Nekalbant apie tai, jog klaidas daro net ir labiausiai patyrę programuotojai, tad taip pat reikėtų taisyti begalę klaidų. Toks programavimas yra pernelyg neoptimalus.
Procedūrinis programavimas yra paremtas procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėk į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

* šviesa_įjungta (True False)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (True arba False)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų neišeina tiesiogiai pakeisti. Pavyzdžiui, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja), tu negalėtum pakeisti elektros tėkmės tiesiogiai. Tu taip pat negali tiesiogiai įtakoti lemputės šviesos (ne, tu negali atsukti lemputės ar jos sudaužyti!). Bet tu visada gali šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsi mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei tu įjungsi jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, „Ką tai turi bendro su Python'u?“ ar, „Aš nesuprantu, bet kaip man sukurti tą objektą?“. Na, beveik priėjai prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Python'e objekto atributai ir metodai yra nurodomi klasės. Galvok apie klasę kaip apie objekto techninį piešinį. Pavyzdžiui, tavo namai - objektas kuriame gyveni - taip pat jį gali vadinti butu, vasarnamiu, prakartėle ar bet kuo kitu, buvo pastatytas naudojant techinius piešinius. Šie techniniai piešiniai būtų vadinami klasėmis, kurios buvo panaudotos projektuojant tavo namus, butą, vasarnamį, na, supranti apie ką kalbu.

Dar kartą, klasė pasako, kaip sukurti objektą. Techniniais terminais tariant, ir tai yra labai svarbu, klasė nusako naudojamus duomenų atributus ir metodus objekte.

Norint sukurti klasę, mes suprogramuojame klasės apibrėžimą. Klasės apibrėžimas, tai grupė teiginių, kurie nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiu.
<syntaxhighlight lang="python">

# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012

# Procedūra 1
def main():
try:
# Pasiimk skaičių, kurį manipuliuosi.
sk = float(input("Įrašyk skaičių.\n"))
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiumi atlik matematinius
# veiksmus naudojant procedūrą 2
pridėksk = pridėkpenkis(sk)
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atlik
# matematinius veiksmus naudojant procedūrą 3
dauginksk = daugink(pridėksk)
# Paduok skaičių procedūrai 4
rodyk(dauginksk)
# Susidorok su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalai įvesti tinkamą skaičių.\n")
# Atstatyk kintamojo num reikšmę, kad ištrintum netinkamą vartotojo įvestį.
sk = 0
# Dar kartą iškviesk main.
main()

# Procedūra 2
def pridėkpenkis(sk):
return sk + 5

# Procedūra 3
def daugink(pridėksk):
return pridėksk * 2.452

# Procedūra 4
def rodyk(dauginksk):
# Parodyk galutinį rezultatą.
print("Galutinis rezultatas yra", dauginksk)

# Kviesk procedūrą 1
main()
</syntaxhighlight>

Jei įrašysi skaitemnį "5", gausi išvestį parodytą žemiau.

Įrašyk skaičių.
5
Galutinis rezultatas yra 24.52

Jei įrašysi reikšmę "g", tada pasitaisysi ir įrašysi skaitmenį "8", tada gausi išvestį parodytą žemiau.

Įrašyk skaičių.
g
Privalai įvesti tinkamą skaičių.

Įrašyk skaičių.
8
Galutinis rezultatas yra 31.875999999999998

Žemiau matai klasę ir programą, kuri naudoja nurodytą klasę. Ši objektinio programavimo būdu parašyta programa daro tą patį, ką prieš tai darė procedūriniu programavimo būdu parašyta programa. Apžiūrėk keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, naudok <code>class</code> raktažodį. Po raktažodžio rašyk pavadinimą, kurį norėtum, jog turėtų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu purvinoskojinės, kodas atrodytų taip:
<syntaxhighlight lang="python">
class PurvinosKojinės
</syntaxhighlight>

Iš pradžių pažiūrėk į klasę. Programa, kuri naudos šią klasę, bus parodyta vėliau.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Klasė

class SkKeitimas:

def __init__(self):
self.__skaičius = 0

def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5

def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.452
</syntaxhighlight>

Programa, kuri naudoja viršuje esančią klasę yra parašyta žemiau.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Programa

import ooppavyzdys

matkė = ooppavyzdys.SkKeitimas()

def main():

sk = float(input("Įrašyk skaičių.\n"))

pridėtas = matkė.pridėkpenkis(sk)

daugintas = matkė.padaugink(pridėtas)

print("Galutinis rezultatas yra", daugintas)

main()
</syntaxhighlight>

Tikriausiai dabar esi pasimetęs. Tai visiškai suprantama. Iš pradžių, pasistenk suprasti klasę.
Klasė yra pavadinta "SkKeitimas"
Ši klasė turi tris metodus
* __init__
* pridėkpenkis
* padaugink

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

Atkreipk dėmesį į tai, jog kiekvienas metodas turi parametrą pavadinimu „self“. Kiekvienas klasės metodas turi būtinai turėti šį parametrą. Šis parametras nebūtinai turi būti su pavadinimu „self“, bet tai yra priimta kaip gerosios praktikos, tad tikriausiai ir tu turėtum jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes, kai jis yra iškviečiamas, jis turi žinoti, su kuriuo objekto atributu turėtų atlikti operacijas. Net kai turi tik vieną objektą, turi pasirūpinti, kad programa žinotų, jog nori naudoti atributus aprašytus būtent toje klasėje. Todėl turi būti saugus ir naudoti „self“ parametrą.

Peržiūrėk pirmą metodą.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Dauguma Python'o klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės objektas (kai sukuriame nuorodą į klasę, yra sukuriama tos klasės objektas). Šis metodas yra paprastai vadinamas inicijavimo metodu. Kai šis metodas yra paleidžiamas, „self“ parametras yra automatiškai priskiriamas tariamam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Po __init__ metodu, iš pradžių <code>skaičius</code> atributui mes priskiriame 0.
Yra sukuriama nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__skaičius = 0
</syntaxhighlight>
Kodas <code>self.__skaičius = 0</code> reiškia, jog objekte esančio „skaičius“ atributo reikšmė yra 0.

Pažiūrėk į kitą metodą.
<syntaxhighlight lang="python">
def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5
</syntaxhighlight>

Šis metodas yra pavadintas „pridėkpenkis“. Jis priima parametrą pavadinimu „sk“. Metode esanti logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina jį kviečiančiam.

Pažiūrėk į trečiajį metodą.
<syntaxhighlight lang="python">
def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas „padaugink“. Jis priima parametrą pavadinimu „pridėtas“. Metodas priskiria priimtą reikšmę objekte esančiam atributui su pavadinimu „pridėtas“ ir grąžina „pridėtas“ atributo ir 2.452 sandaugą jį kviečiančiam.

Ar atkreipei dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandyk tai suprasti.
Prieš tai buvo minėta, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus galėtum pakeisti TIK SU METODAIS ESANČIAIS PAČIAME OBJEKTE. Įmanoma turėti iššorinį kodą, kuris galėtų manipuliuoti tais pačiais atributais. Norint „paslėpti“ atributus, taip, kad juos matytų metodai aprašyti pačiame objekte, turi naudoti du pabraukimus prieš objekto pavadinimą, taip kaip ir buvo rodyta. Ištrynus abu pabraukimus nuo atributo pavadinimo tu juo galėsi manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėki į programą, kuri naudoja aptartą klasę.

Atkreipk dėmesį į pirmą eilutę, kuri nėra komentaras.
<syntaxhighlight lang="python">
import ooppavyzdys
</syntaxhighlight>

Ši kodo eilutė importuoją klasę, kurią išsaugojai atskirame faile (modulyje). Klasės nebūtinai turi būti talpinamos atskiruose failuose, bet tai yra priimta kaip gerosios praktikos, tad yra verta jau nuo pat pradžių priprasti prie modulių importavimo.

Kita eilutė:
<syntaxhighlight lang="python">
matkė = ooppavyzdys.SkKeitimas()
</syntaxhighlight>

Ši eilutė sukuria SkKeitimas pavadinimu „ooppavyzdys“ modulyje patalpintos klasės objektą, kuris yra priskiriamas „matkė“ kintamajam.
Sintaksė atrodo taip: <code>moduliopavadinimas.Klasėspavadinimas()</code> Toliau apibrėžiama ''main'' funkciją ir paimamas skaičius iš vartotojo.

Kita eilutė <code>pridėtas = matkė.pridėkpenkis(sk)</code> nusiunčia „sk“ kintamojo reikšmę metodui pavadinimu „pridėkpenkis“. Metodas yra aprašytas klasėje, kurios objektą išsaugojai kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „pridėtas“.

Kita eilutė <code>daugintas = matkė.daugink(pridėtas)</code> nusiunčia „pridėtas“ kintamojo reikšmę metodui pavadinimu „daugink“. Metodas yra aprašytas klasėje, kurios objektą išsaugojome kintamajame pavadinimu „matkė“. „daugink“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „daugintas“.

Kita eilutė atspausdina „Galutinis rezultatas yra <daugintas reikšmė>“. Paskutinė eilutė iškviečia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

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

Python Vadovėlis/Daugiau apie tekstines eilutes

2021-12-27T17:22:22Z

ZivileB:

Šiame skyriuje pamatysi, kiek šaunių dalykų galime padaryti su tekstine reikšme:

<syntaxhighlight lang="python">
def rėk(tekstinė_reikšmė):
for raidė in tekstinė_reikšmė:
print("Duok man " + raidė)
print("'" + raidė + "'")

rėk("Ačiū")

def vidurys(tekstas):
print("Raidė esanti viduryje yra:", tekstas[len(tekstas) // 2])

vidurys("abcdefg")
vidurys("The Python Programming Language")
vidurys("Atlanta")
</syntaxhighlight>

Rezultatas:

Duok man A
'A'
Duok man č
'č'
Duok man i
'i'
Duok man ū
'ū'
Raidė esanti viduryje yra: d
Raidė esanti viduryje yra: r
Raidė esanti viduryje yra: a

Šios dvi programos rodo, kad tekstinė reikšmė(strings) yra keliais aspektais panaši į sąrašus (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad tekstinėje reikšmėje galima naudotis Python'o programavimo kalboje jau esančia funkcija <code>len()</code>, taip pat masyvų indeksavimu ir pjaustymu. Dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

Kita šio skyriaus funkcija parodo tam tikras tekstinės reikšmės ypatybes:
<syntaxhighlight lang="python">
def pavertimas_didžiosiomis_raidėmis(tekstas):
## Ši funkcija, tekstinę reikšmę užrašo didžiosiomis raidėmis
didžiosios_raidės = ""
for raidė in tekstas:
if 'a' <= raidė <= 'z':
lokacija = ord(raidė) - ord('a')
naujas_ascii = lokacija + ord('A')
raidė= chr(naujas_ascii)
didžiosios_raidės = didžiosios_raidės + raidė
return didžiosios_raidės

print(pavertimas_didžiosiomis_raidėmis("Įrašytas tekstas"))
</syntaxhighlight>

Rezultatas:

ĮRAŠYTAS TEKSTAS

Tai veikia, nes kompiuteris tekstinės reikšmės simbolius šifruoja skaičiais nuo 0 iki 1 114 111. Visos šios tekstinės reikšmės turi savo unikalias unikodo reikšmes. Pavyzdžiui, simboliui „A“ yra priskirtas skaičius 65, simbolis „B“ kompiuterio suprantamas kaip 66, o simbolis א yra 1488. Python'o programavimo kalba turi funkciją, vadinamą <code>ord()</code> (trumpinys angliško žodžio ordinal, kuris reiškia iš eilės), kuri grąžina simbolį kaip skaičių. Taip pat Python'o programavimo kalba turi ir atvirkščią funkciją, vadinamą <code>chr()</code>, kuri skaičių paverčia simboliu. Supratus, kaip veikia šios funkcijos aukščiau užrašyta programa turėtų atrodyti logiška.

Programos pirmoji eilutė <code>if 'a' <= simbolis <= 'z':</code> patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės:
Pirmiausia eilutė <code>lokacija= ord(simbolis) - ord('a')</code> nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t.
Tada nauja reikšmė randama su kodo eilute <code>naujas_ascii = lokacija + ord ('A')</code>.
Tada ši reikšmė paverčiama atgal į simbolį, kuris dabar yra didžioji raidė.

Žinoma, tai tik programos pavyzdys, daug paprasčiau tai padaryti gali pasinaudodamas šiuo <code>metodu=var.upper()</code>, kuris veikia su visomis kalbomis.

O dabar pabandykime pasižiūrėti į šį pavyzdį:

>>> '''# Skaičius į tekstinę reikšmę'''
>>> '''2'''
2
>>> '''str(2)'''
'2'
>>> '''-123'''
-123
>>> '''str(-123)'''
'-123'
>>> '''# Tekstinė reikšmė į skaičių'''
>>> '''"23"'''
'23'
>>> '''int("23")'''
23
>>> '''"23" * 2'''
'2323'
>>> '''int("23") * 2'''
46
>>> '''# Skaičius po kablelio į tekstinę reikšmę'''
>>> '''1.23'''
1.23
>>> '''str(1.23)'''
'1.23'
>>> '''# Skaičius po kablelio į skaičių'''
>>> '''1.23'''
1.23
>>> '''int(1.23)'''
1
>>> '''int(-1.23)'''
-1
>>> '''# Tekstinė reikšmė į skaičių po kablelio'''
>>> '''float("1.23")'''
1.23
>>> '''"1.23"'''
'1.23'
>>> '''float("123")'''
123.0

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę, o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į skaičių po kablelio. Grįžtant prie funkcijos <code>str()</code> - ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

>>> '''str(1)'''
'1'
>>> '''str(234.14)'''
'234.14'
>>> '''str([4, 42, 10])'''
'[4, 42, 10]'

Funkcija <code>int()</code> konvertuoja tekstinę reikšmę (ar skaičių su reikšme po kablelio) į sveikąjį skaičių. Panaši funkcija <Code>float</code> konvertuoja skaičių ar tekstinę reikšmę į skaičių su reikšme po kablelio. Taip pat Python'o programavimo kalba turi funkciją <code>type()</code>, kuri grąžina eilutės tipą. Pavyzdžiui:

<syntaxhighlight lang="python">
v = '123'
print(type(v))
# <class 'str'>

v = 645.123
print(type(v))
# <class 'float'>

v = [1, 2, 3]
print(type(v))
# <class 'list'>
</syntaxhighlight>

Jeigu pamatai funkciją <code>type()</code> tai pasitikrink, ar grąžinamas toks reikšmės tipas, kurio tikėjaisi.

Taip pat naudingas ir dažnai paprastose užduotyse naudojamas metodas <code>split()</code>:

>>> '''"Čia yra tik ždožių kratinys".split()'''
['Čia', 'yra', 'tik', 'žodžių', 'kratinys']
>>> '''tekstas= "Pirma partija, antra partija, trečia, ketvirta"'''
>>> '''tekstas.split(",")'''
['Pirma partija', ' antra partija', ' trečia', ' ketvirta']

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Pagal numatytus nustatymus tekstinė reikšmė padalijama pagal nurodytus tarpus, šiuo atveju pagal nurodytą argumentą - kablelį.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

>>> '''sąrašas= tekstas.split(",")'''
>>> '''len(sąrašas)'''
4
>>> '''sąrašas[-1]'''
' ketvirta'
>>> '''sąrašas = tekstas.split(",", 2)'''
>>> '''len(sąrašas)'''
3
>>> '''sąrašas[-1]'''
' trečia, ketvirta'


=== Tekstinės (ir sąrašo) reikšmės pjaustymas (Slicing strings(and lists) ===

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje, kai laužtiniuose skliaustuose <code>[]</code> buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: <code>tekstas[pradžios_indeksas:pabaigos_indeksas]</code> (retais atvejais galime pridėti dar ir trečią argumentą, kaip apačioje esančiame pavyzdyje)

Kad nesusipainiotum įrašydamas indekso skaičius, įsivaizduok, kad žirklėmis karpai tekstą, o programai nurodai, kurioje vietoje kirpti. Štai vienas pavyzdys, kaip tai viekia - geltonai pažymėtos kirpimo vietos, o raudonai ir mėlynai indekso numeris

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | -2
| style="width:2ex" |
| style="width:2ex;color:blue" | -1
| style="width:2ex" |
| style="width:2ex" |
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
|-
| tekstas =
|"
| style="background:#FFFF88" |
!S
| style="background:#FFFF88" |
!T
| style="background:#FFFF88" |
!R
| style="background:#FFFF88" |
!I
| style="background:#FFFF88" |
!N
| style="background:#FFFF88" |
!G
| style="background:#FFFF88" |
|"
|-
|
|
| style="background:#FFFF88" |↑
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |↑
|
|-
|
|
|[:
|
|
|
|
|
|
|
|
|
|
|
|:]
|
|}
</tt>

Įsidėmėk, kad raudonai pažymėti indeksai skaičiuojami nuo pradžios, o mėlyni atvirkščiai nuo kito galo t.y. teksto pabaigos. Taip pat ar pastebėjai, kad skaičiuojant nuo galo nėra -0 reikšmės? Taip yra todėl, kad 0 visada priskiriamas tik reikšmės pradžiai:

<tt>
{|
|-
|tekstas[1:4] || style="width:3em;text-align:center" | → || "TRI"
|-
|tekstas[:5] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[:-1] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[-4:] || style="width:3em;text-align:center" | → || "RING"
|-
|tekstas[2] || style="width:3em;text-align:center" | → || "R"
|-
|tekstas[:] || style="width:3em;text-align:center" | → || "STRING"
|-
|tekstas[::-1] || style="width:3em;text-align:center" | → || "GNIRTS"
|}
</tt>

<tt>tekstas[1:4]</tt> duoda visas <tt>tekstas</tt> reikšmes tarp 1 ir 4, "<tt>TRI</tt>". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: <tt>tekstas[:5]</tt> atspausdina"<tt>STRIN</tt>". Taip pat, tiek su <tt>pradžios_indeksas</tt>, tiek su <tt>pabaigos_indeksas</tt> galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: <tt>tekstas[:-1]</tt> duoda tą patį rezultatą kaip <tt>tekstas[:5]</tt>, todėl, kad indekas -1 šiame žodyje yra toje pačioje vietoje kaip indeksas 5. Jeigu nenaudojame argumento kartu su dvitaškiu, tai skaičius traktuojamas kitaip, pavyzdžiui: <tt>tekstas[2]</tt> duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "<tt>R</tt>". Speciali pjaustymo operacija <tt>tekstas[:]</tt> reiškia nuo pradžios iki pabaigos ir duodą visos tekstinės reikšmės ar sąrašo (list) kopiją.

Na ir galiausiai, pjaustymo operacija gali turėti ir trečią argumentą, kuris suprantamas, kaip „žingsnio dydis“: <tt>tekstas[::-1]</tt> yra <tt>tekstas</tt> nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "<tt>STRING</tt>" atvirkščiai yra "<tt>GNIRTS</tt>" (jeigu nesupratai, tai pabandyk prasitestuoti įrašydamas kaip žingsnio ilgį skaičių 2).

Visos šios pjaustymo operacijos veikia ir su sąrašais (lists). Šiuo atveju tekstinę reikšmę galime suprasti, kaip sąrašą, kai visi sąrašo elementai yra atskiros raidės. Iš šio skyriaus atsimink pagrindinį principą - į viską žiūrėk taip lyg karpytum, tai padės nesusipainioti įrašant indeksus.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa reikalauja dešimtainių skaičių supratimo.
def į_tekstą(į_skaičių):
"""Konvertuoja skaičių į tekstą"""
tekstas = ""
prefiksas = ""
if į_skaičių < 0:
prefiksas = "-"
į_skaičių = -į_skaičių
while į_skaičių // 10 != 0:
tekstas = str(į_skaičių % 10) + tekstas
į_skaičių= į_skaičių// 10
tekstas = str(į_skaičių % 10) + tekstas
return prefiksas + tekstas

def į_skaičių(į_tekstą):
"""Konvertuoja tekstą į skaičių"""
skaičius = 0
if į_tekstą[0] == "-":
daugiklis = -1
į_tekstą = į_tekstą[1:]
else:
daugiklis = 1
for c in į_tekstą:
skaičius = skaičius* 10 + int(c)
return skaičius * daugiklis

print(į_tekstą(2))
print(į_tekstą(23445))
print(į_tekstą(-23445))
print(į_skaičių("14234"))
print(į_skaičių("12345"))
print(į_skaičių("-3512"))
</syntaxhighlight>

Rezultatas:

2
23445
-23445
14234
12345
-3512

{{navigation |previous=Daugiau apie sąrašus |next=Failų IO}}
{{BookCat}}

Python Vadovėlis/Daugiau apie tekstines eilutes

2021-12-27T16:44:02Z

ZivileB:

Šiame skyriuje pamatysi, kiek šaunių dalykų galime padaryti su tekstine reikšme:

<syntaxhighlight lang="python">
def rėk(tekstinė_reikšmė):
for raidė in tekstinė_reikšmė:
print("Duok man " + raidė)
print("'" + raidė + "'")

rėk("Ačiū")

def vidurys(tekstas):
print("Raidė esanti viduryje yra:", tekstas[len(tekstas) // 2])

vidurys("abcdefg")
vidurys("The Python Programming Language")
vidurys("Atlanta")
</syntaxhighlight>

Rezultatas:

Duok man A
'A'
Duok man č
'č'
Duok man i
'i'
Duok man ū
'ū'
Raidė esanti viduryje yra: d
Raidė esanti viduryje yra: r
Raidė esanti viduryje yra: a

Šios dvi programos rodo, kad tekstinė reikšmė(strings) yra keliais aspektais panaši į sąrašus (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad tekstinėje reikšmėje galima naudotis Python'o programavimo kalboje jau esančia funkcija <code>len()</code>, taip pat masyvų indeksavimu ir pjaustymu. Dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

Kita šio skyriaus funkcija parodo tam tikras tekstinės reikšmės ypatybes:
<syntaxhighlight lang="python">
def pavertimas_didžiosiomis_raidėmis(tekstas):
## Ši funkcija, tekstinę reikšmę užrašo didžiosiomis raidėmis
didžiosios_raidės = ""
for raidė in tekstas:
if 'a' <= raidė <= 'z':
lokacija = ord(raidė) - ord('a')
naujas_ascii = lokacija + ord('A')
raidė= chr(naujas_ascii)
didžiosios_raidės = didžiosios_raidės + raidė
return didžiosios_raidės

print(pavertimas_didžiosiomis_raidėmis("Įrašytas tekstas"))
</syntaxhighlight>

Rezultatas:

ĮRAŠYTAS TEKSTAS

Tai veikia, nes kompiuteris tekstinės reikšmės simbolius šifruoja skaičiais nuo 0 iki 1 114 111. Visos šios tekstinės reikšmės turi savo unikalias unikodo reikšmes. Pavyzdžiui, simboliui „A“ yra priskirtas skaičius 65, simbolis „B“ kompiuterio suprantamas kaip 66, o simbolis א yra 1488. Python'o programavimo kalba turi funkciją, vadinamą <code>ord()</code> (trumpinys angliško žodžio ordinal, kuris reiškia iš eilės), kuri grąžina simbolį kaip skaičių. Taip pat Python'o programavimo kalba turi ir atvirkščią funkciją, vadinamą <code>chr()</code>, kuri skaičių paverčia simboliu. Supratus, kaip veikia šios funkcijos aukščiau užrašyta programa turėtų atrodyti logiška.

Programos pirmoji eilutė <code>if 'a' <= simbolis <= 'z':</code> patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės:
Pirmiausia eilutė <code>lokacija= ord(simbolis) - ord('a')</code> nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t.
Tada nauja reikšmė randama su kodo eilute <code>naujas_ascii = lokacija + ord ('A')</code>.
Tada ši reikšmė paverčiama atgal į simbolį, kuris dabar yra didžioji raidė.

Žinoma, tai tik programos pavyzdys, daug paprasčiau tai padaryti gali pasinaudodamas šiuo <code>metodu=var.upper()</code>, kuris veikia su visomis kalbomis.

O dabar pabandykime pasižiūrėti į šį pavyzdį:

>>> '''# Skaičius į tekstinę reikšmę'''
>>> '''2'''
2
>>> '''str(2)'''
'2'
>>> '''-123'''
-123
>>> '''str(-123)'''
'-123'
>>> '''# Tekstinė reikšmė į skaičių'''
>>> '''"23"'''
'23'
>>> '''int("23")'''
23
>>> '''"23" * 2'''
'2323'
>>> '''int("23") * 2'''
46
>>> '''# Skaičius po kablelio į tekstinę reikšmę'''
>>> '''1.23'''
1.23
>>> '''str(1.23)'''
'1.23'
>>> '''# Skaičius po kablelio į skaičių'''
>>> '''1.23'''
1.23
>>> '''int(1.23)'''
1
>>> '''int(-1.23)'''
-1
>>> '''# Tekstinė reikšmė į skaičių po kablelio'''
>>> '''float("1.23")'''
1.23
>>> '''"1.23"'''
'1.23'
>>> '''float("123")'''
123.0

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę, o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į skaičių po kablelio. Grįžtant prie funkcijos <code>str()</code> - ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

>>> '''str(1)'''
'1'
>>> '''str(234.14)'''
'234.14'
>>> '''str([4, 42, 10])'''
'[4, 42, 10]'

Funkcija <code>int()</code> konvertuoja tekstinę reikšmę (ar skaičių su reikšme po kablelio) į sveikąjį skaičių. Panaši funkcija <Code>float</code> konvertuoja skaičių ar tekstinę reikšmę į skaičių su reikšme po kablelio. Taip pat Python'o programavimo kalba turi funkciją <code>type()</code>, kuri grąžina eilutės tipą. Pavyzdžiui:

<syntaxhighlight lang="python">
v = '123'
print(type(v))
# <class 'str'>

v = 645.123
print(type(v))
# <class 'float'>

v = [1, 2, 3]
print(type(v))
# <class 'list'>
</syntaxhighlight>

Jeigu pamatai funkciją <code>type()</code> tai pasitikrink, ar grąžinamas toks reikšmės tipas, kurio tikėjaisi.

Taip pat naudingas ir dažnai paprastose užduotyse naudojamas metodas <code>split()</code>:

>>> '''"Čia yra tik ždožių kratinys".split()'''
['Čia', 'yra', 'tik', 'žodžių', 'kratinys']
>>> '''tekstas= "Pirma partija, antra partija, trečia, ketvirta"'''
>>> '''tekstas.split(",")'''
['Pirma partija', ' antra partija', ' trečia', ' ketvirta']

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Pagal numatytus nustatymus tekstinė reikšmė padalijama pagal nurodytus tarpus, šiuo atveju pagal nurodytą argumentą - kablelį.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

>>> '''sąrašas= tekstas.split(",")'''
>>> '''len(sąrašas)'''
4
>>> '''sąrašas[-1]'''
' ketvirta'
>>> '''list = tekstas.split(",", 2)'''
>>> '''len(list)'''
3
>>> '''sąrašas[-1]'''
' trečia, ketvirta'


=== Tekstinės (ir sąrašo) reikšmės pjaustymas (Slicing strings(and lists) ===

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje, kai laužtiniuose skliaustuose <code>[]</code> buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: <code>tekstas[pradžios_indeksas:pabaigos_indeksas]</code> (retais atvejais galime pridėti dar ir trečią argumentą, kaip apačioje esančiame pavyzdyje)

Kad nesusipainiotum įrašydamas indekso skaičius, įsivaizduok, kad žirklėmis karpai tekstą, o programai nurodai, kurioje vietoje kirpti. Štai vienas pavyzdys, kaip tai viekia - geltonai pažymėtos kirpimo vietos, o raudonai ir mėlynai indekso numeris

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | -2
| style="width:2ex" |
| style="width:2ex;color:blue" | -1
| style="width:2ex" |
| style="width:2ex" |
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
|-
| tekstas =
|"
| style="background:#FFFF88" |
!S
| style="background:#FFFF88" |
!T
| style="background:#FFFF88" |
!R
| style="background:#FFFF88" |
!I
| style="background:#FFFF88" |
!N
| style="background:#FFFF88" |
!G
| style="background:#FFFF88" |
|"
|-
|
|
| style="background:#FFFF88" |↑
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |↑
|
|-
|
|
|[:
|
|
|
|
|
|
|
|
|
|
|
|:]
|
|}
</tt>

Įsidėmėk, kad raudonai pažymėti indeksai skaičiuojami nuo pradžios, o mėlyni atvirkščiai nuo kito galo t.y. teksto pabaigos. Taip pat ar pastebėjai, kad skaičiuojant nuo galo nėra -0 reikšmės? Taip yra todėl, kad 0 visada priskiriamas tik reikšmės pradžiai:

<tt>
{|
|-
|tekstas[1:4] || style="width:3em;text-align:center" | → || "TRI"
|-
|tekstas[:5] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[:-1] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[-4:] || style="width:3em;text-align:center" | → || "RING"
|-
|tekstas[2] || style="width:3em;text-align:center" | → || "R"
|-
|tekstas[:] || style="width:3em;text-align:center" | → || "STRING"
|-
|tekstas[::-1] || style="width:3em;text-align:center" | → || "GNIRTS"
|}
</tt>

<tt>tekstas[1:4]</tt> duoda visas <tt>tekstas</tt> reikšmes tarp 1 ir 4, "<tt>TRI</tt>". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: <tt>tekstas[:5]</tt> atspausdina"<tt>STRIN</tt>". Taip pat, tiek su <tt>pradžios_indeksas</tt>, tiek su <tt>pabaigos_indeksas</tt> galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: <tt>tekstas[:-1]</tt> duoda tą patį rezultatą kaip <tt>tekstas[:5]</tt>, todėl, kad indekas -1 šiame žodyje yra toje pačioje vietoje kaip indeksas 5. Jeigu nenaudojame argumento kartu su dvitaškiu, tai skaičius traktuojamas kitaip, pavyzdžiui: <tt>tekstas[2]</tt> duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "<tt>R</tt>". Speciali pjaustymo operacija <tt>tekstas[:]</tt> reiškia nuo pradžios iki pabaigos ir duodą visos tekstinės reikšmės ar sąrašo (list) kopiją.

Na ir galiausiai, pjaustymo operacija gali turėti ir trečią argumentą, kuris suprantamas, kaip „žingsnio dydis“: <tt>tekstas[::-1]</tt> yra <tt>tekstas</tt> nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "<tt>STRING</tt>" atvirkščiai yra "<tt>GNIRTS</tt>" (jeigu nesupratai, tai pabandyk prasitestuoti įrašydamas kaip žingsnio ilgį skaičių 2).

Visos šios pjaustymo operacijos veikia ir su sąrašais (lists). Šiuo atveju tekstinę reikšmę galime suprasti, kaip sąrašą, kai visi sąrašo elementai yra atskiros raidės. Iš šio skyriaus atsimink pagrindinį principą - į viską žiūrėk taip lyg karpytum, tai padės nesusipainioti įrašant indeksus.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa reikalauja dešimtainių skaičių supratimo.
def į_tekstą(į_skaičių):
"""Konvertuoja skaičių į tekstą"""
tekstas = ""
prefiksas = ""
if į_skaičių < 0:
prefiksas = "-"
į_skaičių = -į_skaičių
while į_skaičių // 10 != 0:
tekstas = str(į_skaičių % 10) + tekstas
į_skaičių= į_skaičių// 10
tekstas = str(į_skaičių % 10) + tekstas
return prefiksas + tekstas

def į_skaičių(į_tekstą):
"""Konvertuoja tekstą į skaičių"""
skaičius = 0
if į_tekstą[0] == "-":
daugiklis = -1
į_tekstą = į_tekstą[1:]
else:
daugiklis = 1
for c in į_tekstą:
skaičius = skaičius* 10 + int(c)
return skaičius * daugiklis

print(į_tekstą(2))
print(į_tekstą(23445))
print(į_tekstą(-23445))
print(į_skaičių("14234"))
print(į_skaičių("12345"))
print(į_skaičių("-3512"))
</syntaxhighlight>

Rezultatas:

2
23445
-23445
14234
12345
-3512

{{navigation |previous=Daugiau apie sąrašus |next=Failų IO}}
{{BookCat}}

Python Vadovėlis/Daugiau apie tekstines eilutes

2021-12-27T16:34:11Z

ZivileB:

Šiame skyriuje pamatysi, kiek šaunių dalykų galime padaryti su tekstine reikšme:

<syntaxhighlight lang="python">
def rėk(tekstinė_reikšmė):
for raidė in tekstinė_reikšmė:
print("Duok man " + raidė)
print("'" + raidė + "'")

rėk("Ačiū")

def vidurys(tekstas):
print("Raidė esanti viduryje yra:", tekstas[len(tekstas) // 2])

vidurys("abcdefg")
vidurys("The Python Programming Language")
vidurys("Atlanta")
</syntaxhighlight>

Rezultatas:

Duok man A
'A'
Duok man č
'č'
Duok man i
'i'
Duok man ū
'ū'
Raidė esanti viduryje yra: d
Raidė esanti viduryje yra: r
Raidė esanti viduryje yra: a

Šios dvi programos rodo, kad tekstinė reikšmė(strings) yra keliais aspektais panaši į sąrašus (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad tekstinėje reikšmėje galima naudotis Python'o programavimo kalboje jau esančia funkcija <code>len()</code>, taip pat masyvų indeksavimu ir pjaustymu. Dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

Kita šio skyriaus funkcija parodo tam tikras tekstinės reikšmės ypatybes:
<syntaxhighlight lang="python">
def pavertimas_didžiosiomis_raidėmis(tekstas):
## Ši funkcija, tekstinę reikšmę užrašo didžiosiomis raidėmis
didžiosios_raidės = ""
for raidė in tekstas:
if 'a' <= raidė <= 'z':
lokacija = ord(raidė) - ord('a')
naujas_ascii = lokacija + ord('A')
raidė= chr(naujas_ascii)
didžiosios_raidės = didžiosios_raidės + raidė
return didžiosios_raidės

print(pavertimas_didžiosiomis_raidėmis("Įrašytas tekstas"))
</syntaxhighlight>

Rezultatas:

ĮRAŠYTAS TEKSTAS

Tai veikia, nes kompiuteris tekstinės reikšmės simbolius šifruoja skaičiais nuo 0 iki 1 114 111. Visos šios tekstinės reikšmės turi savo unikalias unikodo reikšmes. Pavyzdžiui, simboliui „A“ yra priskirtas skaičius 65, simbolis „B“ kompiuterio suprantamas kaip 66, o simbolis א yra 1488. Python'o programavimo kalba turi funkciją, vadinamą <code>ord()</code> (trumpinys angliško žodžio ordinal, kuris reiškia iš eilės), kuri grąžina simbolį kaip skaičių. Taip pat Python'o programavimo kalba turi ir atvirkščią funkciją, vadinamą <code>chr()</code>, kuri skaičių paverčia simboliu. Supratus, kaip veikia šios funkcijos aukščiau užrašyta programa turėtų atrodyti logiška.

Programos pirmoji eilutė <code>if 'a' <= simbolis <= 'z':</code> patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės:
Pirmiausia eilutė <code>lokacija= ord(simbolis) - ord('a')</code> nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t.
Tada nauja reikšmė randama su kodo eilute <code>naujas_ascii = lokacija + ord ('A')</code>.
Tada ši reikšmė paverčiama atgal į simbolį, kuris dabar yra didžioji raidė.

Žinoma, tai tik programos pavyzdys, daug paprasčiau tai padaryti gali pasinaudodamas šiuo <code>metodu=var.upper()</code>, kuris veikia su visomis kalbomis.

O dabar pabandykime pasižiūrėti į šį pavyzdį:

>>> '''# Skaičius į tekstinę reikšmę'''
>>> '''2'''
2
>>> '''str(2)'''
'2'
>>> '''-123'''
-123
>>> '''str(-123)'''
'-123'
>>> '''# Tekstinė reikšmė į skaičių'''
>>> '''"23"'''
'23'
>>> '''int("23")'''
23
>>> '''"23" * 2'''
'2323'
>>> '''int("23") * 2'''
46
>>> '''# Skaičius po kablelio į tekstinę reikšmę'''
>>> '''1.23'''
1.23
>>> '''str(1.23)'''
'1.23'
>>> '''# Skaičius po kablelio į skaičių'''
>>> '''1.23'''
1.23
>>> '''int(1.23)'''
1
>>> '''int(-1.23)'''
-1
>>> '''# Tekstinė reikšmė į skaičių po kablelio'''
>>> '''float("1.23")'''
1.23
>>> '''"1.23"'''
'1.23'
>>> '''float("123")'''
123.0

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę, o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į skaičių po kablelio. Grįžtant prie funkcijos <code>str()</code> - ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

>>> '''str(1)'''
'1'
>>> '''str(234.14)'''
'234.14'
>>> '''str([4, 42, 10])'''
'[4, 42, 10]'

Funkcija <code>int()</code> konvertuoja tekstinę reikšmę (ar skaičių su reikšme po kablelio) į sveikąjį skaičių. Panaši funkcija <Code>float</code> konvertuoja skaičių ar tekstinę reikšmę į skaičių su reikšme po kablelio. Taip pat Python'o programavimo kalba turi funkciją <code>type()</code>, kuri grąžina eilutės tipą. Pavyzdžiui:

<syntaxhighlight lang="python">
v = '123'
print(type(v))
# <class 'str'>

v = 645.123
print(type(v))
# <class 'float'>

v = [1, 2, 3]
print(type(v))
# <class 'list'>
</syntaxhighlight>

Jeigu pamatai funkciją <code>type()</code> tai pasitikrink, ar grąžinamas toks reikšmės tipas, kurio tikėjaisi.

Taip pat naudingas ir dažnai paprastose užduotyse naudojamas metodas <code>split()</code>:

>>> '''"Čia yra tik ždožių kratinys".split()'''
['Čia', 'yra', 'tik', 'žodžių', 'kratinys']
>>> '''tekstas= "Pirma partija, antra partija, trečia, ketvirta"'''
>>> '''tekstas.split(",")'''
['Pirma partija', ' antra partija', ' trečia', ' ketvirta']

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Pagal numatytus nustatymus tekstinė reikšmė padalijama pagal nurodytus tarpus, šiuo atveju pagal nurodytą argumentą - kablelį.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

>>> '''sąrašas= tekstas.split(",")'''
>>> '''len(sąrašas)'''
4
>>> '''sąrašas[-1]'''
' ketvirta'
>>> '''list = tekstas.split(",", 2)'''
>>> '''len(list)'''
3
>>> '''sąrašas[-1]'''
' trečia, ketvirta'


=== Tekstinės (ir sąrašo) reikšmės pjaustymas (Slicing strings(and lists) ===

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje, kai laužtiniuose skliaustuose <code>[]</code> buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: <code>tekstas[pradžios_indeksas:pabaigos_indeksas]</code> (retais atvejais galime pridėti dar ir trečią argumentą, kaip apačioje esančiame pavyzdyje)

Kad nesusipainiotum įrašydamas indekso skaičius, įsivaizduok, kad žirklėmis karpai tekstą, o programai nurodai, kurioje vietoje kirpti. Štai vienas pavyzdys, kaip tai viekia - geltonai pažymėtos kirpimo vietos, o raudonai ir mėlynai indekso numeris

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | -2
| style="width:2ex" |
| style="width:2ex;color:blue" | -1
| style="width:2ex" |
| style="width:2ex" |
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
|-
| tekstas =
|"
| style="background:#FFFF88" |
!S
| style="background:#FFFF88" |
!T
| style="background:#FFFF88" |
!R
| style="background:#FFFF88" |
!I
| style="background:#FFFF88" |
!N
| style="background:#FFFF88" |
!G
| style="background:#FFFF88" |
|"
|-
|
|
| style="background:#FFFF88" |↑
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |↑
|
|-
|
|
|[:
|
|
|
|
|
|
|
|
|
|
|
|:]
|
|}
</tt>

Įsidėmėk, kad raudonai pažymėti indeksai skaičiuojami nuo pradžios, o mėlyni atvirkščiai nuo kito galo t.y. teksto pabaigos. Taip pat ar pastebėjai, kad skaičiuojant nuo galo nėra -0 reikšmės? Taip yra todėl, kad 0 visada priskiriamas tik reikšmės pradžiai:

<tt>
{|
|-
|tekstas[1:4] || style="width:3em;text-align:center" | → || "TRI"
|-
|tekstas[:5] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[:-1] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[-4:] || style="width:3em;text-align:center" | → || "RING"
|-
|tekstas[2] || style="width:3em;text-align:center" | → || "R"
|-
|tekstas[:] || style="width:3em;text-align:center" | → || "STRING"
|-
|tekstas[::-1] || style="width:3em;text-align:center" | → || "GNIRTS"
|}
</tt>

<tt>tekstas[1:4]</tt> duoda visas <tt>tekstas</tt> reikšmes tarp 1 ir 4, "<tt>TRI</tt>". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: <tt>tekstas[:5]</tt> atspausdina"<tt>STRIN</tt>". Taip pat, tiek su <tt>pradžios_indeksas</tt>, tiek su <tt>pabaigos_indeksas</tt> galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: <tt>tekstas[:-1]</tt> duoda tą patį rezultatą kaip <tt>tekstas[:5]</tt>, todėl, kad indekas -1 šiame žodyje yra toje pačioje vietoje kaip indeksas 5. Jeigu nenaudojame argumento kartu su dvitaškiu, tai skaičius traktuojamas kitaip, pavyzdžiui: <tt>tekstas[2]</tt> duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "<tt>R</tt>". Speciali pjaustymo operacija <tt>tekstas[:]</tt> reiškia nuo pradžios iki pabaigos ir duodą visos tekstinės reikšmės ar sąrašo (list) kopiją.

Na ir galiausiai, pjaustymo operacija gali turėti ir trečią argumentą, kuris suprantamas, kaip „žingsnio dydis“: <tt>tekstas[::-1]</tt> yra <tt>tekstas</tt> nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "<tt>STRING</tt>" atvirkščiai yra "<tt>GNIRTS</tt>" (jeigu nesupratai, tai pabandyk prasitestuoti įrašydamas kaip žingsnio ilgį skaičių 2).

Visos šios pjaustymo operacijos veikia ir su sąrašais (lists). Šiuo atveju tekstinę reikšmę galime suprasti, kaip sąrašą, kai visi sąrašo elementai yra atskiros raidės. Iš šio skyriaus atsimink pagrindinį principą - į viską žiūrėk taip lyg karpytum, tai padės nesusipainioti įrašant indeksus.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa reikalauja dešimtainių skaičių supratimo.
def į_tekstą(į_skaičių):
"""Konvertuoja skaičių į tekstą"""
tekstas = ""
prefiksas = ""
if į_skaičių < 0:
prefiksas = "-"
į_skaičių = -į_skaičių
while į_skaičių // 10 != 0:
out_str = str(į_skaičių % 10) + tekstas
į_skaičių= į_skaičių// 10
tekstas = str(į_skaičių % 10) + tekstas
return prefiksas + tekstas

def į_skaičių(į_tekstą):
"""Konvertuoja tekstą į skaičių"""
skaičius = 0
if į_tekstą[0] == "-":
daugiklis = -1
į_tekstą = į_tekstą[1:]
else:
daugiklis = 1
for c in į_tekstą:
skaičius = skaičius* 10 + int(c)
return skaičius * daugiklis

print(į_tekstą(2))
print(į_tekstą(23445))
print(į_tekstą(-23445))
print(į_skaičių("14234"))
print(į_skaičių("12345"))
print(į_skaičių("-3512"))
</syntaxhighlight>

Rezultatas:

2
23445
-23445
14234
12345
-3512

{{navigation |previous=Daugiau apie sąrašus |next=Failų IO}}
{{BookCat}}

Python Vadovėlis/Daugiau apie tekstines eilutes

2021-12-27T16:28:38Z

ZivileB:

Šiame skyriuje pamatysi, kiek šaunių dalykų galime padaryti su tekstine reikšme:

<syntaxhighlight lang="python">
def rėk(tekstinė_reikšmė):
for raidė in tekstinė_reikšmė:
print("Duok man " + raidė)
print("'" + raidė + "'")

rėk("Ačiū")

def vidurys(tekstas):
print("Raidė esanti viduryje yra:", tekstas[len(tekstas) // 2])

vidurys("abcdefg")
vidurys("The Python Programming Language")
vidurys("Atlanta")
</syntaxhighlight>

Rezultatas:

Duok man A
'A'
Duok man č
'č'
Duok man i
'i'
Duok man ū
'ū'
Raidė esanti viduryje yra: d
Raidė esanti viduryje yra: r
Raidė esanti viduryje yra: a

Šios dvi programos rodo, kad tekstinė reikšmė(strings) yra keliais aspektais panaši į sąrašus (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad tekstinėje reikšmėje galima naudotis Python'o programavimo kalboje jau esančia funkcija <code>len()</code>, taip pat masyvų indeksavimu ir pjaustymu. Dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

Kita šio skyriaus funkcija parodo tam tikras tekstinės reikšmės ypatybes:
<syntaxhighlight lang="python">
def pavertimas_didžiosiomis_raidėmis(tekstas):
## Ši funkcija, tekstinę reikšmę užrašo didžiosiomis raidėmis
didžiosios_raidės = ""
for raidei in tekstas:
if 'a' <= tekstas <= 'z':
lokacija = ord(raidei) - ord('a')
naujas_ascii = lokacija + ord('A')
raidei= chr(naujas_ascii)
didžiosios_raidės = didžiosios_raidės + raidei
return didžiosios_raidės

print(pavertimas_didžiosiomis_raidėmis("Įrašytas tekstas"))
</syntaxhighlight>

Rezultatas:

ĮRAŠYTAS TEKSTAS

Tai veikia, nes kompiuteris tekstinės reikšmės simbolius šifruoja skaičiais nuo 0 iki 1 114 111. Visos šios tekstinės reikšmės turi savo unikalias unikodo reikšmes. Pavyzdžiui, simboliui „A“ yra priskirtas skaičius 65, simbolis „B“ kompiuterio suprantamas kaip 66, o simbolis א yra 1488. Python'o programavimo kalba turi funkciją, vadinamą <code>ord()</code> (trumpinys angliško žodžio ordinal, kuris reiškia iš eilės), kuri grąžina simbolį kaip skaičių. Taip pat Python'o programavimo kalba turi ir atvirkščią funkciją, vadinamą <code>chr()</code>, kuri skaičių paverčia simboliu. Supratus, kaip veikia šios funkcijos aukščiau užrašyta programa turėtų atrodyti logiška.

Programos pirmoji eilutė <code>if 'a' <= simbolis <= 'z':</code> patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės:
Pirmiausia eilutė <code>lokacija= ord(simbolis) - ord('a')</code> nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t.
Tada nauja reikšmė randama su kodo eilute <code>naujas_ascii = lokacija + ord ('A')</code>.
Tada ši reikšmė paverčiama atgal į simbolį, kuris dabar yra didžioji raidė.

Žinoma, tai tik programos pavyzdys, daug paprasčiau tai padaryti gali pasinaudodamas šiuo <code>metodu=var.upper()</code>, kuris veikia su visomis kalbomis.

O dabar pabandykime pasižiūrėti į šį pavyzdį:

>>> '''# Skaičius į tekstinę reikšmę'''
>>> '''2'''
2
>>> '''str(2)'''
'2'
>>> '''-123'''
-123
>>> '''str(-123)'''
'-123'
>>> '''# Tekstinė reikšmė į skaičių'''
>>> '''"23"'''
'23'
>>> '''int("23")'''
23
>>> '''"23" * 2'''
'2323'
>>> '''int("23") * 2'''
46
>>> '''# Skaičius po kablelio į tekstinę reikšmę'''
>>> '''1.23'''
1.23
>>> '''str(1.23)'''
'1.23'
>>> '''# Skaičius po kablelio į skaičių'''
>>> '''1.23'''
1.23
>>> '''int(1.23)'''
1
>>> '''int(-1.23)'''
-1
>>> '''# Tekstinė reikšmė į skaičių po kablelio'''
>>> '''float("1.23")'''
1.23
>>> '''"1.23"'''
'1.23'
>>> '''float("123")'''
123.0

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę, o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į skaičių po kablelio. Grįžtant prie funkcijos <code>str()</code> - ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

>>> '''str(1)'''
'1'
>>> '''str(234.14)'''
'234.14'
>>> '''str([4, 42, 10])'''
'[4, 42, 10]'

Funkcija <code>int()</code> konvertuoja tekstinę reikšmę (ar skaičių su reikšme po kablelio) į sveikąjį skaičių. Panaši funkcija <Code>float</code> konvertuoja skaičių ar tekstinę reikšmę į skaičių su reikšme po kablelio. Taip pat Python'o programavimo kalba turi funkciją <code>type()</code>, kuri grąžina eilutės tipą. Pavyzdžiui:

<syntaxhighlight lang="python">
v = '123'
print(type(v))
# <class 'str'>

v = 645.123
print(type(v))
# <class 'float'>

v = [1, 2, 3]
print(type(v))
# <class 'list'>
</syntaxhighlight>

Jeigu pamatai funkciją <code>type()</code> tai pasitikrink, ar grąžinamas toks reikšmės tipas, kurio tikėjaisi.

Taip pat naudingas ir dažnai paprastose užduotyse naudojamas metodas <code>split()</code>:

>>> '''"Čia yra tik ždožių kratinys".split()'''
['Čia', 'yra', 'tik', 'žodžių', 'kratinys']
>>> '''tekstas= "Pirma partija, antra partija, trečia, ketvirta"'''
>>> '''tekstas.split(",")'''
['Pirma partija', ' antra partija', ' trečia', ' ketvirta']

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Pagal numatytus nustatymus tekstinė reikšmė padalijama pagal nurodytus tarpus, šiuo atveju pagal nurodytą argumentą - kablelį.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

>>> '''sąrašas= tekstas.split(",")'''
>>> '''len(sąrašas)'''
4
>>> '''sąrašas[-1]'''
' ketvirta'
>>> '''list = tekstas.split(",", 2)'''
>>> '''len(list)'''
3
>>> '''sąrašas[-1]'''
' trečia, ketvirta'


=== Tekstinės (ir sąrašo) reikšmės pjaustymas (Slicing strings(and lists) ===

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje, kai laužtiniuose skliaustuose <code>[]</code> buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: <code>tekstas[pradžios_indeksas:pabaigos_indeksas]</code> (retais atvejais galime pridėti dar ir trečią argumentą, kaip apačioje esančiame pavyzdyje)

Kad nesusipainiotum įrašydamas indekso skaičius, įsivaizduok, kad žirklėmis karpai tekstą, o programai nurodai, kurioje vietoje kirpti. Štai vienas pavyzdys, kaip tai viekia - geltonai pažymėtos kirpimo vietos, o raudonai ir mėlynai indekso numeris

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | -2
| style="width:2ex" |
| style="width:2ex;color:blue" | -1
| style="width:2ex" |
| style="width:2ex" |
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
|-
| tekstas =
|"
| style="background:#FFFF88" |
!S
| style="background:#FFFF88" |
!T
| style="background:#FFFF88" |
!R
| style="background:#FFFF88" |
!I
| style="background:#FFFF88" |
!N
| style="background:#FFFF88" |
!G
| style="background:#FFFF88" |
|"
|-
|
|
| style="background:#FFFF88" |↑
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |↑
|
|-
|
|
|[:
|
|
|
|
|
|
|
|
|
|
|
|:]
|
|}
</tt>

Įsidėmėk, kad raudonai pažymėti indeksai skaičiuojami nuo pradžios, o mėlyni atvirkščiai nuo kito galo t.y. teksto pabaigos. Taip pat ar pastebėjai, kad skaičiuojant nuo galo nėra -0 reikšmės? Taip yra todėl, kad 0 visada priskiriamas tik reikšmės pradžiai:

<tt>
{|
|-
|tekstas[1:4] || style="width:3em;text-align:center" | → || "TRI"
|-
|tekstas[:5] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[:-1] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[-4:] || style="width:3em;text-align:center" | → || "RING"
|-
|tekstas[2] || style="width:3em;text-align:center" | → || "R"
|-
|tekstas[:] || style="width:3em;text-align:center" | → || "STRING"
|-
|tekstas[::-1] || style="width:3em;text-align:center" | → || "GNIRTS"
|}
</tt>

<tt>tekstas[1:4]</tt> duoda visas <tt>tekstas</tt> reikšmes tarp 1 ir 4, "<tt>TRI</tt>". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: <tt>tekstas[:5]</tt> atspausdina"<tt>STRIN</tt>". Taip pat, tiek su <tt>pradžios_indeksas</tt>, tiek su <tt>pabaigos_indeksas</tt> galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: <tt>tekstas[:-1]</tt> duoda tą patį rezultatą kaip <tt>tekstas[:5]</tt>, todėl, kad indekas -1 šiame žodyje yra toje pačioje vietoje kaip indeksas 5. Jeigu nenaudojame argumento kartu su dvitaškiu, tai skaičius traktuojamas kitaip, pavyzdžiui: <tt>tekstas[2]</tt> duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "<tt>R</tt>". Speciali pjaustymo operacija <tt>tekstas[:]</tt> reiškia nuo pradžios iki pabaigos ir duodą visos tekstinės reikšmės ar sąrašo (list) kopiją.

Na ir galiausiai, pjaustymo operacija gali turėti ir trečią argumentą, kuris suprantamas, kaip „žingsnio dydis“: <tt>tekstas[::-1]</tt> yra <tt>tekstas</tt> nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "<tt>STRING</tt>" atvirkščiai yra "<tt>GNIRTS</tt>" (jeigu nesupratai, tai pabandyk prasitestuoti įrašydamas kaip žingsnio ilgį skaičių 2).

Visos šios pjaustymo operacijos veikia ir su sąrašais (lists). Šiuo atveju tekstinę reikšmę galime suprasti, kaip sąrašą, kai visi sąrašo elementai yra atskiros raidės. Iš šio skyriaus atsimink pagrindinį principą - į viską žiūrėk taip lyg karpytum, tai padės nesusipainioti įrašant indeksus.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa reikalauja dešimtainių skaičių supratimo.
def į_tekstą(į_skaičių):
"""Konvertuoja skaičių į tekstą"""
tekstas = ""
prefiksas = ""
if į_skaičių < 0:
prefiksas = "-"
į_skaičių = -į_skaičių
while į_skaičių // 10 != 0:
out_str = str(į_skaičių % 10) + tekstas
į_skaičių= į_skaičių// 10
tekstas = str(į_skaičių % 10) + tekstas
return prefiksas + tekstas

def į_skaičių(į_tekstą):
"""Konvertuoja tekstą į skaičių"""
skaičius = 0
if į_tekstą[0] == "-":
daugiklis = -1
į_tekstą = į_tekstą[1:]
else:
daugiklis = 1
for c in į_tekstą:
skaičius = skaičius* 10 + int(c)
return skaičius * daugiklis

print(į_tekstą(2))
print(į_tekstą(23445))
print(į_tekstą(-23445))
print(į_skaičių("14234"))
print(į_skaičių("12345"))
print(į_skaičių("-3512"))
</syntaxhighlight>

Rezultatas:

2
23445
-23445
14234
12345
-3512

{{navigation |previous=Daugiau apie sąrašus |next=Failų IO}}
{{BookCat}}

Python Vadovėlis/Daugiau apie tekstines eilutes

2021-12-27T16:20:33Z

ZivileB:

Šiame skyriuje pamatysi, kiek šaunių dalykų galime padaryti su tekstine reikšme:

<syntaxhighlight lang="python">
def rėk(tekstinė_reikšmė):
for raidė in tekstinė_reikšmė:
print("Duok man " + raidė)
print("'" + raidė + "'")

rėk("Ačiū")

def vidurys(tekstas):
print("Raidė esanti viduryje yra:", tekstas[len(tekstas) // 2])

vidurys("abcdefg")
vidurys("The Python Programming Language")
vidurys("Atlanta")
</syntaxhighlight>

Rezultatas:

Duok man A
'A'
Duok man č
'č'
Duok man i
'i'
Duok man ū
'ū'
Raidė esanti viduryje yra: d
Raidė esanti viduryje yra: r
Raidė esanti viduryje yra: a

Šios dvi programos rodo, kad tekstinė reikšmė(strings) yra keliais aspektais panaši į sąrašus (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad tekstinėje reikšmėje galima naudotis Python'o programavimo kalboje jau esančia funkcija <code>len()</code>, taip pat masyvų indeksavimu ir pjaustymu. Dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

Kita šio skyriaus funkcija parodo tam tikras tekstinės reikšmės ypatybes:
<syntaxhighlight lang="python">
def pavertimas_didžiosiomis_raidėmis(tekstas):
## Ši funkcija, tekstinę reikšmę užrašo didžiosiomis raidėmis
didžiosios_raidės = ""
for raidei in tekstas:
if 'a' <= tekstas <= 'z':
lokacija = ord(raidei) - ord('a')
naujas_ascii = lokacija + ord('A')
raidei= chr(naujas_ascii)
didžiosios_raidės = pavertimas_didžiosiomis_raidėmis + raidei
return didžiosios_raidės

print(pavertimas_didžiosiomis_raidėmis("Įrašytas tekstas"))
</syntaxhighlight>

Rezultatas:

ĮRAŠYTAS TEKSTAS

Tai veikia, nes kompiuteris tekstinės reikšmės simbolius šifruoja skaičiais nuo 0 iki 1 114 111. Visos šios tekstinės reikšmės turi savo unikalias unikodo reikšmes. Pavyzdžiui, simboliui „A“ yra priskirtas skaičius 65, simbolis „B“ kompiuterio suprantamas kaip 66, o simbolis א yra 1488. Python'o programavimo kalba turi funkciją, vadinamą <code>ord()</code> (trumpinys angliško žodžio ordinal, kuris reiškia iš eilės), kuri grąžina simbolį kaip skaičių. Taip pat Python'o programavimo kalba turi ir atvirkščią funkciją, vadinamą <code>chr()</code>, kuri skaičių paverčia simboliu. Supratus, kaip veikia šios funkcijos aukščiau užrašyta programa turėtų atrodyti logiška.

Programos pirmoji eilutė <code>if 'a' <= simbolis <= 'z':</code> patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės:
Pirmiausia eilutė <code>lokacija= ord(simbolis) - ord('a')</code> nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t.
Tada nauja reikšmė randama su kodo eilute <code>naujas_ascii = lokacija + ord ('A')</code>.
Tada ši reikšmė paverčiama atgal į simbolį, kuris dabar yra didžioji raidė.

Žinoma, tai tik programos pavyzdys, daug paprasčiau tai padaryti gali pasinaudodamas šiuo <code>metodu=var.upper()</code>, kuris veikia su visomis kalbomis.

O dabar pabandykime pasižiūrėti į šį pavyzdį:

>>> '''# Skaičius į tekstinę reikšmę'''
>>> '''2'''
2
>>> '''str(2)'''
'2'
>>> '''-123'''
-123
>>> '''str(-123)'''
'-123'
>>> '''# Tekstinė reikšmė į skaičių'''
>>> '''"23"'''
'23'
>>> '''int("23")'''
23
>>> '''"23" * 2'''
'2323'
>>> '''int("23") * 2'''
46
>>> '''# Skaičius po kablelio į tekstinę reikšmę'''
>>> '''1.23'''
1.23
>>> '''str(1.23)'''
'1.23'
>>> '''# Skaičius po kablelio į skaičių'''
>>> '''1.23'''
1.23
>>> '''int(1.23)'''
1
>>> '''int(-1.23)'''
-1
>>> '''# Tekstinė reikšmė į skaičių po kablelio'''
>>> '''float("1.23")'''
1.23
>>> '''"1.23"'''
'1.23'
>>> '''float("123")'''
123.0

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę, o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į skaičių po kablelio. Grįžtant prie funkcijos <code>str()</code> - ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

>>> '''str(1)'''
'1'
>>> '''str(234.14)'''
'234.14'
>>> '''str([4, 42, 10])'''
'[4, 42, 10]'

Funkcija <code>int()</code> konvertuoja tekstinę reikšmę (ar skaičių su reikšme po kablelio) į sveikąjį skaičių. Panaši funkcija <Code>float</code> konvertuoja skaičių ar tekstinę reikšmę į skaičių su reikšme po kablelio. Taip pat Python'o programavimo kalba turi funkciją <code>type()</code>, kuri grąžina eilutės tipą. Pavyzdžiui:

<syntaxhighlight lang="python">
v = '123'
print(type(v))
# <class 'str'>

v = 645.123
print(type(v))
# <class 'float'>

v = [1, 2, 3]
print(type(v))
# <class 'list'>
</syntaxhighlight>

Jeigu pamatai funkciją <code>type()</code> tai pasitikrink, ar grąžinamas toks reikšmės tipas, kurio tikėjaisi.

Taip pat naudingas ir dažnai paprastose užduotyse naudojamas metodas <code>split()</code>:

>>> '''"Čia yra tik ždožių kratinys".split()'''
['Čia', 'yra', 'tik', 'žodžių', 'kratinys']
>>> '''tekstas= "Pirma partija, antra partija, trečia, ketvirta"'''
>>> '''tekstas.split(",")'''
['Pirma partija', ' antra partija', ' trečia', ' ketvirta']

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Pagal numatytus nustatymus tekstinė reikšmė padalijama pagal nurodytus tarpus, šiuo atveju pagal nurodytą argumentą - kablelį.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

>>> '''sąrašas= tekstas.split(",")'''
>>> '''len(sąrašas)'''
4
>>> '''sąrašas[-1]'''
' ketvirta'
>>> '''list = tekstas.split(",", 2)'''
>>> '''len(list)'''
3
>>> '''sąrašas[-1]'''
' trečia, ketvirta'


=== Tekstinės (ir sąrašo) reikšmės pjaustymas (Slicing strings(and lists) ===

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje, kai laužtiniuose skliaustuose <code>[]</code> buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: <code>tekstas[pradžios_indeksas:pabaigos_indeksas]</code> (retais atvejais galime pridėti dar ir trečią argumentą, kaip apačioje esančiame pavyzdyje)

Kad nesusipainiotum įrašydamas indekso skaičius, įsivaizduok, kad žirklėmis karpai tekstą, o programai nurodai, kurioje vietoje kirpti. Štai vienas pavyzdys, kaip tai viekia - geltonai pažymėtos kirpimo vietos, o raudonai ir mėlynai indekso numeris

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | -2
| style="width:2ex" |
| style="width:2ex;color:blue" | -1
| style="width:2ex" |
| style="width:2ex" |
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
|-
| tekstas =
|"
| style="background:#FFFF88" |
!S
| style="background:#FFFF88" |
!T
| style="background:#FFFF88" |
!R
| style="background:#FFFF88" |
!I
| style="background:#FFFF88" |
!N
| style="background:#FFFF88" |
!G
| style="background:#FFFF88" |
|"
|-
|
|
| style="background:#FFFF88" |↑
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |↑
|
|-
|
|
|[:
|
|
|
|
|
|
|
|
|
|
|
|:]
|
|}
</tt>

Įsidėmėk, kad raudonai pažymėti indeksai skaičiuojami nuo pradžios, o mėlyni atvirkščiai nuo kito galo t.y. teksto pabaigos. Taip pat ar pastebėjai, kad skaičiuojant nuo galo nėra -0 reikšmės? Taip yra todėl, kad 0 visada priskiriamas tik reikšmės pradžiai:

<tt>
{|
|-
|tekstas[1:4] || style="width:3em;text-align:center" | → || "TRI"
|-
|tekstas[:5] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[:-1] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[-4:] || style="width:3em;text-align:center" | → || "RING"
|-
|tekstas[2] || style="width:3em;text-align:center" | → || "R"
|-
|tekstas[:] || style="width:3em;text-align:center" | → || "STRING"
|-
|tekstas[::-1] || style="width:3em;text-align:center" | → || "GNIRTS"
|}
</tt>

<tt>tekstas[1:4]</tt> duoda visas <tt>tekstas</tt> reikšmes tarp 1 ir 4, "<tt>TRI</tt>". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: <tt>tekstas[:5]</tt> atspausdina"<tt>STRIN</tt>". Taip pat, tiek su <tt>pradžios_indeksas</tt>, tiek su <tt>pabaigos_indeksas</tt> galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: <tt>tekstas[:-1]</tt> duoda tą patį rezultatą kaip <tt>tekstas[:5]</tt>, todėl, kad indekas -1 šiame žodyje yra toje pačioje vietoje kaip indeksas 5. Jeigu nenaudojame argumento kartu su dvitaškiu, tai skaičius traktuojamas kitaip, pavyzdžiui: <tt>tekstas[2]</tt> duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "<tt>R</tt>". Speciali pjaustymo operacija <tt>tekstas[:]</tt> reiškia nuo pradžios iki pabaigos ir duodą visos tekstinės reikšmės ar sąrašo (list) kopiją.

Na ir galiausiai, pjaustymo operacija gali turėti ir trečią argumentą, kuris suprantamas, kaip „žingsnio dydis“: <tt>tekstas[::-1]</tt> yra <tt>tekstas</tt> nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "<tt>STRING</tt>" atvirkščiai yra "<tt>GNIRTS</tt>" (jeigu nesupratai, tai pabandyk prasitestuoti įrašydamas kaip žingsnio ilgį skaičių 2).

Visos šios pjaustymo operacijos veikia ir su sąrašais (lists). Šiuo atveju tekstinę reikšmę galime suprasti, kaip sąrašą, kai visi sąrašo elementai yra atskiros raidės. Iš šio skyriaus atsimink pagrindinį principą - į viską žiūrėk taip lyg karpytum, tai padės nesusipainioti įrašant indeksus.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa reikalauja dešimtainių skaičių supratimo.
def į_tekstą(į_skaičių):
"""Konvertuoja skaičių į tekstą"""
tekstas = ""
prefiksas = ""
if į_skaičių < 0:
prefiksas = "-"
į_skaičių = -į_skaičių
while į_skaičių // 10 != 0:
out_str = str(į_skaičių % 10) + tekstas
į_skaičių= į_skaičių// 10
tekstas = str(į_skaičių % 10) + tekstas
return prefiksas + tekstas

def į_skaičių(į_tekstą):
"""Konvertuoja tekstą į skaičių"""
skaičius = 0
if į_tekstą[0] == "-":
daugiklis = -1
į_tekstą = į_tekstą[1:]
else:
daugiklis = 1
for c in į_tekstą:
skaičius = skaičius* 10 + int(c)
return skaičius * daugiklis

print(į_tekstą(2))
print(į_tekstą(23445))
print(į_tekstą(-23445))
print(į_skaičių("14234"))
print(į_skaičių("12345"))
print(į_skaičių("-3512"))
</syntaxhighlight>

Rezultatas:

2
23445
-23445
14234
12345
-3512

{{navigation |previous=Daugiau apie sąrašus |next=Failų IO}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2021-12-15T13:41:46Z

ZivileB:

=== ...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 įvestas skaičius <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> bloke.

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

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu ()
while meniu_pasirinkimas != 5:
try:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-5): "))
if meniu_pasirinkimas == 1:
print("Telefono numeriai: ")
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
print()
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
numeriai[vardas] = numeris
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas != 5:
print_menu()
except ValueError:
print("Tai buvo ne skaičius.")</syntaxhighlight>

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

Python Vadovėlis/Siekiant tobulumo

2021-12-15T13:39:57Z

ZivileB:

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

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

Dabar, kai vykdome programą ir įvedame <code>@#&</code>, programa mums pasako, kad <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> bloke.

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

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu ()
while meniu_pasirinkimas != 5:
try:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-5): "))
if meniu_pasirinkimas == 1:
print("Telefono numeriai: ")
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
print()
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
numeriai[vardas] = numeris
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas != 5:
print_menu()
except ValueError:
print("Tai buvo ne skaičius.")</syntaxhighlight>

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

Python Vadovėlis/Rekursija

2021-12-15T13:32:49Z

ZivileB:

== Rekursija ==

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

=== Įvadas į rekursiją ===

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

sk = 0

def main():
skaitliukas(sk)

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

main()
</syntaxhighlight>

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

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

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

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

main()
</syntaxhighlight>

Aukščiau naudojami argumentai/parametrai rekursijų skaičiui valdyti. Tiesiog naudok tai, ką jau žinai apie funkcijas, ir sek programos eigą. Tai paprasta išsiaiškinti. Jei kyla problemų, grįžk į [[Vadovėlis/Pažangių funkcijų pavyzdys|Pažangių funkcijų pavyzdys]].

== Praktiniai rekursijos pritaikymai ==

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

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

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

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

Štai keletas pagrindinių faktorialų taisyklių:

Jei n = 0 tai n! = 1

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

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

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

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

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

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

main()
</syntaxhighlight>

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

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

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

Python Vadovėlis/Suskaičiuoti iki 10

2021-12-14T16:25:23Z

ZivileB:

=== Ciklai kol (While loops) ===
Šiame skyriuje susipažinsi su ciklu <code>while</code> lietuviškas atitikmuo būtų ciklas kol. Kaip jau sužinojai praeitame skyriuje, tai kompiuteris įprastai programą pradeda skaityti ir vykdyti nuo pirmos eilutės ir taip eilutė po eilutės keliauja žemyn per visas duoto kodo eilutes. Tačiau ciklas <code>while</code> šią tvarką pakeičia ir dėl to kompiuteris priėjęs šią kodo vietą eilutes skaito iki galo, pagal šio ciklo nustatytą tvarką. Štai čia yra programos su ciklo <code>while</code> pavyzdžiu:

<syntaxhighlight lang="python">
a = 0 # PIRMA, nustatome pradinio kintamojo a reikšmę 0 (nuliui).
while a < 10: # Kol kintamojo a vertė yra mažesnė nei 10, programa atlieka šiuos veiksmus:
a = a + 1 # Padidina kintamojo a reikšmę 1 (vienu), visai taip kaip nurodyta: a = a + 1!
print(a) # Tuomet nurodome, kad spausdintų. Viskas tam, kad pamatytumėte, kokia yra dabartinė kintamojo a vertė.
# Ir visą šitą ciklą programa vykdo tol, kol kintamojo a reikšmė bus lygi 9!? Žr. Pastabą.

# PASTABA:
# Kintamojo a vertė padidės 1
# su kiekvienu pakartojimu ar ciklu, kol pasieks nustatytą sąlygą ir sustos.
# pvz. a = 1, tada a = 2, tada a = 3 ir t.t., kol a bus lygus 9 (a = 9), tada...
# kodas baigs pridėjinėti po 1 prie a, nes taps lygus 10 (a = 10) kaip ir numatyta mūsų parašytoje sąlygoje.
# O kai mūsų nurodyta sąlyga yra patenkinama, programa atspausdina rezultatą.
# --
# While a < 10: |
# a = a + 1 |<--[ Ciklo Kol sąlygos blokas ]
# print (a) |
# --
</syntaxhighlight>

Na, o jeigu paleidžiame programą, tai turime štai tokį įdomų rezultatą:

1
2
3
4
5
6
7
8
9
10

(Tikriausiai iki šios pamokos net nesusimąstei, kad kompiuterį gali paversti pigiu skaičiuotuvu...)

Na, o dabar pasiaiškinkime kaip veikia ši programa. Pirmiausia kompiuteris mato eilutę <code>a = 0</code> ir nustato <code>a</code> reikšmę lygią nuliui. Tada programa mato sąlygą <code>while a < 10:</code>, todėl kompiuteris patikrina, ar <code>a < 10</code>. Kompiuteriui pirmą kartą matant šį teiginį, <code>a</code> yra lygus 0, ir akivaizdu, kad turima reikšmė yra mažesnė nei. Kitaip tariant, kol <code>a</code> yra mažesnis skaičius nei dešimt, tol kompiuteris tikrins teiginį ir kartos jį (t.y. pridėjinės po 1), kol <code>a</code> bus lygus dešimčiai. Kai pasieks šią nustatytą reikšmę programa nustos skaityti eilutes ir prie kitų kodo eilučių. Kadangi šiame kode daugiau nieko nėra, tai programa sustoja.

ĮSIDĖMĖK: Nepamiršk parašyti dvitaškio <code>:</code> eilutės pabaigoje, tik taip kompiuteris supras, kad čia yra teiginys!

Kitas ciklo <code>while</code> pavyzdys:
<syntaxhighlight lang="python">
a = 1
s = 0
print('Įvesk skaičius, kuriuos nori pridėti prie sumos.')
print('Norint išeiti, įvesk 0.')
while a != 0:
print('Dabartinė suma:', s)
a = float(input('Skaičius? '))
s = s + a
print('Galutinė suma =', s)
</syntaxhighlight>

Galimas programos scenarijus:

Įvesk skaičius, kuriuos nori pridėti prie sumos.
Norint išeiti, įveskite 0.
Dabartinė suma: 0
Skaičius? '''200'''
Dabartinė suma: 200.0
Skaičius? '''-15.25'''
Dabartinė suma: 184.75
Skaičius? '''-151.85'''
Dabartinė suma: 32.9
Skaičius? '''10.00'''
Dabartinė suma: 42.9
Skaičius? '''0'''
Galutinė suma = 42.9

Atkreipk dėmesį, kad <code>print('Galutinė suma =', s)</code> yra paleidžiama tik pačiame gale. Teiginys <code>while</code> veikia tik tas eilutes, kurios yra atitrauktos nuo krašto ir priklauso ciklo <code>while</code> blokui. <code>! =</code> reiškia nelygu, taigi <code>while a! = 0:</code> reiškia tol, kol <code>a</code> nėra nulis, programa vykdo kodą.

Ar pastebėjai, kad šiuo atveju <code>a</code> yra skaičius su reikšme po kablelio ir ne visi tokie skaičiai gali būti tiksliai atvaizduoti, kai naudojamas <code>!=</code>. Pabandyk paleidęs programą įvesti 1.1

==== Begaliniai ciklai (infinitive loops) arba niekada nesibaigaintys ciklai (Never Ending Loop)====
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis:
<syntaxhighlight lang="python">
while True:
print("Padėk! Užstrigau cikle!")
</syntaxhighlight>
Operatorius <code>== </code> naudojamas abiejų operatoriaus pusių išraiškų lygybei patikrinti, kaip ir <code> & lt; </code> buvo naudojami norint pasakyt „mažiau nei“ (kitame skyriuje rasi išsamų visų palyginimo operatorių sąrašą).

Ši mūsų sukurta programa spausdins <code>Padėk! Užstrigau cikle!</code> visą amžinybę... Tol, kol pats ją sustabdysi, todėl kad ji visą laiką yra <code>True</code> (visada atitinka teigiamą reikšmę) arba kitaip tariant 1 reikšmės. Kaip programaą sustabdyti? Paprasčiausiai paspausk ctrl + c mygtukus.

=== Pavyzdžiai ===
==== Fibonačio seka ====
'''Fibonacci-metodas1.py'''
<syntaxhighlight lang="python">
# Ši programa skaičiuoja Fibonačio seką
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 20

while pradinis_skačius < maksimalus_skaičius:
pradinis_skačius = pradinis_skačius + 1
print(a, pabaiga=" ") # Atkreipkite dėmesį į pabaiga=" " spausdinimo funkcijos argumentuose
# tai neleidžia sukurti naujos eilutės.
senas_a = a # turime sekti, nes mes jį keičiame.
a = b
b = senas_a + b
print() # gauna naują (tuščią) eilutę.
</syntaxhighlight>
Išvestis :
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

Įsidėmėk, kad išvestis yra vienoje eilutėje dėl papildomų argumentų <code>pabaiga=" "</code> argumentuose <code>print</code>.

'''Fibonacci-metodas2.py'''
<syntaxhighlight lang="python">
# Supaprastintas ir greitesnis Fibonačio sekos apskaičiavimo metodas
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 10

while pradinis_skačius < maksimalus_skaičius:
pradinis_skačius = pradinis_skačius + 1
print(a, b, pabaiga=" ") # Įsidėmėk pabaiga=" "
a = a + b
b = a + b
print() # gauna naują (tuščią) eilutę.
</syntaxhighlight>

Išvestis:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

'''Fibonacci-metodas3.py'''
<syntaxhighlight lang="python">
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 20

#kai ciklas prasideda, mes jame pasiliekame
while pradinis_skačius < maksimalus_skaičius:
pradinis_skačius += 1
senas_a = a
a = a + b
b = senas_a
print(senas_a,pabaiga=" ")
print()
</syntaxhighlight>

Išvestis:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

==== Įvesk slaptažodį ====
'''Slaptaždis.py'''
<syntaxhighlight lang="python">
# Laukia, kol bus įvestas slaptažodis. Naudok „ctrl+ C“, kad sustabdytum programą
# be slaptažodžio

#atkreipk dėmesį, kad tai neturi būti slaptažodis, kad
# ciklas while turi prasisukti bent kartą.
slaptažodis= str()

# įsidėmėk != reiškia nelygu
while slaptažodis!= "Angis":
slaptažodis = input("Slaptažodis: ")
print("Prisijungimas sėkmingas")
</syntaxhighlight>

Kaip programa veikia:
Slaptažodis: '''auo'''
Slaptažodis: '''y22'''
Slaptažodis: '''slaptažodis'''
Slaptažodis: '''Sezamai atsiverk''
Slaptažodis: '''Angis'''
Prisijungimas sėkmingas

=== Užduotis===
Parašyk programą, kuri prašo: vartotojo prisijungimo vardo ir slaptažodžio. Tada, kai vartotojas įveda „užrakinti“, jis turi įvesti savo vardą ir slaptažodį, kad atrakintų programą.
<syntaxhighlight lang="python">
vardas= input("Koks tavo prisijungimo vardas?: ")
slaptažodis = input("Koks tavo slaptažodis: ")
print("print("Kad užrakintum kompiuterį, parašyk: užrakinti"))
įvesta_komanda = None
input1 = None
input2 = None
while komanda!= "užrakinti":
įvesta_komanda = input("Kokia tavo komanda: ")
while input1 != vardas:
input1 = input("Tavo prisijungimo vardas: ")
while input2 != slaptažodis:
input2 = input("Tavo slaptažodis: ")
print("Prisijungimas sėkmingas")
</syntaxhighlight>

Jei nori, kad programa veiktų nepertraukiamai, tiesiog pridėk <code>while 1 == 1: </code>prieš visą programą. Tik nepamiršk, kad reikia visą likusią programos dalį, t.y. ciklo bloką reikia atitraukti nuo krašto.

Kitas sprendimo būdas
<syntaxhighlight lang="python">
vardas = input('Nustatyti vardą: ')
slaptažodis = input('Nustatyti slaptažodį: ')
while 1 == 1:
vardospėjimas=""
slaptažodžiospėjimas=""
raktas=""
while (vardospėjimas!= vardas) or (slaptažodžiospėjimas!= slaptažodis):
vardospėjimas = input('Vardas? ')
slaptažodžiospėjimas= input('Slaptažodis? ')
print("Labas,", vardas, ". Parašyk užrakinti, kad užrakintum.")
while raktas != "užrakinti":
raktas = input("")
</syntaxhighlight>

Atkreipk dėmesį į <code>or</code>, kuris yra prie <code>(vardospėjimas!= vardas) or (slaptažodžiospėjimas!= slaptažodis)</code>, kurių dar neįvedėme. Pabandyk suprasti šią logiką ir kaip ji veikia.

}}

{{navigation |previous=Kas čia eina? |next=Pasirinkimai}}

Python Vadovėlis/Pasirinkimai

2021-12-14T16:12:00Z

ZivileB:

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

Štai rezultatas po dviejų programos vykdymų:

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

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

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

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

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

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

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

ir išvestis:

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

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

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

Ir išvestis

False
False

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

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

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

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

Pavyzdinis vykdymas:

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

'''lyginis.py'''

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

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

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

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

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

Python Vadovėlis/Loginiai reiškiniai

2021-12-14T15:35:18Z

ZivileB:

Š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: Liepa

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.

{{Solution|title=Sprendimas|text=
<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/Ciklai For

2021-12-14T15:16:55Z

ZivileB:

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: 7
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/Funkcijų apibrėžimas

2021-12-14T15:10:21Z

ZivileB:

=== Funkcijų kūrimas ===
Prieš pradėdami šį skyrių pateiksime tau pavyzdį, kurio gali nepersirašinėti:
<syntaxhighlight lang=python>
a = 23
b = -23

if a < 0:
a = -a
if b < 0:
b = -b
if a == b:
print("Absoliučios", a, "ir", b, "reikšmės yra lygios.")
else:
print("Absoliučios", a, "ir", b, "reikšmės yra skirtingos.")
</syntaxhighlight>

Programos rezultatas:

Absoliučios 23 ir 23 reikšmės yra lygios.

Ar neatrodo, kad programa yra šiek tiek pasikartojanti?.. Ir tikriausiai jau numanai, programuotojai nemėgsta pasikartojančių dalykų, nes juk pasikartojantiems dalykams atlikti ir yra sukurti kompiuteriai!! Be to atkreipk dėmesį, kad radus absoliučią reikšmę pasikeitė kintamojo vertė, todėl programa spausdina 23, o ne -23. Mūsų laimei Python'as leidžia sukurti funkcijas, kurios šalina dubliavimą:
<syntaxhighlight lang=python>
a = 23
b = -23

def absoliuti_reikšmė(n):
if n < 0:
n = -n
return n

if absoliuti_reikšmė(a) == absoliuti_reikšmė(b):
print("Absoliučios", a, "ir", b, "reikšmės yra lygios.")
else:
print("Absoliučios", a, "ir", b, "reikšmės yra lygios.")
</syntaxhighlight>

Programos rezultatas:

Absoliučios 23 ir -23 reikšmės yra lygios.

Pagrindinis šios programos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra paimama iš programos, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esantys teiginiai yra vykdomi naudojant šią funkciją. Teiginiai tęsiami tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> teiginys grąžina reikšmę į vietą, kur buvo iškviesta funkcija, kaip pirmoje mūsų kurtoje programoje rezultatas buvo grąžintas, kur kvietėme <code>print()</code> funkciją. Na, o dabar galime kurti naujas funkcijas.

Ar pastebėjai, kad <code>a</code> ir <code>b</code> reikšmės nepasikeitė?

Funkcijos gali būti naudojamos kartojant užduotis, kurios negrąžina reikšmių. Štai keli pavyzdžiai:
<syntaxhighlight lang="python">
def labas():
print("Labas")

def plotas(plotis, aukštis):
return plotis * aukštis

def rašyk_mano_vardas(vardas):
print("Mano vardas", vardas)

labas()
labas()

rašyk_labas("Fredas")
w = 4
h = 5
print("plotis =", w, " aukštis=", h, " plotas=", plotas(w, h))
</syntaxhighlight>

programos rezultatas

Labas
Labas
Mano vardas Fredas
plotis = 4 aukštis = 5 plotas = 20

Šis pavyzdys parodo ir daugiau dalykų, kuriuos galima padaryti su funkcijomis. Atkreipk dėmesį, kad galima nenaudoti argumentų arba galima naudoti du argumentus, ar daugiau. Šis pavyzdys rodo dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad funkcijai nereikia grąžinti vertės - grąžinimas yra neprivalomas.



=== Kintamieji funkcijose ===
Dažnai pasitaiko, kad pasikartojančiam kode yra kintamųjų, todėl į juos reikia atkreipti dėmesį, kai šaliname pakartotiną kodą. Iki šiol visi kintamieji, kuriuos matėme yra globalūs kintamieji, o funkcijose esantys kintamieji yra vadinami specialiu pavadinimu - lokalūs kintamieji. Šie kintamieji egzistuoja tik veikiant funkcijai. Kai lokalus kintamasis turi globalaus kintamojo pavadinimą, tai funkcijoje pirmenybė teikiama ir naudojamas lokalus kintamasis. Skamba painiai? Štai keli pavyzdžiai:

<syntaxhighlight lang="python">
a = 4

def manoFunkcija():
a = 17
print("Mano funkcijoje a =", a)

manoFunkcija()
print("a = ", a)
</syntaxhighlight>

Gaunamas rezultatas
Mano funkcijoje a = 17
a = 4

Kaip matai pavyzdyje, funkcijos viduje esantis kintamasis nepaiso globalaus kintamojo, nes jis egzistuoja tik funkcijos viduje. Taip pat, turėjai pastebėti, kad funkcijos viduje kintamajam <code>a</code> buvo priskirta nauja reikšmė, bet ji buvo aktuali tik funkcijoje, o ne už jos ribų - globalus kintamasis <code>a</code> liko nepakitęs.

Kitas kiek sudėtingesnis kodo pavyzdys:
<syntaxhighlight lang="python">
a_var = 10
b_var = 15
e_var = 25

def funkcija(a_var):
print("funkcijoje a_var =", a_var)
b_var = 100 + a_var
d_var = 2 * a_var
print("funkcijoje b_var =", b_var)
print("funkcijoje d_var =", d_var)
print("funkcijoje e_var =", e_var)
return b_var + 10

c_var = funkcija(b_var)

print("a_var =", a_var)
print("b_var =", b_var)
print("c_var =", c_var)
print("d_var =", d_var)

</syntaxhighlight>

rezultatas:

funkcijoje a_var = 15
funkcijoje b_var = 115
funkcijoje d_var = 30
funkcijoje e_var = 25
a_var = 10
b_var = 15
c_var = 125
d_var =

Klaida (paskutinė aptikta klaida):
File "C:\def2.py", eilutė 19, in <module> (modulyje)
print("d_var = ", d_var)
NameError: pavadinimas 'd_var' yra neapibrėžtas

Šiame pavyzdyje kintamieji <code>a_var</code>, <code>b_var</code> ir <code>d_var</code> yra lokalūs kintamieji priklausantys funkcijai <code>funkcija()</code>. Po argumento <code>return b_var + 10</code> visi jie nustoja egzistuoti. Kintamasis <code>a_var</code> yra parametro pavadinimas, todėl tai jį automatiškai padaro lokaliu kintamuoju. Kintamieji <code>b_var</code> ir <code>d_var</code> yra lokalūs kintamieji, nes jie - rodomi funkcijos lygybės ženklo kairėje pusėje esančiuose teiginiuose <code>b_var = 100 + a_var</code> ir <code>d_var = 2 * a_var</code>.

Funkcijos <code>funkcija()</code> viduje nėra jai priskirtos vertės. Kai funkcija iškviečiama naudojant <code>c_var = funkcija(b_var)</code>, 15 priskiriama <code> a_var </code>, nes tuo metu <code> _var</code> yra 15, kai kviečiama funkcija <code>funkcija(15)</code>. Galiausiai <code>a_var</code> reikšmė nustatoma į 15, kai jis yra funkcijos <code>funkcija()</code> viduje.

Kaip matai, pasibaigus funkcijai, lokalūs kintamieji <code>a_var</code> ir <code>b_var</code>, kurie buvo naudojami vietoj globalių kintamųjų dingo. Tada teiginys <code>print ("a_var =", a_var)</code> atspausdina reikšmę <code>10</code>, o ne reikšmę <code>15</code> kai dingo lokalus kintamasis, kuris slėpė globalaus kintamojo reikšmę.

Taip pat, atkreipk dėmesį į klaidą <code> NameError </code>, kuri atsiranda mūsų programos pabaigoje. Tai nutinka, nes kintamasis <code>d_var</code> nebeegzistuoja nuo tada, kai baigėsi <code>funkcija()</code>. Išjungus funkciją, visi lokalūs kintamieji ištrinami. Jeigu nori, ką nors gauti iš funkcijos, turėsi naudoti žodį <code>return</code>.

Paskutinis dalykas, į kurį reikia atkreipti dėmesį, yra tai, kad funkcijos viduje <code>e_var</code> vertė išlieka nepakitusi, nes tai nėra parametras ir jis niekada nerodomas kairėje funkcijos pusėje. <code>a_func</code>. Kai funkcijos viduje pasiekiamas globalus kintamasis, tai yra išorinis kintamasis esantis už funkcijos ribų.

Funkcijos naudoja lokalius kintamuosius, kurie egzistuoja tik funkcijos viduje, ir gali ignoruoti kitus kintamuosius, kurie yra už funkcijos ribų.

=== Pavyzdžiai ===
'''temperatūra2.py'''
<syntaxhighlight lang="python">
#! /usr/bin/python
#-*-coding: utf-8 -*-
# konvertuoja temperatūrą į Farenheitus ar Celsijų

def spausdinti_pasirinkimus():
print("Pasirinkimai:")
print(" 'p' spausdinti pasirinkimus")
print(" 'c' konvertuoti iš Celsijaus")
print(" 'f' konvertuoti iš Farenheitų")
print(" 'q' išjungti programą")

def celsijus_į_farenheitus(c_temp):
return 9.0 / 5.0 * c_temp + 32

def farenheitai_į_celsijų(f_temp):
return (f_temp - 32.0) * 5.0 / 9.0

pasirinkimas = "p"
while pasirinkimas != "q":
if pasirinkimas == "c":
c_temp = float(input("Celsijaus temperatūra: "))
print("Farenheitai:", celsijus_į_farenheitus(c_temp))
pasirinkimas = input("pasirinkimas: ")
elif pasirinkimas == "f":
f_temp = float(input("farenheitai_į_celsijų: "))
print("Celsijus:", farenheitai_į_celsijų(f_temp))
pasirinkimas= input("pasirinkimas: ")
else:
pasirinkimas= "p" #Arba pasirinkimas! = "q": kad spausdintų
#kai įrašoma, kas nors netikėto
spausdinti_pasirinkimus()
pasirinkimas = input("pasirinkimas: ")
</syntaxhighlight>

Kaip tai veikia?:

Pasirinkimai:
'p' spausdinti pasirinkimus
'c' konvertuoti iš Celsijaus
'f' konvertuoti iš Farenheitų
'q' išjungti programą
pasirinkimas: '''c'''
Celsijaus temperatūra: '''30'''
Farenheitai: 86.0
pasirinkimas: '''f'''
Farenheitų temperatūra: '''60'''
Celsijus: 15.5555555556
pasirinkimas: '''q'''

'''plotas2.py'''
<syntaxhighlight lang="python">
#! /usr/bin/python
#-*-coding: utf-8 -*-
# apskaičiuoja duotą stačiakampio plotą

def pasisveikinimas():
print('Labas!')

def plotas(plotis, aukštis):
return plotis * aukštis

def mano_vardas(vardas):
print('Mano vardas yra,', vardas)

def teigiama_įvestis(sugalvotas_skaičius):
skaičius = float(input(sugalvotas_skaičius))
while skaičius<= 0:
print('Privalo būti teigiamas skaičius')
skaičius = float(input(sugalvotas_skaičius))
return skaičius

vardas = input('Tavo vardas: ')
pasisveikinimas()
mano_vardas(name)
print()
print('Kad rastum stačiakampio plotą,')
print('įrašyk plotį ir aukštį')
print()
w = teigiama_įvestis('Plotis: ')
h = teigiama_įvestis('Aukštis: ')

print('Plotis =', w, ' Aukštis =', h, ' Plotas =', area(w, h))
</syntaxhighlight>

Kaip veikia ši programa?

Tavo vardas: '''Jonas'''
Labas!
Mano vardas yra Jonas

Kad rastum stačiakampio plotą,
įrašyk plotį ir aukštį.

Plotis: '''-4'''
Privalo būti teigiamas skaičius
Plotis: '''4'''
Aukštis: '''3'''
Plotis = 4 Aukštis = 3 Plotas = 12

=== Užduotis ===
Perrašyk programą plotas2.py, kuri yra aukščiau pateiktame pavyzdyje, kad turėtum atskiras kvadrato, stačiakampio ir apskritimo ploto funkcijas ((<code>3.14 * spindulys**2</code>). Taip pat šioje programoje turėtų būti sukurtas meniu:

{{Solution|title=Sprendimas|text=

<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

def stačiakampis(aukštis, plotis):
return aukštis * plotis

def apskritimas(spindulys):
return 3.14159 * spindulys** 2

def opcijos():
print()
print("Pasirinkimai:")
print("s = skaičiuoti kvadrato plotą.")
print("c = skaičiuoti apskritimo plotą.")
print("r = skaičiuoti stačiakampio plotą.")
print("q = išeiti")
print()

print("Ši programa apskaičiuos kvadrato, apskritimo ar stačiakampio plotą.")
pasirinkimas = "x"
opcijos()
while pasirinkimas != "q":
choice = input("Įrašyk savo pasirinkimą: ")
if pasirinkimas== "s":
L = float(input("Kvadrato kraštinės ilgis: "))
print("Šio kvadrato plotas", kvadratas(L))
opcijos()
elif pasirinkimas == "c":
spindulys = float(input("Apskritimo spindulys yra: "))
print("Apskritimo plotas yra", apskritimas(spindulys))
opcijos()
elif pasirinkimas == "r":
plotis = float(input("Stačiakampio plotis: "))
aukštis = float(input("Stačiakampio aukštis: "))
print("Stačiakampio plotas yra", kvadratas(plotis, aukštis))
opcijos()
elif pasirinkimas == "q":
print(" ",end="")
else:
print("Neatpažintas pasirinkimas.")
opcijos()
</syntaxhighlight>
}}

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

Python Vadovėlis/Daugiau apie tekstines eilutes

2021-12-14T15:00:47Z

ZivileB:

Šiame skyriuje pamatysi, kiek šaunių dalykų galime padaryti su tekstine reikšme:

<syntaxhighlight lang="python">
def rėk(tekstinė_reikšmė):
for raidei in tekstinė_reikšmė:
print("Duok man " + raidė)
print("'" + raidė + "'")

rėk("Ačiū")

def vidurys(tekstas):
print("Raidė esanti viduryje yra:", tekstas[len(tekstas) // 2])

vidurys("abcdefg")
vidurys("The Python Programming Language")
vidurys("Atlanta")
</syntaxhighlight>

Rezultatas:

Duok man A
'A'
Duok man č
'č'
Duok man i
'i'
Duok man ū
'ū'
Raidė esanti viduryje yra: d
Raidė esanti viduryje yra: r
Raidė esanti viduryje yra: a

Šios dvi programos rodo, kad tekstinė reikšmė(strings) yra keliais aspektais panaši į sąrašus (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad tekstinėje reikšmėje galima naudotis Python'o programavimo kalboje jau esančia funkcija <code>len()</code>, taip pat masyvų indeksavimu ir pjaustymu. Dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

Kita šio skyriaus funkcija parodo tam tikras tekstinės reikšmės ypatybes:
<syntaxhighlight lang="python">
def pavertimas_didžiosiomis_raidėmis(tekstas):
## Ši funkcija, tekstinę reikšmę užrašo didžiosiomis raidėmis
didžiosios_raidės = ""
for raidei in tekstas:
if 'a' <= tekstas <= 'z':
lokacija = ord(raidei) - ord('a')
naujas_ascii = lokacija + ord('A')
raidei= chr(naujas_ascii)
didžiosios_raidės = pavertimas_didžiosiomis_raidėmis + raidei
return didžiosios_raidės

print(pavertimas_didžiosiomis_raidėmis("Įrašytas tekstas"))
</syntaxhighlight>

Rezultatas:

ĮRAŠYTAS TEKSTAS

Tai veikia, nes kompiuteris tekstinės reikšmės simbolius šifruoja skaičiais nuo 0 iki 1 114 111. Visos šios tekstinės reikšmės turi savo unikalias unikodo reikšmes. Pavyzdžiui, simboliui „A“ yra priskirtas skaičius 65, simbolis „B“ kompiuterio suprantamas kaip 66, o simbolis א yra 1488. Python'o programavimo kalba turi funkciją, vadinamą <code>ord()</code> (trumpinys angliško žodžio ordinal, kuris reiškia iš eilės), kuri grąžina simbolį kaip skaičių. Taip pat Python'o programavimo kalba turi ir atvirkščią funkciją, vadinamą <code>chr()</code>, kuri skaičių paverčia simboliu. Supratus, kaip veikia šios funkcijos aukščiau užrašyta programa turėtų atrodyti logiška.

Programos pirmoji eilutė <code>if 'a' <= simbolis <= 'z':</code> patikrina, ar raidė yra mažoji. Jeigu taip, tada naudojamos kitos programos eilutės:
Pirmiausia eilutė <code>lokacija= ord(simbolis) - ord('a')</code> nurodo simbolio vietą: a = 0, b = 1, c = 2 ir t.t.
Tada nauja reikšmė randama su kodo eilute <code>naujas_ascii = lokacija + ord ('A')</code>.
Tada ši reikšmė paverčiama atgal į simbolį, kuris dabar yra didžioji raidė.

Žinoma, tai tik programos pavyzdys, daug paprasčiau tai padaryti gali pasinaudodamas šiuo <code>metodu=var.upper()</code>, kuris veikia su visomis kalbomis.

O dabar pabandykime pasižiūrėti į šį pavyzdį:

>>> '''# Skaičius į tekstinę reikšmę'''
>>> '''2'''
2
>>> '''str(2)'''
'2'
>>> '''-123'''
-123
>>> '''str(-123)'''
'-123'
>>> '''# Tekstinė reikšmė į skaičių'''
>>> '''"23"'''
'23'
>>> '''int("23")'''
23
>>> '''"23" * 2'''
'2323'
>>> '''int("23") * 2'''
46
>>> '''# Skaičius po kablelio į tekstinę reikšmę'''
>>> '''1.23'''
1.23
>>> '''str(1.23)'''
'1.23'
>>> '''# Skaičius po kablelio į skaičių'''
>>> '''1.23'''
1.23
>>> '''int(1.23)'''
1
>>> '''int(-1.23)'''
-1
>>> '''# Tekstinė reikšmė į skaičių po kablelio'''
>>> '''float("1.23")'''
1.23
>>> '''"1.23"'''
'1.23'
>>> '''float("123")'''
123.0

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę, o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į skaičių po kablelio. Grįžtant prie funkcijos <code>str()</code> - ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

>>> '''str(1)'''
'1'
>>> '''str(234.14)'''
'234.14'
>>> '''str([4, 42, 10])'''
'[4, 42, 10]'

Funkcija <code>int()</code> konvertuoja tekstinę reikšmę (ar skaičių su reikšme po kablelio) į sveikąjį skaičių. Panaši funkcija <Code>float</code> konvertuoja skaičių ar tekstinę reikšmę į skaičių su reikšme po kablelio. Taip pat Python'o programavimo kalba turi funkciją <code>type()</code>, kuri grąžina eilutės tipą. Pavyzdžiui:

<syntaxhighlight lang="python">
v = '123'
print(type(v))
# <class 'str'>

v = 645.123
print(type(v))
# <class 'float'>

v = [1, 2, 3]
print(type(v))
# <class 'list'>
</syntaxhighlight>

Jeigu pamatai funkciją <code>type()</code> tai pasitikrink, ar grąžinamas toks reikšmės tipas, kurio tikėjaisi.

Taip pat naudingas ir dažnai paprastose užduotyse naudojamas metodas <code>split()</code>:

>>> '''"Čia yra tik ždožių kratinys".split()'''
['Čia', 'yra', 'tik', 'žodžių', 'kratinys']
>>> '''tekstas= "Pirma partija, antra partija, trečia, ketvirta"'''
>>> '''tekstas.split(",")'''
['Pirma partija', ' antra partija', ' trečia', ' ketvirta']

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Pagal numatytus nustatymus tekstinė reikšmė padalijama pagal nurodytus tarpus, šiuo atveju pagal nurodytą argumentą - kablelį.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

>>> '''sąrašas= tekstas.split(",")'''
>>> '''len(sąrašas)'''
4
>>> '''sąrašas[-1]'''
' ketvirta'
>>> '''list = tekstas.split(",", 2)'''
>>> '''len(list)'''
3
>>> '''sąrašas[-1]'''
' trečia, ketvirta'


=== Tekstinės (ir sąrašo) reikšmės pjaustymas (Slicing strings(and lists) ===

Tekstinę reikšmę galima pjaustyti/skaidyti į skirtingas mažesnes reikšmes. Tą jau matei ankstesniame pavyzdyje, kai laužtiniuose skliaustuose <code>[]</code> buvo nurodyta reikiama teksto vieta. Pjaustymo operatorius veikia taip: <code>tekstas[pradžios_indeksas:pabaigos_indeksas]</code> (retais atvejais galime pridėti dar ir trečią argumentą, kaip apačioje esančiame pavyzdyje)

Kad nesusipainiotum įrašydamas indekso skaičius, įsivaizduok, kad žirklėmis karpai tekstą, o programai nurodai, kurioje vietoje kirpti. Štai vienas pavyzdys, kaip tai viekia - geltonai pažymėtos kirpimo vietos, o raudonai ir mėlynai indekso numeris

<tt>
{| style="text-align:center" cellspacing="0px"
|
| style="width:2ex" |
| style="width:2ex;color:red" |0
| style="width:2ex" |
| style="width:2ex;color:red" |1
| style="width:2ex" |
| style="width:2ex;color:red" |2
| style="width:2ex" |
| style="width:2ex" | ...
| style="width:2ex" |
| style="width:2ex;color:blue" | -2
| style="width:2ex" |
| style="width:2ex;color:blue" | -1
| style="width:2ex" |
| style="width:2ex" |
| style="width:2ex" |
|-
|
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
| style="background:#FFFF88" |↓
|
|-
| tekstas =
|"
| style="background:#FFFF88" |
!S
| style="background:#FFFF88" |
!T
| style="background:#FFFF88" |
!R
| style="background:#FFFF88" |
!I
| style="background:#FFFF88" |
!N
| style="background:#FFFF88" |
!G
| style="background:#FFFF88" |
|"
|-
|
|
| style="background:#FFFF88" |↑
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |
|
| style="background:#FFFF88" |↑
|
|-
|
|
|[:
|
|
|
|
|
|
|
|
|
|
|
|:]
|
|}
</tt>

Įsidėmėk, kad raudonai pažymėti indeksai skaičiuojami nuo pradžios, o mėlyni atvirkščiai nuo kito galo t.y. teksto pabaigos. Taip pat ar pastebėjai, kad skaičiuojant nuo galo nėra -0 reikšmės? Taip yra todėl, kad 0 visada priskiriamas tik reikšmės pradžiai:

<tt>
{|
|-
|tekstas[1:4] || style="width:3em;text-align:center" | → || "TRI"
|-
|tekstas[:5] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[:-1] || style="width:3em;text-align:center" | → || "STRIN"
|-
|tekstas[-4:] || style="width:3em;text-align:center" | → || "RING"
|-
|tekstas[2] || style="width:3em;text-align:center" | → || "R"
|-
|tekstas[:] || style="width:3em;text-align:center" | → || "STRING"
|-
|tekstas[::-1] || style="width:3em;text-align:center" | → || "GNIRTS"
|}
</tt>

<tt>tekstas[1:4]</tt> duoda visas <tt>tekstas</tt> reikšmes tarp 1 ir 4, "<tt>TRI</tt>". Jei praleisi vieną iš argumentų [pradžios_indeksas:pabaigos indeksas], automatiškai gausi tekstinę reikšmę nuo pradžios ar pabaigos: <tt>tekstas[:5]</tt> atspausdina"<tt>STRIN</tt>". Taip pat, tiek su <tt>pradžios_indeksas</tt>, tiek su <tt>pabaigos_indeksas</tt> galime naudoti raudonai ir mėlynai pavaizduotą skaičiavimo schemą - t.y. galime skaičuoti nuo pradžios, arba nuo pabaigos: <tt>tekstas[:-1]</tt> duoda tą patį rezultatą kaip <tt>tekstas[:5]</tt>, todėl, kad indekas -1 šiame žodyje yra toje pačioje vietoje kaip indeksas 5. Jeigu nenaudojame argumento kartu su dvitaškiu, tai skaičius traktuojamas kitaip, pavyzdžiui: <tt>tekstas[2]</tt> duoda vieną raidę, kuri yra nurodytoje vietoje, šiuo atveju "<tt>R</tt>". Speciali pjaustymo operacija <tt>tekstas[:]</tt> reiškia nuo pradžios iki pabaigos ir duodą visos tekstinės reikšmės ar sąrašo (list) kopiją.

Na ir galiausiai, pjaustymo operacija gali turėti ir trečią argumentą, kuris suprantamas, kaip „žingsnio dydis“: <tt>tekstas[::-1]</tt> yra <tt>tekstas</tt> nuo pradžios iki pabaigos, kai nurodytas žingsnio dydis yra -1. Tai reiškia - kiekviena raidė, tik atvirkštine eilės tvarka. "<tt>STRING</tt>" atvirkščiai yra "<tt>GNIRTS</tt>" (jeigu nesupratai, tai pabandyk prasitestuoti įrašydamas kaip žingsnio ilgį skaičių 2).

Visos šios pjaustymo operacijos veikia ir su sąrašais (lists). Šiuo atveju tekstinę reikšmę galime suprasti, kaip sąrašą, kai visi sąrašo elementai yra atskiros raidės. Iš šio skyriaus atsimink pagrindinį principą - į viską žiūrėk taip lyg karpytum, tai padės nesusipainioti įrašant indeksus.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa reikalauja dešimtainių skaičių supratimo.
def į_tekstą(į_skaičių):
"""Konvertuoja skaičių į tekstą"""
tekstas = ""
prefiksas = ""
if į_skaičių < 0:
prefiksas = "-"
į_skaičių = -į_skaičių
while į_skaičių // 10 != 0:
out_str = str(į_skaičių % 10) + tekstas
į_skaičių= į_skaičių// 10
tekstas = str(į_skaičių % 10) + tekstas
return prefiksas + tekstas

def į_skaičių(į_tekstą):
"""Konvertuoja tekstą į skaičių"""
skaičius = 0
if į_tekstą[0] == "-":
daugiklis = -1
į_tekstą = į_tekstą[1:]
else:
daugiklis = 1
for c in į_tekstą:
skaičius = skaičius* 10 + int(c)
return skaičius * daugiklis

print(į_tekstą(2))
print(į_tekstą(23445))
print(į_tekstą(-23445))
print(į_skaičių("14234"))
print(į_skaičių("12345"))
print(į_skaičių("-3512"))
</syntaxhighlight>

Rezultatas:

2
23445
-23445
14234
12345
-3512

{{navigation |previous=Daugiau apie sąrašus |next=Failų IO}}
{{BookCat}}

Python Vadovėlis/Failų tvarkymas

2021-12-14T14:48:21Z

ZivileB:

=== Failų I/O ===

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

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

print(tekstas)
</syntaxhighlight>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print("Viso!")
</syntaxhighlight>

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

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

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

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

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

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

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

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

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

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

Užkrovimo dalis yra šiek tiek sudėtingesnė. Ji prasideda failo objekto gavimu. Tada ji naudoja <code>while True:</code> ciklą, kad tęstųsi ciklas tol, kol bus aptiktas <code>break</code> teiginys. Toliau nuskaitoma eilutė su kodu <code>skaitoma_eilutė = skaitymo_failas.readline()</code>. Pasiekus failo pabaigą, funkcija <code>readline</code> grąžins tuščią eilutę. Teiginys <code>if</code> tai patikrina ir panaudojant kodą <code>break</code> nutraukia <code>while</code> ciklą. Žinoma, jei funkcija <code>readline</code> negrąžintų naujos eilutės eilutės pabaigoje, nebūtų jokio būdo pasakyti, ar tuščia eilutė yra tuščia eilutė, ar failo pabaiga, todėl nauja eilutė įtraukiama į tai ką grąžina funckoja <code>readline</code>. Taigi turime atsikratyti tos naujos eilutės. Eilutė <code>skaitoma_eilutė = skaitoma_eilutė[:-1]</code> tai padaro už mus, išmesdama paskutinį simbolį. Toliau eilutė <code>vardas, numeris = skaitoma_eilutė.split(",")</code> padalija eilutę ties kableliu į pavadinimą ir telefono numerį. Tada tai įtraukiama į <code>numeriai</code> žodyną

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

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

Yra keletas skirtingų būdų, kaip tai padaryti. Iš tikrųjų, lengviausias būdas atidaro kitą programą, tačiau viskuo pasirūpina Python'o kodas ir vartotojui nereikia nurodyti spausdinamo failo. Šis metodas apima kitos programos subproceso (arba antrinis procesas; biblioteka 'subprocess') iškvietimą.

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

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

pagrindinis()
</syntaxhighlight>

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

=== Pratimai ===
Dabar pakeisk pažymių programą iš skyriaus [[Vadovėlis/Žodynai|Žodynai]], kad ji naudotų failus mokinių pažymiams saugoti.

{{Solution|title=Sprendimas|text=

<syntaxhighlight lang="python">
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = { }

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

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

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

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

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

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

</syntaxhighlight>

}}

{{navigation |previous=Daugiau apie tekstines eilutes |next=Susidorojimas su netobulumu}}
{{BookCat}}

Python Vadovėlis/Failų tvarkymas

2021-12-13T13:08:18Z

ZivileB:

=== Failų I/O ===

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

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

print(tekstas)
</syntaxhighlight>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

print("Viso!")
</syntaxhighlight>

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

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

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

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

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

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

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

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

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

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

Užkrovimo dalis yra šiek tiek sudėtingesnė. Ji prasideda failo objekto gavimu. Tada ji naudoja <code>while True:</code> ciklą, kad tęstųsi ciklas tol, kol bus aptiktas <code>break</code> teiginys. Toliau nuskaitoma eilutė su kodu <code>skaitoma_eilutė = skaitymo_failas.readline()</code>. Pasiekus failo pabaigą, funkcija <code>readline</code> grąžins tuščią eilutę. Teiginys <code>if</code> tai patikrina ir panaudojant kodą <code>break</code> nutraukia <code>while</code> ciklą. Žinoma, jei funkcija <code>readline</code> negrąžintų naujos eilutės eilutės pabaigoje, nebūtų jokio būdo pasakyti, ar tuščia eilutė yra tuščia eilutė, ar failo pabaiga, todėl nauja eilutė įtraukiama į tai ką grąžina funckoja <code>readline</code>. Taigi turime atsikratyti tos naujos eilutės. Eilutė <code>skaitoma_eilutė = skaitoma_eilutė[:-1]</code> tai padaro už mus, išmesdama paskutinį simbolį. Toliau eilutė <code>vardas, numeris = skaitoma_eilutė.split(",")</code> padalija eilutę ties kableliu į pavadinimą ir telefono numerį. Tada tai įtraukiama į <code>numeriai</code> žodyną

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

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

Yra keletas skirtingų būdų, kaip tai padaryti. Iš tikrųjų, lengviausias būdas atidaro kitą programą, tačiau viskuo pasirūpina Python'o kodas ir vartotojui nereikia nurodyti spausdinamo failo. Šis metodas apima kitos programos subproceso (arba antrinis procesas; biblioteka 'subprocess') iškvietimą.

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

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

pagrindinis()
</syntaxhighlight>

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

=== Pratimai ===
Dabar pakeisk pažymių programą iš skyriaus [[../Vadovėlis/Dictionaries]], kad ji naudotų failus mokinių pažymiams saugoti.

{{Solution|title=Sprendimas|text=

<syntaxhighlight lang="python">
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = { }

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

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

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

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

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

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

</syntaxhighlight>

}}

{{navigation |previous=Revenge of the Strings |next=Dealing with the imperfect}}
{{BookCat}}

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

2021-12-06T15:11:28Z

ZivileB:

== Į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'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=Intro to Object Oriented Programming in Python 3 |next=The End}}
{{BookCat}}

Python Vadovėlis/Terminai

2021-12-06T15:10:24Z

ZivileB:

Computer - kompiuteris

Container - konteineris

Control strukture - valdymo struktūra

Counter - skaitliukas

Debugging - derinimas

Directory - katalogas

Exercise - pratimas

Expression - reiškinys

False - klaidinga

Feature - ypatybė

Floating point - slankusis kablelis

Good practices - gerosios praktikos

Hard-coded - įkoduotas/užprogramuotas

IDLE - „IDLE“ kodo redaktorius/kodo redaktorius

Indent - įtrauka

Instance - objektas

Item - elementas

Iterable - iteruojamasis

List - sąrašas

Loop - ciklas

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvestis/rezultatas

Prepackaged - iš anksto paruošti paketai

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Shell - terminalas/konsolės langas

Site-packages - svetainės paketai

Solution - sprendimas

Source code - pirminis programos tekstas

Statement - sakinys

String - eilutė

Terminate - nutraukti darbą/stabdyti programą

True - teisinga

User - naudotojas

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

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

2021-12-06T15:09:50Z

ZivileB:

== Į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'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 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 ž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=Intro to Object Oriented Programming in Python 3 |next=The End}}
{{BookCat}}

Python Vadovėlis/Siekiant tobulumo

2021-12-06T15:01:43Z

ZivileB:

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

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

Dabar, kai vykdome programą ir įvedame <code>@#&</code>, programa mums pasako, kad <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> bloke.

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

{{Solution|title=Sprendimas|text=
<syntaxhighlight lang="python">
def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Išeik')
print()

numeriai = {}
meniu_pasirinkimas = 0
spausdink_meniu ()
while meniu_pasirinkimas != 5:
try:
meniu_pasirinkimas = int(input("Įvesk skaičių (1-5): "))
if meniu_pasirinkimas == 1:
print("Telefono numeriai: ")
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
print()
elif meniu_pasirinkimas == 2:
print("Pridėk vardą ir telefono numerį")
vardas = input("Vardas: ")
numeris = input("Telefono numeris: ")
numeriai[vardas] = numeris
elif meniu_pasirinkimas == 3:
print("Pašalink vardą ir telefono numerį")
vardas = input("Vardas: ")
if vardas in numeriai:
del numeriai[vardas]
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas == 4:
print("Ieškok telefono numerio")
vardas = input("Vardas: ")
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
else:
print(vardas, " nebuvo rastas")
elif meniu_pasirinkimas != 5:
print_menu()
except ValueError:
print("Tai buvo ne skaičius.")</syntaxhighlight>

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

Python Vadovėlis/Rekursinės funkcijos

2021-12-01T15:19:25Z

ZivileB:

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
resultas = daug(3, 2)
print("3 * 2 = ", resultas)
</syntaxhighlight>

Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reik 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=Defining Functions |next=Lists}}

Python Vadovėlis/Derinimas

2021-11-30T16:52:31Z

ZivileB:

=== Kas yra derinimas? ===
:„Kai tik pradėjome programuoti, mūsų nuostabai, supratome, kad nėra taip lengva kurti teisingai veikiančias programas, kaip manėme iš pradžių. Derinimas turėjo būti atrastas. Atsimenu tą akimirką, kai supratau, kad didelė mano gyvenimo dalis bus skirta klaidų ieškojimui savo sukurtose programose.“ — ''Maurice Wilkes atranda derinimą'', 1949

Jei jau bandei parašyti kelias programas, turbūt pastebėjai, kad kartais programa daro ką nors, ko neturėtų daryti. Tai yra tikrai dažna situacija. Derinimas tai yra procesas, kuomet bandoma suprasti, ką kompiuteris daro ir kaip jį priversti daryti tai, ką norėtum, kad jis darytų. Tai gali būti sudėtinga. Vieną kartą aš praleidau beveik savaitę ieškodamas ir taisydamas klaidą, kurią sukėlė kitas žmogus, kode parašęs <code>x</code> vietoje <code>y</code>.

Ši dalis bus abstraktesnė, nei prieš tai buvusios dalys.

=== Ką turėtų daryti programa? ===

Pirmas dalykas, ką reikia padaryti (kad ir kaip akivaizdžiai tai skamba), tai suprasti, ką turėtų daryti teisingai veikianti programa. Sugalvok kelis tikrinimo scenarijus ir pažiūrėk, kas nutiks. Tarkime, kad aš noriu sukurti programą, kuri suskaičiuoja stačiakampio perimetrą (visų kraštinių sumą). Turiu tokius tikrinimo scenarijus:

{| class="wikitable"
|-
!aukštis !! plotis !!perimetras
|-
|3 ||4 ||14
|--
|2 ||3 ||10
|-
|4 ||4 ||16
|-
|2 ||2 ||8
|-
|5 ||1 ||12
|-
|}

Dabar galiu vykdyti savo programą su visais tikrinimo scenarijais ir pamatyti, ar programa daro tai, ko tikiuosi. Jei ne, turiu suprasti, ką iš tiesų daro kompiuteris.

Dažniausiai, dalis tikrinimo scenarijų veikia, dalis - ne. Jei toks yra ir tavo atvejis, turėtum bandyti suprasti, ką veikiantys scenarijai turi bendro.
Pavyzdžiui, apačioje yra perimetro programos išvestis (kodas bus pateiktas kiek vėliau):

Aukštis: '''3'''
Plotis: '''4'''
Perimetras = 15

Aukštis: '''2'''
Plotis: '''3'''
Perimetras = 11

Aukštis: '''4'''
Plotis: '''4'''
Perimetras = 16

Aukštis: '''2'''
Plotis: '''2'''
Perimetras = 8

Aukštis: '''5'''
Plotis: '''1'''
Perimetras = 8

Gali pastebėti, kad programa neveikė su pirmomis dvejomis įvestimis, veikė su sekančiomis dvejomis ir vėl neveikė su paskutine. Pabandyk sugalvoti, kas yra bendro tarp veikiančių scenarijų. Kai supranti, kokia yra programos problema, atrasti jos priežastį yra daug lengviau. Jei reikia, savo programoms gali sugalvoti ir daugiau tikrinimo scenarijų.

=== Ką daro programa? ===

Kitas dalykas, ką reikia padaryti, tai peržiūrėti pirminį programos tekstą. Tai vienas iš svarbiausių dalykų programavime. Pagrindinis būdas, kaip tai daroma - tai kodo peržiūros.

Kodo peržiūra prasideda pirma eilute ir tęsiasi iki programos galo. <code>while</code> ciklai ir <code>if</code> sakiniai reiškia, kad kai kurios eilutės gali būti nekviečiamos niekada, o kai kurios - vykdomos keletą kartų. Kiekvienoje eilutėje turi suprasti, ką daro Python'as.

Pradėkime su paprasta parametro programa. Šios programos nerašyk. Tau reikės ją tik skaityti, ne vykdyti. Programos pirminis tekstas:

<syntaxhighlight lang="python">
aukstis = int(input("Aukštis: "))
plotis = int(input("Plotis: "))
print("perimetras =", plotis + aukstis + plotis + plotis)
</syntaxhighlight>

; ''Klausimas:'' Kuri eilutė vykdoma pirma?
: ''Atsakymas:'' Pirmoji kodo eilutė visada yra vykdoma pirma. Šiuo atveju tai: <code>aukstis = int(input("Aukštis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Aukštis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>aukstis</code>.
; Kuri eilutė vykdoma po to?
: Bendrai, tai yra kita eilutė, kuri yra <code>plotis= int(input("Plotis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Plotis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>plotis</code>.
; Kuri eilutė vykdoma po to?
: Kai kita eilutė nėra daugiau ar mažiau įtraukta, nei esama eilutė, ji ir yra vykdoma. Šiuo atveju tai: <code>print("perimetras =", plotis + aukstis + plotis + plotis)</code> (Taip pat gali būti kviečiama funkcija esamoje eilutėje, bet tai bus paaiškinta tolimesniame skyriuje)
; Ką daro ši eilutė?
: Visų pirma, ji spausdina <code>perimetras = </code>, o tada - sumą, sudarytą iš kintamųjų <code>plotis</code> ir <code>aukstis</code>, kuri užrašoma taip: <code>plotis + aukstis + plotis + plotis</code>.
; Ar kodas <code>plotis + aukstis + plotis + plotis</code> skaičiuoja perimetrą teisingai?
: Pažiūrėk: stačiakampio perimetras yra apatinė kraštinė (plotis), plius kairė (aukstis), plius viršutinė (plotis), plius dešinė kraštinė (a?). Paskutinis kintamasis turėtų būti dešinės kraštinės ilgis, arba kitaip - aukštis.
; Ar supranti, kodėl, kai kuriais atvejais, skaičiuojant perimetrą buvo gaunamas teisingas atsakymas?
: Teisingas atsakymas buvo gaunamas kai aukštis ir plotis buvo lygūs.

Kita programa, kurios kodo peržiūrą darysime, tai programa, kuri turėtų ekrane išvesti 5 taškus. Tačiau, programos išvestis yra:

. . . .

Programa:
<syntaxhighlight lang="python">
skaicius = 5
while skaicius > 1:
print(".",pabaiga=" ")
skaicius = skaicius - 1
print()
</syntaxhighlight>

Šios programos peržiūra bus kiek sudėtingesnė, nes joje yra įtrauktų kodo dalių. Pradėk.
; Kuri eilutė vykdoma pirma?
: Pirmoji kodo eilutė: <code>skaicius = 5</code>
; Ką ji daro?
: Priskiria skaičių 5 kintamajam <code>skaicius</code>.
; Kuri eilutė vykdoma po to?
: Kita eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Na, <code>while</code> sakiniai žiūri į juose esančius reiškinius. Jei jie yra tesingi, vykdomas kitas įtrauktas blokas. Jei klaidingi - įtrauktas blokas yra praleidžiamas.
; Tai ką ji daro šiuo atveju?
: Jei <code>skaicius > 1</code> yra teisinga, bus vykdomos kitos dvi eilutės.
; Taigi, ar <code>skaicius > 1</code>?
: Paskutinė vertė, kuri buvo priskirta <code>skaicius</code> buvo <code>5</code> ir <code>5 > 1</code>, taigi - taip.
; O kuri eilutė vykdoma po to?
: Kadangi <code>while</code> buvo teisinga, tai kita eilutė yra: <code>print(".",end=" ")</code>
; Ką daro ši eilutė?
: Spausdina vieną tašką. Kadangi funkcija turi papildomą argumentą <code>pabaiga=" "</code>, toliau spausdinamas tekstas nebus pradedamas naujoje eilutėje.
; Kuri eilutė vykdoma po to?
: <code>skaicius = skaicius - 1</code>, nes tai yra kita eilutė ir nėra jokių įtraukos pasikeitimų.
; Ką ji daro?
: Eilutė skaičiuoja <code>skaicius - 1</code>: iš esamos <code>skaicius</code> vertės (5) atimamas 1, ir tai tampa nauja kintamojo <code>skaicius</code> reikšmė. Sutrumpintai, <code>skaicius</code> vertė yra pakeičiama iš 5 į 4.
; Kuri eilutė vykdoma po to?
: Įtraukos lygis keičiasi, todėl turi žiūrėti į tai, kokią valdymo struktūrą turime. Peržiūrėk <code>while</code> ciklą, taigi turi grįžti į <code>while</code> sąlygą, kuri yra <code>while skaicius > 1:</code>
; Ką ji daro?
: Eilutė žiūri į <code>skaicius</code> reikšmę, kuri yra 4, ir lygina ją su 1. Kadangi <code>4 > 1</code>, ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo teisinga, kita eilutė yra: <code>print(".",pabaiga=" ")</code>
; Ką ji daro?
: Ekrane išspausdina dar vieną tašką, po jo padėdama tarpą.
; Kuri eilutė vykdoma po to?
: Nėra įtraukos pokyčio, todėl: <code>skaicius = skaicius - 1</code>
; Ir ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (4), atima 1, kas yra lygu 3 ir priskiria 3 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Kadangi turime įtraukos pokytį dėl ciklo, kita eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę <code>skaicius</code> reikšmę (3) su 1. <code>3 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga yra teisinga, kita eilutė: <code>print(".",pabaiga=" ")</code>
; O ji daro?
: Trečias taškas yra spausdinamas eilutėje.
; Kuri eilutė vykdoma po to?
: Tai: <code>skaicius = skaicius - 1</code>
; Ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (3), atima 1, kas yra lygu 2 ir priskiria 2 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Vėl grįžtame į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę <code>skaicius</code> reikšmę (2) su 1. <code>2 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklas tęsiasi: <code>print(".",pabaiga=" ")</code>
; Ką ji daro?
: Atranda atsakymą gyvenimui, Visatai, ir viskam. Juokauju (turėjau patikrinti, kad dar neužmigai). Eilutė spausdina ketvirtą tašką ekrane.
; Kuri eilutė vykdoma po to?
: Tai: <code>skaicius = skaicius - 1</code>
; Ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (2), atima 1, kas yra lygu 1 ir priskiria 1 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Atgal į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką daro ši eilutė?
: Ji palygina <code>skaicius</code> reikšmę (1) to 1. Kadangi <code>1 > 1</code> yra klaidinga (vienas nėra daugiau nei vienas), ciklas baigiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo klaidinga, vykdoma kita eilutė esanti už ciklo. Tai yra: <code>print()</code>
; Ką daro ši eilutė?
: Priverčia ekraną eiti į sekančią eilutę.
; Kodėl programa nespausdina 5 taškų?
: Ciklas baigiasi vienu tašku per anksti.
; Kaip tai sutvarkyti?
: Priversti ciklą baigtis vienu tašku vėliau.
; Ir kaip tai padaryti?
: Yra keli būdai. Vienas iš jų yra pakeisti ciklo sąlygą į: <code>while skaicius > 0:</code>. Kitas būdas pakeisti sąlygą į: <code>skaicius >= 1</code>. Yra ir daugiau būdų.

=== Kaip turėčiau taisyti savo programą? ===

Tau reikia suprasti, ką programa daro. Tau reikia suprasti, ką programa turėtų daryti. Suprasti, koks skirtumas tarp šių dviejų dalykų. Derinimas - tai įgūdis, kurį norint išmokti, reikia daug praktikos. Jei po valandos nepavyksta išspręsti problemos, pailsėk, pakalbėk su kuo nors apie tai. Po kurio laiko sugrįžk prie problemos ir greičiausiai turėsi naujų minčių, kaip ją įveikti. Sėkmės.

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

Python Vadovėlis/Rekursinės funkcijos

2021-11-30T16:30:53Z

ZivileB:

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 mult(a, b): #multiplication angliškai daugyba
if b == 0:
return 0
rest= mult(a, b - 1) #rest angliškai likutis
value= a + rest #value angliškai reikšmė
return value
result = mult(3, 2) #result angliškai rezultatas
print("3 * 2 = ", result)
</syntaxhighlight>

Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reik 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 mult(a, b):
if b == 0:
return 0
rest = mult(a, b - 1)
value = a + rest
return value
</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>result = mult(3, 2)</code>
; Ką daro ši eilutė?
: Ši eilutė priskiria grąžinimo reikšmę <code>mult(3, 2)</code> kintamajam <code>result</code>.
; Ką grąžina <code>mult(3, 2)</code>?
: Norėdami tai išsiaiškinti, turime peržiūrėti funkciją <code>mult()</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>rest = mult (a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>rest</code> reikšmę į <code>mult (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>mult (3,1)</code>
; Taigi kokia yra <code>mult (3, 1)</code> reikšmė?
: Turime paleisti funkciją <code>mult()</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>rest = mult (a, b - 1)</code>.
; Ką daro ši eilutė?
: Ši eilutė <code>mult (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>mult (3, 0)</code> turi reikšmę 0. Dar žinome, ką daro eilutė <code>rest = mult (a, b - 1)</code>, nes paleidžiame funkciją <code>mult()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>mult (3, 0)</code> ir dabar vėl pradedame vykdyti <code>mult (3, 1)</code>. Kintamajam <code>rest</code> priskiriama vertė 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>value = a + rest</code>. Žinome, kad <code>a = 3</code> ir <code>rest = 0</code> todėl dabar <code>value = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return value</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>mult (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>mult (3, 2)</code>.
; Kur yra <code>mult (3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>rest = mult (a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>rest</code> priskiriama reikšmė 3. Kita eilutė <code>value = a + rest</code> nustato <code>value</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>result = mult(3, 2)</code>, kuriai dabar galima priskirti reikšmę 6 kintamajam <code>result</code>
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", result)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>result</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:

mult(3, 2)
3 + mult(3, 1)
3 + 3 + mult(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=Defining Functions |next=Lists}}

Python Vadovėlis/Įvadas į objektinį programavimą Python 3

2021-11-24T17:53:31Z

ZivileB:

==Objektinis programavimas==

Iki šiol rašei kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinoti abu programavimo tipus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinio programavimo taisykles.

Pradedantiesiems ir mokiniams, neturintiems programavimo žinių, objektinis programavimas dažnai gali atrodyti painus ir tai yra visiškai normalu. Nesijausk blogai, jei nesiseka suprasti iš pat pradžių. Jei šis skyrius nepadės tau suprasti, yra ir daugiau informatyvių šaltinių, kurie padės atsakyti į visus klausimus.

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka - skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti jas visas. Nepamiršk prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvok apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Paprastai, procedūros manipuliuoja duomenis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos procedūros į kitą. Ir kai programa pasidaro per didelė, tai padaro duomenų perdavimą komplikuotą.
Pavyzdžiui, parašei programą, kuri kintamuosiuose išsaugo produkto duomenis. Kai klientas paprašo informacijos apie produktą, kintamieji, kurie turi visą informaciją, yra perduodami įvairioms funkcijoms su skirtingomis paskirtimis. Laikui bėgant ir saugant vis daugiau duomenų apie turimus produktus, tu sugalvoji išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog tavo programa veiktų, tu dabar turi redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduok kiek laiko tau reikėtų norint peržiūrėti ir pakeisti šimtus failų. Tu išprotėtum! Nekalbant apie tai, jog klaidas daro net ir labiausiai patyrę programuotojai, tad taip pat reikėtų taisyti begalę klaidų. Toks programavimas yra pernelyg neoptimalus.
Procedūrinis programavimas yra paremtas procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėk į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

* šviesa_įjungta (True False)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (True arba False)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų neišeina tiesiogiai pakeisti. Pavyzdžiui, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja), tu negalėtum pakeisti elektros tėkmės tiesiogiai. Tu taip pat negali tiesiogiai įtakoti lemputės šviesos (ne, tu negali atsukti lemputės ar jos sudaužyti!). Bet tu visada gali šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsi mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei tu įjungsi jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, „Ką tai turi bendro su Piton'u?“ ar, „Aš nesuprantu, bet kaip man sukurti tą objektą?“. Na, beveik priėjai prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Piton'e objekto atributai ir metodai yra nurodomi klasės. Galvok apie klasę kaip apie objekto techninį piešinį. Pavyzdžiui, tavo namai - objektas kuriame gyveni - taip pat jį gali vadinti butu, vasarnamiu, prakartėle ar bet kuo kitu, buvo pastatytas naudojant techinius piešinius. Šie techniniai piešiniai būtų vadinami klasėmis, kurios buvo panaudotos projektuojant tavo namus, butą, vasarnamį, na, supranti apie ką kalbu.

Dar kartą, klasė pasako, kaip sukurti objektą. Techniniais terminais tariant, ir tai yra labai svarbu, klasė nusako naudojamus duomenų atributus ir metodus objekte.

Norint sukurti klasę, mes suprogramuojame klasės apibrėžimą. Klasės apibrėžimas, tai grupė pareiškimų, kurie nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiu.
<syntaxhighlight lang="python">

# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012

# Procedūra 1
def main():
try:
# Pasiimk skaičių, kurį manipuliuosi.
sk = float(input("Įrašyk skaičių.\n"))
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 2
pridėksk= pridėkpenkis(sk)
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 3
dauginksk= daugink(pridėksk)
# Paduok skaičių procedūrai 4
rodyk(dauginksk)
# Susidorok su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalai įvesti tinkamą skaičių.\n")
# Atstatyk kintamojo num reikšmę, kad ištrintum netinkamą vartotojo įvestį.
sk = 0
# Dar kartą iškviesk main.
main()

# Procedūra 2
def pridėkpenkis(sk):
return sk + 5

# Procedūra 3
def daugink(pridėksk):
return pridėksk * 2.452

# Procedūra 4
def rodyk(dauginksk):
# Parodyk galutinį rezultatą.
print("Galutinis rezultatas yra ", dauginksk)

# Kviesk procedūrą 1
main()
</syntaxhighlight>

Jei įrašysi skaitemnį "5", gausi išvestį parodytą žemiau.

Įrašyk skaičių.
5
Galutinis rezultatas yra 24.52

Jei įrašysi reikšmę "g", tada pasitaisysi ir įrašysi skaitmenį "8", tada gausi išvestį parodytą žemiau.

Įrašyk skaičių.
g
Privalai įvesti tinkamą skaičių.

Įrašyk skaičių.
8
Galutinis rezultatas yra 31.875999999999998

Žemiau matai klasę ir programą, kuri naudoja nurodytą klasę. Ši objektinio programavimo programavimo būdu parašyta programa daro tą patį, ką prieš tai darė procedūriniu programavimo būdu parašyta programa. Apžiūrėk keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, naudok <code>class</code> raktažodį. Po raktažodžio rašyk pavadinimą, kurį norėtum, jog turėtų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu purvinoskojinės, kodas atrodytų taip:
<syntaxhighlight lang="python">
class PurvinosKojinės
</syntaxhighlight>

Iš pradžių pažiūrėk į klasę. Programa, kuri naudos šią klasę, bus parodyta paskui.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Klasė

class SkKeitimas:

def __init__(self):
self.__skaičius = 0

def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5

def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.452
</syntaxhighlight>

Programa, kuri naudoja viršuje esančią klasę yra parašyta žemiau.

<syntaxhighlight lang="python">
# Filename: ooppavyzdys.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Programa

import ooppavyzdys

maths = ooppavyzdys.SkKeitimas()

def main():

sk = float(input("Įrašyk skaičių.\n"))

pridėt = matkė.pridėkpenkis(sk)

daug = matkė.padaugink(pridėtas)

print("Galutinis rezultatas yra ", daug )

main()
</syntaxhighlight>

Tikriausiai dabar esi pasimetęs. Tai visiškai suprantama. Iš pradžių, pasistenk suprasti klasę.
Klasė yra pavadinta "SkKeitimas"
Ši klasė turi tris metodus
* __init__
* pridėkpenkis
* padaugink

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

Atkreipk dėmesį į tai, jog kiekvienas metodas turi parametrą pavadinimu „self“. Kiekvienas klasės metodas turi būtinai turėti šį parametrą. Šis parametras nebūtinai turi būti su pavadinimu „self“, bet tai yra priimta kaip gerosios praktikos, tad tikriausiai ir tu turėtum jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes, kai jis yra iškviečiamas, jis turi žinoti, su kuriuo objekto atributu turėtų atlikti operacijas. Net kai turi tik vieną objektą, turi pasirūpinti, kad programa žinotų, jog nori naudoti atributus aprašytus būtent toje klasėje. Todėl turi būti saugus ir naudoti „self“ parametrą.

Peržiūrėk pirmą metodą.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Dauguma Piton'o klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės objektas (kai sukuriame nuorodą į klasę, yra sukuriama tos klasės objektas). Šis metodas yra paprastai vadinamas inicijavimo metodu. Kai šis metodas yra paleidžiamas, „self“ parametras yra automatiškai priskiriamas tariamam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Po __init__ metodu, iš pradžių <code>skaičius</code> atributui mes priskiriame 0.
Yra sukuriama nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__skaičius = 0
</syntaxhighlight>
Kodas <code>self.__skaičius = 0</code> reiškia, jog objekte esančio „skaičius“ atributo reikšmė yra 0.

Pažiūrėk į kitą metodą.
<syntaxhighlight lang="python">
def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5
</syntaxhighlight>

Šis metodas yra pavadintas „pridėkpenkis“. Jis priima parametrą pavadinimu „sk“. Metode esanti logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina jį kviečiančiam.

Pažiūrėk į trečiajį metodą.
<syntaxhighlight lang="python">
def padaugink(self,pridėtas):
self.__pridėtas= pridėtas
return self.__pridėtas * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas „padaugink“. Jis priima parametrą pavadinimu „pridėtas“. Metodas priskiria priimtą reikšmę objekte esančiam atributui su pavadinimu „pridėtas“ ir grąžina „pridėtas“ atributo ir 2.452 sandaugą jį kviečiančiam.

Ar atkreipei dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandyk tai suprasti.
Prieš tai buvo minėta, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus galėtum pakeisti TIK SU METODAIS ESANČIAIS PAČIAME OBJEKTE. Įmanoma turėti iššorinį kodą, kuris galėtų manipuliuoti tais pačiais atributais. Norint „paslėpti“ atributus, taip, kad juos matytų metodai aprašyti pačiame objekte, turi naudoti du pabraukimus prieš objekto pavadinimą, taip kaip ir buvo rodyta. Ištrynus abu pabraukimus nuo atributo pavadinimo tu juo galėsi manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėki į programą, kuri naudoja aptartą klasę.

Atkreipk dėmesį į pirmą eilutę, kuri nėra komentaras.
<syntaxhighlight lang="python">
import ooppavyzdys
</syntaxhighlight>

Ši kodo eilutė importuoją klasę, kurią išsaugojai atskirame faile (modulyje). Klasės nebūtinai turi būti talpinamos atskiruose failuose, bet tai yra priimta kaip gerosios praktikos, tad yra verta jau nuo pat pradžių priprasti prie modulių importavimo.

Kita eilutė:
<syntaxhighlight lang="python">
matkė = ooppavyzdys.SkKeitimas()
</syntaxhighlight>

Ši eilutė sukuria SkKeitimas pavadinimu, „ooppavyzdys“ modulyje patalpintos klasės objektą, kuris yra priskiriamas „matkė“ kintamajam.
Sintaksė atrodo taip:
<code>moduliopavadinimas.Klasėspavadinimas()</code>
Apibrėžk main funkciją.
Pasiimk skaičių iš vartotojo.

Kita eilutė <code>pridėtas = matkė.pridėkpenkis(sk)</code> nusiunčia „sk“ kintamojo reikšmę metodui pavadinimu „pridėkpenkis“. Metodas yra aprašytas klasėje, kurios objektą išsaugojai kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „pridėtas“.

Kita eilutė <code>daug = matkė.daugink(pridėtas)</code> nusiunčia „pridėtas“ kintamojo reikšmę metodui pavadinimu „daugink“. Metodas yra aprašytas klasėje, kurios objektą išsaugojome kintamajame pavadinimu „matkė“. „daugink“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „daug“.

Kita eilutė atspausdina „Galutinis rezultatas yra <daug reikšmė>“. Paskutinė eilutė iškviečia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

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

Python Vadovėlis/Terminai

2021-11-24T17:48:54Z

ZivileB:

Computer - kompiuteris

Container - konteineris

Control strukture - valdymo struktūra

Counter - skaitliukas

Debugging - derinimas

Directory - katalogas

Exercise - pratimas

Expression - reiškinys

False - klaidinga

Feature - ypatybė

Floating point - slankusis kablelis

Good practices - gerosios praktikos

Hard-coded - įkoduotas/užprogramuotas

IDLE - „IDLE“ kodo redaktorius/kodo redaktorius

Indent - įtrauka

Instance - objektas

Item - elementas

Iterable - iteruojamasis

List - sąrašas

Loop - ciklas

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvestis/rezultatas

Prepackaged - iš anksto paruošti paketai

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Shell - terminalas/kosolės langas

Site-packages - svetainės paketai

Solution - sprendimas

Source code - pirminis programos tekstas

Statement - sakinys

String - eilutė

Terminate - nutraukti darbą/stabdyti programą

True - teisinga

User - naudotojas

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

Python Vadovėlis/Įvadas į objektinį programavimą Python 3

2021-11-23T17:27:33Z

ZivileB:

==Objektinis programavimas==

Iki šiol rašei kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinoti abu programavimo tipus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinio programavimo taisykles.

Pradedantiesiems ir mokiniams, neturintiems programavimo žinių, objektinis programavimas dažnai gali atrodyti painus ir tai yra visiškai normalu. Nesijausk blogai, jei nesiseka suprasti iš pat pradžių. Jei šis skyrius nepadės tau suprasti, yra ir daugiau informatyvių šaltinių, kurie padės atsakyti į visus klausimus.

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka - skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti jas visas. Nepamiršk prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvok apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Paprastai, procedūros manipuliuoja duomenis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos procedūros į kitą. Ir kai programa pasidaro per didelė, tai padaro duomenų perdavimą komplikuotą.
Pavyzdžiui, parašei programą, kuri kintamuosiuose išsaugo produkto duomenis. Kai klientas paprašo informacijos apie produktą, kintamieji, kurie turi visą informaciją, yra perduodami įvairioms funkcijoms su skirtingomis paskirtimis. Laikui bėgant ir saugant vis daugiau duomenų apie turimus produktus, tu sugalvoji išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog tavo programa veiktų, tu dabar turi redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduok kiek laiko tau reikėtų norint peržiūrėti ir pakeisti šimtus failų. Tu išprotėtum! Nekalbant apie tai, jog klaidas daro net ir labiausiai patyrę programuotojai, tad taip pat reikėtų taisyti begalę klaidų. Toks programavimas yra pernelyg neoptimalus.
Procedūrinis programavimas yra paremtas procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėk į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

* šviesa_įjungta (True False)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (True arba False)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų neišeina tiesiogiai pakeisti. Pavyzdžiui, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja), tu negalėtum pakeisti elektros tėkmės tiesiogiai. Tu taip pat negali tiesiogiai įtakoti lemputės šviesos (ne, tu negali atsukti lemputės ar jos sudaužyti!). Bet tu visada gali šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsi mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei tu įjungsi jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, „Ką tai turi bendro su Piton'u?“ ar, „Aš nesuprantu, bet kaip man sukurti tą objektą?“. Na, beveik priėjai prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Piton'e objekto atributai ir metodai yra nurodomi klasės. Galvok apie klasę kaip apie objekto techninį piešinį. Pavyzdžiui, tavo namai - objektas kuriame gyveni - taip pat jį gali vadinti butu, vasarnamiu, prakartėle ar bet kuo kitu, buvo pastatytas naudojant techinius piešinius. Šie techniniai piešiniai būtų vadinami klasėmis, kurios buvo panaudotos projektuojant tavo namus, butą, vasarnamį, na, supranti apie ką kalbu.

Dar kartą, klasė pasako, kaip sukurti objektą. Techniniais terminais tariant, ir tai yra labai svarbu, klasė nusako naudojamus duomenų atributus ir metodus objekte.

Norint sukurti klasę, mes suprogramuojame klasės apibrėžimą. Klasės apibrėžimas, tai grupė pareiškimų, kurie nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiu.
<syntaxhighlight lang="python">

# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012

# Procedūra 1
def main():
try:
# Pasiimk skaičių, kurį manipuliuosi.
sk = float(input("Įrašyk skaičių.\n"))
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 2
pridėksk= pridėkpenkis(sk)
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 3
dauginksk= daugink(pridėksk)
# Paduok skaičių procedūrai 4
rodyk(dauginksk)
# Susidorok su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalai įvesti tinkamą skaičių.\n")
# Atstatyk kintamojo num reikšmę, kad ištrintum netinkamą vartotojo įvestį.
sk = 0
# Dar kartą iškviesk main.
main()

# Procedūra 2
def pridėkpenkis(sk):
return sk + 5

# Procedūra 3
def daugink(pridėksk):
return pridėksk * 2.452

# Procedūra 4
def rodyk(dauginksk):
# Parodyk galutinį rezultatą.
print("Galutinis rezultatas yra ", dauginksk)

# Kviesk procedūrą 1
main()
</syntaxhighlight>

Jei įrašysi skaitemnį "5", gausi išvestį parodytą žemiau.

Įrašyk skaičių.
5
Galutinis rezultatas yra 24.52

Jei įrašysi reikšmę "g", tada pasitaisysi ir įrašysi skaitmenį "8", tada gausi išvestį parodytą žemiau.

Įrašyk skaičių.
g
Privalai įvesti tinkamą skaičių.

Įrašyk skaičių.
8
Galutinis rezultatas yra 31.875999999999998

Žemiau matai klasę ir programą, kuri naudoja nurodytą klasę. Ši objektinio programavimo programavimo būdu parašyta programa daro tą patį, ką prieš tai darė procedūriniu programavimo būdu parašyta programa. Apžiūrėk keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, naudok <code>class</code> raktažodį. Po raktažodžio rašyk pavadinimą, kurį norėtum, jog turėtų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu purvinoskojinės, kodas atrodytų taip:
<syntaxhighlight lang="python">
class PurvinosKojinės
</syntaxhighlight>

Iš pradžių pažiūrėk į klasę. Programa, kuri naudos šią klasę, bus parodyta paskui.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Klasė

class SkKeitimas:

def __init__(self):
self.__skaičius = 0

def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5

def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.452
</syntaxhighlight>

Programa, kuri naudoja viršuje esančią klasę yra parašyta žemiau.

<syntaxhighlight lang="python">
# Filename: ooppavyzdys.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Programa

import ooppavyzdys

maths = ooppavyzdys.SkKeitimas()

def main():

sk = float(input("Įrašyk skaičių.\n"))

pridėt = matkė.pridėkpenkis(sk)

daug = matkė.padaugink(pridėtas)

print("Galutinis rezultatas yra ", daug )

main()
</syntaxhighlight>

Tikriausiai dabar esi pasimetęs. Tai visiškai suprantama. Iš pradžių, pasistenk suprasti klasę.
Klasė yra pavadinta "SkKeitimas"
Ši klasė turi tris metodus
* __init__
* pridėkpenkis
* padaugink

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

Atkreipk dėmesį į tai, jog kiekvienas metodas turi parametrą pavadinimu „self“. Kiekvienas klasės metodas turi būtinai turėti šį parametrą. Šis parametras nebūtinai turi būti su pavadinimu „self“, bet tai yra priimta kaip geriausia praktika, tad tikriausiai ir tu turėtum jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes, kai jis yra iškviečiamas, jis turi žinoti, su kuriuo objekto atributu turėtų atlikti operacijas. Net kai turi tik vieną objektą, turi pasirūpinti, kad programa žinotų, jog nori naudoti atributus aprašytus būtent toje klasėje. Todėl turi būti saugus ir naudoti „self“ parametrą.

Peržiūrėk pirmą metodą.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Dauguma Piton'o klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija/egzempliorius (Kai sukuriame nuorodą į klasę, yra sukuriama tos klasės instancija [objektas]). Šis metodas yra paprastai vadinamas inicijavimo metodu. Kai šis metodas yra paleidžiamas, „self“ parametras yra automatiškai priskiriamas tariamam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Po __init__ metodu, iš pradžių <code>skaičius</code> atributui mes priskiriame 0.
Yra sukuriama nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__skaičius = 0
</syntaxhighlight>
Kodas <code>self.__skaičius = 0</code> reiškia, jog objekte esančio „skaičius“ atributo reikšmė yra 0.

Pažiūrėk į kitą metodą.
<syntaxhighlight lang="python">
def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5
</syntaxhighlight>

Šis metodas yra pavadintas „pridėkpenkis“. Jis priima parametrą pavadinimu „sk“. Metode esanti logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina jį kviečiančiam.

Pažiūrėk į trečiajį metodą.
<syntaxhighlight lang="python">
def padaugink(self,pridėtas):
self.__pridėtas= pridėtas
return self.__pridėtas * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas „padaugink“. Jis priima parametrą pavadinimu „pridėtas“. Metodas priskiria priimtą reikšmę objekte esančiam atributui su pavadinimu „pridėtas“ ir grąžina „pridėtas“ atributo ir 2.452 sandaugą jį kviečiančiam.

Ar atkreipei dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandyk tai suprasti.
Prieš tai buvo minėta, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus galėtum pakeisti TIK SU METODAIS ESANČIAIS PAČIAME OBJEKTE. Įmanoma turėti iššorinį kodą, kuris galėtų manipuliuoti tais pačiais atributais. Norint „paslėpti“ atributus, taip, kad juos matytų metodai aprašyti pačiame objekte, turi naudoti du pabraukimus prieš objekto pavadinimą, taip kaip ir buvo rodyta. Ištrynus abu pabraukimus nuo atributo pavadinimo tu juo galėsi manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėki į programą, kuri naudoja aptartą klasę.

Atkreipk dėmesį į pirmą eilutę, kuri nėra komentaras.
<syntaxhighlight lang="python">
import ooppavyzdys
</syntaxhighlight>

Ši kodo eilutė importuoją klasę, kurią išsaugojai atskirame faile (modulyje). Klasės nebūtinai turi būti talpinamos atskiruose failuose, bet tai yra priimta kaip gera praktika, tad yra verta jau nuo pat pradžių priprasti prie modulių importavimo.

Kita eilutė:
<syntaxhighlight lang="python">
matkė = ooppavyzdys.SkKeitimas()
</syntaxhighlight>

Ši eilutė sukuria SkKeitimas pavadinimu, „ooppavyzdys“ modulyje patalpintos klasės instanciją/egzempliorių, kuri yra priskiriama „matkė“ kintamajam.
Sintaksė atrodo taip:
<code>moduliopavadinimas.Klasėspavadinimas()</code>
Apibrėžk main funkciją.
Pasiimk skaičių iš vartotojo.

Kita eilutė <code>pridėtas = matkė.pridėkpenkis(sk)</code> nusiunčia „sk“ kintamojo reikšmę metodui pavadinimu „pridėkpenkis“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojai kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „pridėtas“.

Kita eilutė <code>daug = matkė.daugink(pridėtas)</code> nusiunčia „pridėtas“ kintamojo reikšmę metodui pavadinimu „daugink“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojome kintamajame pavadinimu „matkė“. „daugink“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „daug“.

Kita eilutė atspausdina „Galutinis rezultatas yra <daug reikšmė>“. Paskutinė eilutė iškviečia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

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

Python Vadovėlis/Įvadas į objektinį programavimą Python 3

2021-11-23T17:26:55Z

ZivileB:

==Objektinis programavimas==

Iki šiol rašei kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinoti abu programavimo tipus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinio programavimo taisykles.

Pradedantiesiems ir mokiniams, neturintiems programavimo žinių, objektinis programavimas dažnai gali atrodyti painus ir tai yra visiškai normalu. Nesijausk blogai, jei nesiseka suprasti iš pat pradžių. Jei šis skyrius nepadės tau suprasti, yra ir daugiau informatyvių šaltinių, kurie padės atsakyti į visus klausimus.

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka - skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti jas visas. Nepamiršk prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvok apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Paprastai, procedūros manipuliuoja duomenis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos procedūros į kitą. Ir kai programa pasidaro per didelė, tai padaro duomenų perdavimą komplikuotą.
Pavyzdžiui, parašei programą, kuri kintamuosiuose išsaugo produkto duomenis. Kai klientas paprašo informacijos apie produktą, kintamieji, kurie turi visą informaciją, yra perduodami įvairioms funkcijoms su skirtingomis paskirtimis. Laikui bėgant ir saugant vis daugiau duomenų apie turimus produktus, tu sugalvoji išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog tavo programa veiktų, tu dabar turi redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduok kiek laiko tau reikėtų norint peržiūrėti ir pakeisti šimtus failų. Tu išprotėtum! Nekalbant apie tai, jog klaidas daro net ir labiausiai patyrę programuotojai, tad taip pat reikėtų taisyti begalę klaidų. Toks programavimas yra pernelyg neoptimalus.
Procedūrinis programavimas yra paremtas procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėk į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

* šviesa_įjungta (True False)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (True arba False)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų neišeina tiesiogiai pakeisti. Pavyzdžiui, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja), tu negalėtum pakeisti elektros tėkmės tiesiogiai. Tu taip pat negali tiesiogiai įtakoti lemputės šviesos (ne, tu negali atsukti lemputės ar jos sudaužyti!). Bet tu visada gali šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsi mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei tu įjungsi jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, „Ką tai turi bendro su Piton'u?“ ar, „Aš nesuprantu, bet kaip man sukurti tą objektą?“. Na, beveik priėjai prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Piton'e objekto atributai ir metodai yra nurodomi klasės. Galvok apie klasę kaip apie objekto techninį piešinį. Pavyzdžiui, tavo namai - objektas kuriame gyveni - taip pat jį gali vadinti butu, vasarnamiu, prakartėle ar bet kuo kitu, buvo pastatytas naudojant techinius piešinius. Šie techniniai piešiniai būtų vadinami klasėmis, kurios buvo panaudotos projektuojant tavo namus, butą, vasarnamį, na, supranti apie ką kalbu.

Dar kartą, klasė pasako, kaip sukurti objektą. Techniniais terminais tariant, ir tai yra labai svarbu, klasė nusako naudojamus duomenų atributus ir metodus objekte.

Norint sukurti klasę, mes suprogramuojame klasės apibrėžimą. Klasės apibrėžimas, tai grupė pareiškimų, kurie nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiu.
<syntaxhighlight lang="python">

# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012

# Procedūra 1
def main():
try:
# Pasiimk skaičių, kurį manipuliuosi.
sk = float(input("Įrašyk skaičių.\n"))
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 2
pridėksk= pridėkpenkis(sk)
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 3
dauginksk= daugink(pridėksk)
# Paduok skaičių procedūrai 4
rodyk(dauginksk)
# Susidorok su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalai įvesti tinkamą skaičių.\n")
# Atstatyk kintamojo num reikšmę, kad ištrintum netinkamą vartotojo įvestį.
sk = 0
# Dar kartą iškviesk main.
main()

# Procedūra 2
def pridėkpenkis(sk):
return sk + 5

# Procedūra 3
def daugink(pridėksk):
return pridėksk * 2.452

# Procedūra 4
def rodyk(dauginksk):
# Parodyk galutinį rezultatą.
print("Galutinis rezultatas yra ", dauginksk)

# Kviesk procedūrą 1
main()
</syntaxhighlight>

Jei įrašysi skaitemnį "5", gausi išvestį parodytą žemiau.

Įrašyk skaičių.
5
Galutinis rezultatas yra 24.52

Jei įrašysi reikšmę "g", tada pasitaisysi ir įrašysi skaitmenį "8", tada gausi išvestį parodytą žemiau.

Įrašyk skaičių.
g
Privalai įvesti tinkamą skaičių.

Įrašyk skaičių.
8
Galutinis rezultatas yra 31.875999999999998

Žemiau matai klasę ir programą, kuri naudoja nurodytą klasę. Ši objektinio programavimo programavimo būdu parašyta programa daro tą patį, ką prieš tai darė procedūriniu programavimo būdu parašyta programa. Apžiūrėk keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, naudok <code>class</code> raktažodį. Po raktažodžio rašyk pavadinimą, kurį norėtum, jog turėtų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu purvinoskojinės, kodas atrodytų taip:
<syntaxhighlight lang="python">
class PurvinosKojinės
</syntaxhighlight>

Iš pradžių pažiūrėk į klasę. Programa, kuri naudos šią klasę, bus parodyta paskui.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Klasė

class SkKeitimas:

def __init__(self):
self.__skaičius = 0

def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5

def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.452
</syntaxhighlight>

Programa, kuri naudoja viršuje esančią klasę yra parašyta žemiau.

<syntaxhighlight lang="python">
# Filename: ooppavyzdys.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Programa

import ooppavyzdys

maths = ooppavyzdys.SkKeitimas()

def main():

sk = float(input("Įrašyk skaičių.\n"))

pridėt = matkė.pridėkpenkis(sk)

daug = matkė.padaugink(pridėtas)

print("Galutinis rezultatas yra ", daug )

main()
</syntaxhighlight>

Tikriausiai dabar esi pasimetęs. Tai visiškai suprantama. Iš pradžių, pasistenk suprasti klasę.
Klasė yra pavadinta "SkKeitimas"
Ši klasė turi tris metodus
* __init__
* pridėkpenkis
* padaugink

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

Atkreipkite dėmesį į tai, jog kiekvienas metodas turi parametrą pavadinimu „self“. Kiekvienas klasės metodas turi būtinai turėti šį parametrą. Šis parametras nebūtinai turi būti su pavadinimu „self“, bet tai yra priimta kaip geriausia praktika, tad tikriausiai ir tu turėtum jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes, kai jis yra iškviečiamas, jis turi žinoti, su kuriuo objekto atributu turėtų atlikti operacijas. Net kai turi tik vieną objektą, turi pasirūpinti, kad programa žinotų, jog nori naudoti atributus aprašytus būtent toje klasėje. Todėl turi būti saugus ir naudoti „self“ parametrą.

Peržiūrėk pirmą metodą.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Dauguma Piton'o klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija/egzempliorius (Kai sukuriame nuorodą į klasę, yra sukuriama tos klasės instancija [objektas]). Šis metodas yra paprastai vadinamas inicijavimo metodu. Kai šis metodas yra paleidžiamas, „self“ parametras yra automatiškai priskiriamas tariamam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Po __init__ metodu, iš pradžių <code>skaičius</code> atributui mes priskiriame 0.
Yra sukuriama nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__skaičius = 0
</syntaxhighlight>
Kodas <code>self.__skaičius = 0</code> reiškia, jog objekte esančio „skaičius“ atributo reikšmė yra 0.

Pažiūrėk į kitą metodą.
<syntaxhighlight lang="python">
def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5
</syntaxhighlight>

Šis metodas yra pavadintas „pridėkpenkis“. Jis priima parametrą pavadinimu „sk“. Metode esanti logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina jį kviečiančiam.

Pažiūrėk į trečiajį metodą.
<syntaxhighlight lang="python">
def padaugink(self,pridėtas):
self.__pridėtas= pridėtas
return self.__pridėtas * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas „padaugink“. Jis priima parametrą pavadinimu „pridėtas“. Metodas priskiria priimtą reikšmę objekte esančiam atributui su pavadinimu „pridėtas“ ir grąžina „pridėtas“ atributo ir 2.452 sandaugą jį kviečiančiam.

Ar atkreipei dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandyk tai suprasti.
Prieš tai buvo minėta, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus galėtum pakeisti TIK SU METODAIS ESANČIAIS PAČIAME OBJEKTE. Įmanoma turėti iššorinį kodą, kuris galėtų manipuliuoti tais pačiais atributais. Norint „paslėpti“ atributus, taip, kad juos matytų metodai aprašyti pačiame objekte, turi naudoti du pabraukimus prieš objekto pavadinimą, taip kaip ir buvo rodyta. Ištrynus abu pabraukimus nuo atributo pavadinimo tu juo galėsi manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėki į programą, kuri naudoja aptartą klasę.

Atkreipk dėmesį į pirmą eilutę, kuri nėra komentaras.
<syntaxhighlight lang="python">
import ooppavyzdys
</syntaxhighlight>

Ši kodo eilutė importuoją klasę, kurią išsaugojai atskirame faile (modulyje). Klasės nebūtinai turi būti talpinamos atskiruose failuose, bet tai yra priimta kaip gera praktika, tad yra verta jau nuo pat pradžių priprasti prie modulių importavimo.

Kita eilutė:
<syntaxhighlight lang="python">
matkė = ooppavyzdys.SkKeitimas()
</syntaxhighlight>

Ši eilutė sukuria SkKeitimas pavadinimu, „ooppavyzdys“ modulyje patalpintos klasės instanciją/egzempliorių, kuri yra priskiriama „matkė“ kintamajam.
Sintaksė atrodo taip:
<code>moduliopavadinimas.Klasėspavadinimas()</code>
Apibrėžk main funkciją.
Pasiimk skaičių iš vartotojo.

Kita eilutė <code>pridėtas = matkė.pridėkpenkis(sk)</code> nusiunčia „sk“ kintamojo reikšmę metodui pavadinimu „pridėkpenkis“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojai kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „pridėtas“.

Kita eilutė <code>daug = matkė.daugink(pridėtas)</code> nusiunčia „pridėtas“ kintamojo reikšmę metodui pavadinimu „daugink“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojome kintamajame pavadinimu „matkė“. „daugink“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „daug“.

Kita eilutė atspausdina „Galutinis rezultatas yra <daug reikšmė>“. Paskutinė eilutė iškviečia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

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

Python Vadovėlis/Įvadas į objektinį programavimą Python 3

2021-11-23T17:24:28Z

ZivileB:

==Objektinis programavimas==

Iki šiol rašei kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinoti abu programavimo tipus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinio programavimo taisykles.

Pradedantiesiems ir mokiniams, neturintiems programavimo žinių, objektinis programavimas dažnai gali atrodyti painus ir tai yra visiškai normalu. Nesijausk blogai, jei nesiseka suprasti iš pat pradžių. Jei šis skyrius nepadės tau suprasti, yra ir daugiau informatyvių šaltinių, kurie padės atsakyti į visus klausimus.

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka - skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti jas visas. Nepamiršk prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvok apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Paprastai, procedūros manipuliuoja duomenis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos procedūros į kitą. Ir kai programa pasidaro per didelė, tai padaro duomenų perdavimą komplikuotą.
Pavyzdžiui, parašei programą, kuri kintamuosiuose išsaugo produkto duomenis. Kai klientas paprašo informacijos apie produktą, kintamieji, kurie turi visą informaciją, yra perduodami įvairioms funkcijoms su skirtingomis paskirtimis. Laikui bėgant ir saugant vis daugiau duomenų apie turimus produktus, tu sugalvoji išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog tavo programa veiktų, tu dabar turi redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduok kiek laiko tau reikėtų norint peržiūrėti ir pakeisti šimtus failų. Tu išprotėtum! Nekalbant apie tai, jog klaidas daro net ir labiausiai patyrę programuotojai, tad taip pat reikėtų taisyti begalę klaidų. Toks programavimas yra pernelyg neoptimalus.
Procedūrinis programavimas yra paremtas procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėk į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

* šviesa_įjungta (True False)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (True arba False)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų neišeina tiesiogiai pakeisti. Pavyzdžiui, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja), tu negalėtum pakeisti elektros tėkmės tiesiogiai. Tu taip pat negali tiesiogiai įtakoti lemputės šviesos (ne, tu negali atsukti lemputės ar jos sudaužyti!). Bet tu visada gali šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsi mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei tu įjungsi jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, „Ką tai turi bendro su Piton'u?“ ar, „Aš nesuprantu, bet kaip man sukurti tą objektą?“. Na, beveik priėjai prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Piton'e objekto atributai ir metodai yra nurodomi klasės. Galvok apie klasę kaip apie objekto techninį piešinį. Pavyzdžiui, tavo namai - objektas kuriame gyveni - taip pat jį gali vadinti butu, vasarnamiu, prakartėle ar bet kuo kitu, buvo pastatytas naudojant techinius piešinius. Šie techniniai piešiniai būtų vadinami klasėmis, kurios buvo panaudotos projektuojant tavo namus, butą, vasarnamį, na, supranti apie ką kalbu.

Dar kartą, klasė pasako, kaip sukurti objektą. Techniniais terminais tariant, ir tai yra labai svarbu, klasė nusako naudojamus duomenų atributus ir metodus objekte.

Norint sukurti klasę, mes suprogramuojame klasės apibrėžimą. Klasės apibrėžimas, tai grupė pareiškimų, kurie nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiu.
<syntaxhighlight lang="python">

# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012

# Procedūra 1
def main():
try:
# Pasiimk skaičių, kurį manipuliuosi.
sk = float(input("Įrašyk skaičių.\n"))
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 2
pridėksk= pridėkpenkis(sk)
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 3
dauginksk= daugink(pridėksk)
# Paduok skaičių procedūrai 4
rodyk(dauginksk)
# Susidorok su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalai įvesti tinkamą skaičių.\n")
# Atstatyk kintamojo num reikšmę, kad ištrintum netinkamą vartotojo įvestį.
sk = 0
# Dar kartą iškviesk main.
main()

# Procedūra 2
def pridėkpenkis(sk):
return sk + 5

# Procedūra 3
def daugink(pridėksk):
return pridėksk * 2.452

# Procedūra 4
def rodyk(dauginksk):
# Parodyk galutinį rezultatą.
print("Galutinis rezultatas yra ", dauginksk)

# Kviesk procedūrą 1
main()
</syntaxhighlight>

Jei įrašysi skaitemnį "5", gausi išvestį parodytą žemiau.

Įrašyk skaičių.
5
Galutinis rezultatas yra 24.52

Jei įrašysi reikšmę "g", tada pasitaisysi ir įrašysi skaitmenį "8", tada gausi išvestį parodytą žemiau.

Įrašyk skaičių.
g
Privalai įvesti tinkamą skaičių.

Įrašyk skaičių.
8
Galutinis rezultatas yra 31.875999999999998

Žemiau matai klasę ir programą, kuri naudoja nurodytą klasę. Ši objektinio programavimo programavimo būdu parašyta programa daro tą patį, ką prieš tai darė procedūriniu programavimo būdu parašyta programa. Apžiūrėk keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, naudok <code>class</code> raktažodį. Po raktažodžio rašyk pavadinimą, kurį norėtum, jog turėtų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu purvinoskojinės, kodas atrodytų taip:
<syntaxhighlight lang="python">
class PurvinosKojinės
</syntaxhighlight>

Iš pradžių pažiūrėk į klasę. Programa, kuri naudos šią klasę, bus parodyta paskui.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Klasė

class SkKeitimas:

def __init__(self):
self.__skaičius = 0

def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5

def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.452
</syntaxhighlight>

Programa, kuri naudoja viršuje esančią klasę yra parašyta žemiau.

<syntaxhighlight lang="python">
# Filename: ooppavyzdys.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Programa

import ooppavyzdys

maths = ooppavyzdys.SkKeitimas()

def main():

sk = float(input("Įrašyk skaičių.\n"))

pridėt = matkė.pridėkpenkis(sk)

daug = matkė.padaugink(pridėtas)

print("Galutinis rezultatas yra ", daug )

main()
</syntaxhighlight>

Tikriausiai dabar esi pasimetęs. Tai visiškai suprantama. Iš pradžių, pasistenk suprasti klasę.
Klasė yra pavadinta "SkKeitimas"
Ši klasė turi tris metodus
* __init__
* pridėkpenkis
* padaugink

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

Atkreipkite dėmesį į tai, jog kiekvienas metodas turi parametrą pavadinimu „self“. Kiekvienas klasės metodas turi būtinai turėti šį parametrą. Šis parametras nebūtinai turi būti su pavadinimu „self“, bet tai yra priimta kaip geriausia praktika, tad tikriausiai ir tu turėtum jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes, kai jis yra iškviečiamas, jis turi žinoti, su kuriuo objekto atributu turėtų atlikti operacijas. Net kai turi tik vieną objektą, turi pasirūpinti, kad programa žinotų, jog nori naudoti atributus aprašytus būtent toje klasėje. Todėl turi būti saugus ir naudoti „self“ parametrą.

Peržiūrėk pirmą metodą.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Dauguma Piton'o klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija/egzempliorius (Kai sukuriame nuorodą į klasę, yra sukuriama tos klasės instancija [objektas]). Šis metodas yra paprastai vadinamas inicijavimo metodu. Kai šis metodas yra paleidžiamas, „self“ parametras yra automatiškai priskiriamas tariamam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Po __init__ metodu, iš pradžių <code>number</code> atributui mes priskiriame 0.
Yra sukuriama nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__skaičius = 0
</syntaxhighlight>
Kodas <code>self.__skaičius = 0</code> reiškia, jog objekte esančio „skaičius“ atributo reikšmė yra 0.

Pažiūrėk į kitą metodą.
<syntaxhighlight lang="python">
def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5
</syntaxhighlight>

Šis metodas yra pavadintas „pridėkpenkis“. Jis priima parametrą pavadinimu „sk“. Metode esanti logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina jį kviečiančiam.

Pažiūrėk į trečiajį metodą.
<syntaxhighlight lang="python">
def padaugink(self,pridėtas):
self.__pridėtas= pridėtas
return self.__pridėtas * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas „padaugink“. Jis priima parametrą pavadinimu „pridėtas“. Metodas priskiria priimtą reikšmę objekte esančiam atributui su pavadinimu „pridėtas“ ir grąžina „pridėtas“ atributo ir 2.452 sandaugą jį kviečiančiam.

Ar atkreipei dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandyk tai suprasti.
Prieš tai buvo minėta, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus galėtum pakeisti TIK SU METODAIS ESANČIAIS PAČIAME OBJEKTE. Įmanoma turėti iššorinį kodą, kuris galėtų manipuliuoti tais pačiais atributais. Norint „paslėpti“ atributus, taip, kad juos matytų metodai aprašyti pačiame objekte, turi naudoti du pabraukimus prieš objekto pavadinimą, taip kaip ir buvo rodyta. Ištrynus abu pabraukimus nuo atributo pavadinimo tu juo galėsi manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėki į programą, kuri naudoja aptartą klasę.

Atkreipk dėmesį į pirmą eilutę, kuri nėra komentaras.
<syntaxhighlight lang="python">
import ooppavyzdys
</syntaxhighlight>

Ši kodo eilutė importuoją klasę, kurią išsaugojai atskirame faile (modulyje). Klasės nebūtinai turi būti talpinamos atskiruose failuose, bet tai yra priimta kaip gera praktika, tad yra verta jau nuo pat pradžių priprasti prie modulių importavimo.

Kita eilutė:
<syntaxhighlight lang="python">
matkė = ooppavyzdys.SkKeitimas()
</syntaxhighlight>

Ši eilutė sukuria SkKeitimas pavadinimu, „ooppavyzdys“ modulyje patalpintos klasės instanciją/egzempliorių, kuri yra priskiriama „matkė“ kintamajam.
Sintaksė atrodo taip:
<code>moduliopavadinimas.Klasėspavadinimas()</code>
Apibrėžk main funkciją.
Pasiimk skaičių iš vartotojo.

Kita eilutė <code>pridėtas = matkė.pridėkpenkis(sk)</code> nusiunčia „sk“ kintamojo reikšmę metodui pavadinimu „pridėkpenkis“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojai kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „pridėtas“.

Kita eilutė <code>daug = matkė.daugink(pridėtas)</code> nusiunčia „pridėtas“ kintamojo reikšmę metodui pavadinimu „daugink“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojome kintamajame pavadinimu „matkė“. „daugink“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „daug“.

Kita eilutė atspausdina „Galutinis rezultatas yra <daug reikšmė>“. Paskutinė eilutė iškviečia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

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

Python Vadovėlis/Įvadas į objektinį programavimą Python 3

2021-11-23T17:23:24Z

ZivileB:

==Objektinis programavimas==

Iki šiol rašei kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinoti abu programavimo tipus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinio programavimo taisykles.

Pradedantiesiems ir mokiniams, neturintiems programavimo žinių, objektinis programavimas dažnai gali atrodyti painus ir tai yra visiškai normalu. Nesijausk blogai, jei nesiseka suprasti iš pat pradžių. Jei šis skyrius nepadės tau suprasti, yra ir daugiau informatyvių šaltinių, kurie padės atsakyti į visus klausimus.

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka - skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti jas visas. Nepamiršk prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvok apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Paprastai, procedūros manipuliuoja duomenis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos procedūros į kitą. Ir kai programa pasidaro per didelė, tai padaro duomenų perdavimą komplikuotą.
Pavyzdžiui, parašei programą, kuri kintamuosiuose išsaugo produkto duomenis. Kai klientas paprašo informacijos apie produktą, kintamieji, kurie turi visą informaciją, yra perduodami įvairioms funkcijoms su skirtingomis paskirtimis. Laikui bėgant ir saugant vis daugiau duomenų apie turimus produktus, tu sugalvoji išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog tavo programa veiktų, tu dabar turi redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduok kiek laiko tau reikėtų norint peržiūrėti ir pakeisti šimtus failų. Tu išprotėtum! Nekalbant apie tai, jog klaidas daro net ir labiausiai patyrę programuotojai, tad taip pat reikėtų taisyti begalę klaidų. Toks programavimas yra pernelyg neoptimalus.
Procedūrinis programavimas yra paremtas procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėk į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

* šviesa_įjungta (True False)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (True arba False)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų neišeina tiesiogiai pakeisti. Pavyzdžiui, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja), tu negalėtum pakeisti elektros tėkmės tiesiogiai. Tu taip pat negali tiesiogiai įtakoti lemputės šviesos (ne, tu negali atsukti lemputės ar jos sudaužyti!). Bet tu visada gali šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsi mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei tu įjungsi jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, „Ką tai turi bendro su Piton'u?“ ar, „Aš nesuprantu, bet kaip man sukurti tą objektą?“. Na, beveik priėjai prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Piton'e objekto atributai ir metodai yra nurodomi klasės. Galvok apie klasę kaip apie objekto techninį piešinį. Pavyzdžiui, tavo namai - objektas kuriame gyveni - taip pat jį gali vadinti butu, vasarnamiu, prakartėle ar bet kuo kitu, buvo pastatytas naudojant techinius piešinius. Šie techniniai piešiniai būtų vadinami klasėmis, kurios buvo panaudotos projektuojant tavo namus, butą, vasarnamį, na, supranti apie ką kalbu.

Dar kartą, klasė pasako, kaip sukurti objektą. Techniniais terminais tariant, ir tai yra labai svarbu, klasė nusako naudojamus duomenų atributus ir metodus objekte.

Norint sukurti klasę, mes suprogramuojame klasės apibrėžimą. Klasės apibrėžimas, tai grupė pareiškimų, kurie nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiu.
<syntaxhighlight lang="python">

# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012

# Procedūra 1
def main():
try:
# Pasiimk skaičių, kurį manipuliuosi.
sk = float(input("Įrašyk skaičių.\n"))
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 2
pridėksk= pridėkpenkis(sk)
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 3
dauginksk= daugink(pridėksk)
# Paduok skaičių procedūrai 4
rodyk(dauginksk)
# Susidorok su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalai įvesti tinkamą skaičių.\n")
# Atstatyk kintamojo num reikšmę, kad ištrintum netinkamą vartotojo įvestį.
sk = 0
# Dar kartą iškviesk main.
main()

# Procedūra 2
def pridėkpenkis(sk):
return sk + 5

# Procedūra 3
def daugink(pridėksk):
return pridėksk * 2.452

# Procedūra 4
def rodyk(dauginksk):
# Parodyk galutinį rezultatą.
print("Galutinis rezultatas yra ", dauginksk)

# Kviesk procedūrą 1
main()
</syntaxhighlight>

Jei įrašysi skaitemnį "5", gausi išvestį parodytą žemiau.

Įrašyk skaičių.
5
Galutinis rezultatas yra 24.52

Jei įrašysi reikšmę "g", tada pasitaisysi ir įrašysi skaitmenį "8", tada gausi išvestį parodytą žemiau.

Įrašyk skaičių.
g
Privalai įvesti tinkamą skaičių.

Įrašyk skaičių.
8
Galutinis rezultatas yra 31.875999999999998

Žemiau matai klasę ir programą, kuri naudoja nurodytą klasę. Ši objektinio programavimo programavimo būdu parašyta programa daro tą patį, ką prieš tai darė procedūriniu programavimo būdu parašyta programa. Apžiūrėk keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, naudok <code>class</code> raktažodį. Po raktažodžio rašyk pavadinimą, kurį norėtum, jog turėtų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu purvinoskojinės, kodas atrodytų taip:
<syntaxhighlight lang="python">
class PurvinosKojinės
</syntaxhighlight>

Iš pradžių pažiūrėk į klasę. Programa, kuri naudos šią klasę, bus parodyta paskui.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Klasė

class SkKeitimas:

def __init__(self):
self.__skaičius = 0

def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5

def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.452
</syntaxhighlight>

Programa, kuri naudoja viršuje esančią klasę yra parašyta žemiau.

<syntaxhighlight lang="python">
# Filename: ooppavyzdys.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Programa

import ooppavyzdys

maths = ooppavyzdys.SkKeitimas()

def main():

num = float(input("Įrašyk skaičių.\n"))

pridėt = maths.pridėkpenkis(num)

daug = maths.padaugink(pridėtas)

print("Galutinis rezultatas yra ", daug )

main()
</syntaxhighlight>

Tikriausiai dabar esi pasimetęs. Tai visiškai suprantama. Iš pradžių, pasistenk suprasti klasę.
Klasė yra pavadinta "SkKeitimas"
Ši klasė turi tris metodus
* __init__
* pridėkpenkis
* padaugink

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

Atkreipkite dėmesį į tai, jog kiekvienas metodas turi parametrą pavadinimu „self“. Kiekvienas klasės metodas turi būtinai turėti šį parametrą. Šis parametras nebūtinai turi būti su pavadinimu „self“, bet tai yra priimta kaip geriausia praktika, tad tikriausiai ir tu turėtum jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes, kai jis yra iškviečiamas, jis turi žinoti, su kuriuo objekto atributu turėtų atlikti operacijas. Net kai turi tik vieną objektą, turi pasirūpinti, kad programa žinotų, jog nori naudoti atributus aprašytus būtent toje klasėje. Todėl turi būti saugus ir naudoti „self“ parametrą.

Peržiūrėk pirmą metodą.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Dauguma Piton'o klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija/egzempliorius (Kai sukuriame nuorodą į klasę, yra sukuriama tos klasės instancija [objektas]). Šis metodas yra paprastai vadinamas inicijavimo metodu. Kai šis metodas yra paleidžiamas, „self“ parametras yra automatiškai priskiriamas tariamam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Po __init__ metodu, iš pradžių <code>number</code> atributui mes priskiriame 0.
Yra sukuriama nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__skaičius = 0
</syntaxhighlight>
Kodas <code>self.__skaičius = 0</code> reiškia, jog objekte esančio „skaičius“ atributo reikšmė yra 0.

Pažiūrėk į kitą metodą.
<syntaxhighlight lang="python">
def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5
</syntaxhighlight>

Šis metodas yra pavadintas „pridėkpenkis“. Jis priima parametrą pavadinimu „sk“. Metode esanti logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina jį kviečiančiam.

Pažiūrėk į trečiajį metodą.
<syntaxhighlight lang="python">
def padaugink(self,pridėtas):
self.__pridėtas= pridėtas
return self.__pridėtas * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas „padaugink“. Jis priima parametrą pavadinimu „pridėtas“. Metodas priskiria priimtą reikšmę objekte esančiam atributui su pavadinimu „pridėtas“ ir grąžina „pridėtas“ atributo ir 2.452 sandaugą jį kviečiančiam.

Ar atkreipei dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandyk tai suprasti.
Prieš tai buvo minėta, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus galėtum pakeisti TIK SU METODAIS ESANČIAIS PAČIAME OBJEKTE. Įmanoma turėti iššorinį kodą, kuris galėtų manipuliuoti tais pačiais atributais. Norint „paslėpti“ atributus, taip, kad juos matytų metodai aprašyti pačiame objekte, turi naudoti du pabraukimus prieš objekto pavadinimą, taip kaip ir buvo rodyta. Ištrynus abu pabraukimus nuo atributo pavadinimo tu juo galėsi manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėki į programą, kuri naudoja aptartą klasę.

Atkreipk dėmesį į pirmą eilutę, kuri nėra komentaras.
<syntaxhighlight lang="python">
import ooppavyzdys
</syntaxhighlight>

Ši kodo eilutė importuoją klasę, kurią išsaugojai atskirame faile (modulyje). Klasės nebūtinai turi būti talpinamos atskiruose failuose, bet tai yra priimta kaip gera praktika, tad yra verta jau nuo pat pradžių priprasti prie modulių importavimo.

Kita eilutė:
<syntaxhighlight lang="python">
matkė = ooppavyzdys.SkKeitimas()
</syntaxhighlight>

Ši eilutė sukuria SkKeitimas pavadinimu, „ooppavyzdys“ modulyje patalpintos klasės instanciją/egzempliorių, kuri yra priskiriama „matkė“ kintamajam.
Sintaksė atrodo taip:
<code>moduliopavadinimas.Klasėspavadinimas()</code>
Apibrėžk main funkciją.
Pasiimk skaičių iš vartotojo.

Kita eilutė <code>pridėtas = matkė.pridėkpenkis(sk)</code> nusiunčia „sk“ kintamojo reikšmę metodui pavadinimu „pridėkpenkis“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojai kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „pridėtas“.

Kita eilutė <code>daug = matkė.daugink(pridėtas)</code> nusiunčia „pridėtas“ kintamojo reikšmę metodui pavadinimu „daugink“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojome kintamajame pavadinimu „matkė“. „daugink“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „daug“.

Kita eilutė atspausdina „Galutinis rezultatas yra <daug reikšmė>“. Paskutinė eilutė iškviečia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

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

Python Vadovėlis/Įvadas į objektinį programavimą Python 3

2021-11-23T17:22:36Z

ZivileB:

==Objektinis programavimas==

Iki šiol rašei kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinoti abu programavimo tipus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinio programavimo taisykles.

Pradedantiesiems ir mokiniams, neturintiems programavimo žinių, objektinis programavimas dažnai gali atrodyti painus ir tai yra visiškai normalu. Nesijausk blogai, jei nesiseka suprasti iš pat pradžių. Jei šis skyrius nepadės tau suprasti, yra ir daugiau informatyvių šaltinių, kurie padės atsakyti į visus klausimus.

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka - skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti jas visas. Nepamiršk prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvok apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Paprastai, procedūros manipuliuoja duomenis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos procedūros į kitą. Ir kai programa pasidaro per didelė, tai padaro duomenų perdavimą komplikuotą.
Pavyzdžiui, parašei programą, kuri kintamuosiuose išsaugo produkto duomenis. Kai klientas paprašo informacijos apie produktą, kintamieji, kurie turi visą informaciją, yra perduodami įvairioms funkcijoms su skirtingomis paskirtimis. Laikui bėgant ir saugant vis daugiau duomenų apie turimus produktus, tu sugalvoji išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog tavo programa veiktų, tu dabar turi redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduok kiek laiko tau reikėtų norint peržiūrėti ir pakeisti šimtus failų. Tu išprotėtum! Nekalbant apie tai, jog klaidas daro net ir labiausiai patyrę programuotojai, tad taip pat reikėtų taisyti begalę klaidų. Toks programavimas yra pernelyg neoptimalus.
Procedūrinis programavimas yra paremtas procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėk į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

* šviesa_įjungta (True False)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (True arba False)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų neišeina tiesiogiai pakeisti. Pavyzdžiui, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja), tu negalėtum pakeisti elektros tėkmės tiesiogiai. Tu taip pat negali tiesiogiai įtakoti lemputės šviesos (ne, tu negali atsukti lemputės ar jos sudaužyti!). Bet tu visada gali šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsi mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei tu įjungsi jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, „Ką tai turi bendro su Piton'u?“ ar, „Aš nesuprantu, bet kaip man sukurti tą objektą?“. Na, beveik priėjai prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Piton'e objekto atributai ir metodai yra nurodomi klasės. Galvok apie klasę kaip apie objekto techninį piešinį. Pavyzdžiui, tavo namai - objektas kuriame gyveni - taip pat jį gali vadinti butu, vasarnamiu, prakartėle ar bet kuo kitu, buvo pastatytas naudojant techinius piešinius. Šie techniniai piešiniai būtų vadinami klasėmis, kurios buvo panaudotos projektuojant tavo namus, butą, vasarnamį, na, supranti apie ką kalbu.

Dar kartą, klasė pasako, kaip sukurti objektą. Techniniais terminais tariant, ir tai yra labai svarbu, klasė nusako naudojamus duomenų atributus ir metodus objekte.

Norint sukurti klasę, mes suprogramuojame klasės apibrėžimą. Klasės apibrėžimas, tai grupė pareiškimų, kurie nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiu.
<syntaxhighlight lang="python">

# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012

# Procedūra 1
def main():
try:
# Pasiimk skaičių, kurį manipuliuosi.
sk = float(input("Įrašyk skaičių.\n"))
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 2
pridėksk= pridėkpenkis(sk)
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 3
dauginksk= daugink(pridėksk)
# Paduok skaičių procedūrai 4
rodyk(dauginksk)
# Susidorok su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalai įvesti tinkamą skaičių.\n")
# Atstatyk kintamojo num reikšmę, kad ištrintum netinkamą vartotojo įvestį.
sk = 0
# Dar kartą iškviesk main.
main()

# Procedūra 2
def pridėkpenkis(sk):
return sk + 5

# Procedūra 3
def daugink(pridėksk):
return pridėksk * 2.452

# Procedūra 4
def rodyk(dauginksk):
# Parodyk galutinį rezultatą.
print("Galutinis rezultatas yra ", dauginksk)

# Kviesk procedūrą 1
main()
</syntaxhighlight>

Jei įrašysi skaitemnį "5", gausi išvestį parodytą žemiau.

Įrašyk skaičių.
5
Galutinis rezultatas yra 24.52

Jei įrašysi reikšmę "g", tada pasitaisysi ir įrašysi skaitmenį "8", tada gausi išvestį parodytą žemiau.

Įrašyk skaičių.
g
Privalai įvesti tinkamą skaičių.

Įrašyk skaičių.
8
Galutinis rezultatas yra 31.875999999999998

Žemiau matome klasę ir programą, kuri naudoją nurodytą klasę. Ši objektinio programavimo programavimo būdu parašyta programa daro tą patį, ką prieš tai darė procedūriniu programavimo būdu parašyta programa. Apžiūrėk keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, naudok <code>class</code> raktažodį. Po raktažodžio rašyk pavadinimą, kurį norėtum, jog turėtų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu purvinoskojinės, kodas atrodytų taip:
<syntaxhighlight lang="python">
class PurvinosKojinės
</syntaxhighlight>

Iš pradžių pažiūrėk į klasę. Programa, kuri naudos šią klasę, bus parodyta paskui.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Klasė

class SkKeitimas:

def __init__(self):
self.__skaičius = 0

def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5

def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.452
</syntaxhighlight>

Programa, kuri naudoja viršuje esančią klasę yra parašyta žemiau.

<syntaxhighlight lang="python">
# Filename: ooppavyzdys.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Programa

import ooppavyzdys

maths = ooppavyzdys.SkKeitimas()

def main():

num = float(input("Įrašyk skaičių.\n"))

pridėt = maths.pridėkpenkis(num)

daug = maths.padaugink(pridėtas)

print("Galutinis rezultatas yra ", daug )

main()
</syntaxhighlight>

Tikriausiai dabar esi pasimetęs. Tai visiškai suprantama. Iš pradžių, pasistenk suprasti klasę.
Klasė yra pavadinta "SkKeitimas"
Ši klasė turi tris metodus
* __init__
* pridėkpenkis
* padaugink

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

Atkreipkite dėmesį į tai, jog kiekvienas metodas turi parametrą pavadinimu „self“. Kiekvienas klasės metodas turi būtinai turėti šį parametrą. Šis parametras nebūtinai turi būti su pavadinimu „self“, bet tai yra priimta kaip geriausia praktika, tad tikriausiai ir tu turėtum jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes, kai jis yra iškviečiamas, jis turi žinoti, su kuriuo objekto atributu turėtų atlikti operacijas. Net kai turi tik vieną objektą, turi pasirūpinti, kad programa žinotų, jog nori naudoti atributus aprašytus būtent toje klasėje. Todėl turi būti saugus ir naudoti „self“ parametrą.

Peržiūrėk pirmą metodą.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Dauguma Piton'o klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija/egzempliorius (Kai sukuriame nuorodą į klasę, yra sukuriama tos klasės instancija [objektas]). Šis metodas yra paprastai vadinamas inicijavimo metodu. Kai šis metodas yra paleidžiamas, „self“ parametras yra automatiškai priskiriamas tariamam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Po __init__ metodu, iš pradžių <code>number</code> atributui mes priskiriame 0.
Yra sukuriama nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__skaičius = 0
</syntaxhighlight>
Kodas <code>self.__skaičius = 0</code> reiškia, jog objekte esančio „skaičius“ atributo reikšmė yra 0.

Pažiūrėk į kitą metodą.
<syntaxhighlight lang="python">
def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5
</syntaxhighlight>

Šis metodas yra pavadintas „pridėkpenkis“. Jis priima parametrą pavadinimu „sk“. Metode esanti logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina jį kviečiančiam.

Pažiūrėk į trečiajį metodą.
<syntaxhighlight lang="python">
def padaugink(self,pridėtas):
self.__pridėtas= pridėtas
return self.__pridėtas * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas „padaugink“. Jis priima parametrą pavadinimu „pridėtas“. Metodas priskiria priimtą reikšmę objekte esančiam atributui su pavadinimu „pridėtas“ ir grąžina „pridėtas“ atributo ir 2.452 sandaugą jį kviečiančiam.

Ar atkreipei dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandyk tai suprasti.
Prieš tai buvo minėta, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus galėtum pakeisti TIK SU METODAIS ESANČIAIS PAČIAME OBJEKTE. Įmanoma turėti iššorinį kodą, kuris galėtų manipuliuoti tais pačiais atributais. Norint „paslėpti“ atributus, taip, kad juos matytų metodai aprašyti pačiame objekte, turi naudoti du pabraukimus prieš objekto pavadinimą, taip kaip ir buvo rodyta. Ištrynus abu pabraukimus nuo atributo pavadinimo tu juo galėsi manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėki į programą, kuri naudoja aptartą klasę.

Atkreipk dėmesį į pirmą eilutę, kuri nėra komentaras.
<syntaxhighlight lang="python">
import ooppavyzdys
</syntaxhighlight>

Ši kodo eilutė importuoją klasę, kurią išsaugojai atskirame faile (modulyje). Klasės nebūtinai turi būti talpinamos atskiruose failuose, bet tai yra priimta kaip gera praktika, tad yra verta jau nuo pat pradžių priprasti prie modulių importavimo.

Kita eilutė:
<syntaxhighlight lang="python">
matkė = ooppavyzdys.SkKeitimas()
</syntaxhighlight>

Ši eilutė sukuria SkKeitimas pavadinimu, „ooppavyzdys“ modulyje patalpintos klasės instanciją/egzempliorių, kuri yra priskiriama „matkė“ kintamajam.
Sintaksė atrodo taip:
<code>moduliopavadinimas.Klasėspavadinimas()</code>
Apibrėžk main funkciją.
Pasiimk skaičių iš vartotojo.

Kita eilutė <code>pridėtas = matkė.pridėkpenkis(sk)</code> nusiunčia „sk“ kintamojo reikšmę metodui pavadinimu „pridėkpenkis“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojai kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „pridėtas“.

Kita eilutė <code>daug = matkė.daugink(pridėtas)</code> nusiunčia „pridėtas“ kintamojo reikšmę metodui pavadinimu „daugink“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojome kintamajame pavadinimu „matkė“. „daugink“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „daug“.

Kita eilutė atspausdina „Galutinis rezultatas yra <daug reikšmė>“. Paskutinė eilutė iškviečia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

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

Python Vadovėlis/Įvadas į objektinį programavimą Python 3

2021-11-23T17:21:53Z

ZivileB:

==Objektinis programavimas==

Iki šiol rašei kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinoti abu programavimo tipus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinio programavimo taisykles.

Pradedantiesiems ir mokiniams, neturintiems programavimo žinių, objektinis programavimas dažnai gali atrodyti painus ir tai yra visiškai normalu. Nesijausk blogai, jei nesiseka suprasti iš pat pradžių. Jei šis skyrius nepadės tau suprasti, yra ir daugiau informatyvių šaltinių, kurie padės atsakyti į visus klausimus.

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka - skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti jas visas. Nepamiršk prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvok apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Paprastai, procedūros manipuliuoja duomenis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos procedūros į kitą. Ir kai programa pasidaro per didelė, tai padaro duomenų perdavimą komplikuotą.
Pavyzdžiui, parašei programą, kuri kintamuosiuose išsaugo produkto duomenis. Kai klientas paprašo informacijos apie produktą, kintamieji, kurie turi visą informaciją, yra perduodami įvairioms funkcijoms su skirtingomis paskirtimis. Laikui bėgant ir saugant vis daugiau duomenų apie turimus produktus, tu sugalvoji išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog tavo programa veiktų, tu dabar turi redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduok kiek laiko tau reikėtų norint peržiūrėti ir pakeisti šimtus failų. Tu išprotėtum! Nekalbant apie tai, jog klaidas daro net ir labiausiai patyrę programuotojai, tad taip pat reikėtų taisyti begalę klaidų. Toks programavimas yra pernelyg neoptimalus.
Procedūrinis programavimas yra paremtas procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėk į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

* šviesa_įjungta (True False)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (True arba False)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų neišeina tiesiogiai pakeisti. Pavyzdžiui, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja), tu negalėtum pakeisti elektros tėkmės tiesiogiai. Tu taip pat negali tiesiogiai įtakoti lemputės šviesos (ne, tu negali atsukti lemputės ar jos sudaužyti!). Bet tu visada gali šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsi mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei tu įjungsi jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, „Ką tai turi bendro su Piton'u?“ ar, „Aš nesuprantu, bet kaip man sukurti tą objektą?“. Na, beveik priėjai prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Piton'e objekto atributai ir metodai yra nurodomi klasės. Galvok apie klasę kaip apie objekto techninį piešinį. Pavyzdžiui, tavo namai - objektas kuriame gyveni - taip pat jį gali vadinti butu, vasarnamiu, prakartėle ar bet kuo kitu, buvo pastatytas naudojant techinius piešinius. Šie techniniai piešiniai būtų vadinami klasėmis, kurios buvo panaudotos projektuojant tavo namus, butą, vasarnamį, na, supranti apie ką kalbu.

Dar kartą, klasė pasako, kaip sukurti objektą. Techniniais terminais tariant, ir tai yra labai svarbu, klasė nusako naudojamus duomenų atributus ir metodus objekte.

Norint sukurti klasę, mes suprogramuojame klasės apibrėžimą. Klasės apibrėžimas, tai grupė pareiškimų, kurie nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiu.
<syntaxhighlight lang="python">

# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012

# Procedūra 1
def main():
try:
# Pasiimk skaičių, kurį manipuliuosi.
sk = float(input("Įrašyk skaičių.\n"))
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 2
pridėksk= pridėkpenkis(sk)
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 3
dauginksk= daugink(pridėksk)
# Paduok skaičių procedūrai 4
rodyk(dauginksk)
# Susidorok su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalai įvesti tinkamą skaičių.\n")
# Atstatyk kintamojo num reikšmę, kad ištrintum netinkamą vartotojo įvestį.
sk = 0
# Dar kartą iškviesk main.
main()

# Procedūra 2
def pridėkpenkis(sk):
return sk + 5

# Procedūra 3
def daugink(pridėksk):
return pridėksk * 2.452

# Procedūra 4
def rodyk(dauginksk):
# Parodyk galutinį rezultatą.
print("Galutinis rezultatas yra ", dauginksk)

# Kviesk procedūrą 1
main()
</syntaxhighlight>

Jei įrašysi skaitemnį "5", gausi išvestį parodytą žemiau.

Įrašyk skaičių.
5
Galutinis rezultatas yra 24.52

Jei įrašysi reikšmę "g", tada pasitaisysi ir įrašysi skaitmenį "8", tada gausi išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalai įvesti tinkamą skaičių.

Įrašyk skaičių.
8
Galutinis rezultatas yra 31.875999999999998

Žemiau matome klasę ir programą, kuri naudoją nurodytą klasę. Ši objektinio programavimo programavimo būdu parašyta programa daro tą patį, ką prieš tai darė procedūriniu programavimo būdu parašyta programa. Apžiūrėk keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, naudok <code>class</code> raktažodį. Po raktažodžio rašyk pavadinimą, kurį norėtum, jog turėtų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu purvinoskojinės, kodas atrodytų taip:
<syntaxhighlight lang="python">
class PurvinosKojinės
</syntaxhighlight>

Iš pradžių pažiūrėk į klasę. Programa, kuri naudos šią klasę, bus parodyta paskui.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Klasė

class SkKeitimas:

def __init__(self):
self.__skaičius = 0

def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5

def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.452
</syntaxhighlight>

Programa, kuri naudoja viršuje esančią klasę yra parašyta žemiau.

<syntaxhighlight lang="python">
# Filename: ooppavyzdys.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Programa

import ooppavyzdys

maths = ooppavyzdys.SkKeitimas()

def main():

num = float(input("Įrašyk skaičių.\n"))

pridėt = maths.pridėkpenkis(num)

daug = maths.padaugink(pridėtas)

print("Galutinis rezultatas yra ", daug )

main()
</syntaxhighlight>

Tikriausiai dabar esi pasimetęs. Tai visiškai suprantama. Iš pradžių, pasistenk suprasti klasę.
Klasė yra pavadinta "SkKeitimas"
Ši klasė turi tris metodus
* __init__
* pridėkpenkis
* padaugink

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

Atkreipkite dėmesį į tai, jog kiekvienas metodas turi parametrą pavadinimu „self“. Kiekvienas klasės metodas turi būtinai turėti šį parametrą. Šis parametras nebūtinai turi būti su pavadinimu „self“, bet tai yra priimta kaip geriausia praktika, tad tikriausiai ir tu turėtum jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes, kai jis yra iškviečiamas, jis turi žinoti, su kuriuo objekto atributu turėtų atlikti operacijas. Net kai turi tik vieną objektą, turi pasirūpinti, kad programa žinotų, jog nori naudoti atributus aprašytus būtent toje klasėje. Todėl turi būti saugus ir naudoti „self“ parametrą.

Peržiūrėk pirmą metodą.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Dauguma Piton'o klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija/egzempliorius (Kai sukuriame nuorodą į klasę, yra sukuriama tos klasės instancija [objektas]). Šis metodas yra paprastai vadinamas inicijavimo metodu. Kai šis metodas yra paleidžiamas, „self“ parametras yra automatiškai priskiriamas tariamam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Po __init__ metodu, iš pradžių <code>number</code> atributui mes priskiriame 0.
Yra sukuriama nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__skaičius = 0
</syntaxhighlight>
Kodas <code>self.__skaičius = 0</code> reiškia, jog objekte esančio „skaičius“ atributo reikšmė yra 0.

Pažiūrėk į kitą metodą.
<syntaxhighlight lang="python">
def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5
</syntaxhighlight>

Šis metodas yra pavadintas „pridėkpenkis“. Jis priima parametrą pavadinimu „sk“. Metode esanti logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina jį kviečiančiam.

Pažiūrėk į trečiajį metodą.
<syntaxhighlight lang="python">
def padaugink(self,pridėtas):
self.__pridėtas= pridėtas
return self.__pridėtas * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas „padaugink“. Jis priima parametrą pavadinimu „pridėtas“. Metodas priskiria priimtą reikšmę objekte esančiam atributui su pavadinimu „pridėtas“ ir grąžina „pridėtas“ atributo ir 2.452 sandaugą jį kviečiančiam.

Ar atkreipei dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandyk tai suprasti.
Prieš tai buvo minėta, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus galėtum pakeisti TIK SU METODAIS ESANČIAIS PAČIAME OBJEKTE. Įmanoma turėti iššorinį kodą, kuris galėtų manipuliuoti tais pačiais atributais. Norint „paslėpti“ atributus, taip, kad juos matytų metodai aprašyti pačiame objekte, turi naudoti du pabraukimus prieš objekto pavadinimą, taip kaip ir buvo rodyta. Ištrynus abu pabraukimus nuo atributo pavadinimo tu juo galėsi manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėki į programą, kuri naudoja aptartą klasę.

Atkreipk dėmesį į pirmą eilutę, kuri nėra komentaras.
<syntaxhighlight lang="python">
import ooppavyzdys
</syntaxhighlight>

Ši kodo eilutė importuoją klasę, kurią išsaugojai atskirame faile (modulyje). Klasės nebūtinai turi būti talpinamos atskiruose failuose, bet tai yra priimta kaip gera praktika, tad yra verta jau nuo pat pradžių priprasti prie modulių importavimo.

Kita eilutė:
<syntaxhighlight lang="python">
matkė = ooppavyzdys.SkKeitimas()
</syntaxhighlight>

Ši eilutė sukuria SkKeitimas pavadinimu, „ooppavyzdys“ modulyje patalpintos klasės instanciją/egzempliorių, kuri yra priskiriama „matkė“ kintamajam.
Sintaksė atrodo taip:
<code>moduliopavadinimas.Klasėspavadinimas()</code>
Apibrėžk main funkciją.
Pasiimk skaičių iš vartotojo.

Kita eilutė <code>pridėtas = matkė.pridėkpenkis(sk)</code> nusiunčia „sk“ kintamojo reikšmę metodui pavadinimu „pridėkpenkis“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojai kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „pridėtas“.

Kita eilutė <code>daug = matkė.daugink(pridėtas)</code> nusiunčia „pridėtas“ kintamojo reikšmę metodui pavadinimu „daugink“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojome kintamajame pavadinimu „matkė“. „daugink“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „daug“.

Kita eilutė atspausdina „Galutinis rezultatas yra <daug reikšmė>“. Paskutinė eilutė iškviečia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

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

Python Vadovėlis/Įvadas į objektinį programavimą Python 3

2021-11-23T17:14:17Z

ZivileB:

==Objektinis programavimas==

Iki šiol rašei kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinoti abu programavimo tipus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinio programavimo taisykles.

Pradedantiesiems ir mokiniams, neturintiems programavimo žinių, objektinis programavimas dažnai gali atrodyti painus ir tai yra visiškai normalu. Nesijausk blogai, jei nesiseka suprasti iš pat pradžių. Jei šis skyrius nepadės tau suprasti, yra ir daugiau informatyvių šaltinių, kurie padės atsakyti į visus klausimus.

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka - skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti jas visas. Nepamiršk prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvok apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Paprastai, procedūros manipuliuoja duomenis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos procedūros į kitą. Ir kai programa pasidaro per didelė, tai padaro duomenų perdavimą komplikuotą.
Pavyzdžiui, parašei programą, kuri kintamuosiuose išsaugo produkto duomenis. Kai klientas paprašo informacijos apie produktą, kintamieji, kurie turi visą informaciją, yra perduodami įvairioms funkcijoms su skirtingomis paskirtimis. Laikui bėgant ir saugant vis daugiau duomenų apie turimus produktus, tu sugalvoji išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog tavo programa veiktų, tu dabar turi redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduok kiek laiko tau reikėtų norint peržiūrėti ir pakeisti šimtus failų. Tu išprotėtum! Nekalbant apie tai, jog klaidas daro net ir labiausiai patyrę programuotojai, tad taip pat reikėtų taisyti begalę klaidų. Toks programavimas yra pernelyg neoptimalus.
Procedūrinis programavimas yra paremtas procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėk į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

* šviesa_įjungta (True False)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (True arba False)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų neišeina tiesiogiai pakeisti. Pavyzdžiui, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja), tu negalėtum pakeisti elektros tėkmės tiesiogiai. Tu taip pat negali tiesiogiai įtakoti lemputės šviesos (ne, tu negali atsukti lemputės ar jos sudaužyti!). Bet tu visada gali šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsi mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei tu įjungsi jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, „Ką tai turi bendro su Piton'u?“ ar, „Aš nesuprantu, bet kaip man sukurti tą objektą?“. Na, beveik priėjai prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Piton'e objekto atributai ir metodai yra nurodomi klasės. Galvok apie klasę kaip apie objekto techninį piešinį. Pavyzdžiui, tavo namai - objektas kuriame gyveni - taip pat jį gali vadinti butu, vasarnamiu, prakartėle ar bet kuo kitu, buvo pastatytas naudojant techinius piešinius. Šie techniniai piešiniai būtų vadinami klasėmis, kurios buvo panaudotos projektuojant tavo namus, butą, vasarnamį, na, supranti apie ką kalbu.

Dar kartą, klasė pasako, kaip sukurti objektą. Techniniais terminais tariant, ir tai yra labai svarbu, klasė nusako naudojamus duomenų atributus ir metodus objekte.

Norint sukurti klasę, mes suprogramuojame klasės apibrėžimą. Klasės apibrėžimas, tai grupė pareiškimų, kurie nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiu.
<syntaxhighlight lang="python">

# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012

# Procedūra 1
def main():
try:
# Pasiimk skaičių, kurį manipuliuosi.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugok naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atlik matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduok skaičių procedūrai 4
display(multipliednum)
# Susidorok su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalai įvesti tinkamą skaičių.\n")
# Atstatyk kintamojo num reikšmę, kad ištrintum netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviesk main.
main()

# Procedūra 2
def addfive(num):
return num + 5

# Procedūra 3
def multiply(addednum):
return addednum * 2.452

# Procedūra 4
def display(multi):
# Parodyk galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviesk procedūrą 1
main()
</syntaxhighlight>

Jei įrašysi skaitemnį "5", gausi išvestį parodytą žemiau.

Įrašyk skaičių.
5
Galutinis rezultatas yra 24.52

Jei įrašysi reikšmę "g", tada pasitaisysi ir įrašysi skaitmenį "8", tada gausi išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalai įvesti tinkamą skaičių.

Įrašyk skaičių.
8
Galutinis rezultatas yra 31.875999999999998

Žemiau matome klasę ir programą, kuri naudoją nurodytą klasę. Ši objektinio programavimo programavimo būdu parašyta programa daro tą patį, ką prieš tai darė procedūriniu programavimo būdu parašyta programa. Apžiūrėk keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, naudok <code>class</code> raktažodį. Po raktažodžio rašyk pavadinimą, kurį norėtum, jog turėtų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu purvinoskojinės, kodas atrodytų taip:
<syntaxhighlight lang="python">
class PurvinosKojinės
</syntaxhighlight>

Iš pradžių pažiūrėk į klasę. Programa, kuri naudos šią klasę, bus parodyta paskui.

<syntaxhighlight lang="python">
# Failo pavadinimas: ooppavyzdys.py
# Programa parašyta Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Klasė

class SkKeitimas:

def __init__(self):
self.__skaičius = 0

def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5

def padaugink(self,pridėtas):
self.__pridėtas = pridėtas
return self.__pridėtas * 2.452
</syntaxhighlight>

Programa, kuri naudoja viršuje esančią klasę yra parašyta žemiau.

<syntaxhighlight lang="python">
# Filename: ooppavyzdys.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstracija - Programa

import ooppavyzdys

maths = ooppavyzdys.SkKeitimas()

def main():

num = float(input("Įrašyk skaičių.\n"))

pridėt = maths.pridėkpenkis(num)

daug = maths.padaugink(pridėtas)

print("Galutinis rezultatas yra ", daug )

main()
</syntaxhighlight>

Tikriausiai dabar esi pasimetęs. Tai visiškai suprantama. Iš pradžių, pasistenk suprasti klasę.
Klasė yra pavadinta "SkKeitimas"
Ši klasė turi tris metodus
* __init__
* pridėkpenkis
* padaugink

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

Atkreipkite dėmesį į tai, jog kiekvienas metodas turi parametrą pavadinimu „self“. Kiekvienas klasės metodas turi būtinai turėti šį parametrą. Šis parametras nebūtinai turi būti su pavadinimu „self“, bet tai yra priimta kaip geriausia praktika, tad tikriausiai ir tu turėtum jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes, kai jis yra iškviečiamas, jis turi žinoti, su kuriuo objekto atributu turėtų atlikti operacijas. Net kai turi tik vieną objektą, turi pasirūpinti, kad programa žinotų, jog nori naudoti atributus aprašytus būtent toje klasėje. Todėl turi būti saugus ir naudoti „self“ parametrą.

Peržiūrėk pirmą metodą.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Dauguma Piton'o klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija/egzempliorius (Kai sukuriame nuorodą į klasę, yra sukuriama tos klasės instancija [objektas]). Šis metodas yra paprastai vadinamas inicijavimo metodu. Kai šis metodas yra paleidžiamas, „self“ parametras yra automatiškai priskiriamas tariamam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Po __init__ metodu, iš pradžių <code>number</code> atributui mes priskiriame 0.
Yra sukuriama nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__skaičius = 0
</syntaxhighlight>
Kodas <code>self.__skaičius = 0</code> reiškia, jog objekte esančio „skaičius“ atributo reikšmė yra 0.

Pažiūrėk į kitą metodą.
<syntaxhighlight lang="python">
def pridėkpenkis(self,sk):
self.__skaičius = sk
return self.__skaičius + 5
</syntaxhighlight>

Šis metodas yra pavadintas „pridėkpenkis“. Jis priima parametrą pavadinimu „sk“. Metode esanti logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina jį kviečiančiam.

Pažiūrėk į trečiajį metodą.
<syntaxhighlight lang="python">
def padaugink(self,pridėtas):
self.__pridėtas= pridėtas
return self.__pridėtas * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas „padaugink“. Jis priima parametrą pavadinimu „pridėtas“. Metodas priskiria priimtą reikšmę objekte esančiam atributui su pavadinimu „pridėtas“ ir grąžina „pridėtas“ atributo ir 2.452 sandaugą jį kviečiančiam.

Ar atkreipei dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandyk tai suprasti.
Prieš tai buvo minėta, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus galėtum pakeisti TIK SU METODAIS ESANČIAIS PAČIAME OBJEKTE. Įmanoma turėti iššorinį kodą, kuris galėtų manipuliuoti tais pačiais atributais. Norint „paslėpti“ atributus, taip, kad juos matytų metodai aprašyti pačiame objekte, turi naudoti du pabraukimus prieš objekto pavadinimą, taip kaip ir buvo rodyta. Ištrynus abu pabraukimus nuo atributo pavadinimo tu juo galėsi manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėki į programą, kuri naudoja aptartą klasę.

Atkreipk dėmesį į pirmą eilutę, kuri nėra komentaras.
<syntaxhighlight lang="python">
import ooppavyzdys
</syntaxhighlight>

Ši kodo eilutė importuoją klasę, kurią išsaugojai atskirame faile (modulyje). Klasės nebūtinai turi būti talpinamos atskiruose failuose, bet tai yra priimta kaip gera praktika, tad yra verta jau nuo pat pradžių priprasti prie modulių importavimo.

Kita eilutė:
<syntaxhighlight lang="python">
matkė = ooppavyzdys.SkKeitimas()
</syntaxhighlight>

Ši eilutė sukuria SkKeitimas pavadinimu, „ooppavyzdys“ modulyje patalpintos klasės instanciją/egzempliorių, kuri yra priskiriama „matkė“ kintamajam.
Sintaksė atrodo taip:
<code>moduliopavadinimas.Klasėspavadinimas()</code>
Apibrėžk main funkciją.
Pasiimk skaičių iš vartotojo.

Kita eilutė <code>pridėtas = matkė.pridėkpenkis(sk)</code> nusiunčia „sk“ kintamojo reikšmę metodui pavadinimu „pridėkpenkis“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojai kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „pridėtas“.

Kita eilutė <code>daug = matkė.daugink(pridėtas)</code> nusiunčia „pridėtas“ kintamojo reikšmę metodui pavadinimu „daugink“. Metodas yra aprašytas klasėje, kurios instanciją išsaugojome kintamajame pavadinimu „matkė“. „daugink“ metodas išsaugo gautą reikšmę į kintamajį pavadinimu „daug“.

Kita eilutė atspausdina „Galutinis rezultatas yra <daug reikšmė>“. Paskutinė eilutė iškviečia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

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

Python Vadovėlis/Labas, Pasauli

2021-11-23T16:25:31Z

ZivileB:

=== Ką sužinosi? ===
Perskaitęs šį skyrių, turėtum suprasti, kaip redaguoti programas teksto redaktoriuje arba kitaip vadinamam „IDLE“ kodo redaktoriuje, kaip programas išsaugoti kompiuterio atmintyje ir paprastai paleisti.

=== Spausdinimas ===
Istoriškai taip susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programos pavadinimu „Hello, World!“ arba lietuviškai [[„Labas, Pasauli!“]].

Python'as programavimo kalboje programa atrodytų taip:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

Jeigu naudoji paprastą kompiuterio tekstinį failą (.txt) programai rašyti - išsaugok šį failą ir pervadink, kad jis būtų <code>hello.py</code> ir kodo redaktoriuje paleisk programą parašęs eilutę <code>python3 hello.py</code>

Kitu atveju eik į „IDLE“ kodo redaktorių, sukurk naują langą ir tada sukurk programą, kaip aprašyta skyriuje [[Non-Programmer's Tutorial for Python 3/Intro#Creating_and_Running_Programs|Programų kūrimas ir paleidimas]].

Kai paleisi šią programą, tuomet ji suveiks ir užrašys:

Labas, Pasauli!

Įsidėmėk, kad rekomenduojame visus mūsų pateikiamus programos pavyzdžius pasibandyti pačiam - užrašyk ir tada pasileisk programą. Pagal mūsų turimą praktiką, toks mokymosi procesas yra pats efektyviausias ir geriausiai pasiteisinantis.

Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:

<syntaxhighlight lang="python">
print("Benas ir Liepa pakilo į kalną")
print("Kad atneštų indą pilną vandens.")
print("Benas nukrito ir sulaužė savo karūną,")
print("O Liepa suklupo iškart.")
</syntaxhighlight>

Kai paleidi šią programą, tai ji parašo trumpą istoriją:

Benas ir Liepa pakilo į kalną
Kad atneštų indą pilną vandens.
Benas nukrito ir suslaužė savo karūną,
O Liepa suklupo iškart.

Kai kompiuteris paleidžia programą, tai pirmiausia jis mato:

<syntaxhighlight lang="python">
print("Benas ir Liepa pakilo į kalną")
</syntaxhighlight>

Todėl kompiuteris užrašo:

Benas ir Liepa pakilo į kalną

Tada kompiuteris skaito kitą eilutę ir mato:

<syntaxhighlight lang="python">
print("Kad atneštų indą pilna vandens.")
</syntaxhighlight>

Todėl ir ją užrašo kompiuterio ekrane:

Kad atneštų indą pilna vandens.

Taip kompiuteris žiūri į kiekvieną eilutę, o tada įvykdo duotą komandą ir eina toliau: skaito eilutę, įvykdo komandą ir t.t. Taip kompiuteris vykdo visas duotas komandas, kol pasiekia programos pabaigą.

==== Terminologija ====
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.

Prieš tai rašydami kodą, mes naudojamės „funkcija“ pavadinimu <code>print</code> arba „Angyje“ [[Rašymas|<code>rašyk</code>.]] Po funkcijos pavadinimo <code>print</code> yra skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

yra vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Paprastai, tai vadiname „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme). Kitas tekstinės reikšmės pavyzdys yra <code>"Benas ir Liepa pakilo į kalną"</code>. Na, o funkcijos iškvietimu vadiname eilutę, kurioje yra užrašytas funkcijos pavadinimas ir parametras esantis skliausteliuose.

Funkcija ir jos argumentai yra vieno tipo „teiginys“, kurį galima naudoti Python'o programavimo kalboje. Teiginio pavyzdys:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

Paprasčiau tariant, teiginį gali įsivaizduoti kaip vieną programos eilutę.

Kol kas terminologijos pakaks, keliaujam į kitą poskyrį ir mokomės toliau.

====\n rašyme====
<code>\n</code>, arba nauja eilutė. Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Taip pat <code>\n</code> gali būti naudojamas kaip „pabėgimo simbolis“ (escape character). Pabandyk suprasti šią programą:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\nKą turėčiau daryti?")
</syntaxhighlight>

Kurios rezultatas yra toks:

Labas, Pasauli!
Ką turėčiau daryti?

Taip pat <code>\n</code> naudojamas, kai norime tekstą perkelti į kitą eilutę, bet nenorime naudoti kelių <code>print()</code> komandų.

Be to, spausdinimo teiginys automatiškai naudoja <code>\n</code>, net jeigu pats <code>\n</code> ir neužrašai. Paprasčiau suprasti bus pamačius pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

iš tikrųjų yra:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\n")
</syntaxhighlight>

=== Išraiškos ===
Programos pavyzdys:

<syntaxhighlight lang="python">
print("2 + 2 yra", 2 + 2)
print("3 * 4 yra", 3 * 4)
print("100 - 1 yra", 100 - 1)
print("("(33 + 2) / 5 + 11.5 yra", (33 + 2) / 5 + 11.5)
</syntaxhighlight>

„Angyje“:
<syntaxhighlight lang="python">
rašyk("2 + 2 yra", 2 + 2)
rašyk("3 * 4 yra", 3 * 4)
rašyk("100 - 1 yra", 100 - 1)
rašyk("(33 + 2) / 5 + 11.5 yra", (33 + 2) / 5 + 11.5)
</syntaxhighlight>

Rezultatas:

2 + 2 yra 4
3 * 4 yra 12
100 - 1 yra 99
(33 + 2) / 5 + 11.5 yra 18.5

==== Aritmetinės išraiškos ====

Šiame pavyzdyje, <code>print()</code>(rašymo) funkcija yra su dvejais argumentais, kurie yra atskirti kableliu. Taigi pirmoje programos eilutėje

<syntaxhighlight lang="python">
print("2 + 2 yra", 2 + 2)
</syntaxhighlight>

Pirmas argumentas yra teksto eilutė <code>"2 + 2 yra"</code> ir antras argumentas yra aritmetinė išraiška <code>2 + 2</code>, tiksliau tariant viena iš aritmetinių išraiškų.

Atkreipk dėmesį, kad eilutė, kuri yra užrašyta kabutėse yra atspausdinama kaip tekstas, o išraiška užrašyta be kabučių yra apskaičiuojama ir užrašomas atsakymas.

Python'o programavimo kalba turi septynias pagrindines skaičių operacijas.

{| class="wikitable"
! Operacija
! Simbolis
! Pavyzdys
|-
|Kėlimas laipsniu (exponentiation)
| <code>**</code>
| <code>5 ** 2 == 25</code>
|-
|Daugyba
| <code>*</code>
|<code>2 * 3 == 6</code>
|-
|Dalyba
| <code>/</code>
| <code>14 / 3 == 4.666666666666667</code>
|-
|Sveikųjų skaičių dalyba
| <code>//</code>
| <code>14 // 3 == 4</code>
|-
|Liekana (modulis)
| <code>%</code>
| <code>14 % 3 == 2</code>
|-
|Sudėtis
| <code>+</code>
| <code>1 + 2 == 3</code>
|-
|Atimtis
| <code>-</code>
| <code>4 - 3 == 1</code>
|}

Atkreipk dėmesį, kad yra du dalybos būdai: vienas grąžina pasikartojantį dešimtainį skaičių, o kitas - liekaną ir visą skaičių.
Operacijų tvarka tokia pati kaip matematikoje:
* skliausteliuose <code>()</code>
* rodikliai <code>**</code>
* daugyba <code>*</code>, dalyba<code>/</code>, sveikųjų skaičių dalyba <code>//</code>, dalyba su liekana <code>%</code>
* sudėtis <code>+</code> ir atimtis <code>-</code>

Taigi naudok skliaustelius užrašydamas formules.

=== Komentarai ===

Rašant daug kodo, ateityje tikrai ne viską atsiminsite. Todėl programoje galime naudoti komentarus, kurie gali būti naudojami kaip pastabos/paaiškinimai jums arba kitiems programuotojams. Pavyzdžiui:

<syntaxhighlight lang="python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22 / 7)
</syntaxhighlight>

Rezultatas:

3.14285714286

Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra naudojami ateičiai arba kitiems žmonėms, kurie skaito programą.

Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris šio teksto nepaisys tol, kol atsiras tekstas naujos eilutės pradžioje.

<syntaxhighlight lang = "python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22/7) # Jeigu būtume preciziškai tikslūs, tai čia gauname tik apytikslią PI reikšmę
</syntaxhighlight>

=== Pavyzdžiai ===
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python kodo redaktorių ir pažiūrėti kaip viekia. Jeigu suprasi, keliauk toliau, jeigu ne, bandyk dar kartą perskaityti skyriaus medžiagą ir suprasti pavyzdžių logiką.

'''Danija.py'''

<syntaxhighlight lang="python">
print("Būti ar nebūti, štai kur klausimas.")
print(" -- Šekspyras")
</syntaxhighlight>

Rezultatas:

Būti ar nebūti, štai kur klausimas.
-- Šekspyras

'''Mokykla.py'''

<syntaxhighlight lang="python">
print("Pirmoji klasė")
print("1 + 1 =", 1 + 1)
print("2 + 4 =", 2 + 4)
print("5 - 2 =", 5 - 2)
print()
print("Trečioji klasė")
print("243 - 23 =", 243 - 23)
print("12 * 4 =", 12 * 4)
print("12 / 3 =", 12 / 3)
print("13 / 3 =", 13 // 3, "R", 13 % 3)
print()
print("Vidurinė)
print("123.56 - 62.12 =", 123.56 - 62.12)
print("(4 + 3) * 2 =", (4 + 3) * 2)
print("4 + 3 * 2 =", 4 + 3 * 2)
print("3 ** 2 =", 3 ** 2)
</syntaxhighlight>

Rezultatas:

Pirma klasė
1 + 1 = 2
2 + 4 = 6
5 - 2 = 3

Trečia klasė
243 - 23 = 220
12 * 4 = 48
12 / 3 = 4
13 / 3 = 4 R 1

Vidurinė
123.56 - 62.12 = 61.44
(4 + 3) * 2 = 14
4 + 3 * 2 = 10
3 ** 2 = 9

=== Pratimai ===

# Parašyk programą, kuri atspausdintų tavo vardą ir gimimo datą atskirose eilutėse
# Parašyk programą, kuri parodytų visų 7 [[#Arithmetic_expressions|artimetinių operacijų]] panaudojimą.

{{Solution|title=Sprendimas|text=

1. Parašyk programą, kuri atspausdintų tavo vardą ir gimimo datą atskirose eilutėse
<syntaxhighlight lang="python">
print("Ada Lovelace", "gimusi", "lapkričio 27, 1852")
</syntaxhighlight>

<syntaxhighlight lang="python">
print("Albertas Einšteinas", "gimęs", "14 kovo 1879")
</syntaxhighlight>

<syntaxhighlight lang="python">
print(("Jonas Smitas"), ("gimęs"), ("14 kovo 1879"))
</syntaxhighlight>
}}

{{Solution|title=Sprendimas|text=
2. Parašyk programą, kuri parodytų visų 7 [[#Arithmetic_expressions|artimetinių operacijų]] panaudojimą.
<syntaxhighlight lang="python">
print("5**5 = ", 5**5)
print("6*7 = ", 6*7)
print("56/8 = ", 56/8)
print("14//6 = ", 14//6)
print("14%6 = ", 14%6)
print("5+6 = ", 5+6)
print("9-0 = ", 9-0)
</syntaxhighlight>
}}

----
==== Išnašos====

{{navigation |previous=Intro |next=Who Goes There?}}

Python Vadovėlis/Terminai

2021-11-23T16:03:23Z

ZivileB:

Computer - kompiuteris

Container - konteineris

Control strukture - valdymo struktūra

Counter - skaitliukas

Debugging - derinimas

Directory - katalogas

Exercise - pratimas

Expression - reiškinys

False - klaidinga

Feature - ypatybė

Floating point - slankusis kablelis

Hard-coded - įkoduotas/užprogramuotas

IDLE - „IDLE“ kodo redaktorius/kodo redaktorius

Indent - įtrauka

Item - elementas

Iterable - iteruojamasis

List - sąrašas

Loop - ciklas

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvestis/rezultatas

Prepackaged - iš anksto paruošti paketai

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Shell - terminalas/kosolės langas

Site-packages - svetainės paketai

Solution - sprendimas

Source code - pirminis programos tekstas

Statement - sakinys

String - eilutė

Terminate - nutraukti darbą/stabdyti programą

True - teisinga

User - naudotojas

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

Python Vadovėlis/Sąrašai

2021-11-17T18:38:19Z

ZivileB:

=== 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>, reiškias 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 surasti <code>elementoIndeksas</code> ir tada įdėti <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 [[../Boolean Expressions|Boolean Expressions]]).
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“.

<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=Advanced Functions Example |next=For Loops}}
{{BookCat}}

Python Vadovėlis/Terminai

2021-11-17T18:16:07Z

ZivileB:

Computer - kompiuteris

Container - konteineris

Control strukture - valdymo struktūra

Counter - skaitliukas

Debugging - derinimas

Directory - katalogas

Exercise - pratimas

Expression - reiškinys

False - klaidinga

Feature - ypatybė

Floating point - slankusis kablelis

Hard-coded - įkoduotas/užprogramuotas

IDLE - IDLE kodo redaktorius/kodo redaktorius

Indent - įtrauka

Item - elementas

Iterable - iteruojamasis

List - sąrašas

Loop - ciklas

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvestis/rezultatas

Prepackaged - iš anksto paruošti paketai

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Shell - terminalas/kosolės langas

Site-packages - svetainės paketai

Solution - sprendimas

Source code - pirminis programos tekstas

Statement - sakinys

String - eilutė

Terminate - nutraukti darbą/stabdyti programą

True - teisinga

User - naudotojas

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

Python Vadovėlis/Terminai

2021-11-17T18:12:19Z

ZivileB:

Computer - kompiuteris

Control strukture - valdymo struktūra

Counter - skaitliukas

Debugging - derinimas

Directory - katalogas

Exercise - pratimas

Expression - reiškinys

False - klaidinga

Feature - ypatybė

Floating point - slankusis kablelis

Hard-coded - įkoduotas/užprogramuotas

IDLE - IDLE kodo redaktorius/kodo redaktorius

Indent - įtrauka

Item - elementas

Iterable - iteruojamasis

Loop - ciklas

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvestis/rezultatas

Prepackaged - iš anksto paruošti paketai

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Shell - terminalas/kosolės langas

Site-packages - svetainės paketai

Solution - sprendimas

Source code - pirminis programos tekstas

Statement - sakinys

String - eilutė

Terminate - nutraukti darbą/stabdyti programą

True - teisinga

User - naudotojas

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

Python Vadovėlis/Pasirinkimai

2021-11-17T18:11:28Z

ZivileB:

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

Štai rezultatas po dviejų programos vykdymų:

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

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

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

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

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

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

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

ir išvestis:

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

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

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

Ir išvestis

False
False

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

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

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

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

Pavyzdinis vykdymas:

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

'''lyginis.py'''

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

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

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

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

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

Python Vadovėlis/Rekursija

2021-11-17T17:54:47Z

ZivileB:

== Rekursija ==

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

=== Įvadas į rekursiją ===

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

sk = 0

def main():
skaitliukas(sk)

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

main()
</syntaxhighlight>

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

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

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

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

main()
</syntaxhighlight>

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

== Praktiniai rekursijos pritaikymai ==

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

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

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

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

Štai keletas pagrindinių faktorialų taisyklių:

Jei n = 0 tai n! = 1

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

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

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

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

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

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

main()
</syntaxhighlight>

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

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

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