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

Python Vadovėlis/Rekursinės funkcijos

2022-08-05T07:07:12Z

MindaugasP: sprendimo patikslinimas

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

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

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

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

Štai kaip viskas veikia:

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

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

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

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

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

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

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

Rezultatas:

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

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

atgalinis_skaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



=== Pratimai ===
Parašyk programą, kuri paprašytų vartotojo įvesti skaičių ir laipsnį. Naudodamas rekursija, atspausdink skaičių pakelta duotuoju laipsniu. (Pvz: 23=8)

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
rezultatas = int()

def keltiLaipsniu(skaičius, laipsnis):
if laipsnis == 0:
return 1
return skaičius * keltiLaipsniu(skaičius, laipsnis - 1)

rezultatas = keltiLaipsniu(2, 3)

print(rezultatas)
</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Ciklai For

2022-08-05T07:05:31Z

MindaugasP: sprendimo patikslinimas

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

{{BookCat}}

=== Ciklas <code>for</code> ===
Ir štai naujas spausdinimo būdas:
<syntaxhighlight lang="python">
nuo_vieno_iki_dešimt = range(1, 11)
for skaičius in nuo_vieno_iki_dešimt:
print(skaičius)
</syntaxhighlight>

ir kodo išvestis būtų tokia:

1
2
3
4
5
6
7
8
9
10

Išvestis atrodo labai pažįstama, tačiau programos kodas atrodo kitaip. Pirmoje eilutėje naudojama funkcija <code>range</code>. Funkcija <code>range</code> naudoja du argumentus, tokius kaip šie <code>range(pradžia, pabaiga)</code>, kurie nurodo intervalo galus. <code>pradžia</code> yra pirmasis intervalo skaičius. <code>pabaiga</code> yra vienu didesnis nei paskutinis intervalo skaičius. Atkreipk dėmesį, kad šį kodą galima parašyti ir trumpiau:
<syntaxhighlight lang="python">
for skaičius in range(1, 11):
print(skaičius)
</syntaxhighlight>

<code>range</code> funkcija grąžina iteraciją (proceso kartojimas skirtas rezultatų sekos generavimui). Tai galima paversti sąrašu naudojant funkciją <code>list</code>.
Štai keli pavyzdžiai, parodantys, kas nutinka su komanda <code>range</code>:

>>> '''range(1, 10)'''
range(1, 10)
>>> '''list(range(1, 10))'''
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> '''list(range(-32, -20))'''
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> '''list(range(5,21))'''
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> '''list(range(5))'''
[0, 1, 2, 3, 4]
>>> '''list(range(21, 5))'''
[]

Eilutė <code>for skaičius in nuo_vieno_iki_dešimt:</code> naudoja <code>for</code> valdymo struktūrą. <code>for</code> struktūra atrodo taip: <code>for elementas in sąrašas:</code>. <code>sąrašas</code> pereinamas nuo pirmojo sąrašo elemento iki paskutinio. Kai <code>for</code> eina per kiekvieną sąrašo elementą, jis kiekvieną reikšmę priskiria <code>elementas</code> kintamajam. Tai leidžia naudoti <code>elementas</code> kiekvieną kartą, kai ciklas <code>for</code> pereinamas iš eilės. Štai dar vienas pavyzdys, kad būtų lengviau suprasti:
<syntaxhighlight lang="python">
demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9, "oras"]
for elementas in demoSąrašas:
print("Dabartinis elementas yra:", elementas)
</syntaxhighlight>

Rezultatas yra:

Dabartinis elementas yra: gyvybė
Dabartinis elementas yra: 42
Dabartinis elementas yra: visata
Dabartinis elementas yra: 6
Dabartinis elementas yra: ir
Dabartinis elementas yra: 9
Dabartinis elementas yra: oras

Atkreipk dėmesį, kaip ciklas <code>for</code> praeina ir nustato elemento reikšmę kiekvienam sąrašo elementui. Taigi, kam tinkamas <code>for</code>? Pirmasis naudojimas yra peržiūrėti visus sąrašo elementus ir ką nors padaryti su kiekvienu iš jų. Štai greitas būdas sudėti visus elementus:

<syntaxhighlight lang="python">
sąrašas = [2, 4, 6, 8]
suma = 0
for skaičius in sąrašas:
suma = suma + skaičius

print("Suma yra:", suma)
</syntaxhighlight>

o išvestis yra tiesiog:

Suma yra: 20

Arba gali parašyti programą, kad sužinotum, ar sąraše yra dublikatų. Pavyzdžiui kaip ši programa:

<syntaxhighlight lang="python">
sąrašas = [4, 5, 7, 8, 9, 1, 0, 7, 10]
sąrašas.sort()
praeitas = None
for elementas in sąrašas:
if praeitas == elementas:
print("Dublikatas", praeitas, "rastas.")
praeitas = elementas
</syntaxhighlight>

ir turime rezultatą:

Dublikatas 7 rastas.

Gerai, tai kaip gi tai veikia? Čia yra speciali derinimo versija, kuri turėtų tau padėti suprasti (tau to nereikia įvesti):

<syntaxhighlight lang="python">
l = [4, 5, 7, 8, 9, 1, 0, 7, 10]
print("l = [4, 5, 7, 8, 9, 1, 0, 7, 10]", "\t\tl:", l)
l.sort()
print("l.sort()", "\t\tl:", l)
praeitas = l[0]
print("praeitas = l[0]", "\t\tpraeitas:", praeitas)
del l[0]
print("del l[0]", "\t\tl:", l)
for elementas in l:
if praeitas == elementas:
print("Dublikatas", praeitas, "rastas.")
print("if praeitas == elementas:", "\t\tpraeitas:", praeitas, "\telementas:", elementas)
praeitas = elementas
print("praeitas = elementas", "\t\tpraeitas:", praeitas, "\telementas:", elementas)
</syntaxhighlight>

ir kodo išvestis būtų:

l = [4, 5, 7, 8, 9, 1, 0, 7, 10] l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort() l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
praeitas = l[0] praeitas: 0
del l[0] l: [1, 4, 5, 7, 7, 8, 9, 10]
if praeitas == elementas: praeitas: 0 elementas: 1
praeitas = elementas praeitas: 1 elementas: 1
if praeitas == elementas: praeitas: 1 elementas: 4
praeitas = elementas praeitas: 4 elementas: 4
if praeitas == elementas: praeitas: 4 elementas: 5
praeitas = elementas praeitas: 5 elementas: 5
if praeitas == elementas: praeitas: 5 elementas: 7
praeitas = elementas praeitas: 7 elementas: 7
Dublikatas 7 rastas.
if praeitas == elementas: praeitas: 7 elementas: 7
praeitas = elementas praeitas: 7 elementas: 7
if praeitas == elementas: praeitas: 7 elementas: 8
praeitas = elementas praeitas: 8 elementas: 8
if praeitas == elementas: praeitas: 8 elementas: 9
praeitas = elementas praeitas: 9 elementas: 9
if praeitas == elementas: praeitas: 9 elementas: 10
praeitas = elementas praeitas: 10 elementas: 10

Priežastis, kodėl į kodą įdėjau tiek daug <code>print</code> komandų, buvo ta, kad galėtum matyti, kas vyksta kiekvienoje eilutėje (beje, jei kažkada negalėsi suprasti, kodėl programa neveikia, pabandyk įdėti spausdintų komandų tose vietose, kur nori sužinoti, kas vyksta). Pirmiausia programa prasideda nuobodžiu senu sąrašu. Toliau programa surūšiuoja sąrašą. Tai darome tam, kad visi dublikatai būtų dedami vienas šalia kito. Tada programa apibrėžia kintamąjį <code>praeitas</code>. Tada pirmasis sąrašo elementas ištrinamas, kad pirmasis elementas nebūtų klaidingai laikomas dublikatu. Toliau aprašomas <code>for</code> ciklas. Kiekvienas sąrašo elementas tikrinamas, ar jis sutampa su ankstesniu. Jeigu sutampa – dublikatas rastas. Tada kintamasis <code>praeitas</code> yra pakeičiamas taip, kad kitame <code>for</code> cikle kintamasis <code>praeitas</code> būtų ankstesnis dabartinis elementas. Be abejo, nustatytome, kad 7 yra dublikatas. (Atkreipk dėmesį, kaip <code>\t</code> naudojamas spausdinant tabuliavimo žymę (tab'as).)

Kitas būdas naudoti <code>for</code> ciklą yra norint ką nors padaryti tam tikrą skaičių kartų. Štai trumpas kodas, kaip atspausdinti pirmuosius 9 „Fibonacci“ serijos sakičius:
<syntaxhighlight lang="python">
a = 1
b = 1
for c in range(1, 10):
print(a, end=" ")
n = a + b
a = b
b = n
</syntaxhighlight>

su stebėtinu rezultatu:

1 1 2 3 5 8 13 21 34

Viskas, ką galima padaryti naudojant <code>for</code> ciklą, taip pat gali būti padaryta naudojant <code>while</code> ciklą, bet <code>for</code> ciklas suteikia lengvą būdą pereiti per visus sąrašo elementus arba ką nors padaryti tam tikrą skaičių kartų.

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

Ciklas <code>for</code> taip pat dažnai naudojamas sąrašų rūšiavimo užduotyse. Paprastų sąrašų, kurie yra sudaryti iš skaičių ar eilučių, rūšiavimui gali naudoti funkciją <code>sort</code>, kuri buvo paminėta prieš tai skaitytame skyriuje. Tačiau gali susidurti su situacijomis, kai ši funkcija yra nepakankama. Egzistuoja daug rūšiavimo algoritmų, tačiau čia išmoksi vieną paprasčiausių iš jų - burbuliuko algoritmą (angl. bubble sort).

Algoritmo idėja yra tokia, kad iš kairės į dešinę lyginame gretimų elementų poras ir sukeičiame elementus vietomis, jei pirmasis yra didesnis už antrąjį. Kiekvienos iteracijos metu, didžiausias nesurūšiuotas elementas juda link sąrašo galo. Toks judėjimas primena burbuliukų vandenyje judėjimą į paviršių, iš ko ir kilo algoritmo pavadinimas. Iteracijos kartojamos tol, kol visi elementai yra savo vietose.

[[Vaizdas:1 iteracija.png|miniatiūra]]
Pavyzdžiui, surūšiuokime jau prieš tai naudotą sąrašą [42, 7, 0, 123].

'''Pirma iteracija:'''
* Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
* Lyginami antras ir trečias elementai. Trečiasis yra didesnis už antrąjį, todėl elementai pakeičiami vietomis.
* Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

[[Vaizdas:2 iteracija.png|miniatiūra]]
'''Antra iteracija:'''
* Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
* Lyginami antras ir trečias elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.
* Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

[[Vaizdas:3 iteracija.png|miniatiūra]]
'''Trečia iteracija:'''
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.

Trečios iteracijos metu algoritmas neatlieka jokių pakeitimų, tad nustatoma, kad sąrašas yra surūšiuotas, algoritmas baigtas.

Algoritmo kodą galima užrašyti taip:

<syntaxhighlight lang="python">
def burbuliukoRūšiavimas(sąrašas):
sąrašoIlgis = len(sąrašas)
# Maksimalus iteracijų skaičius - sąrašo ilgis - 1 elementas
for i in range(sąrašoIlgis - 1):
arBuvoPakeitimų = 0
# Kiekvienoje iteracijoje lyginami visi elementai
for j in range(sąrašoIlgis - 1):
if sąrašas[j] > sąrašas[j + 1]:
# Sukuriame laikiną elementą, kuris saugo pirmąjį lyginamą elementą
laikinasElementas = sąrašas[j]
# Pirmąjam elementui priskiriame antro elemento reikšmę
sąrašas[j] = sąrašas[j + 1]
# Antrajam elementui priskiriame laikino elemento reikšmę, kuri yra lygi buvusiam pirmąjam elementui
sąrašas[j + 1] = laikinasElementas
# Pasižymime, kad iteracijos metu buvo padaryti pakeitimai, taigi reikės papildomų iteracijų
arBuvoPakeitimų = 1
# Jei visos iteracijos metu nebuvo nei vieno pakeitimo, algoritmas baigiamas
if arBuvoPakeitimų == 0:
break
return sąrašas

rezultatas = burbuliukoRūšiavimas([42, 7, 0, 123])

print (rezultatas)
</syntaxhighlight >

Programos išvestis:

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

=== Pratimai ===
Sukurk naują sarašą, kuris turėtų tik skaičiaus 3 daliklius (skaičius turi dalintis iš 3) iš 'x' sąrašo ir tik skaičiaus 5 daliklius iš 'y' sąrašo.

x = [1,2,3,4,5,6,7,8,9,10]

y = [11,12,13,14,15,16,17,18,19,20]

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
x = [1,2,3,4,5,6,7,8,9,10]
y = [11,12,13,14,15,16,17,18,19,20]
c = []
for i in x:
if i % 3 == 0:
c.append(i)
for i in y:
if i % 5 == 0:
c.append(i)
print(c)
</syntaxhighlight>
|-
|}

Parašyk programą, kuri atspausdintų eglutę, pagal vartotojo įvesta eglutės aukštį.

Pvz. Įvestis = 3

Išvestis:
<syntaxhighlight lang="python">
*
**
***
</syntaxhighlight>
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def spausdintiEglutę(aukstis):
for i in range(1, aukstis + 1):
print('*'*i)

spausdintiEglutę(3)
</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Ciklai For

2022-08-04T22:13:59Z

MindaugasP: sprendimo pataisymas

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

{{BookCat}}

=== Ciklas <code>for</code> ===
Ir štai naujas spausdinimo būdas:
<syntaxhighlight lang="python">
nuo_vieno_iki_dešimt = range(1, 11)
for skaičius in nuo_vieno_iki_dešimt:
print(skaičius)
</syntaxhighlight>

ir kodo išvestis būtų tokia:

1
2
3
4
5
6
7
8
9
10

Išvestis atrodo labai pažįstama, tačiau programos kodas atrodo kitaip. Pirmoje eilutėje naudojama funkcija <code>range</code>. Funkcija <code>range</code> naudoja du argumentus, tokius kaip šie <code>range(pradžia, pabaiga)</code>, kurie nurodo intervalo galus. <code>pradžia</code> yra pirmasis intervalo skaičius. <code>pabaiga</code> yra vienu didesnis nei paskutinis intervalo skaičius. Atkreipk dėmesį, kad šį kodą galima parašyti ir trumpiau:
<syntaxhighlight lang="python">
for skaičius in range(1, 11):
print(skaičius)
</syntaxhighlight>

<code>range</code> funkcija grąžina iteraciją (proceso kartojimas skirtas rezultatų sekos generavimui). Tai galima paversti sąrašu naudojant funkciją <code>list</code>.
Štai keli pavyzdžiai, parodantys, kas nutinka su komanda <code>range</code>:

>>> '''range(1, 10)'''
range(1, 10)
>>> '''list(range(1, 10))'''
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> '''list(range(-32, -20))'''
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> '''list(range(5,21))'''
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> '''list(range(5))'''
[0, 1, 2, 3, 4]
>>> '''list(range(21, 5))'''
[]

Eilutė <code>for skaičius in nuo_vieno_iki_dešimt:</code> naudoja <code>for</code> valdymo struktūrą. <code>for</code> struktūra atrodo taip: <code>for elementas in sąrašas:</code>. <code>sąrašas</code> pereinamas nuo pirmojo sąrašo elemento iki paskutinio. Kai <code>for</code> eina per kiekvieną sąrašo elementą, jis kiekvieną reikšmę priskiria <code>elementas</code> kintamajam. Tai leidžia naudoti <code>elementas</code> kiekvieną kartą, kai ciklas <code>for</code> pereinamas iš eilės. Štai dar vienas pavyzdys, kad būtų lengviau suprasti:
<syntaxhighlight lang="python">
demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9, "oras"]
for elementas in demoSąrašas:
print("Dabartinis elementas yra:", elementas)
</syntaxhighlight>

Rezultatas yra:

Dabartinis elementas yra: gyvybė
Dabartinis elementas yra: 42
Dabartinis elementas yra: visata
Dabartinis elementas yra: 6
Dabartinis elementas yra: ir
Dabartinis elementas yra: 9
Dabartinis elementas yra: oras

Atkreipk dėmesį, kaip ciklas <code>for</code> praeina ir nustato elemento reikšmę kiekvienam sąrašo elementui. Taigi, kam tinkamas <code>for</code>? Pirmasis naudojimas yra peržiūrėti visus sąrašo elementus ir ką nors padaryti su kiekvienu iš jų. Štai greitas būdas sudėti visus elementus:

<syntaxhighlight lang="python">
sąrašas = [2, 4, 6, 8]
suma = 0
for skaičius in sąrašas:
suma = suma + skaičius

print("Suma yra:", suma)
</syntaxhighlight>

o išvestis yra tiesiog:

Suma yra: 20

Arba gali parašyti programą, kad sužinotum, ar sąraše yra dublikatų. Pavyzdžiui kaip ši programa:

<syntaxhighlight lang="python">
sąrašas = [4, 5, 7, 8, 9, 1, 0, 7, 10]
sąrašas.sort()
praeitas = None
for elementas in sąrašas:
if praeitas == elementas:
print("Dublikatas", praeitas, "rastas.")
praeitas = elementas
</syntaxhighlight>

ir turime rezultatą:

Dublikatas 7 rastas.

Gerai, tai kaip gi tai veikia? Čia yra speciali derinimo versija, kuri turėtų tau padėti suprasti (tau to nereikia įvesti):

<syntaxhighlight lang="python">
l = [4, 5, 7, 8, 9, 1, 0, 7, 10]
print("l = [4, 5, 7, 8, 9, 1, 0, 7, 10]", "\t\tl:", l)
l.sort()
print("l.sort()", "\t\tl:", l)
praeitas = l[0]
print("praeitas = l[0]", "\t\tpraeitas:", praeitas)
del l[0]
print("del l[0]", "\t\tl:", l)
for elementas in l:
if praeitas == elementas:
print("Dublikatas", praeitas, "rastas.")
print("if praeitas == elementas:", "\t\tpraeitas:", praeitas, "\telementas:", elementas)
praeitas = elementas
print("praeitas = elementas", "\t\tpraeitas:", praeitas, "\telementas:", elementas)
</syntaxhighlight>

ir kodo išvestis būtų:

l = [4, 5, 7, 8, 9, 1, 0, 7, 10] l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort() l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
praeitas = l[0] praeitas: 0
del l[0] l: [1, 4, 5, 7, 7, 8, 9, 10]
if praeitas == elementas: praeitas: 0 elementas: 1
praeitas = elementas praeitas: 1 elementas: 1
if praeitas == elementas: praeitas: 1 elementas: 4
praeitas = elementas praeitas: 4 elementas: 4
if praeitas == elementas: praeitas: 4 elementas: 5
praeitas = elementas praeitas: 5 elementas: 5
if praeitas == elementas: praeitas: 5 elementas: 7
praeitas = elementas praeitas: 7 elementas: 7
Dublikatas 7 rastas.
if praeitas == elementas: praeitas: 7 elementas: 7
praeitas = elementas praeitas: 7 elementas: 7
if praeitas == elementas: praeitas: 7 elementas: 8
praeitas = elementas praeitas: 8 elementas: 8
if praeitas == elementas: praeitas: 8 elementas: 9
praeitas = elementas praeitas: 9 elementas: 9
if praeitas == elementas: praeitas: 9 elementas: 10
praeitas = elementas praeitas: 10 elementas: 10

Priežastis, kodėl į kodą įdėjau tiek daug <code>print</code> komandų, buvo ta, kad galėtum matyti, kas vyksta kiekvienoje eilutėje (beje, jei kažkada negalėsi suprasti, kodėl programa neveikia, pabandyk įdėti spausdintų komandų tose vietose, kur nori sužinoti, kas vyksta). Pirmiausia programa prasideda nuobodžiu senu sąrašu. Toliau programa surūšiuoja sąrašą. Tai darome tam, kad visi dublikatai būtų dedami vienas šalia kito. Tada programa apibrėžia kintamąjį <code>praeitas</code>. Tada pirmasis sąrašo elementas ištrinamas, kad pirmasis elementas nebūtų klaidingai laikomas dublikatu. Toliau aprašomas <code>for</code> ciklas. Kiekvienas sąrašo elementas tikrinamas, ar jis sutampa su ankstesniu. Jeigu sutampa – dublikatas rastas. Tada kintamasis <code>praeitas</code> yra pakeičiamas taip, kad kitame <code>for</code> cikle kintamasis <code>praeitas</code> būtų ankstesnis dabartinis elementas. Be abejo, nustatytome, kad 7 yra dublikatas. (Atkreipk dėmesį, kaip <code>\t</code> naudojamas spausdinant tabuliavimo žymę (tab'as).)

Kitas būdas naudoti <code>for</code> ciklą yra norint ką nors padaryti tam tikrą skaičių kartų. Štai trumpas kodas, kaip atspausdinti pirmuosius 9 „Fibonacci“ serijos sakičius:
<syntaxhighlight lang="python">
a = 1
b = 1
for c in range(1, 10):
print(a, end=" ")
n = a + b
a = b
b = n
</syntaxhighlight>

su stebėtinu rezultatu:

1 1 2 3 5 8 13 21 34

Viskas, ką galima padaryti naudojant <code>for</code> ciklą, taip pat gali būti padaryta naudojant <code>while</code> ciklą, bet <code>for</code> ciklas suteikia lengvą būdą pereiti per visus sąrašo elementus arba ką nors padaryti tam tikrą skaičių kartų.

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

Ciklas <code>for</code> taip pat dažnai naudojamas sąrašų rūšiavimo užduotyse. Paprastų sąrašų, kurie yra sudaryti iš skaičių ar eilučių, rūšiavimui gali naudoti funkciją <code>sort</code>, kuri buvo paminėta prieš tai skaitytame skyriuje. Tačiau gali susidurti su situacijomis, kai ši funkcija yra nepakankama. Egzistuoja daug rūšiavimo algoritmų, tačiau čia išmoksi vieną paprasčiausių iš jų - burbuliuko algoritmą (angl. bubble sort).

Algoritmo idėja yra tokia, kad iš kairės į dešinę lyginame gretimų elementų poras ir sukeičiame elementus vietomis, jei pirmasis yra didesnis už antrąjį. Kiekvienos iteracijos metu, didžiausias nesurūšiuotas elementas juda link sąrašo galo. Toks judėjimas primena burbuliukų vandenyje judėjimą į paviršių, iš ko ir kilo algoritmo pavadinimas. Iteracijos kartojamos tol, kol visi elementai yra savo vietose.

[[Vaizdas:1 iteracija.png|miniatiūra]]
Pavyzdžiui, surūšiuokime jau prieš tai naudotą sąrašą [42, 7, 0, 123].

'''Pirma iteracija:'''
* Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
* Lyginami antras ir trečias elementai. Trečiasis yra didesnis už antrąjį, todėl elementai pakeičiami vietomis.
* Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

[[Vaizdas:2 iteracija.png|miniatiūra]]
'''Antra iteracija:'''
* Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
* Lyginami antras ir trečias elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.
* Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

[[Vaizdas:3 iteracija.png|miniatiūra]]
'''Trečia iteracija:'''
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.

Trečios iteracijos metu algoritmas neatlieka jokių pakeitimų, tad nustatoma, kad sąrašas yra surūšiuotas, algoritmas baigtas.

Algoritmo kodą galima užrašyti taip:

<syntaxhighlight lang="python">
def burbuliukoRūšiavimas(sąrašas):
sąrašoIlgis = len(sąrašas)
# Maksimalus iteracijų skaičius - sąrašo ilgis - 1 elementas
for i in range(sąrašoIlgis - 1):
arBuvoPakeitimų = 0
# Kiekvienoje iteracijoje lyginami visi elementai
for j in range(sąrašoIlgis - 1):
if sąrašas[j] > sąrašas[j + 1]:
# Sukuriame laikiną elementą, kuris saugo pirmąjį lyginamą elementą
laikinasElementas = sąrašas[j]
# Pirmąjam elementui priskiriame antro elemento reikšmę
sąrašas[j] = sąrašas[j + 1]
# Antrajam elementui priskiriame laikino elemento reikšmę, kuri yra lygi buvusiam pirmąjam elementui
sąrašas[j + 1] = laikinasElementas
# Pasižymime, kad iteracijos metu buvo padaryti pakeitimai, taigi reikės papildomų iteracijų
arBuvoPakeitimų = 1
# Jei visos iteracijos metu nebuvo nei vieno pakeitimo, algoritmas baigiamas
if arBuvoPakeitimų == 0:
break
return sąrašas

rezultatas = burbuliukoRūšiavimas([42, 7, 0, 123])

print (rezultatas)
</syntaxhighlight >

Programos išvestis:

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

=== Pratimai ===
Sukurk naują sarašą, kuris turėtų tik skaičiaus 3 daliklius (skaičius turi dalintis iš 3) iš 'x' sąrašo ir tik skaičiaus 5 daliklius iš 'y' sąrašo.

x = [1,2,3,4,5,6,7,8,9,10]

y = [11,12,13,14,15,16,17,18,19,20]

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
x = [1,2,3,4,5,6,7,8,9,10]
y = [11,12,13,14,15,16,17,18,19,20]
c = []
for i in x:
if i % 3 == 0:
c.append(i)
for i in y:
if i % 5 == 0:
c.append(i)
print(c)
</syntaxhighlight>
|-
|}

Parašyk programą, kuri atspausdintų eglutę, pagal vartotojo įvesta eglutės aukštį.

Pvz. Įvestis = 3

Išvestis:
<syntaxhighlight lang="python">
*
**
***
</syntaxhighlight>
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def spausdintiEglute(aukstis):
for i in range(1, aukstis + 1):
print('*'*i)

spausdintiEglute(3)
</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Ciklai For

2022-08-04T22:12:01Z

MindaugasP: sprendimas

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

{{BookCat}}

=== Ciklas <code>for</code> ===
Ir štai naujas spausdinimo būdas:
<syntaxhighlight lang="python">
nuo_vieno_iki_dešimt = range(1, 11)
for skaičius in nuo_vieno_iki_dešimt:
print(skaičius)
</syntaxhighlight>

ir kodo išvestis būtų tokia:

1
2
3
4
5
6
7
8
9
10

Išvestis atrodo labai pažįstama, tačiau programos kodas atrodo kitaip. Pirmoje eilutėje naudojama funkcija <code>range</code>. Funkcija <code>range</code> naudoja du argumentus, tokius kaip šie <code>range(pradžia, pabaiga)</code>, kurie nurodo intervalo galus. <code>pradžia</code> yra pirmasis intervalo skaičius. <code>pabaiga</code> yra vienu didesnis nei paskutinis intervalo skaičius. Atkreipk dėmesį, kad šį kodą galima parašyti ir trumpiau:
<syntaxhighlight lang="python">
for skaičius in range(1, 11):
print(skaičius)
</syntaxhighlight>

<code>range</code> funkcija grąžina iteraciją (proceso kartojimas skirtas rezultatų sekos generavimui). Tai galima paversti sąrašu naudojant funkciją <code>list</code>.
Štai keli pavyzdžiai, parodantys, kas nutinka su komanda <code>range</code>:

>>> '''range(1, 10)'''
range(1, 10)
>>> '''list(range(1, 10))'''
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> '''list(range(-32, -20))'''
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> '''list(range(5,21))'''
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> '''list(range(5))'''
[0, 1, 2, 3, 4]
>>> '''list(range(21, 5))'''
[]

Eilutė <code>for skaičius in nuo_vieno_iki_dešimt:</code> naudoja <code>for</code> valdymo struktūrą. <code>for</code> struktūra atrodo taip: <code>for elementas in sąrašas:</code>. <code>sąrašas</code> pereinamas nuo pirmojo sąrašo elemento iki paskutinio. Kai <code>for</code> eina per kiekvieną sąrašo elementą, jis kiekvieną reikšmę priskiria <code>elementas</code> kintamajam. Tai leidžia naudoti <code>elementas</code> kiekvieną kartą, kai ciklas <code>for</code> pereinamas iš eilės. Štai dar vienas pavyzdys, kad būtų lengviau suprasti:
<syntaxhighlight lang="python">
demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9, "oras"]
for elementas in demoSąrašas:
print("Dabartinis elementas yra:", elementas)
</syntaxhighlight>

Rezultatas yra:

Dabartinis elementas yra: gyvybė
Dabartinis elementas yra: 42
Dabartinis elementas yra: visata
Dabartinis elementas yra: 6
Dabartinis elementas yra: ir
Dabartinis elementas yra: 9
Dabartinis elementas yra: oras

Atkreipk dėmesį, kaip ciklas <code>for</code> praeina ir nustato elemento reikšmę kiekvienam sąrašo elementui. Taigi, kam tinkamas <code>for</code>? Pirmasis naudojimas yra peržiūrėti visus sąrašo elementus ir ką nors padaryti su kiekvienu iš jų. Štai greitas būdas sudėti visus elementus:

<syntaxhighlight lang="python">
sąrašas = [2, 4, 6, 8]
suma = 0
for skaičius in sąrašas:
suma = suma + skaičius

print("Suma yra:", suma)
</syntaxhighlight>

o išvestis yra tiesiog:

Suma yra: 20

Arba gali parašyti programą, kad sužinotum, ar sąraše yra dublikatų. Pavyzdžiui kaip ši programa:

<syntaxhighlight lang="python">
sąrašas = [4, 5, 7, 8, 9, 1, 0, 7, 10]
sąrašas.sort()
praeitas = None
for elementas in sąrašas:
if praeitas == elementas:
print("Dublikatas", praeitas, "rastas.")
praeitas = elementas
</syntaxhighlight>

ir turime rezultatą:

Dublikatas 7 rastas.

Gerai, tai kaip gi tai veikia? Čia yra speciali derinimo versija, kuri turėtų tau padėti suprasti (tau to nereikia įvesti):

<syntaxhighlight lang="python">
l = [4, 5, 7, 8, 9, 1, 0, 7, 10]
print("l = [4, 5, 7, 8, 9, 1, 0, 7, 10]", "\t\tl:", l)
l.sort()
print("l.sort()", "\t\tl:", l)
praeitas = l[0]
print("praeitas = l[0]", "\t\tpraeitas:", praeitas)
del l[0]
print("del l[0]", "\t\tl:", l)
for elementas in l:
if praeitas == elementas:
print("Dublikatas", praeitas, "rastas.")
print("if praeitas == elementas:", "\t\tpraeitas:", praeitas, "\telementas:", elementas)
praeitas = elementas
print("praeitas = elementas", "\t\tpraeitas:", praeitas, "\telementas:", elementas)
</syntaxhighlight>

ir kodo išvestis būtų:

l = [4, 5, 7, 8, 9, 1, 0, 7, 10] l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort() l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
praeitas = l[0] praeitas: 0
del l[0] l: [1, 4, 5, 7, 7, 8, 9, 10]
if praeitas == elementas: praeitas: 0 elementas: 1
praeitas = elementas praeitas: 1 elementas: 1
if praeitas == elementas: praeitas: 1 elementas: 4
praeitas = elementas praeitas: 4 elementas: 4
if praeitas == elementas: praeitas: 4 elementas: 5
praeitas = elementas praeitas: 5 elementas: 5
if praeitas == elementas: praeitas: 5 elementas: 7
praeitas = elementas praeitas: 7 elementas: 7
Dublikatas 7 rastas.
if praeitas == elementas: praeitas: 7 elementas: 7
praeitas = elementas praeitas: 7 elementas: 7
if praeitas == elementas: praeitas: 7 elementas: 8
praeitas = elementas praeitas: 8 elementas: 8
if praeitas == elementas: praeitas: 8 elementas: 9
praeitas = elementas praeitas: 9 elementas: 9
if praeitas == elementas: praeitas: 9 elementas: 10
praeitas = elementas praeitas: 10 elementas: 10

Priežastis, kodėl į kodą įdėjau tiek daug <code>print</code> komandų, buvo ta, kad galėtum matyti, kas vyksta kiekvienoje eilutėje (beje, jei kažkada negalėsi suprasti, kodėl programa neveikia, pabandyk įdėti spausdintų komandų tose vietose, kur nori sužinoti, kas vyksta). Pirmiausia programa prasideda nuobodžiu senu sąrašu. Toliau programa surūšiuoja sąrašą. Tai darome tam, kad visi dublikatai būtų dedami vienas šalia kito. Tada programa apibrėžia kintamąjį <code>praeitas</code>. Tada pirmasis sąrašo elementas ištrinamas, kad pirmasis elementas nebūtų klaidingai laikomas dublikatu. Toliau aprašomas <code>for</code> ciklas. Kiekvienas sąrašo elementas tikrinamas, ar jis sutampa su ankstesniu. Jeigu sutampa – dublikatas rastas. Tada kintamasis <code>praeitas</code> yra pakeičiamas taip, kad kitame <code>for</code> cikle kintamasis <code>praeitas</code> būtų ankstesnis dabartinis elementas. Be abejo, nustatytome, kad 7 yra dublikatas. (Atkreipk dėmesį, kaip <code>\t</code> naudojamas spausdinant tabuliavimo žymę (tab'as).)

Kitas būdas naudoti <code>for</code> ciklą yra norint ką nors padaryti tam tikrą skaičių kartų. Štai trumpas kodas, kaip atspausdinti pirmuosius 9 „Fibonacci“ serijos sakičius:
<syntaxhighlight lang="python">
a = 1
b = 1
for c in range(1, 10):
print(a, end=" ")
n = a + b
a = b
b = n
</syntaxhighlight>

su stebėtinu rezultatu:

1 1 2 3 5 8 13 21 34

Viskas, ką galima padaryti naudojant <code>for</code> ciklą, taip pat gali būti padaryta naudojant <code>while</code> ciklą, bet <code>for</code> ciklas suteikia lengvą būdą pereiti per visus sąrašo elementus arba ką nors padaryti tam tikrą skaičių kartų.

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

Ciklas <code>for</code> taip pat dažnai naudojamas sąrašų rūšiavimo užduotyse. Paprastų sąrašų, kurie yra sudaryti iš skaičių ar eilučių, rūšiavimui gali naudoti funkciją <code>sort</code>, kuri buvo paminėta prieš tai skaitytame skyriuje. Tačiau gali susidurti su situacijomis, kai ši funkcija yra nepakankama. Egzistuoja daug rūšiavimo algoritmų, tačiau čia išmoksi vieną paprasčiausių iš jų - burbuliuko algoritmą (angl. bubble sort).

Algoritmo idėja yra tokia, kad iš kairės į dešinę lyginame gretimų elementų poras ir sukeičiame elementus vietomis, jei pirmasis yra didesnis už antrąjį. Kiekvienos iteracijos metu, didžiausias nesurūšiuotas elementas juda link sąrašo galo. Toks judėjimas primena burbuliukų vandenyje judėjimą į paviršių, iš ko ir kilo algoritmo pavadinimas. Iteracijos kartojamos tol, kol visi elementai yra savo vietose.

[[Vaizdas:1 iteracija.png|miniatiūra]]
Pavyzdžiui, surūšiuokime jau prieš tai naudotą sąrašą [42, 7, 0, 123].

'''Pirma iteracija:'''
* Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
* Lyginami antras ir trečias elementai. Trečiasis yra didesnis už antrąjį, todėl elementai pakeičiami vietomis.
* Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

[[Vaizdas:2 iteracija.png|miniatiūra]]
'''Antra iteracija:'''
* Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
* Lyginami antras ir trečias elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.
* Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

[[Vaizdas:3 iteracija.png|miniatiūra]]
'''Trečia iteracija:'''
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.

Trečios iteracijos metu algoritmas neatlieka jokių pakeitimų, tad nustatoma, kad sąrašas yra surūšiuotas, algoritmas baigtas.

Algoritmo kodą galima užrašyti taip:

<syntaxhighlight lang="python">
def burbuliukoRūšiavimas(sąrašas):
sąrašoIlgis = len(sąrašas)
# Maksimalus iteracijų skaičius - sąrašo ilgis - 1 elementas
for i in range(sąrašoIlgis - 1):
arBuvoPakeitimų = 0
# Kiekvienoje iteracijoje lyginami visi elementai
for j in range(sąrašoIlgis - 1):
if sąrašas[j] > sąrašas[j + 1]:
# Sukuriame laikiną elementą, kuris saugo pirmąjį lyginamą elementą
laikinasElementas = sąrašas[j]
# Pirmąjam elementui priskiriame antro elemento reikšmę
sąrašas[j] = sąrašas[j + 1]
# Antrajam elementui priskiriame laikino elemento reikšmę, kuri yra lygi buvusiam pirmąjam elementui
sąrašas[j + 1] = laikinasElementas
# Pasižymime, kad iteracijos metu buvo padaryti pakeitimai, taigi reikės papildomų iteracijų
arBuvoPakeitimų = 1
# Jei visos iteracijos metu nebuvo nei vieno pakeitimo, algoritmas baigiamas
if arBuvoPakeitimų == 0:
break
return sąrašas

rezultatas = burbuliukoRūšiavimas([42, 7, 0, 123])

print (rezultatas)
</syntaxhighlight >

Programos išvestis:

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

=== Pratimai ===
Sukurk naują sarašą, kuris turėtų tik skaičiaus 3 daliklius (skaičius turi dalintis iš 3) iš 'x' sąrašo ir tik skaičiaus 5 daliklius iš 'y' sąrašo.

x = [1,2,3,4,5,6,7,8,9,10]

y = [11,12,13,14,15,16,17,18,19,20]

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
x = [1,2,3,4,5,6,7,8,9,10]
y = [11,12,13,14,15,16,17,18,19,20]
c = []
for i in x:
if i % 3 == 0:
c.append(i)
for i in y:
if i % 5 == 0:
c.append(i)
print(c)
</syntaxhighlight>
|-
|}

Parašyk programą, kuri atspausdintų eglutę, pagal vartotojo įvesta eglutės aukštį.

Pvz. Įvestis = 3

Išvestis:
<syntaxhighlight lang="python">
*
**
***
</syntaxhighlight>
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def spausdintiEglute(aukstis):
for i in range(1, aukstis + 1):
print(*'*'*i)

spausdintiEglute(3)
</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Rekursinės funkcijos

2022-08-04T21:58:29Z

MindaugasP: uzduoties atsakymas

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

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

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

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

Štai kaip viskas veikia:

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

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

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

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

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

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

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

Rezultatas:

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

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

atgalinis_skaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



=== Pratimai ===
Parašyk programą, kuri paprašytų vartotojo įvesti skaičių ir laipsnį. Naudodamas rekursija, atspausdink skaičių pakelta duotuoju laipsniu. (Pvz: 23=8)

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
rezultatas = int()

def keltiLaipsniu(skaicius, laipsnis):
if laipsnis == 0:
return 1
return skaicius * keltiLaipsniu(skaicius, laipsnis - 1)

rezultatas = keltiLaipsniu(2, 3)

print(rezultatas)
</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Žodynai

2022-08-04T11:03:41Z

MindaugasP: funkcijos detales

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

=== Pratimai ===
Parašyk balsų skaičiavimo programą, kurioje tu vedi vardus tol, kol yra įvedamas žodis "pabaiga". Tada programa išveda, visus vardus ir kiek kartų jis buvo įvestas.

Įvesits:

Benas, Liepa, Benas, Benas, Benas, Jonas, Liepa

Išvestis:

<syntaxhighlight lang="python">
Benas 4
Liepa 2
Jonas 1
</syntaxhighlight>

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
balsai = dict()
vardas = str()

def balsuoti(naujasBalsas, balsai):
if naujasBalsas in balsai:
balsai[naujasBalsas] += 1
else:
if naujasBalsas != "pabaiga":
balsai[naujasBalsas] = 1

while vardas != "pabaiga":
print("Įrašyk vardą ir spausk 'enter' klavišą")
vardas = input()
balsuoti(vardas, balsai)

print(balsai)
</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Žodynai

2022-08-04T11:01:13Z

MindaugasP: funkcijos pavadinimas

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

=== Pratimai ===
Parašyk balsų skaičiavimo programą, kurioje tu vedi vardus tol, kol yra įvedamas žodis "pabaiga". Tada programa išveda, visus vardus ir kiek kartų jis buvo įvestas.

Įvesits:

Benas, Liepa, Benas, Benas, Benas, Jonas, Liepa

Išvestis:

<syntaxhighlight lang="python">
Benas 4
Liepa 2
Jonas 1
</syntaxhighlight>

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
balsai = dict()
vardas = str()

def balsuoti(naujasBalsas, balsai):
if naujasBalsas in balsai:
balsai[naujasBalsas] += 1
else:
if naujasBalsas != "Pabaiga":
balsai[naujasBalsas] = 1

while vardas != "Pabaiga":
print("Įrašyk vardą ir spausk 'enter' klavišą")
vardas = input()
balsuoti(vardas, balsai)

print(balsai)
</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Žodynai

2022-08-04T10:48:54Z

MindaugasP: Sprendimas

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

=== Pratimai ===
Parašyk balsų skaičiavimo programą, kurioje tu vedi vardus tol, kol yra įvedamas žodis "pabaiga". Tada programa išveda, visus vardus ir kiek kartų jis buvo įvestas.

Įvesits:

Benas, Liepa, Benas, Benas, Benas, Jonas, Liepa

Išvestis:

<syntaxhighlight lang="python">
Benas 4
Liepa 2
Jonas 1
</syntaxhighlight>

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
balsai = dict()
vardas = str()

def Balsuoti(naujasBalsas, balsai):
if naujasBalsas in balsai:
balsai[naujasBalsas] += 1
else:
if naujasBalsas != "Pabaiga":
balsai[naujasBalsas] = 1

while vardas != "Pabaiga":
print("Įrašyk vardą ir spausk 'enter' klavišą")
vardas = input()
Balsuoti(vardas, balsai)

print(balsai)
<syntaxhighlight lang="python">
</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Įžanga

2022-05-19T15:07:23Z

MindaugasP:

{{navigation |previous=Autoriai|next=Įvadas}}

Visi pavyzdiniai Python kodai šiame vadovėlyje yra skirti viešam naudojimui (angl. public domain). Jūs galite bet kaip keisti ir platinti modifikuotus kodus, naudojant bet kokią norimą licenciją (nebūtinai Creative Commons Attribution-ShareAlike).

Šis vadovėlis sukurtas knygos "Non-Programmer's Tutorial for Python" pagrindu. Panašūs vertimai sukurti anglų, korėjiečių, ispanų, italų, graikų ir kitomis kalbomis, žr. [http://jjc.freeshell.org/easytut/ http://jjc.freeshell.org/easytut/]

Šis vadovėlis yra įvadas į Python programavimo kalbą. Skirtas neturintiems ar turintiems kiek mažiau programavimo žinių.

Tokiu atveju, jeigu jau esi programavęs kokia nors kita programavimo kalba ir ją esi gerai įvaldęs, vietoje šio vadovėlio siūlau kitą resursą - [https://docs.python.org/3/tutorial/index.html Python Tutorial for Programmers], kurį parašė Gvidas van Rosumas (Guido van Rossum).

Jei turi klausimų ar komentarų, naudokis šio portalo diskusijų puslapiais, arba susisiek su [https://wiki.angis.net/w/Vadov%C4%97lis/Autoriai autoriais]. Visi klausimai ir pasiūlymai labai laukiami. Bandysime atsakyti kaip įmanoma greičiau.

=== Kiti resursų puslapiai (anglų kalba) ===

* [http://www.python.org Python Home Page]
* [https://docs.python.org/3/ Python 3 Documentation]
* [http://www.swaroopch.com/notes/python A Byte of Python by Swaroop C H]
* [http://python3porting.com/ Porting to Python 3: An in-depth guide]

{{navigation |previous=Autoriai|next=Įvadas}}

Python Vadovėlis/Įžanga

2022-05-19T15:07:09Z

MindaugasP:

{{navigation |previous=Autoriai|next=Įvadas}}

Visi pavyzdiniai Python kodai šiame vadovėlyje yra skirti viešam naudojimui (angl. public domain). Jūs galite bet kaip keisti ir platinti modifikuotus kodus, naudojant bet kokią norimą licenciją (nebūtinai Creative Commons Attribution-ShareAlike).

Šis vadovėlis sukurtas knygos "Non-Programmer's Tutorial for Python" pagrindu. Panašūs vertimai sukurti anglų, korėjiečių, ispanų, italų, graikų ir kitomis kalbomis, žr. [http://jjc.freeshell.org/easytut/ http://jjc.freeshell.org/easytut/]

Šis vadovėlis yra įvadas į Python programavimo kalbą. Skirtas neturintiems ar turintiems mažiau programavimo žinių.

Tokiu atveju, jeigu jau esi programavęs kokia nors kita programavimo kalba ir ją esi gerai įvaldęs, vietoje šio vadovėlio siūlau kitą resursą - [https://docs.python.org/3/tutorial/index.html Python Tutorial for Programmers], kurį parašė Gvidas van Rosumas (Guido van Rossum).

Jei turi klausimų ar komentarų, naudokis šio portalo diskusijų puslapiais, arba susisiek su [https://wiki.angis.net/w/Vadov%C4%97lis/Autoriai autoriais]. Visi klausimai ir pasiūlymai labai laukiami. Bandysime atsakyti kaip įmanoma greičiau.

=== Kiti resursų puslapiai (anglų kalba) ===

* [http://www.python.org Python Home Page]
* [https://docs.python.org/3/ Python 3 Documentation]
* [http://www.swaroopch.com/notes/python A Byte of Python by Swaroop C H]
* [http://python3porting.com/ Porting to Python 3: An in-depth guide]

{{navigation |previous=Autoriai|next=Įvadas}}

Python Vadovėlis/Įžanga

2022-05-19T15:05:09Z

MindaugasP: autorių navigacija

{{navigation |previous=Autoriai|next=Įvadas}}

Visi pavyzdiniai Python kodai šiame vadovėlyje yra skirti viešam naudojimui (angl. public domain). Jūs galite bet kaip keisti ir platinti modifikuotus kodus, naudojant bet kokią norimą licenciją (nebūtinai Creative Commons Attribution-ShareAlike).

Šis vadovėlis sukurtas knygos "Non-Programmer's Tutorial for Python" pagrindu. Panašūs vertimai sukurti anglų, korėjiečių, ispanų, italų, graikų ir kitomis kalbomis, žr. [http://jjc.freeshell.org/easytut/ http://jjc.freeshell.org/easytut/]

Šis vadovėlis yra įvadas į Python programavimo kalbą. Skirtas neturintiems ar turintiems ne daug programavimo žinių.

Tokiu atveju, jeigu jau esi programavęs kokia nors kita programavimo kalba ir ją esi gerai įvaldęs, vietoje šio vadovėlio siūlau kitą resursą - [https://docs.python.org/3/tutorial/index.html Python Tutorial for Programmers], kurį parašė Gvidas van Rosumas (Guido van Rossum).

Jei turi klausimų ar komentarų, naudokis šio portalo diskusijų puslapiais, arba susisiek su [https://wiki.angis.net/w/Vadov%C4%97lis/Autoriai autoriais]. Visi klausimai ir pasiūlymai labai laukiami. Bandysime atsakyti kaip įmanoma greičiau.

=== Kiti resursų puslapiai (anglų kalba) ===

* [http://www.python.org Python Home Page]
* [https://docs.python.org/3/ Python 3 Documentation]
* [http://www.swaroopch.com/notes/python A Byte of Python by Swaroop C H]
* [http://python3porting.com/ Porting to Python 3: An in-depth guide]

{{navigation |previous=Autoriai|next=Įvadas}}

Python Vadovėlis/Įžanga

2022-05-19T15:00:39Z

MindaugasP: žodžio korekcija

{{navigation |previous=Autoriai|next=Įvadas}}

Visi pavyzdiniai Python kodai šiame vadovėlyje yra skirti viešam naudojimui (angl. public domain). Jūs galite bet kaip keisti ir platinti modifikuotus kodus, naudojant bet kokią norimą licenciją (nebūtinai Creative Commons Attribution-ShareAlike).

Šis vadovėlis sukurtas knygos "Non-Programmer's Tutorial for Python" pagrindu. Panašūs vertimai sukurti anglų, korėjiečių, ispanų, italų, graikų ir kitomis kalbomis, žr. [http://jjc.freeshell.org/easytut/ http://jjc.freeshell.org/easytut/]

Šis vadovėlis yra įvadas į Python programavimo kalbą. Skirtas neturintiems ar turintiems ne daug programavimo žinių.

Tokiu atveju, jeigu jau esi programavęs kokia nors kita programavimo kalba ir ją esi gerai įvaldęs, vietoje šio vadovėlio siūlau kitą resursą - [https://docs.python.org/3/tutorial/index.html Python Tutorial for Programmers], kurį parašė Gvidas van Rosumas (Guido van Rossum).

Jei turi klausimų ar komentarų, naudokis šio portalo diskusijų puslapiais, arba susisiek su autoriais. Visi klausimai ir pasiūlymai labai laukiami. Bandysime atsakyti kaip įmanoma greičiau.

=== Kiti resursų puslapiai (anglų kalba) ===

* [http://www.python.org Python Home Page]
* [https://docs.python.org/3/ Python 3 Documentation]
* [http://www.swaroopch.com/notes/python A Byte of Python by Swaroop C H]
* [http://python3porting.com/ Porting to Python 3: An in-depth guide]

{{navigation |previous=Autoriai|next=Įvadas}}

Python Vadovėlis/Įžanga

2022-05-19T14:59:52Z

MindaugasP: Sakinių papildymas ar jų korekcija.

{{navigation |previous=Autoriai|next=Įvadas}}

Visi pavyzdiniai Python kodai šiame vadovėlyje yra skirti viešam naudojimui (angl. public domain). Jūs galite bet kaip keisti ir platinti modifikuotus kodus, naudojant bet kokią norimą licenciją (nebūtinai Creative Commons Attribution-ShareAlike).

Šis vadovėlis sukurtas knygos "Non-Programmer's Tutorial for Python" pagrindu. Panašūs vertimai sukurti anglų, korėjiečių, ispanų, italų, graikų ir kitomis kalbomis, žr. [http://jjc.freeshell.org/easytut/ http://jjc.freeshell.org/easytut/]

Šis vadovėlis yra įvadas į Python programavimo kalbą. Skirtas neturintiems ir turintiems ne daug programavimo žinių.

Tokiu atveju, jeigu jau esi programavęs kokia nors kita programavimo kalba ir ją esi gerai įvaldęs, vietoje šio vadovėlio siūlau kitą resursą - [https://docs.python.org/3/tutorial/index.html Python Tutorial for Programmers], kurį parašė Gvidas van Rosumas (Guido van Rossum).

Jei turi klausimų ar komentarų, naudokis šio portalo diskusijų puslapiais, arba susisiek su autoriais. Visi klausimai ir pasiūlymai labai laukiami. Bandysime atsakyti kaip įmanoma greičiau.

=== Kiti resursų puslapiai (anglų kalba) ===

* [http://www.python.org Python Home Page]
* [https://docs.python.org/3/ Python 3 Documentation]
* [http://www.swaroopch.com/notes/python A Byte of Python by Swaroop C H]
* [http://python3porting.com/ Porting to Python 3: An in-depth guide]

{{navigation |previous=Autoriai|next=Įvadas}}

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

2022-03-09T10:40:57Z

MindaugasP: Navigacija viršuje

{{navigation |previous=Rekursija|next=Įvadas į importuotas bibliotekas ir kitas funkcijas}}
==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==

Tu jau žinai, kad funkcija turi konkrečią paskyrtį ir ji gali būti įvairi: rinkti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar kitaip manipuliuoti duomenimis. Paprastai, funkcijos manipuliuoja duomenimis, kurie yra aprašyti atskirai. Šie duomenys yra dažnai perduodami iš vienos funkcijos į 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ą, reikia išrinkti visus kintamuosius, saugančius tuos duomenis ir pateikti atitinkamoms funkcijoms. 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 funkcijomis (procedūromis). 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 veiksmus su tais duomenimis (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas. 

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ų reikšmės neišeina tiesiogiai pakeisti. Pavyzdžiui, tu negalėtum pakeisti elektros tėkmės tiesiogiai, nebent būtų nukerpami laidai (to nedaryk ir dėl šio pavyzdžio; manyk, jog laidai neegzistuoja). 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ė komandų, kurios nusako objekto atributus ir metodus.

<big>Pirma pamoka</big>

Apačioje yra procedūrinė programa, kuri atlieka paprastą matematinį veiksmą su vartotojo įvestu skaičiumi.
<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):
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>

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 laikoma gerąja 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 Python'o klasių turi <code>__init__</code> metodą, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriamas tos klasės objektas (kai vykdoma programa kreipiasi į 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 sukurtam objektui. __init__ metodas inicijuoja klasės atributus, dėl šios priežasties jis yra pavadintas inicijavimo metodu. Vykdant __init__ metodą, <code>skaičius</code> atributui priskiriame 0.
Į objekto atributą skaičius kreipiamės panaudojant tašką.
<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ė tampa lygi 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 komanda priskiria „sk“ reikšmę objekte esančiui atributui pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina į tą vietą, kur metodas buvo iškviestas.

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ą į tą vietą, kur metodas buvo iškviestas.

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

Pažiūrėk į 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 geroji 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 objektą, kuris yra priskiriamas „matkė“ kintamajam.
Sintaksė atrodo taip: <code>moduliopavadinimas.Klasėspavadinimas()</code>. Toliau apibrėžiama ''main'' funkcija ir paimamas skaičius iš vartotojo priskiriamas kintamajam <code>sk</code>.

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ą sukūrei kintamajame pavadinimu „matkė“. „pridėkpenkis“ metodas grąžina apskaičiuotį reikšmę, kuri priskiriama kintamajam 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 objekto „matkė“ klasėje. „daugink“ metodas apskaičiuja ir grąžina reikšmę, kuri yra priskiriama kintamajam pavadinimu „daugintas“.

Paskutinė main() funkcijos eilutė atspausdina „Galutinis rezultatas yra <kintamojo daugintas reikšmė>“.

Programos 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/Rekursija

2021-12-15T13:46:17Z

MindaugasP: pav

== 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=Siekiant tobulumo |next=Įvadas į objektinį programavimą Python 3}}
{{BookCat}}

Python Vadovėlis/Failų tvarkymas

2021-12-15T13:45:55Z

MindaugasP: pav

=== 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=Siekiant tobulumo}}
{{BookCat}}

Python Vadovėlis/Žodynai

2021-12-15T13:43:13Z

MindaugasP: klaidinga

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

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

</syntaxhighlight>

O čia - mano išvestis:

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

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

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

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

Ši programa yra panaši į vardų sąrašą, pateiktą prieš tai buvusiame skyriuje apie sąrašus. Štai kaip veikia programa. Pirmiausia, funkcija <code>spausdink_meniu</code> yra apibrėžiama. <code>spausdink_meniu</code> tiesiog spausdina meniu, kuris vėliau du kartus naudojamas programoje. Po to, pateikiama keistai atrodanti eilutė <code>numeriai = {}</code>. Ši eilutė Python'ui pasako, kad <code>numeriai</code> yra žodynas. Kitos kelios eilutės tiesiog padaro taip, kad meniu veiktų. Eilutės
<syntaxhighlight lang="python">
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
</syntaxhighlight>
eina per žodyną ir spausdina visą informaciją. Funkcija <code> numeriai.keys()</code> grąžina sąrašą, kuris yra vėliau naudojamas <code>for</code> cikle. Sąrašas grąžinamas <code>keys()</code> metodo pagalba neturi jokio eiliškumo, todėl, jei tu nori, kad jis būtų abėcėlės tvarka, jis turi būti surūšiuotas. Panašiai kaip sąrašai, teiginys <code>numeriai[x]</code> naudojamas norint pasiekti konkretų žodyno narį. Žinoma, šiuo atveju <code>x</code> yra eilutė. Toliau, eilutė <code>numeriai[vardas] = telefonas</code> prideda vardą ir telefono numerį į žodyną. Jei <code>vardas</code> jau būtų buvęs žodyne, <code>telefonas</code> pakeistų, prieš tai buvusią reikšmę. Toliau eilutės
<syntaxhighlight lang="python">
if vardas in numeriai:
del numeriai[vardas]
</syntaxhighlight>
tikrina, ar vardas yra žodyne, ir jei yra, pašalina. Operatorius <code>vardas in numeriai</code> grąžina teisinga (angl. true), jei <code>vardas</code> yra <code>numeriai</code> žodyne, bet kitu atveju grąžina klaidinga (angl. false). Eilutė <code>del numeriai[vardas]</code> pašalina raktą <code>vardas</code> ir su tuo raktu susietą reikšmę. Eilutės
<syntaxhighlight lang="python">
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
</syntaxhighlight>
patikrina, ar žodynas turi tam tikrą raktą ir jei žodynas turi tą raktą, išspausdina su juo susietą numerį. Galiausiai, jei meniu pasirinkimas negalioja, pagrindinis meniu yra atspausdinamas, kad tu galėtum juo pasigrožėti.


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

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

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

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

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

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

o štai čia yra išvestis:

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

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

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

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

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

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

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

Štai kaip veikia programa. Iš esmės, kintamasis <code>mokiniai</code> yra žodynas, kurio raktai yra mokinių vardas, o reikšmės - jų pažymiai. Pirmosios dvi eilutės tik sukuria du sąrašus.
Kita eilutė <code>mokiniai = {'#Max': max_taškai}</code> sukuria naują
žodyną su raktu {<code>#Max</code>}, o reikšmė yra <code>[25, 25, 50, 25, 100]</code> (nes <code>max_taškai</code> ir buvo tai, kai priskyrimas buvo padarytas) (aš naudoju raktą <code>#Max</code>, nes <code>#</code> yra surūšiuotas prieš bet kokias abėcėlės raides). Toliau, <code>spausdink_meniu</code> yra apibrėžtas. Po to, <code>spausdink_visus_pažymius</code> funkcija yra apibrėžta žemiau esančiose
eilutėse:
<syntaxhighlight lang="python">
def spausdink_visus_pažymius():
print('\t',end=" ")
for i in range(len(užduotys)):
print(užduotys[i], '\t',end=" ")
print()
raktai = list(mokiniai.keys())
keys.sort()
for x in raktai:
print(x, '\t',end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
</syntaxhighlight>

Atkreipk dėmesį, į tai, kaip pirmieji raktai yra išimami iš <code>mokiniai</code> žodyno su <code>raktai</code> funkcija eilutėje <code>raktai = list(mokiniai.keys())</code>. <code>raktai</code> yra iteruojamasis ir yra paverčiamas į sąrašą, tam kad būtų galima naudoti visas sąrašų funkcijas. Toliau raktai yra surūšiuojami eilutėje <code>raktai.sort()</code>. <code>for</code> yra naudojamas pereiti per visus raktus. Pažymiai yra saugomi kaip sąrašas žodyno viduje, todėl priskyrimas <code>pažymiai = mokiniai[x]</code> duoda <code>pažymiai</code> sąrašą, kuris yra saugomas <code>x</code> rakte. Funkcija <code>spausdink_pažymius</code> tiesiog spausdina sąrašą ir yra apibrėžta keliomis eilutėmis žemiau.

Tolimesnės programos eilutės įgyvendina įvairius meniu pasirinkimus. Eilutė <code>mokiniai[vardas] = [0] * len(max_taškai)</code> prideda mokinį prie savo vardo rakto. Žymėjimas <code>[0] * len(max_taškai)</code> tiesiog sukuria sąrašą 0-ių, kuris yra tokio pat ilgio kaip ir <code>max_taškai</code> sąrašas.

Pašalinti mokinį pasirinkimas tiesiog ištrina mokinį, panašiai kaip ir telefonų knygutės pavyzdyje. Įrašyti mokinį pasirinkimas yra šiek tiek sudėtingesnis. Pažymiai yra gaunami eilutėje <code>pažymiai = mokiniai[vardas]</code>, ji gauna nuorodą į mokinio <code>vardas</code> pažymius. Tada pažymys yra įrašomas eilutėje <code>pažymiai[kuris] = pažymys</code>. Tu gali pastebėti, kad <code>pažymiai</code> niekada negrąžinami į mokinių žodyną (kaip ir ne <code>mokiniai[vardas] = pažymiai</code>). Trūkstamo teiginio priežastis yra ta, kad <code>pažymiai</code> iš tiesų yra kitas pavadinimas skirtas <code>mokiniai[vardas]</code> ir dėl to keičiant <code>pažymiai</code> keičiasi ir <code>mokiniai[vardas]</code>.

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

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

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

2021-12-15T13:17:18Z

MindaugasP: nedideli pakeitimai

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gauk_pastorintą(poema)
</syntaxhighlight>

šios programos išvestis yra:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

































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

Python Vadovėlis/Labas, Pasauli

2021-12-15T13:06:50Z

MindaugasP: pagražinimas ir asmens keitimas

=== 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'o 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šytą 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 - parašyk ir tada pasileisk programą. Pagal mūsų turimą praktiką, toks mokymosi procesas yra pats efektyviausias ir labiausiai 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ą, 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ą, 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ą atsiminsi. Todėl programoje gali naudoti komentarus, kurie gali būti naudojami kaip pastabos/paaiškinimai tau 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 [[#Aritmetinės_išraiškos|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 [[#Aritmetinės_išraiškos|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=Įvadas |next=Kas čia eina?}}

Python Vadovėlis/Žodynai

2021-12-15T12:14:01Z

MindaugasP: viena raidelė

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

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

</syntaxhighlight>

O čia - mano išvestis:

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

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

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

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

Ši programa yra panaši į vardų sąrašą, pateiktą prieš tai buvusiame skyriuje apie sąrašus. Štai kaip veikia programa. Pirmiausia, funkcija <code>spausdink_meniu</code> yra apibrėžiama. <code>spausdink_meniu</code> tiesiog spausdina meniu, kuris vėliau du kartus naudojamas programoje. Po to, pateikiama keistai atrodanti eilutė <code>numeriai = {}</code>. Ši eilutė Python'ui pasako, kad <code>numeriai</code> yra žodynas. Kitos kelios eilutės tiesiog padaro taip, kad meniu veiktų. Eilutės
<syntaxhighlight lang="python">
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
</syntaxhighlight>
eina per žodyną ir spausdina visą informaciją. Funkcija <code> numeriai.keys()</code> grąžina sąrašą, kuris yra vėliau naudojamas <code>for</code> cikle. Sąrašas grąžinamas <code>keys()</code> metodo pagalba neturi jokio eiliškumo, todėl, jei tu nori, kad jis būtų abėcėlės tvarka, jis turi būti surūšiuotas. Panašiai kaip sąrašai, teiginys <code>numeriai[x]</code> naudojamas norint pasiekti konkretų žodyno narį. Žinoma, šiuo atveju <code>x</code> yra eilutė. Toliau, eilutė <code>numeriai[vardas] = telefonas</code> prideda vardą ir telefono numerį į žodyną. Jei <code>vardas</code> jau būtų buvęs žodyne, <code>telefonas</code> pakeistų, prieš tai buvusią reikšmę. Toliau eilutės
<syntaxhighlight lang="python">
if vardas in numeriai:
del numeriai[vardas]
</syntaxhighlight>
tikrina, ar vardas yra žodyne, ir jei yra, pašalina. Operatorius <code>vardas in numeriai</code> grąžina teisinga (angl. true), jei <code>vardas</code> yra <code>numeriai</code> žodyne, bet kitu atveju grąžina neteisinga (angl. false). Eilutė <code>del numeriai[vardas]</code> pašalina raktą <code>vardas</code> ir su tuo raktu susietą reikšmę. Eilutės
<syntaxhighlight lang="python">
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
</syntaxhighlight>
patikrina, ar žodynas turi tam tikrą raktą ir jei žodynas turi tą raktą, išspausdina su juo susietą numerį. Galiausiai, jei meniu pasirinkimas negalioja, pagrindinis meniu yra atspausdinamas, kad tu galėtum juo pasigrožėti.


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

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

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

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

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

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

o štai čia yra išvestis:

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

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

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

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

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

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

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

Štai kaip veikia programa. Iš esmės, kintamasis <code>mokiniai</code> yra žodynas, kurio raktai yra mokinių vardas, o reikšmės - jų pažymiai. Pirmosios dvi eilutės tik sukuria du sąrašus.
Kita eilutė <code>mokiniai = {'#Max': max_taškai}</code> sukuria naują
žodyną su raktu {<code>#Max</code>}, o reikšmė yra <code>[25, 25, 50, 25, 100]</code> (nes <code>max_taškai</code> ir buvo tai, kai priskyrimas buvo padarytas) (aš naudoju raktą <code>#Max</code>, nes <code>#</code> yra surūšiuotas prieš bet kokias abėcėlės raides). Toliau, <code>spausdink_meniu</code> yra apibrėžtas. Po to, <code>spausdink_visus_pažymius</code> funkcija yra apibrėžta žemiau esančiose
eilutėse:
<syntaxhighlight lang="python">
def spausdink_visus_pažymius():
print('\t',end=" ")
for i in range(len(užduotys)):
print(užduotys[i], '\t',end=" ")
print()
raktai = list(mokiniai.keys())
keys.sort()
for x in raktai:
print(x, '\t',end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
</syntaxhighlight>

Atkreipk dėmesį, į tai, kaip pirmieji raktai yra išimami iš <code>mokiniai</code> žodyno su <code>raktai</code> funkcija eilutėje <code>raktai = list(mokiniai.keys())</code>. <code>raktai</code> yra iteruojamasis ir yra paverčiamas į sąrašą, tam kad būtų galima naudoti visas sąrašų funkcijas. Toliau raktai yra surūšiuojami eilutėje <code>raktai.sort()</code>. <code>for</code> yra naudojamas pereiti per visus raktus. Pažymiai yra saugomi kaip sąrašas žodyno viduje, todėl priskyrimas <code>pažymiai = mokiniai[x]</code> duoda <code>pažymiai</code> sąrašą, kuris yra saugomas <code>x</code> rakte. Funkcija <code>spausdink_pažymius</code> tiesiog spausdina sąrašą ir yra apibrėžta keliomis eilutėmis žemiau.

Tolimesnės programos eilutės įgyvendina įvairius meniu pasirinkimus. Eilutė <code>mokiniai[vardas] = [0] * len(max_taškai)</code> prideda mokinį prie savo vardo rakto. Žymėjimas <code>[0] * len(max_taškai)</code> tiesiog sukuria sąrašą 0-ių, kuris yra tokio pat ilgio kaip ir <code>max_taškai</code> sąrašas.

Pašalinti mokinį pasirinkimas tiesiog ištrina mokinį, panašiai kaip ir telefonų knygutės pavyzdyje. Įrašyti mokinį pasirinkimas yra šiek tiek sudėtingesnis. Pažymiai yra gaunami eilutėje <code>pažymiai = mokiniai[vardas]</code>, ji gauna nuorodą į mokinio <code>vardas</code> pažymius. Tada pažymys yra įrašomas eilutėje <code>pažymiai[kuris] = pažymys</code>. Tu gali pastebėti, kad <code>pažymiai</code> niekada negrąžinami į mokinių žodyną (kaip ir ne <code>mokiniai[vardas] = pažymiai</code>). Trūkstamo teiginio priežastis yra ta, kad <code>pažymiai</code> iš tiesų yra kitas pavadinimas skirtas <code>mokiniai[vardas]</code> ir dėl to keičiant <code>pažymiai</code> keičiasi ir <code>mokiniai[vardas]</code>.

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

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

Python Vadovėlis/Žodynai

2021-12-15T12:06:48Z

MindaugasP: brūkšnelis (yra)

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

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

</syntaxhighlight>

O čia - mano išvestis:

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

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

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

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

Ši programa yra panaši į vardų sąrašą, pateiktą prieš tai buvusiame skyriuje apie sąrašus. Štai kaip veikia programa. Pirmiausia, funkcija <code>spausdink_meniu</code> yra apibrėžiama. <code>spausdink_meniu</code> tiesiog spausdina meniu, kuris vėliau du kartus naudojamas programoje. Po to, pateikiama keistai atrodanti eilutė <code>numeriai = {}</code>. Ši eilutė Python'ui pasako, kad <code>numeriai</code> yra žodynas. Kitos kelios eilutės tiesiog padaro taip, kad meniu veiktų. Eilutės
<syntaxhighlight lang="python">
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
</syntaxhighlight>
eina per žodyną ir spausdina visą informaciją. Funkcija <code> numeriai.keys()</code> grąžina sąrašą, kuris yra vėliau naudojamas <code>for</code> cikle. Sąrašas grąžinamas <code>keys()</code> metodo pagalba neturi jokio eiliškumo, todėl, jei tu nori, kad jis būtų abėcėlės tvarka, jis turi būti surūšiuotas. Panašiai kaip sąrašai, teiginys <code>numeriai[x]</code> naudojamas norint pasiekti konkretų žodyno narį. Žinoma, šiuo atveju <code>x</code> yra eilutė. Toliau, eilutė <code>numeriai[vardas] = telefonas</code> prideda vardą ir telefono numerį į žodyną. Jei <code>vardas</code> jau būtų buvęs žodyne, <code>telefonas</code> pakeistų, prieš tai buvusią reikšmę. Toliau eilutės
<syntaxhighlight lang="python">
if vardas in numeriai:
del numeriai[vardas]
</syntaxhighlight>
tikrina, ar vardas yra žodyne, ir jei yra, pašalina. Operatorius <code>vardas in numeriai</code> grąžina teisinga (angl. true), jei <code>vardas</code> yra <code>numeriai</code> žodyne, bet kitu atveju grąžina neteisinga (angl. false). Eilutė <code>del numeriai[vardas]</code> pašalina raktą <code>vardas</code> ir su tuo raktu susietą reikšmę. Eilutės
<syntaxhighlight lang="python">
if vardas in numeriai:
print("Telefono numeris yra ", numeriai[vardas])
</syntaxhighlight>
patikrina, ar žodynas turi tam tikrą raktą ir jei žodynas turi tą raktą, išspausdina su juo susietą numerį. Galiausiai, jei meniu pasirinkimas negalioja, pagrindinis meniu yra atspausdinamas, kad tu galėtum juo pasigrožėti.


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

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

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

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

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

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

o štai čia yra išvestis:

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

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

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

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

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

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

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

Štai kaip veikia programa. Iš esmės, kintamasis <code>mokiniai</code> yra žodynas, kurio raktai yra mokinių vardas, o reikšmės - jų pažymiai. Pirmosios dvi eilutės tik sukuria du sąrašus.
Kita eilutė <code>mokiniai = {'#Max': max_taškai}</code> sukuria naują
žodyną su raktu {<code>#Max</code>}, o reikšmė yra <code>[25, 25, 50, 25, 100]</code> (nes <code>max_taškai</code> ir buvo tai, kai priskyrimas buvo padarytas) (aš naudoju raktą <code>#Max</code>, nes <code>#</code> yra surūšiuotas prieš bet kokias abėcėlės raides). Toliau, <code>spausdink_meniu</code> yra apibrėžtas. Po to, <code>spausdink_visus_pažymius</code> funkcija yra apibrėžta žemiau esančiose
eilutėse:
<syntaxhighlight lang="python">
def spausdink_visus_pažymius():
print('\t',end=" ")
for i in range(len(užduotys)):
print(užduotys[i], '\t',end=" ")
print()
raktai = list(mokiniai.keys())
keys.sort()
for x in raktai:
print(x, '\t',end=' ')
pažymiai = mokiniai[x]
spausdink_pažymius(pažymiai)
</syntaxhighlight>

Atkreipk dėmesį, į tai, kaip pirmieji raktai yra išimami iš <code>mokiniai</code> žodyno su <code>raktai</code> funkcija eilutėje <code>raktai = list(mokiniai.keys())</code>. <code>raktai</code> yra iteruojamasis ir yra paverčiamas į sąrašą, tam kad būtų galima naudoti visas sąrašų funkcijas. Toliau raktai yra surūšiuojami eilutėje <code>raktai.sort()</code>. <code>for</code> yra naudojamas pereiti per visus raktus. Pažymiai yra saugomi kaip sąrašas žodyno viduje, todėl priskyrimas <code>pažymiai = mokiniai[x]</code> duoda <code>pažymiai</code> sąrašą, kuris yra saugomas <code>x</code> rakte. Funkcija <code>spausdink_pažymius</code> tiesiog spausdina sąrašą ir yra apibrėžtas keliomis eilutėmis žemiau.

Tolimesnės programos eilutės įgyvendina įvairius meniu pasirinkimus. Eilutė <code>mokiniai[vardas] = [0] * len(max_taškai)</code> prideda mokinį prie savo vardo rakto. Žymėjimas <code>[0] * len(max_taškai)</code> tiesiog sukuria sąrašą 0-ių, kuris yra tokio pat ilgio kaip ir <code>max_taškai</code> sąrašas.

Pašalinti mokinį pasirinkimas tiesiog ištrina mokinį, panašiai kaip ir telefonų knygutės pavyzdyje. Įrašyti mokinį pasirinkimas yra šiek tiek sudėtingesnis. Pažymiai yra gaunami eilutėje <code>pažymiai = mokiniai[vardas]</code>, ji gauna nuorodą į mokinio <code>vardas</code> pažymius. Tada pažymys yra įrašomas eilutėje <code>pažymiai[kuris] = pažymys</code>. Tu gali pastebėti, kad <code>pažymiai</code> niekada negrąžinami į mokinių žodyną (kaip ir ne <code>mokiniai[vardas] = pažymiai</code>). Trūkstamo teiginio priežastis yra ta, kad <code>pažymiai</code> iš tiesų yra kitas pavadinimas skirtas <code>mokiniai[vardas]</code> ir dėl to keičiant <code>pažymiai</code> keičiasi ir <code>mokiniai[vardas]</code>.

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

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

Python Vadovėlis/Funkcijų apibrėžimas

2021-12-07T11:52:32Z

MindaugasP: peržiūra nr. 1

=== 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 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> b_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("option: ")
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šykite jūsų 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=Debugging |next=Advanced Functions Example}}

Python Vadovėlis/Autoriai

2021-12-07T10:59:53Z

MindaugasP: /* Lietuviškas vertimas ir modifikacija */

Originalaus (angliško) vadovėlio autoriai

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

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

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

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

Python Vadovėlis/Autoriai

2021-12-07T10:57:40Z

MindaugasP: /* Lietuviškas vertimas ir modifikacija */

Originalaus (angliško) vadovėlio autoriai

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

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

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

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

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

2021-11-17T12:27:33Z

MindaugasP: Paskutinės dvi eilutės

==Objektinis programavimas==

Iki šiol jūs rašėte kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinant 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. Nesijauskite blogai jei iš pradžių suprasti nesiseka. Jei šis skyrius jums to suprasti nepadės, yra ir daugiau informatyvių šaltinių, kurie jums 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škite prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvokite 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šėte 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, jūs sugalvojate išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog jūsų programa veiktų, jūs dabar turite redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduokite kiek laiko jums reikėtų norint peržiūrėti ir pakeisti šimtus failų. Jūs išprotėtumėte! 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 prisimenate kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimenate programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvokite 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. 

Galvokite apie duomenų atributus kaip apie kintamuosius. 

Galvokite apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėkime į 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, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvojate, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantate apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

Įrašykite 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ėkime keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, mes naudojame <code>class</code> raktažodį. Po raktažodžio jūs rašote pavadinimą kurį norėtumėte, jog turėtų jūsų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu dirtysocks, kodas atrodytų taip:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

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

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

import oopexample

maths = oopexample.NumChange()

def main():

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

added = maths.addfive(num)

multip = maths.multiply(added)

print("Galutinis rezultatas yra ", multip)

main()
</syntaxhighlight>

Tikriausiai jūs dabar esate pasimetę. Tai visiškai suprantama. Pradžioje pasistenkime suprasti klasę.
Klasė yra pavadinta "NumChange"
Ši klasė turi tris metodus
* __init__
* addfive
* multiply

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</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 jūs turėtumėte 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 turime tik vieną objektą, mes turime pasirūpinti, kad programa žinotų, jog mes norime naudoti atributus aprašytus būtent toje klasėje. Todėl mes turime būti saugūs ir naudoti "self" parametrą.

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

Dauguma pitono klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija. (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.
Mes sukuriame nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
Kodas <code>self.__number = 0</code> reiškia, jog "objekte esančio "number" atributo reikšmė yra 0"

Pažiūrėkime į sekantį metodą.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

Šis metodas yra pavadintas "addfive". Jis priima parametrą pavadinimu "num". Metode esanti logika tada priskiria "num" reikšmę objekte esančiui atributui su pavadinimu "number". Tada metodas prideda 5 prie "number" ir jį grąžina jį iššaukiančiui.

Pažiūrėkime į trečiajį metodą.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas "multiply". Jis priima parametrą pavadinimu "added". Metodas priskiria priimtą reikšmę objekte esančiui atributui su pavadinimu "added" ir grąžina "added" atributo ir 2.452 sandaugą jį iššaukiančiui.

Ar atkreipėte dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandykime tai suprasti.
Prieš tai mes minėjome, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus mes galėtumėm 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, turime naudoti du pabraukimus prieš objekto pavadinima, taip kaip ir demonstravome. Ištrynus abu pabraukimus nuo atributo pavadinimo mes juo galėsime manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėkime į programą, kuri naudoja klasę, kurią aptarėme.

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

Ši kodo eilutė importuoją klasę, kurią išsaugojome 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">
maths = oopexample.NumChange()
</syntaxhighlight>

Ši eilutė sukuria NumChange pavadinimu, "oopexample" modulyje patalpintos klasės instanciją, kuri yra priskiriama "maths" kintamajam.
Sintaksė atrodo taip:
<code>modulename.Classname()</code>
Apibrėžiame main funkciją.
Pasiimame skaičių iš vartotojo.

Kita eilutė <code>added = maths.addfive(num)</code> nusiunčia "num" kintamojo reikšmę metodui pavadinimu "addfive". Metodas yra aprašytas klasėje, kurios instanciją išsaugojome kintamajame pavadinimu "maths". "addfive" metodas išsaugo gautą reikšmę į kintamajį pavadinimu "added".

Kita eilutė <code>multip = maths.multiply(added)</code> nusiunčia "added" kintamojo reikšmę metodui pavadinimu "multiply". Metodas yra aprašytas klasėje, kurios instanciją išsaugojome kintamajame pavadinimu "maths". "multiply" metodas išsaugo gautą reikšmę į kintamajį pavadinimu "multip".

Kita eilutė atspausdina "Galutinis rezultatas yra <multip reikšmė>". Paskutinė eilutė iššaukia 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-15T20:45:34Z

MindaugasP: Viso likusio teksto redagavimas apart paskutinių neišverstų eilučių.

==Objektinis programavimas==

Iki šiol jūs rašėte kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinant 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. Nesijauskite blogai jei iš pradžių suprasti nesiseka. Jei šis skyrius jums to suprasti nepadės, yra ir daugiau informatyvių šaltinių, kurie jums 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škite prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvokite 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šėte 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, jūs sugalvojate išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog jūsų programa veiktų, jūs dabar turite redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduokite kiek laiko jums reikėtų norint peržiūrėti ir pakeisti šimtus failų. Jūs išprotėtumėte! 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 prisimenate kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimenate programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvokite 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. 

Galvokite apie duomenų atributus kaip apie kintamuosius. 

Galvokite apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėkime į 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, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvojate, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantate apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

Įrašykite 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ėkime keletą svarbių objektinio programavimo būdo konceptų prieš neriant į ankščiau minėtą klasę ir programą.
Norint sukurti klasę, mes naudojame <code>class</code> raktažodį. Po raktažodžio jūs rašote pavadinimą kurį norėtumėte, jog turėtų jūsų klasė. Dažnai naudojama praktika kuriant klasių pavadinimus yra NaujųŽodžiųRašymasIšDidžiosiosRaidės.
Jei norėčiau sukurti klasę pavadinimu dirtysocks, kodas atrodytų taip:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

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

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

import oopexample

maths = oopexample.NumChange()

def main():

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

added = maths.addfive(num)

multip = maths.multiply(added)

print("Galutinis rezultatas yra ", multip)

main()
</syntaxhighlight>

Tikriausiai jūs dabar esate pasimetę. Tai visiškai suprantama. Pradžioje pasistenkime suprasti klasę.
Klasė yra pavadinta "NumChange"
Ši klasė turi tris metodus
* __init__
* addfive
* multiply

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</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 jūs turėtumėte 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 turime tik vieną objektą, mes turime pasirūpinti, kad programa žinotų, jog mes norime naudoti atributus aprašytus būtent toje klasėje. Todėl mes turime būti saugūs ir naudoti "self" parametrą.

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

Dauguma pitono klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija. (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.
Mes sukuriame nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
Kodas <code>self.__number = 0</code> reiškia, jog "objekte esančio "number" atributo reikšmė yra 0"

Pažiūrėkime į sekantį metodą.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

Šis metodas yra pavadintas "addfive". Jis priima parametrą pavadinimu "num". Metode esanti logika tada priskiria "num" reikšmę objekte esančiui atributui su pavadinimu "number". Tada metodas prideda 5 prie "number" ir jį grąžina jį iššaukiančiui.

Pažiūrėkime į trečiajį metodą.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas "multiply". Jis priima parametrą pavadinimu "added". Metodas priskiria priimtą reikšmę objekte esančiui atributui su pavadinimu "added" ir grąžina "added" atributo ir 2.452 sandaugą jį iššaukiančiui.

Ar atkreipėte dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandykime tai suprasti.
Prieš tai mes minėjome, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus mes galėtumėm 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, turime naudoti du pabraukimus prieš objekto pavadinima, taip kaip ir demonstravome. Ištrynus abu pabraukimus nuo atributo pavadinimo mes juo galėsime manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėkime į programą, kuri naudoja klasę, kurią aptarėme.

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

Ši kodo eilutė importuoją klasę, kurią išsaugojome 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">
maths = oopexample.NumChange()
</syntaxhighlight>

Ši eilutė sukuria NumChange pavadinimu, "oopexample" modulyje patalpintos klasės instanciją, kuri yra priskiriama "maths" kintamajam.
Sintaksė atrodo taip:
<code>modulename.Classname()</code>
Apibrėžiame main funkciją.
Pasiimame skaičių iš vartotojo.

Kita eilutė <code>added = maths.addfive(num)</code> nusiunčia "num" kintamojo reikšmę metodui pavadinimu "addfive". Metodas yra aprašytas klasėje sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

Kita eilutė <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

Kita eilutė atspausdina "Galutinis rezultatas yra <multip reikšmė>". Paskutinė eilutė iššaukia 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-15T19:33:59Z

MindaugasP: Finalinis redagavimas iki pirmos pamokos.

==Objektinis programavimas==

Iki šiol jūs rašėte kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinant 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. Nesijauskite blogai jei iš pradžių suprasti nesiseka. Jei šis skyrius jums to suprasti nepadės, yra ir daugiau informatyvių šaltinių, kurie jums 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škite prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvokite 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šėte 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, jūs sugalvojate išsaugoti turimą informaciją sąrašuose ar žodynuose. Norint, jog jūsų programa veiktų, jūs dabar turite redaguoti kiekvieną funkciją, kuri naudojo tuos kintamuosius, taip, kad dabar ji galėtų priimti ir manipuliuoti sąrašus ar žodynus. Įsivaizduokite kiek laiko jums reikėtų norint peržiūrėti ir pakeisti šimtus failų. Jūs išprotėtumėte! 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 prisimenate kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimenate programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvokite 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. 

Galvokite apie duomenų atributus kaip apie kintamuosius. 

Galvokite apie metodus kaip apie funkcijas ar procedūras. 

Pažiūrėkime į 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, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į FALSE. Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvojate, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną dalyką prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantate apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

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

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

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

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

import oopexample

maths = oopexample.NumChange()

def main():

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

added = maths.addfive(num)

multip = maths.multiply(added)

print("Galutinis rezultatas yra ", multip)

main()
</syntaxhighlight>

Tikriausiai jūs dabar esate pasimetę. Tai visiškai suprantama. Pradėkime nuo klasės supratimo.
Klasė yra pavadinta "NumChange"
Ši klasė turi tris metodus
* __init__
* addfive
* multiply

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</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 geriausia praktika, tad tikriausiai ir jūs turėtumėte jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes kai jis yra iškviečiamas, jis turi žinoti which object's attributes to operate on. Net kai turime tik vieną objektą, mes turime pasirūpinti, kad programa žinotų, jog mes norime naudoti atributus aprašytus būtent toje klasėje. Todėl mes turime būti saugūs ir naudoti "self" parametrą.

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

Dauguma pitono klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija. (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.
Mes sukuriame nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
Kodas <code>self.__number = 0</code> reiškia, jog "objekte esančio "number" atributo reikšmė yra 0"

Pažiūrėkime į sekantį metodą.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

Šis metodas yra pavadintas "addfive". Jis priima parametrą pavadinimu "num". Metode esanti logika tada priskiria "num" reikšmę objekte esančiui atributui su pavadinimu "number". This method is named "addfive". Tada metodas prideda 5 prie "number" ir jį grąžina jį iššaukiančiui.

Pažiūrėkime į trečiajį metodą.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas "multiply". Jis priima parametrą pavadinimu "added". Metodas priskiria priimtą reikšmę objekte esančiui atributui su pavadinimu "added" ir grąžina "added" atributo ir 2.452 sandaugą jį iššaukiančiui.

Ar atkreipėte dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandykime tai suprasti.
Prieš tai mes minėjome, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus mes galėtumėm 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, turime naudoti du pabraukimus prieš objekto pavadinima, taip kaip ir demonstravome. Ištrynus abu pabraukimus nuo atributo pavadinimo mes juo galėsime manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėkime į programą, kuri naudoja klasę, kurią aptarėme.

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

Ši kodo eilutė importuoją klasę, kurią išsaugojome 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">
maths = oopexample.NumChange()
</syntaxhighlight>

Ši eilutė sukuria NumChange pavadinimu, "oopexample" modulyje patalpintos klasės instanciją, kuri yra priskiriama "maths" kintamajam.
Sintaksė atrodo taip:
<code>modulename.Classname()</code>
Apibrėžiame main funkciją.
Pasiimame skaičių iš vartotojo.

Kita eilutė <code>added = maths.addfive(num)</code> nusiunčia "num" kintamojo reikšmę metodui pavadinimu "addfive". Metodas yra aprašytas klasėje sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

Kita eilutė <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

Kita eilutė atspausdina "Galutinis rezultatas yra <multip reikšmė>". Paskutinė eilutė iššaukia 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-15T19:00:59Z

MindaugasP: Įžangos finalinė korekcija

==Objektinis programavimas==

Iki šiol jūs rašėte kodą pagal procedūrinio programavimo taisykles. Tačiau, yra daug programų, kurios - parašytos pagal objektinio programavimo taisykles. Žinant 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. Nesijauskite blogai jei iš pradžių suprasti nesiseka. Jei šis skyrius jums to suprasti nepadės, yra ir daugiau informatyvių šaltinių, kurie jums 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škite prieš kiekvieną pamoką perskaityti įžangą, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

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

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

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

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

import oopexample

maths = oopexample.NumChange()

def main():

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

added = maths.addfive(num)

multip = maths.multiply(added)

print("Galutinis rezultatas yra ", multip)

main()
</syntaxhighlight>

Tikriausiai jūs dabar esate pasimetę. Tai visiškai suprantama. Pradėkime nuo klasės supratimo.
Klasė yra pavadinta "NumChange"
Ši klasė turi tris metodus
* __init__
* addfive
* multiply

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</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 geriausia praktika, tad tikriausiai ir jūs turėtumėte jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes kai jis yra iškviečiamas, jis turi žinoti which object's attributes to operate on. Net kai turime tik vieną objektą, mes turime pasirūpinti, kad programa žinotų, jog mes norime naudoti atributus aprašytus būtent toje klasėje. Todėl mes turime būti saugūs ir naudoti "self" parametrą.

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

Dauguma pitono klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija. (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.
Mes sukuriame nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
Kodas <code>self.__number = 0</code> reiškia, jog "objekte esančio "number" atributo reikšmė yra 0"

Pažiūrėkime į sekantį metodą.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

Šis metodas yra pavadintas "addfive". Jis priima parametrą pavadinimu "num". Metode esanti logika tada priskiria "num" reikšmę objekte esančiui atributui su pavadinimu "number". This method is named "addfive". Tada metodas prideda 5 prie "number" ir jį grąžina jį iššaukiančiui.

Pažiūrėkime į trečiajį metodą.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas "multiply". Jis priima parametrą pavadinimu "added". Metodas priskiria priimtą reikšmę objekte esančiui atributui su pavadinimu "added" ir grąžina "added" atributo ir 2.452 sandaugą jį iššaukiančiui.

Ar atkreipėte dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandykime tai suprasti.
Prieš tai mes minėjome, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus mes galėtumėm 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, turime naudoti du pabraukimus prieš objekto pavadinima, taip kaip ir demonstravome. Ištrynus abu pabraukimus nuo atributo pavadinimo mes juo galėsime manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėkime į programą, kuri naudoja klasę, kurią aptarėme.

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

Ši kodo eilutė importuoją klasę, kurią išsaugojome 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">
maths = oopexample.NumChange()
</syntaxhighlight>

Ši eilutė sukuria NumChange pavadinimu, "oopexample" modulyje patalpintos klasės instanciją, kuri yra priskiriama "maths" kintamajam.
Sintaksė atrodo taip:
<code>modulename.Classname()</code>
Apibrėžiame main funkciją.
Pasiimame skaičių iš vartotojo.

Kita eilutė <code>added = maths.addfive(num)</code> nusiunčia "num" kintamojo reikšmę metodui pavadinimu "addfive". Metodas yra aprašytas klasėje sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

Kita eilutė <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

Kita eilutė atspausdina "Galutinis rezultatas yra <multip reikšmė>". Paskutinė eilutė iššaukia 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-09T12:15:43Z

MindaugasP: next teksto pavadinimo korekcija

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

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

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

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

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

import oopexample

maths = oopexample.NumChange()

def main():

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

added = maths.addfive(num)

multip = maths.multiply(added)

print("Galutinis rezultatas yra ", multip)

main()
</syntaxhighlight>

Tikriausiai jūs dabar esate pasimetę. Tai visiškai suprantama. Pradėkime nuo klasės supratimo.
Klasė yra pavadinta "NumChange"
Ši klasė turi tris metodus
* __init__
* addfive
* multiply

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</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 geriausia praktika, tad tikriausiai ir jūs turėtumėte jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes kai jis yra iškviečiamas, jis turi žinoti which object's attributes to operate on. Net kai turime tik vieną objektą, mes turime pasirūpinti, kad programa žinotų, jog mes norime naudoti atributus aprašytus būtent toje klasėje. Todėl mes turime būti saugūs ir naudoti "self" parametrą.

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

Dauguma pitono klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija. (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.
Mes sukuriame nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
Kodas <code>self.__number = 0</code> reiškia, jog "objekte esančio "number" atributo reikšmė yra 0"

Pažiūrėkime į sekantį metodą.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

Šis metodas yra pavadintas "addfive". Jis priima parametrą pavadinimu "num". Metode esanti logika tada priskiria "num" reikšmę objekte esančiui atributui su pavadinimu "number". This method is named "addfive". Tada metodas prideda 5 prie "number" ir jį grąžina jį iššaukiančiui.

Pažiūrėkime į trečiajį metodą.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas "multiply". Jis priima parametrą pavadinimu "added". Metodas priskiria priimtą reikšmę objekte esančiui atributui su pavadinimu "added" ir grąžina "added" atributo ir 2.452 sandaugą jį iššaukiančiui.

Ar atkreipėte dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandykime tai suprasti.
Prieš tai mes minėjome, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus mes galėtumėm 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, turime naudoti du pabraukimus prieš objekto pavadinima, taip kaip ir demonstravome. Ištrynus abu pabraukimus nuo atributo pavadinimo mes juo galėsime manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėkime į programą, kuri naudoja klasę, kurią aptarėme.

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

Ši kodo eilutė importuoją klasę, kurią išsaugojome 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">
maths = oopexample.NumChange()
</syntaxhighlight>

Ši eilutė sukuria NumChange pavadinimu, "oopexample" modulyje patalpintos klasės instanciją, kuri yra priskiriama "maths" kintamajam.
Sintaksė atrodo taip:
<code>modulename.Classname()</code>
Apibrėžiame main funkciją.
Pasiimame skaičių iš vartotojo.

Kita eilutė <code>added = maths.addfive(num)</code> nusiunčia "num" kintamojo reikšmę metodui pavadinimu "addfive". Metodas yra aprašytas klasėje sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

Kita eilutė <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

Kita eilutė atspausdina "Galutinis rezultatas yra <multip reikšmė>". Paskutinė eilutė iššaukia 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-09T12:14:53Z

MindaugasP: Nebaigtas teksto galas

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

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

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

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

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

import oopexample

maths = oopexample.NumChange()

def main():

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

added = maths.addfive(num)

multip = maths.multiply(added)

print("Galutinis rezultatas yra ", multip)

main()
</syntaxhighlight>

Tikriausiai jūs dabar esate pasimetę. Tai visiškai suprantama. Pradėkime nuo klasės supratimo.
Klasė yra pavadinta "NumChange"
Ši klasė turi tris metodus
* __init__
* addfive
* multiply

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</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 geriausia praktika, tad tikriausiai ir jūs turėtumėte jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes kai jis yra iškviečiamas, jis turi žinoti which object's attributes to operate on. Net kai turime tik vieną objektą, mes turime pasirūpinti, kad programa žinotų, jog mes norime naudoti atributus aprašytus būtent toje klasėje. Todėl mes turime būti saugūs ir naudoti "self" parametrą.

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

Dauguma pitono klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija. (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.
Mes sukuriame nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
Kodas <code>self.__number = 0</code> reiškia, jog "objekte esančio "number" atributo reikšmė yra 0"

Pažiūrėkime į sekantį metodą.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

Šis metodas yra pavadintas "addfive". Jis priima parametrą pavadinimu "num". Metode esanti logika tada priskiria "num" reikšmę objekte esančiui atributui su pavadinimu "number". This method is named "addfive". Tada metodas prideda 5 prie "number" ir jį grąžina jį iššaukiančiui.

Pažiūrėkime į trečiajį metodą.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas "multiply". Jis priima parametrą pavadinimu "added". Metodas priskiria priimtą reikšmę objekte esančiui atributui su pavadinimu "added" ir grąžina "added" atributo ir 2.452 sandaugą jį iššaukiančiui.

Ar atkreipėte dėmesį į tai, jog kiekvienas metodo pavadinimas prasideda su dviem pabraukimais? Pabandykime tai suprasti.
Prieš tai mes minėjome, jog objektas, su metodų pagalba, dirba su atributais apibrėžtais jame pačiame. Būtų idealu, jei tuos atributus mes galėtumėm 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, turime naudoti du pabraukimus prieš objekto pavadinima, taip kaip ir demonstravome. Ištrynus abu pabraukimus nuo atributo pavadinimo mes juo galėsime manipuliuoti kodu, kuris yra parašytas objekto išorėje.

Pažiūrėkime į programą, kuri naudoja klasę, kurią aptarėme.

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

Ši kodo eilutė importuoją klasę, kurią išsaugojome 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">
maths = oopexample.NumChange()
</syntaxhighlight>

Ši eilutė sukuria NumChange pavadinimu, "oopexample" modulyje patalpintos klasės instanciją, kuri yra priskiriama "maths" kintamajam.
Sintaksė atrodo taip:
<code>modulename.Classname()</code>
Apibrėžiame main funkciją.
Pasiimame skaičių iš vartotojo.

Kita eilutė <code>added = maths.addfive(num)</code> nusiunčia "num" kintamojo reikšmę metodui pavadinimu "addfive". Metodas yra aprašytas klasėje sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

Kita eilutė <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

Kita eilutė atspausdina "Galutinis rezultatas yra <multip reikšmė>". Paskutinė eilutė iššaukia main funkciją, kuri įvykdo žingsnius nurodytus viršuje.

{{navigation |previous=Rekursija|next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-11-09T10:52:36Z

MindaugasP: antras ir trečias metodai

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

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

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

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

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

import oopexample

maths = oopexample.NumChange()

def main():

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

added = maths.addfive(num)

multip = maths.multiply(added)

print("Galutinis rezultatas yra ", multip)

main()
</syntaxhighlight>

Tikriausiai jūs dabar esate pasimetę. Tai visiškai suprantama. Pradėkime nuo klasės supratimo.
Klasė yra pavadinta "NumChange"
Ši klasė turi tris metodus
* __init__
* addfive
* multiply

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</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 geriausia praktika, tad tikriausiai ir jūs turėtumėte jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes kai jis yra iškviečiamas, jis turi žinoti which object's attributes to operate on. Net kai turime tik vieną objektą, mes turime pasirūpinti, kad programa žinotų, jog mes norime naudoti atributus aprašytus būtent toje klasėje. Todėl mes turime būti saugūs ir naudoti "self" parametrą.

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

Dauguma pitono klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija. (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.
Mes sukuriame nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
Kodas <code>self.__number = 0</code> reiškia, jog "objekte esančio "number" atributo reikšmė yra 0"

Pažiūrėkime į sekantį metodą.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

Šis metodas yra pavadintas "addfive". Jis priima parametrą pavadinimu "num". Metode esanti logika tada priskiria "num" reikšmę objekte esančiui atributui su pavadinimu "number". This method is named "addfive". Tada metodas prideda 5 prie "number" ir jį grąžina jį iššaukiančiui.

Pažiūrėkime į trečiajį metodą.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

Šis metodas yra pavadintas "multiply". Jis priima parametrą pavadinimu "added". Metodas priskiria priimtą reikšmę objekte esančiui atributui su pavadinimu "added" ir grąžina "added" atributo ir 2.452 sandaugą jį iššaukiančiui.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-11-09T07:57:54Z

MindaugasP: demonstracinės programos pradžia

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

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

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

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

import oopexample

maths = oopexample.NumChange()

def main():

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

added = maths.addfive(num)

multip = maths.multiply(added)

print("Galutinis rezultatas yra ", multip)

main()
</syntaxhighlight>

Tikriausiai jūs dabar esate pasimetę. Tai visiškai suprantama. Pradėkime nuo klasės supratimo.
Klasė yra pavadinta "NumChange"
Ši klasė turi tris metodus
* __init__
* addfive
* multiply

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</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 geriausia praktika, tad tikriausiai ir jūs turėtumėte jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes kai jis yra iškviečiamas, jis turi žinoti which object's attributes to operate on. Net kai turime tik vieną objektą, mes turime pasirūpinti, kad programa žinotų, jog mes norime naudoti atributus aprašytus būtent toje klasėje. Todėl mes turime būti saugūs ir naudoti "self" parametrą.

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

Dauguma pitono klasių turi <code>__init__</code>, kuris yra paleidžiamas automatiškai kiekvieną kartą, kai atmintyje yra sukuriama tos klasės instancija. (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.
Mes sukuriame nuorodą į turimo objekto atributą panaudojant taškinį žymėjimą.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-11-08T15:52:03Z

MindaugasP: Antros programos dalis

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

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

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# Nėra autoriaus teisių
# 2012
# OOP Demonstratica - Programa

import oopexample

maths = oopexample.NumChange()

def main():

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

added = maths.addfive(num)

multip = maths.multiply(added)

print("Galutinis rezultatas yra ", multip)

main()
</syntaxhighlight>

Tikriausiai jūs dabar esate pasimetę. Tai visiškai suprantama. Pradėkime nuo klasės supratimo.
Klasė yra pavadinta "NumChange"
Ši klasė turi tris metodus
* __init__
* addfive
* multiply

Šie trys metodai savyje turi labai panašų kodą.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</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 geriausia praktika, tad tikriausiai ir jūs turėtumėte jį taip vadinti. Šis parametras yra reikalingas kiekviename metode nes kai jis yra iškviečiamas, jis turi žinoti which object's attributes to operate on. Net kai turime tik vieną objektą, mes turime pasirūpinti, kad programa žinotų, jog mes norime naudoti atributus aprašytus būtent toje klasėje. Todėl mes turime būti saugūs ir naudoti "self" parametrą.

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

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-11-08T13:41:50Z

MindaugasP: Antros programos įžanga

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

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

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

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Program

import oopexample

maths = oopexample.NumChange()

def main():

num = float(input("Please enter a number.\n"))

added = maths.addfive(num)

multip = maths.multiply(added)

print("The manipulated value is ",multip)

main()
</syntaxhighlight>

After looking at that program, you are probably a bit lost. That's OK. Let's start off by dissecting the class.
The class is named "NumChange"
There are three methods to this class:
* __init__
* addfive
* multiply

These three methods each have a similar code.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</syntaxhighlight>

Notice how each method has a parameter named "self". This parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.

Let's look at the first method.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-11-08T12:55:32Z

MindaugasP: procedūra pavadinimas

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

Below, is a Class, and a program which uses that class. This Object Oriented Program does the same thing as the procedural program above. Let's cover some important OOP coding concepts before we dive into the Class and program.
To create a class, we use the <code>class</code> keyword. After the keyword, you type the name you want to name your class. It is common practice that the name of your class uses CapWords convention.
If I wanted to create a class named dirtysocks, the code would be:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

The Class is shown first. The program which uses the class is second.

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Program

import oopexample

maths = oopexample.NumChange()

def main():

num = float(input("Please enter a number.\n"))

added = maths.addfive(num)

multip = maths.multiply(added)

print("The manipulated value is ",multip)

main()
</syntaxhighlight>

After looking at that program, you are probably a bit lost. That's OK. Let's start off by dissecting the class.
The class is named "NumChange"
There are three methods to this class:
* __init__
* addfive
* multiply

These three methods each have a similar code.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</syntaxhighlight>

Notice how each method has a parameter named "self". This parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.

Let's look at the first method.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-11-08T12:55:00Z

MindaugasP: Pirma programa

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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

# Procedure 1
def main():
try:
# Pasiimame skaičių, kurį manipuliuosime.
num = float(input("Įrašykite skaičių.\n"))
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su pasiimtu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 2
addednum = addfive(num)
# Išsaugome naują skaičių į kintamąjį. Prieš tai, su ankščiau išsaugotu skaičiu atliekame matematinius veiksmus naudojant
# procedūrą 3
multipliednum = multiply(addednum)
# Paduodame skaičių procedūrai 4
display(multipliednum)
# Susidorojame su išimtimis, kurios gali atsirasti dėl netinkamo vartotojo skaičiaus įvedimo
except ValueError:
print("Privalote įvesti tinkamą skaičių.\n")
# Atstatome kintamojo num reikšmę, kad ištrintumėm netinkamą vartotojo įvestį.
num = 0
# Dar kartą iškviečiame 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):
# Parodome galutinį rezultatą.
print("Galutinis rezultatas yra ", multi)

# Kviečiame procedūrą 1
main()
</syntaxhighlight>

Jei mes įrašysime skaitemnį "5", gausime išvestį parodytą žemiau.

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

Jei mes įrašysime reikšmę "g", tada pasitaisysime ir įrašysime skaitmenį "8", tada gausime išvestį parodytą žemiau.

Įrašykite skaičių.
g
Privalote įvesti tinkamą skaičių.

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

Below, is a Class, and a program which uses that class. This Object Oriented Program does the same thing as the procedural program above. Let's cover some important OOP coding concepts before we dive into the Class and program.
To create a class, we use the <code>class</code> keyword. After the keyword, you type the name you want to name your class. It is common practice that the name of your class uses CapWords convention.
If I wanted to create a class named dirtysocks, the code would be:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

The Class is shown first. The program which uses the class is second.

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Program

import oopexample

maths = oopexample.NumChange()

def main():

num = float(input("Please enter a number.\n"))

added = maths.addfive(num)

multip = maths.multiply(added)

print("The manipulated value is ",multip)

main()
</syntaxhighlight>

After looking at that program, you are probably a bit lost. That's OK. Let's start off by dissecting the class.
The class is named "NumChange"
There are three methods to this class:
* __init__
* addfive
* multiply

These three methods each have a similar code.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</syntaxhighlight>

Notice how each method has a parameter named "self". This parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.

Let's look at the first method.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-11-08T12:00:27Z

MindaugasP: pavadinimo korekcija

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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>

Below is a Procedural program that performs simple math on a single number, entered by a user.
<syntaxhighlight lang="python">

# Program by Mitchell Aikens
# No Copyright
# 2012

# Procedure 1
def main():
try:
# Get a number to maniuplate
num = float(input("Please enter a number to manipulate.\n"))
# Store the result of the value, after it has been manipulated
# by Procedure 2
addednum = addfive(num)
# Store the result of the value, after it has been manipulated
# by Procedure 3
multipliednum = multiply(addednum)
# Send the value to Procedure 4
display(multipliednum)
# Deal with exceptions from non-numeric user entry
except ValueError:
print("You must enter a valid number.\n")
# Reset the value of num, to clear non-numeric data.
num = 0
# Call main, again.
main()

# Procedure 2
def addfive(num):
return num + 5

# Procedure 3
def multiply(addednum):
return addednum * 2.452

# Procedure 4
def display(multi):
# Display the final value
print("The final value is ",multi)

# Call Procedure 1
main()
</syntaxhighlight>

If we were to enter a value of "5", the output would be as shown below.

Please enter a number to manipulate.
5
The final value is 24.52

If we were to enter a value of "g", and then correct the input and enter a value of "8", the output would be as shown below.

Please enter a number to manipulate.
g
You must enter a valid number.

Please enter a number to manipulate.
8
The final value is 31.875999999999998

Below, is a Class, and a program which uses that class. This Object Oriented Program does the same thing as the procedural program above. Let's cover some important OOP coding concepts before we dive into the Class and program.
To create a class, we use the <code>class</code> keyword. After the keyword, you type the name you want to name your class. It is common practice that the name of your class uses CapWords convention.
If I wanted to create a class named dirtysocks, the code would be:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

The Class is shown first. The program which uses the class is second.

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Program

import oopexample

maths = oopexample.NumChange()

def main():

num = float(input("Please enter a number.\n"))

added = maths.addfive(num)

multip = maths.multiply(added)

print("The manipulated value is ",multip)

main()
</syntaxhighlight>

After looking at that program, you are probably a bit lost. That's OK. Let's start off by dissecting the class.
The class is named "NumChange"
There are three methods to this class:
* __init__
* addfive
* multiply

These three methods each have a similar code.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</syntaxhighlight>

Notice how each method has a parameter named "self". This parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.

Let's look at the first method.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-11-08T11:59:08Z

MindaugasP: išverstas tekstas iki pirmos pamokos

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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 duomens 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ėkime į paprastą, kasdienį pavyzdį. Lemputė ir jungiklis tavo kambaryje.
Duomenų atributai bus štai tokie.

//Mindaugo komentaras: ar verčiame True/False?
* šviesa_įjungta ((True)Taip arba (False)Ne)
* jungiklio_pozicija (Viršuje arba Apačioje)
* elektros_tekėjimas (Taip arba Ne)

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Duomenų atributai gali būti matomi ir nematomi. Pavyzdžiui, mes negalime matyti elektros tekančios į lemputę. Mes tik žinome, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, mes galime matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat mes matome 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 nedarykite ir vardan šio pavyzdžio manykite, jog laidai neegzistuoja), jūs negalėtumėte pakeisti elektros tėkmės tiesiogiai. Jūs taip pat negalite tiesiogiai įtakoti lemputės šviesos (ne, jūs negalite atsukti lemputės ar jos sudaužyti!). Bet, jūs visada galite šiuos atributus įtakoti netiesiogiai naudojant objekto metodus. Jeigu nesumokėsite mokesčių, metodas pavadinimu <code>pakeisti_elektros_tekėjimą</code> pakeis <code>elektros_tekėjimas</code> reikšmę į NE(FALSE). Jei jūs įjungsite jungiklį, <code>pakeisti_jungiklio_poziciją</code> metodas pakeis <code>šviesa_įjungta</code> atributo reikšmę.

Dabar jau tikriausiai galvoji, "Ką tai turi bendro su Pitonu?" ar, "Aš nesuprantu, bet kaip man sukurti tą Objektą?". Na, mes beveik priėjome prie atsakymų! Tik turiu paaiškinti dar vieną idėją prieš neriant į kodą.

Pitone objekto duomenų atributai ir metodai yra nurodomi klasės. Galvokite apie klasė kaip apie objekto techninį piešinį. Pavyzdžiui, jūsų namai - objektas kuriame gyvenate - taip pat jį galite 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 jūsų namus, butą, vasarnamį, na suprantat apie ką kalbu.

Dar kartą, klasė mums 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>

Below is a Procedural program that performs simple math on a single number, entered by a user.
<syntaxhighlight lang="python">

# Program by Mitchell Aikens
# No Copyright
# 2012

# Procedure 1
def main():
try:
# Get a number to maniuplate
num = float(input("Please enter a number to manipulate.\n"))
# Store the result of the value, after it has been manipulated
# by Procedure 2
addednum = addfive(num)
# Store the result of the value, after it has been manipulated
# by Procedure 3
multipliednum = multiply(addednum)
# Send the value to Procedure 4
display(multipliednum)
# Deal with exceptions from non-numeric user entry
except ValueError:
print("You must enter a valid number.\n")
# Reset the value of num, to clear non-numeric data.
num = 0
# Call main, again.
main()

# Procedure 2
def addfive(num):
return num + 5

# Procedure 3
def multiply(addednum):
return addednum * 2.452

# Procedure 4
def display(multi):
# Display the final value
print("The final value is ",multi)

# Call Procedure 1
main()
</syntaxhighlight>

If we were to enter a value of "5", the output would be as shown below.

Please enter a number to manipulate.
5
The final value is 24.52

If we were to enter a value of "g", and then correct the input and enter a value of "8", the output would be as shown below.

Please enter a number to manipulate.
g
You must enter a valid number.

Please enter a number to manipulate.
8
The final value is 31.875999999999998

Below, is a Class, and a program which uses that class. This Object Oriented Program does the same thing as the procedural program above. Let's cover some important OOP coding concepts before we dive into the Class and program.
To create a class, we use the <code>class</code> keyword. After the keyword, you type the name you want to name your class. It is common practice that the name of your class uses CapWords convention.
If I wanted to create a class named dirtysocks, the code would be:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

The Class is shown first. The program which uses the class is second.

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Program

import oopexample

maths = oopexample.NumChange()

def main():

num = float(input("Please enter a number.\n"))

added = maths.addfive(num)

multip = maths.multiply(added)

print("The manipulated value is ",multip)

main()
</syntaxhighlight>

After looking at that program, you are probably a bit lost. That's OK. Let's start off by dissecting the class.
The class is named "NumChange"
There are three methods to this class:
* __init__
* addfive
* multiply

These three methods each have a similar code.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</syntaxhighlight>

Notice how each method has a parameter named "self". This parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.

Let's look at the first method.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-11-03T08:15:32Z

MindaugasP: trumpas pirmos dalies papildymas

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Galvokite 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.).

Data inside an object is called a data attribute. 

Functions, or procedures inside the object are called methods. 

Think of data attributes as variables. 

Think of methods as functions or procedures. 

Let's look at a simple, everyday example. The light and light switch in your bedroom.
The data attributes would be as follows.

* light_on (True or False)
* switch_position (Up or Down)
* electricity_flow (True or False)

The methods would be as follows.

* move_switch
* change_electricity_flow

The data attributes may or may not be visible. For example, you cannot directly see the electricity flowing to the light. You only know there is electricity, because the light is on. However, you can see the position of the switch (switch_position), and you can see if the light is on or off (light_on). Some methods are private. This means that you cannot directly change them. For example, unless you cut the wires in your light fixture (please don't do that, and for the sake of this example, assume that you don't know the wires exist), you cannot change the flow of electricity directly. You also cannot directly change if the light is on or off (and no, you can't unscrew the bulb! work with me here!). However, you can indirectly change these attributes by using the methods in the object. If you don't pay your bill, the <code>change_electricity_flow</code> method will change the value of the <code>electricity_flow</code> attribute to FALSE. If you flip the switch, the <code>move_switch</code> method changes the value of the <code>light_on</code> attribute.

By now you're probably thinking, "What does this have to do with Python?" or, "I understand, but how do I code an Object?" Well, we are almost to that point! One more concept must be explained before we can dive into code.

In Python, an object's data attributes and methods are specified by a class. Think of a class as a blueprint to an object. For example, your home - the object that you live in - you can also call it your pad, bungalow, crib, or whatever, was built based on a set of blueprints; these blueprints would be considered the class used to design your home, pad, crib, ahem, you get the idea.

Again, a class tells us how to make an object. In technical terms, and this is important here, a class defines the data attributes and methods inside an object.

To create a class, we code a class definition. A class definition is a group of statements which define an object's data attributes and methods.

<big>Lesson One</big>

Below is a Procedural program that performs simple math on a single number, entered by a user.
<syntaxhighlight lang="python">

# Program by Mitchell Aikens
# No Copyright
# 2012

# Procedure 1
def main():
try:
# Get a number to maniuplate
num = float(input("Please enter a number to manipulate.\n"))
# Store the result of the value, after it has been manipulated
# by Procedure 2
addednum = addfive(num)
# Store the result of the value, after it has been manipulated
# by Procedure 3
multipliednum = multiply(addednum)
# Send the value to Procedure 4
display(multipliednum)
# Deal with exceptions from non-numeric user entry
except ValueError:
print("You must enter a valid number.\n")
# Reset the value of num, to clear non-numeric data.
num = 0
# Call main, again.
main()

# Procedure 2
def addfive(num):
return num + 5

# Procedure 3
def multiply(addednum):
return addednum * 2.452

# Procedure 4
def display(multi):
# Display the final value
print("The final value is ",multi)

# Call Procedure 1
main()
</syntaxhighlight>

If we were to enter a value of "5", the output would be as shown below.

Please enter a number to manipulate.
5
The final value is 24.52

If we were to enter a value of "g", and then correct the input and enter a value of "8", the output would be as shown below.

Please enter a number to manipulate.
g
You must enter a valid number.

Please enter a number to manipulate.
8
The final value is 31.875999999999998

Below, is a Class, and a program which uses that class. This Object Oriented Program does the same thing as the procedural program above. Let's cover some important OOP coding concepts before we dive into the Class and program.
To create a class, we use the <code>class</code> keyword. After the keyword, you type the name you want to name your class. It is common practice that the name of your class uses CapWords convention.
If I wanted to create a class named dirtysocks, the code would be:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

The Class is shown first. The program which uses the class is second.

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Program

import oopexample

maths = oopexample.NumChange()

def main():

num = float(input("Please enter a number.\n"))

added = maths.addfive(num)

multip = maths.multiply(added)

print("The manipulated value is ",multip)

main()
</syntaxhighlight>

After looking at that program, you are probably a bit lost. That's OK. Let's start off by dissecting the class.
The class is named "NumChange"
There are three methods to this class:
* __init__
* addfive
* multiply

These three methods each have a similar code.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</syntaxhighlight>

Notice how each method has a parameter named "self". This parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.

Let's look at the first method.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-10-22T14:16:23Z

MindaugasP: Pirma dalis įžangos su nebaigtais tarpiniais sakiniais

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Įžanga==

Galvokite apie procedūrą kaip apie funkciją. Funkcija turi konkrečią paskyrtį ir jų gali būti įvairių: rikti įvestis, atlikti matematinius skaičiavimus, atvaizduoti ar manipuliuoti duomenis. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
Pavyzdžiui, suprogramavai 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 panipuliuoti sąrašus ar žodynus. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedūrinis programavimas yra paremtas procedūromis ar funkcijomis. Objektinis programavimas yra paremtas objektais. Ar prisimeni kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni tą programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai narpstytis?
Well, think of an object as a sort of "combination" of those files and data into one "being". In a technical sense, an Object is an entity which contains data, AND procedures (code, functions, etc.).

Data inside an object is called a data attribute. 

Functions, or procedures inside the object are called methods. 

Think of data attributes as variables. 

Think of methods as functions or procedures. 

Let's look at a simple, everyday example. The light and light switch in your bedroom.
The data attributes would be as follows.

* light_on (True or False)
* switch_position (Up or Down)
* electricity_flow (True or False)

The methods would be as follows.

* move_switch
* change_electricity_flow

The data attributes may or may not be visible. For example, you cannot directly see the electricity flowing to the light. You only know there is electricity, because the light is on. However, you can see the position of the switch (switch_position), and you can see if the light is on or off (light_on). Some methods are private. This means that you cannot directly change them. For example, unless you cut the wires in your light fixture (please don't do that, and for the sake of this example, assume that you don't know the wires exist), you cannot change the flow of electricity directly. You also cannot directly change if the light is on or off (and no, you can't unscrew the bulb! work with me here!). However, you can indirectly change these attributes by using the methods in the object. If you don't pay your bill, the <code>change_electricity_flow</code> method will change the value of the <code>electricity_flow</code> attribute to FALSE. If you flip the switch, the <code>move_switch</code> method changes the value of the <code>light_on</code> attribute.

By now you're probably thinking, "What does this have to do with Python?" or, "I understand, but how do I code an Object?" Well, we are almost to that point! One more concept must be explained before we can dive into code.

In Python, an object's data attributes and methods are specified by a class. Think of a class as a blueprint to an object. For example, your home - the object that you live in - you can also call it your pad, bungalow, crib, or whatever, was built based on a set of blueprints; these blueprints would be considered the class used to design your home, pad, crib, ahem, you get the idea.

Again, a class tells us how to make an object. In technical terms, and this is important here, a class defines the data attributes and methods inside an object.

To create a class, we code a class definition. A class definition is a group of statements which define an object's data attributes and methods.

<big>Lesson One</big>

Below is a Procedural program that performs simple math on a single number, entered by a user.
<syntaxhighlight lang="python">

# Program by Mitchell Aikens
# No Copyright
# 2012

# Procedure 1
def main():
try:
# Get a number to maniuplate
num = float(input("Please enter a number to manipulate.\n"))
# Store the result of the value, after it has been manipulated
# by Procedure 2
addednum = addfive(num)
# Store the result of the value, after it has been manipulated
# by Procedure 3
multipliednum = multiply(addednum)
# Send the value to Procedure 4
display(multipliednum)
# Deal with exceptions from non-numeric user entry
except ValueError:
print("You must enter a valid number.\n")
# Reset the value of num, to clear non-numeric data.
num = 0
# Call main, again.
main()

# Procedure 2
def addfive(num):
return num + 5

# Procedure 3
def multiply(addednum):
return addednum * 2.452

# Procedure 4
def display(multi):
# Display the final value
print("The final value is ",multi)

# Call Procedure 1
main()
</syntaxhighlight>

If we were to enter a value of "5", the output would be as shown below.

Please enter a number to manipulate.
5
The final value is 24.52

If we were to enter a value of "g", and then correct the input and enter a value of "8", the output would be as shown below.

Please enter a number to manipulate.
g
You must enter a valid number.

Please enter a number to manipulate.
8
The final value is 31.875999999999998

Below, is a Class, and a program which uses that class. This Object Oriented Program does the same thing as the procedural program above. Let's cover some important OOP coding concepts before we dive into the Class and program.
To create a class, we use the <code>class</code> keyword. After the keyword, you type the name you want to name your class. It is common practice that the name of your class uses CapWords convention.
If I wanted to create a class named dirtysocks, the code would be:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

The Class is shown first. The program which uses the class is second.

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Program

import oopexample

maths = oopexample.NumChange()

def main():

num = float(input("Please enter a number.\n"))

added = maths.addfive(num)

multip = maths.multiply(added)

print("The manipulated value is ",multip)

main()
</syntaxhighlight>

After looking at that program, you are probably a bit lost. That's OK. Let's start off by dissecting the class.
The class is named "NumChange"
There are three methods to this class:
* __init__
* addfive
* multiply

These three methods each have a similar code.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</syntaxhighlight>

Notice how each method has a parameter named "self". This parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.

Let's look at the first method.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-10-21T19:26:46Z

MindaugasP: /* Objektinis programavimas */

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Introduction==

Think of a procedure as a function. A function has a specific purpose. That purpose may be gathering input, performing mathematical calculations, displaying data, or manipulating data to, from, or in, a file. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
For example, you have designed a program which stores information about a product in variables. When a customer requests information on a product, these variables are passed to different functions for different purposes. Later on, as more data is stored on these products, you decide to store the information in a list or dictionary. In order for your program to function, you must now edit each function that accepted variables, to now accept and manipulate a list or dictionary. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedural programming is centered on procedures or functions. But, OOP is centered on creating Objects. Remember how a procedural program has separated data and code? Remember how that huge program was hundreds of files and would take FOREVER to edit? Well, think of an object as a sort of "combination" of those files and data into one "being". In a technical sense, an Object is an entity which contains data, AND procedures (code, functions, etc.).

Data inside an object is called a data attribute. 

Functions, or procedures inside the object are called methods. 

Think of data attributes as variables. 

Think of methods as functions or procedures. 

Let's look at a simple, everyday example. The light and light switch in your bedroom.
The data attributes would be as follows.

* light_on (True or False)
* switch_position (Up or Down)
* electricity_flow (True or False)

The methods would be as follows.

* move_switch
* change_electricity_flow

The data attributes may or may not be visible. For example, you cannot directly see the electricity flowing to the light. You only know there is electricity, because the light is on. However, you can see the position of the switch (switch_position), and you can see if the light is on or off (light_on). Some methods are private. This means that you cannot directly change them. For example, unless you cut the wires in your light fixture (please don't do that, and for the sake of this example, assume that you don't know the wires exist), you cannot change the flow of electricity directly. You also cannot directly change if the light is on or off (and no, you can't unscrew the bulb! work with me here!). However, you can indirectly change these attributes by using the methods in the object. If you don't pay your bill, the <code>change_electricity_flow</code> method will change the value of the <code>electricity_flow</code> attribute to FALSE. If you flip the switch, the <code>move_switch</code> method changes the value of the <code>light_on</code> attribute.

By now you're probably thinking, "What does this have to do with Python?" or, "I understand, but how do I code an Object?" Well, we are almost to that point! One more concept must be explained before we can dive into code.

In Python, an object's data attributes and methods are specified by a class. Think of a class as a blueprint to an object. For example, your home - the object that you live in - you can also call it your pad, bungalow, crib, or whatever, was built based on a set of blueprints; these blueprints would be considered the class used to design your home, pad, crib, ahem, you get the idea.

Again, a class tells us how to make an object. In technical terms, and this is important here, a class defines the data attributes and methods inside an object.

To create a class, we code a class definition. A class definition is a group of statements which define an object's data attributes and methods.

<big>Lesson One</big>

Below is a Procedural program that performs simple math on a single number, entered by a user.
<syntaxhighlight lang="python">

# Program by Mitchell Aikens
# No Copyright
# 2012

# Procedure 1
def main():
try:
# Get a number to maniuplate
num = float(input("Please enter a number to manipulate.\n"))
# Store the result of the value, after it has been manipulated
# by Procedure 2
addednum = addfive(num)
# Store the result of the value, after it has been manipulated
# by Procedure 3
multipliednum = multiply(addednum)
# Send the value to Procedure 4
display(multipliednum)
# Deal with exceptions from non-numeric user entry
except ValueError:
print("You must enter a valid number.\n")
# Reset the value of num, to clear non-numeric data.
num = 0
# Call main, again.
main()

# Procedure 2
def addfive(num):
return num + 5

# Procedure 3
def multiply(addednum):
return addednum * 2.452

# Procedure 4
def display(multi):
# Display the final value
print("The final value is ",multi)

# Call Procedure 1
main()
</syntaxhighlight>

If we were to enter a value of "5", the output would be as shown below.

Please enter a number to manipulate.
5
The final value is 24.52

If we were to enter a value of "g", and then correct the input and enter a value of "8", the output would be as shown below.

Please enter a number to manipulate.
g
You must enter a valid number.

Please enter a number to manipulate.
8
The final value is 31.875999999999998

Below, is a Class, and a program which uses that class. This Object Oriented Program does the same thing as the procedural program above. Let's cover some important OOP coding concepts before we dive into the Class and program.
To create a class, we use the <code>class</code> keyword. After the keyword, you type the name you want to name your class. It is common practice that the name of your class uses CapWords convention.
If I wanted to create a class named dirtysocks, the code would be:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

The Class is shown first. The program which uses the class is second.

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Program

import oopexample

maths = oopexample.NumChange()

def main():

num = float(input("Please enter a number.\n"))

added = maths.addfive(num)

multip = maths.multiply(added)

print("The manipulated value is ",multip)

main()
</syntaxhighlight>

After looking at that program, you are probably a bit lost. That's OK. Let's start off by dissecting the class.
The class is named "NumChange"
There are three methods to this class:
* __init__
* addfive
* multiply

These three methods each have a similar code.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</syntaxhighlight>

Notice how each method has a parameter named "self". This parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.

Let's look at the first method.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}

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

2021-10-21T19:26:28Z

MindaugasP: Pradinis įvado vertimas

==Objektinis programavimas==

Iki šiol tu naudojai procedūrinį programavimo būdą. Tačiau, yra daug programų, kurios - parašytos naudojant objektinį programavimo būdą. Žinant abu būdus ir jų skirtumus yra labai svarbu. Informatikoje, daug svarbių kalbų kaip C++ ar Java dažnai naudoja objektinį programavimo būdą.

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

Šis skyrius yra padalintas į keletą pamokų. Kiekviena pamoka yra skirta paaiškinti skirtingas objektinio programavimo dalis. YRA LABAI SVARBU suprasti visas objektinio programavimo dalis. Prieš kiekvieną pamoką, bus parašyta įžanga, kuri paaiškins pagrindines idėjas, sąvokas ir kitas objektinio programavimo sritis, kurios yra reikalingos suprasti kiekvieną pamoką.

==Introduction==

Think of a procedure as a function. A function has a specific purpose. That purpose may be gathering input, performing mathematical calculations, displaying data, or manipulating data to, from, or in, a file. Typically, procedures use data which is separate from code for manipulation. This data is often passed between procedures. When a program becomes much larger and complex, this can cause problems.
For example, you have designed a program which stores information about a product in variables. When a customer requests information on a product, these variables are passed to different functions for different purposes. Later on, as more data is stored on these products, you decide to store the information in a list or dictionary. In order for your program to function, you must now edit each function that accepted variables, to now accept and manipulate a list or dictionary. Imagine the time that would take for a program that was hundreds of megabytes, and hundreds of files in size! It would drive you insane! not to mention, errors in your code, are almost guaranteed, just because of the large volume of work and possibilities to make a typo or other error. This is less than optimal.
Procedural programming is centered on procedures or functions. But, OOP is centered on creating Objects. Remember how a procedural program has separated data and code? Remember how that huge program was hundreds of files and would take FOREVER to edit? Well, think of an object as a sort of "combination" of those files and data into one "being". In a technical sense, an Object is an entity which contains data, AND procedures (code, functions, etc.).

Data inside an object is called a data attribute. 

Functions, or procedures inside the object are called methods. 

Think of data attributes as variables. 

Think of methods as functions or procedures. 

Let's look at a simple, everyday example. The light and light switch in your bedroom.
The data attributes would be as follows.

* light_on (True or False)
* switch_position (Up or Down)
* electricity_flow (True or False)

The methods would be as follows.

* move_switch
* change_electricity_flow

The data attributes may or may not be visible. For example, you cannot directly see the electricity flowing to the light. You only know there is electricity, because the light is on. However, you can see the position of the switch (switch_position), and you can see if the light is on or off (light_on). Some methods are private. This means that you cannot directly change them. For example, unless you cut the wires in your light fixture (please don't do that, and for the sake of this example, assume that you don't know the wires exist), you cannot change the flow of electricity directly. You also cannot directly change if the light is on or off (and no, you can't unscrew the bulb! work with me here!). However, you can indirectly change these attributes by using the methods in the object. If you don't pay your bill, the <code>change_electricity_flow</code> method will change the value of the <code>electricity_flow</code> attribute to FALSE. If you flip the switch, the <code>move_switch</code> method changes the value of the <code>light_on</code> attribute.

By now you're probably thinking, "What does this have to do with Python?" or, "I understand, but how do I code an Object?" Well, we are almost to that point! One more concept must be explained before we can dive into code.

In Python, an object's data attributes and methods are specified by a class. Think of a class as a blueprint to an object. For example, your home - the object that you live in - you can also call it your pad, bungalow, crib, or whatever, was built based on a set of blueprints; these blueprints would be considered the class used to design your home, pad, crib, ahem, you get the idea.

Again, a class tells us how to make an object. In technical terms, and this is important here, a class defines the data attributes and methods inside an object.

To create a class, we code a class definition. A class definition is a group of statements which define an object's data attributes and methods.

<big>Lesson One</big>

Below is a Procedural program that performs simple math on a single number, entered by a user.
<syntaxhighlight lang="python">

# Program by Mitchell Aikens
# No Copyright
# 2012

# Procedure 1
def main():
try:
# Get a number to maniuplate
num = float(input("Please enter a number to manipulate.\n"))
# Store the result of the value, after it has been manipulated
# by Procedure 2
addednum = addfive(num)
# Store the result of the value, after it has been manipulated
# by Procedure 3
multipliednum = multiply(addednum)
# Send the value to Procedure 4
display(multipliednum)
# Deal with exceptions from non-numeric user entry
except ValueError:
print("You must enter a valid number.\n")
# Reset the value of num, to clear non-numeric data.
num = 0
# Call main, again.
main()

# Procedure 2
def addfive(num):
return num + 5

# Procedure 3
def multiply(addednum):
return addednum * 2.452

# Procedure 4
def display(multi):
# Display the final value
print("The final value is ",multi)

# Call Procedure 1
main()
</syntaxhighlight>

If we were to enter a value of "5", the output would be as shown below.

Please enter a number to manipulate.
5
The final value is 24.52

If we were to enter a value of "g", and then correct the input and enter a value of "8", the output would be as shown below.

Please enter a number to manipulate.
g
You must enter a valid number.

Please enter a number to manipulate.
8
The final value is 31.875999999999998

Below, is a Class, and a program which uses that class. This Object Oriented Program does the same thing as the procedural program above. Let's cover some important OOP coding concepts before we dive into the Class and program.
To create a class, we use the <code>class</code> keyword. After the keyword, you type the name you want to name your class. It is common practice that the name of your class uses CapWords convention.
If I wanted to create a class named dirtysocks, the code would be:
<syntaxhighlight lang="python">
class DirtySocks
</syntaxhighlight>

The Class is shown first. The program which uses the class is second.

<syntaxhighlight lang="python">
# Filename: oopexample.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Class

class NumChange:

def __init__(self):
self.__number = 0

def addfive(self,num):
self.__number = num
return self.__number + 5

def multiply(self,added):
self.__added = added
return self.__added * 2.452
</syntaxhighlight>

The program which uses the class above, is below.

<syntaxhighlight lang="python">
# Filename: oopexampleprog.py
# Mitchell Aikens
# No Copyright
# 2012
# OOP Demonstration - Program

import oopexample

maths = oopexample.NumChange()

def main():

num = float(input("Please enter a number.\n"))

added = maths.addfive(num)

multip = maths.multiply(added)

print("The manipulated value is ",multip)

main()
</syntaxhighlight>

After looking at that program, you are probably a bit lost. That's OK. Let's start off by dissecting the class.
The class is named "NumChange"
There are three methods to this class:
* __init__
* addfive
* multiply

These three methods each have a similar code.
<syntaxhighlight lang="python">
def __init__(self):
def addfive(self,num):
def multiply(self,added):
</syntaxhighlight>

Notice how each method has a parameter named "self". This parameter must be present in each method of the class. This parameter doesn't HAVE TO be called "self", but it is standard practice, which means you should probably stick with it. This parameter is required in each method because when a method executes, it has to know which object's attributes to operate on. Even though there is only one Object, we still need to make sure the interpreter knows that we want to use the data attributes in that class. So we play it safe...and use the "self" parameter.

Let's look at the first method.
<syntaxhighlight lang="python">
def __init__(self):
</syntaxhighlight>

Most Classes in Python have an <code>__init__</code> which executes automatically when an instance of a class is created in memory. (When we reference a class, an instance [or object] of that class is created.) This method is commonly referred to as the initializer method. When the method executes, the "self" parameter is automatically assigned to the object. This method is called the initializer method because is "initializes" the data attributes. ↵Under the __init__ method, we set the value of the <code>number</code> attribute to 0 initially.
We reference the object attribute using dot notation.
<syntaxhighlight lang="python">
def __init__(self):
self.__number = 0
</syntaxhighlight>
The <code>self.__number = 0</code> line simply means ""the value of the attribute "number", in the object, is 0"".

Let's look at the next method.
<syntaxhighlight lang="python">
def addfive(self,num):
self.__number = num
return self.__number + 5
</syntaxhighlight>

This method is named "addfive". It accepts a parameter called "num", from the program using the class. The method then assigns the value of that parameter to the "number" attribute inside the object. The method then returns the value of "number", with 5 added to it, to the statement which called the method.

Let's look at the third method.
<syntaxhighlight lang="python">
def multiply(self,added):
self.__added = added
return self.__added * 2.453
</syntaxhighlight>

This method is named "multiply". It accepts a parameter named "added". It assigns the value of the parameter to the "added" attribute, and returns the value of the "added" attribute multiplied by 2.452, to the statement which called the method.

Notice how the name of each method begins with two underscores? Let's explain that.
Earlier we mentioned that an object operates on data attributes inside itself using methods. Ideally, these data attributes should be able to be manipulated ONLY BY METHODS IN THE OBJECT. It is possible to have outside code manipulate data attributes. To "hide" attributes, so only methods in the object can manipulate them, you use two underscores before the object name, as we have been demonstrating. Omitting those two underscores in the attribute name, allows for the possibility of manipulation from code outside the object.

Let's look at the program which uses the class we just dissected.

Notice the first line of non comment code.
<syntaxhighlight lang="python">
import oopexample
</syntaxhighlight>

This line of code imports the class, which we have saved in a separate file (module). Classes do not have to be in a separate file, but it is almost always the case, and thus is good practice to get used to importing the module now.

The next line:
<syntaxhighlight lang="python">
maths = oopexample.NumChange()
</syntaxhighlight>

This line creates an instance of the NumChange class, stored in the module named "oopexample", and stores the instance in the variable named "maths".
The syntax is:
<code>modulename.Classname()</code>
Next we define the main function.
Then, we get a number from the user.

The next line <code>added = maths.addfive(num)</code> sends the value of the "num" variable to the method named "addfive", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "added".

The next line <code>multip = maths.multiply(added)</code> sends the value of the variable "added", to the method named "multiply", which is part of the class we stored an instance of in the variable named "maths", and stores the returned value in the variable named "multip".

The next line prints "The manipulated value is <value of multip>". The last line calls the main function which executes the steps outlined above.

{{navigation |previous=Recursion |next=Intro to Imported Libraries and other Functions}}
{{BookCat}}