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

Python Vadovėlis/Funkcijų apibrėžimas

2022-02-13T15:15:52Z

Juratevalat:

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

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

Programos rezultatas:

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

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

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

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

Programos rezultatas:

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

Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. pabandykime patyrinėti dar kelias naujas funkcijas.

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

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

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

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

labas()
labas()

rašyk_mano_vardas("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. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.



=== Kintamieji funkcijose ===
Dažnai pasitaiko, kad pasikartojančiam kode yra kintamųjų, todėl į juos reikia atkreipti dėmesį, kai šaliname pakartotiną kodą. Iki šiol visi kintamieji, kuriuos matėme 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>, esantys funkcijos viduje, yra lokalūs kintamieji. Po paskutinės funkcijos eilutės <code>return b_var + 10</code> įvykdymo, 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>.

Kai funkcija iškviečiama naudojant <code>c_var = funkcija(b_var)</code>, 15 priskiriama kintamajam <code>a_var</code>, nes tuo metu, kai kviečiama funkcija <code>funkcija(b_var)</code>, globalaus <code>b_var</code> reikšmė yra 15. Taigi <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 funkcijos viduje, dingo. Tad komanda <code>print ("a_var =", a_var)</code> atspausdina reikšmę <code>10</code>, t. y. globaliojo kintamojo <code>a_var</code> 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>. Pasibaigus funkcijai, visi lokalūs kintamieji ištrinami. Jeigu nori, ką nors gauti iš funkcijos, turėsi naudoti komandą <code>return</code>.

Paskutinis dalykas, į kurį reikia atkreipti dėmesį, yra tai, kad funkcijos viduje <code>e_var</code> reikšmė išlieka nepakitusi, nes tai nėra nei parametras, nei lokalus kintamasis – jis niekada nerodomas kairėje lygybės pusėje. Kai funkcijos viduje kreipiamasi į globalų kintamąjį, tai jis naudoja reikšmę, įgytą už funkcijos ribų.

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

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

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

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

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

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

Kaip tai veikia?:

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

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

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

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

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

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

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

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

Kaip veikia ši programa?

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

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

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

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

Pasirinkimai:
s = skaičiuoti kvadrato plotą.
c = skaičiuoti apskritimo plotą.
r = skaičiuoti stačiakampio plotą.
q = išeiti.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

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

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

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

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

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

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

2022-02-12T15:53:53Z

Juratevalat: /* Įžanga */

==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/Įvadas į objektinį programavimą Python 3

2022-02-12T15:20:54Z

Juratevalat: /* Įžanga */

==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 logika tada priskiria „sk“ reikšmę objekte esančiui atributui su pavadinimu „skaičius“. Tada metodas prideda 5 prie „skaičius“ ir jį grąžina į 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ą jį kviečiančiam.

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

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

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

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

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

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

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

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

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

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

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

2022-02-12T15:05:57Z

Juratevalat: /* Įžanga */

==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):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2022-02-12T14:41:35Z

Juratevalat: /* Įžanga */

==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):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

2022-02-12T14:34:45Z

Juratevalat: /* Įžanga */

==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 duoemnis 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 procedūromis (funkcijomis). Objektinis programavimas yra paremtas objektais. Ar prisimeni, kaip procedūrinė programa atskyrė duomenis nuo kodo? Ar prisimeni programą, kuri turėjo šimtus failų ir norint kažką pakeisti reikėdavo ilgai joje narpstytis?
Galvok apie objektą kaip apie minėtų failų ir duomenų „kombinaciją“ į vieną esybę. Technine prasme, objektas yra esybė, kuri savyje turi duomenis ir procedūras (kodą, funkcijas, t.t.).

Duomenis objekto viduje vadiname atributais. 

Funkcijas ar procedūras objekto viduje vadiname metodais. 

Galvok apie duomenų atributus kaip apie kintamuosius. 

Galvok apie metodus kaip apie funkcijas ar procedūras. 

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

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

Metodai būtų štai tokie.

* pakeisti_jungiklio_poziciją
* pakeisti_elektros_tekėjimą

Atributai gali būti matomi ir nematomi. Pavyzdžiui, tu negali matyti elektros tekančios į lemputę. Tu tik žinai, kad elektra išties teka, nes ji tuo metu skleidžia šviesą. Nepaisant to, tu gali matyti jungiklio poziciją (jungiklio_pozicija) ir taip pat tu matai ar šviesa yra įjungta ar ne (šviesa_įjungta). Kai kurie metodai yra privatūs. Tai reiškia, jog jų 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):
def pridėkpenkis(self,sk):
def padaugink(self,pridėtas):
</syntaxhighlight>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Python Vadovėlis/Terminai

2022-02-12T13:32:13Z

Juratevalat:

Computer - kompiuteris

Container - konteineris

Control strukture - valdymo struktūra

Counter - skaitliukas

Debugging - derinimas

Directory - katalogas

Exercise - pratimas

Expression - reiškinys

False - Melas

Feature - ypatybė

Floating point - slankusis kablelis

Good practices - gerosios praktikos

Hard-coded - įkoduotas/užprogramuotas

IDLE - „IDLE“ kodo redaktorius/kodo redaktorius

Indent - įtrauka

Instance - objektas

Item - elementas

Iterable - iteruojamasis

List - sąrašas

Loop - ciklas

Mouse - pelė

Operator - operatorius

Optional - pasirinktinas

Output - išvestis/rezultatas

Prepackaged - iš anksto paruošti paketai

Prompt - kviesti

Python - Python'as

Run (daikt.) - vykdymas

Shell - terminalas/konsolės langas

Site-packages - svetainės paketai

Solution - sprendimas

Source code - pirminis programos tekstas

Statement - sakinys

String - tekstinė eilutė/eilutė

Terminate - nutraukti darbą/stabdyti programą

True - Tiesa

User - naudotojas

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

Python Vadovėlis/Rekursija

2022-02-12T12:28:03Z

Juratevalat:

== Rekursija ==

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

=== Įvadas į rekursiją ===

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

sk = 0

def main():
skaitliukas(sk)

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

main()
</syntaxhighlight>

Jei šią programą paleistum 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š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.

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

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

main()
</syntaxhighlight>

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

== Praktiniai rekursijos pritaikymai ==

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

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

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

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

Štai keletas pagrindinių faktorialo taisyklių:

Jei n = 0 tai n! = 1

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

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

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

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

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

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

main()
</syntaxhighlight>

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

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

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

Python Vadovėlis/Rekursija

2022-02-12T12:12:13Z

Juratevalat:

== Rekursija ==

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

=== Įvadas į rekursiją ===

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

sk = 0

def main():
skaitliukas(sk)

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

main()
</syntaxhighlight>

Jei šią programą paleistum 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š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.

Rekursija 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/Siekiant tobulumo

2022-02-12T11:27:47Z

Juratevalat: /* Klaidų „gaudymas“ su try */

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

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

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

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

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

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

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

=== Pratimai ===
Pataisyk telefono numerių programą ([[Vadovėlis/Žodynai|Žodynai]] skyriuje), kad ji neužstrigtų, jei naudotojas neįrašo jokios įvesties į meniu.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def spausdink_meniu():
print('1. Spausdink telefonų numerius')
print('2. Pridėk telefono numerį')
print('3. Pašalink telefono numerį')
print('4. Ieškok telefono numerio')
print('5. Išeik')
print()

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

</syntaxhighlight>
|-
|}
{{navigation |previous=Failų IO |next=Rekursija}}
{{BookCat}}

Python Vadovėlis/Failų tvarkymas

2022-02-12T11:24:18Z

Juratevalat: /* Pažangesnis .txt failų naudojimas */

=== 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 toje vietoje peršokti į naują eilutę.

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 failo turinį ir grąžina jį kaip eilutę (kaip padaryta pavyzdyje).

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

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

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

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

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

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

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

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

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

print("Viso!")
</syntaxhighlight>

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

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

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

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

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

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

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

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

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

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

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

=== 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 spausdintuvu atspausdinti failo duomenis neatidarant jokios 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 pačiam failo atidarinėti ir spausdinti. Šis metodas apima kitos programos subproceso (arba antrinis procesas; biblioteka 'subprocess') iškvietimą.

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

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

pagrindinis()
</syntaxhighlight>

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

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

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

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

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

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

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

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

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie tekstines eilutes |next=Siekiant tobulumo}}
{{BookCat}}

Python Vadovėlis/Failų tvarkymas

2022-02-12T11:10:25Z

Juratevalat: /* Failų I/O */

=== 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 toje vietoje peršokti į naują eilutę.

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 failo turinį ir grąžina jį kaip eilutę (kaip padaryta pavyzdyje).

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

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

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

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

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

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

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

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

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

print("Viso!")
</syntaxhighlight>

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

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

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

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

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

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

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

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

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

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

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

=== 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.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
užduotys = ['nd sk 1', 'nd sk 2', 'viktorina ', 'nd sk 3', 'testas']
mokiniai = { }

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

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

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

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

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

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

</syntaxhighlight>
|-
|}

{{navigation |previous=Daugiau apie tekstines eilutes |next=Siekiant tobulumo}}
{{BookCat}}

Python Vadovėlis/Daugiau apie tekstines eilutes

2022-02-12T10:44:18Z

Juratevalat:

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

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

rėk("Ačiū")

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

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

Rezultatas:

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

Šios dvi programos rodo, kad tekstinė reikšmė (string) yra keliais aspektais panaši į sąrašą (list). Funkcija <code>rėk()</code> rodo, kad ciklas <code>for</code> gali būti naudojamas su tekstine reikšme lygiai taip pat kaip ir su sąrašais. Funkcija <code>vidurys()</code> rodo, kad su tekstine reikšme galima naudoti sąrašo funkciją <code>len()</code>, taip pat sąrašo indeksavimu ir pjaustymu. Taigi, dauguma sąrašo (list) funkcijų veikia ir su tekstine reikšme.

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

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

Rezultatas:

ĮRAŠYTAS TEKSTAS

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

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

Žinoma, tai tik programos pavyzdys, tačiau daug paprasčiau tai padaryti naudojantis funkcija <code>tekstoEilutė.upper()</code>, kuri veikia su visomis kalbomis.

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

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

Jeigu dar nesupratai, tai funkcija <code>str()</code> konvertuoja skaičių į tekstinę reikšmę (skaičiai suprantami, kaip simblių seka), o funkcija <code>int()</code> konvertuoja tekstinę reikšmę į sveikąjį skaičių. Funkcija <code>float()</code> konvertuoja tekstinę reikšmę arba skaičių į dešimtainį skaičių (skaičių su kableliu). Grįžtant prie funkcijos <code>str()</code> – ji grąžina tekstinę įrašytos reikšmės versiją. Štai keli pavyzdžiai:

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

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

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

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

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

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

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

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

Ar pastebėjai kaip <code>split()</code> konvertuoja tekstinę reikšmę į tekstinių reikšmių sąrašą (angl. list)? Kai funkcijai nenurodytas argmentas – skyriklis, pagal ką suskirstyti į skirtingus sąrašo elementus, funkcija skirsto pagal tarpus. Antrame pavyzdyje skyriklis yra kablelis.
Taip pat galima pridėti ir kitą argumentą, kuris nurodo <code>split()</code> funkcijai, kurioje sąrašo vietoje reikia atskirti tekstą:

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


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

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

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

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

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

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

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

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

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

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

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

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

Rezultatas:

2
23445
-23445
14234
12345
-3512

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

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

2022-02-12T10:12:18Z

Juratevalat:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gauk_pastorintą(poema)
</syntaxhighlight>

šios programos išvestis yra:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

































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

Python Vadovėlis/Modulių naudojimas

2022-02-12T09:52:55Z

Juratevalat:

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

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

Ir čia yra gautos programos išvestis:

Įvesk metų skaičių: 2001

2001

Sausis Vasaris Kovas

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

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

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

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

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

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

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

Dalis išvesties yra:

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

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

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

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

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

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

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

print("Būtent tas")

</syntaxhighlight>
|-
|}

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

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

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

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

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

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

arba alternatyvus kodas

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

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

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

Python Vadovėlis/Žodynai

2022-02-12T09:11:08Z

Juratevalat:

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

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

</syntaxhighlight>

O čia - mano išvestis:

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

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

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

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

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


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

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

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

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

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

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

O štai čia yra išvestis:

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

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

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

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

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

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

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

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

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

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

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

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

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

Python Vadovėlis/Žodynai

2022-02-08T12:49:33Z

Juratevalat:

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

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

</syntaxhighlight>

O čia - mano išvestis:

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

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

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

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

Ši programa yra panaši į į programą su vardų sąrašu, pateiktą prieš tai buvusiame skyriuje apie sąrašus. Štai kaip veikia programa. Pirmiausiai yra aprašoma funkcija <code>spausdink_meniu</code>. <code>spausdink_meniu</code> tiesiog spausdina meniu, kuris vėliau du kartus naudojamas programoje. Po to, pateikiama keistai atrodanti eilutė <code>numeriai = {}</code>. Ši eilutė Python'ui pasako, kad <code>numeriai</code> yra žodynas. Kitos kelios eilutės tiesiog padaro taip, kad meniu veiktų. Vykdydant ciklą:
<syntaxhighlight lang="python">
for x in numeriai.keys():
print("Vardas: ", x, "\tTelefono numeris:", numeriai[x])
</syntaxhighlight>
einama per žodyną ir spausdinami žodyne esantys elementai. Funkcija <code> numeriai.keys()</code> grąžina žodyno elementų raktų sąrašą, kuris yra vėliau naudojamas <code>for</code> cikle. Sąrašas grąžinamas <code>keys()</code> metodo pagalba neturi jokio eiliškumo, todėl, jei tu nori, kad jis būtų abėcėlės tvarka, jis turi būti surūšiuotas. Panašiai kaip sąrašai, komanda <code>numeriai[x]</code> naudojam norint pasiekti konkretų žodyno elementą. Šiuo atveju <code>x</code> yra tekstinė eilutė. 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:
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ų 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> (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/Loginiai reiškiniai

2022-02-07T19:25:01Z

Juratevalat:

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

Šios programos išvestis yra:

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

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

















Eilučių:

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

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

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

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

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

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

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

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

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

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

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

kiekis = 0

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

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

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

Šios programos rezultatas:
Pirmasis atitikmuo: Gyvenimas

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Pavyzdiniai rezultatai:

Koks tavo vardas? '''Benas'''

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

Sveikas, Benai!

Koks tavo vardas? '''Andrius'''

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

Aš tavęs nepažįstu.

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

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

</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Loginiai reiškiniai

2022-02-07T19:06:07Z

Juratevalat:

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

Šios programos išvestis yra:

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

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

















Eilučių:

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

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

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

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

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

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

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

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

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

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

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

kiekis = 0

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

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

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

Šios programos rezultatas:
Pirmasis atitikmuo: Gyvenimas

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Pavyzdiniai rezultatai:

Koks tavo vardas? '''Benas'''

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

Sveikas, Benai!

Koks tavo vardas? '''Andrius'''

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

Aš tavęs nepažįstu.

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

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

</syntaxhighlight>
|-
|}

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

Python Vadovėlis/Ciklai For

2022-02-07T18:59:00Z

Juratevalat:

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

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

Python Vadovėlis/Sąrašai

2022-02-07T18:38:24Z

Juratevalat: /* Daugiau sąrašų funkcijų */

=== Kintamieji, turintys daugiau nei vieną reikšmę ===
Tu jau žinai įprastus kintamuosius, kuriuose saugoma viena reikšmė. Tačiau kiti kintamųjų tipai gali turėti daugiau nei vieną reikšmę. Jie vadinami konteineriais (containers), nes juose gali būti daugiau nei vienas objektas. Paprasčiausias tipas vadinamas sąrašu (list). Sąrašo pavyzdys:
<syntaxhighlight lang="python">
kuris = int(input("Kuris mėnuo (1-12)? "))
mėnesiai = ["Sausis", "Vasaris", "Kovas", "Balandis", "Gegužė", "Birželis", "Liepa",
"Rugpjūtis", "Rugsėjis", "Spalis", "Lapkritis", "Gruodis"]

if 1 <= kuris <= 12:
print("Mėnuo yra ", mėnesiai[kuris - 1])
</syntaxhighlight>

pavyzdžio išvestis būtų:

Kuris mėnuo (1-12)? '''3'''
Mėnuo yra Kovas

Šiame pavyzdyje <code>mėnesiai</code> yra sąrašas. Kintamasis <code>mėnesiai</code> yra apibrėžtas šia eilute <code>mėnesiai = ["Sausis", "Vasaris", "Kovas", "Balandis", "Gegužė", "Birželis", "Liepa",</code> ir <code>"Rugpjūtis", "Rugsėjis", "Spalis", "Lapkritis", "Gruodis"]</code> (atkreipk dėmesį, kad viena komanda parašyta per dvi eilutes; paprastai keliant eilutę yra naudojamas simbolis / tačiau šiuo atveju jis nėra būtinas, nes Python'as supranta, kad viskas, kas yra laužtiniuose skliaustuose yra kartu). <code>[</code> ir <code>]</code> pradeda ir užbaigia sąrašą, o kableliai (<code>,</code>) atskiria sąrašo elementus. Sąrašas naudojamas šioje dalyje: <code>mėnesiai[kuris - 1]</code>. Sąrašas susideda iš elementų, kurie sunumeruoti pradedant nuo 0. Kitaip tariant, norint sąraše pasiekti elementą "Sausis", turėtum rašyti <code>mėnesiai[0]</code>. Nurodant sąrašui skaičių, tu gauni reikšmę išsaugotą toje sąrašo pozicijoje.

Sąlyginis sakinys <code> if 1 <= kuris <= 12:</code> tikrina, ar skaičius kintamajame <code>kuris</code> yra tarp vieno ir dvylikos imtinai (tiek yra mėnesių ir taip jie numeruojami).

Viename sąraše gali būti saugomi ir skirtingų tipų duomenys. Kiekvienas elementas saugo vis kitą reikšmę. Pavyzdžiui, sąrašas sukurtas šiuo kodu: <code>demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]</code> atrodytų taip:

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

Kiekvienas elementas pasiekiamas per jo eilės numerį – indeksą, todėl komanda <code>demoSąrašas[0]</code> pateiktų reikšmę: <code>"gyvybė"</code>, o komanda <code>demoSąrašas[1]</code> – reikšmę <code>42</code> ir taip toliau iki kol <code>demoSąrašas[5]</code> pateikia reikšmę <code>9</code>.

=== Daugiau sąrašų funkcijų ===
Kitas pavyzdys yra skirtas parodyti daugybę kitų dalykų, kuriuos gali padaryti sąrašai (šį kartą nesitikiu, kad viską pats sugebėsi parašyti, bet tikriausiai turėtum šiek tiek pažaisti su sąrašais interaktyviame režime, kol apsiprasi su jais). Pavyzdys:
<syntaxhighlight lang="python">
demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]
print("demoSąrašas = ", demoSąrašas)
demoSąrašas.append("oras")
print("po 'oras' pridėjimo, demoSąrašas atrodo taip:")
print(demoSąrašas)
print("len(demoSąrašas) =", len(demoSąrašas))
print("demoSąrašas.index(42) =", demoSąrašas.index(42))
print("demoSąrašas[1] =", demoSąrašas[1])

# o dabar mes pereisime per visą sąrašą "for" ciklu
for c in range(len(demoSąrašas)):
print("demoSąrašas[", c, "] =", demoSąrašas[c])

del demoSąrašas[2]
print("Po 'visata' pašalinimo, demoSąrašas atrodo taip:")
print(demoSąrašas)
if "gyvybė" in demoSąrašas:
print("'gyvybė' buvo rasta kintamajame demoSąrašas")
else:
print("'gyvybė' nebuvo rasta kintamajame demoSąrašas")

if "ameba" in demoSąrašas:
print("'ameba' buvo rasta kintamajame demoSąrašas")

if "ameba" not in demoSąrašas:
print("'ameba' nebuvo rasta kintamajame demoSąrašas")

kitasSąrašas = [42, 7, 0, 123]
kitasSąrašas.sort()
print("Išrikiuotas kitasSąrašas atrodo taip", kitasSąrašas)
</syntaxhighlight>

Kodo išvestis būtų tokia:

demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]
po "oras" pridėjimo, demoSąrašas atrodo taip:
["gyvybė", 42, "visata", 6, "ir", 9, "oras"]
len(demoSąrašas) = 7
demoSąrašas.index(42) = 1
demoSąrašas[1] = 42
demoSąrašas[ 0 ] = gyvybė
demoSąrašas[ 1 ] = 42
demoSąrašas[ 2 ] = visata
demoSąrašas[ 3 ] = 6
demoSąrašas[ 4 ] = ir
demoSąrašas[ 5 ] = 9
demoSąrašas[ 6 ] = oras
Po 'visata' pašalinimo, demoSąrašas atrodo taip:
["gyvybė", 42, 6, "ir", 9, "oras"]
"gyvybė" buvo rasta kintamajame demoSąrašas
"ameba" nebuvo rasta kintamajame demoSąrašas
Išrikiuotas kitasSąrašas atrodo taip [0, 7, 42, 123]

Šiame pavyzdyje naudojama visa krūva naujų funkcijų. Atkreipk dėmesį, kad gali tiesiog atspausdinti (<code>print</code>) visą sąrašą. Toliau funkcija <code>append</code> naudojama tam, kad pridėtum naują elementą į sąrašo pabaigą. <code>len</code> grąžina kiek elementų yra sąraše. Tinkami sąrašo indeksai (skaičiai kuriuos naudojame viduje laužtinių skliaustų <code>[]</code>) yra nuo 0 iki <code>len - 1</code>. Funkcija <code>index</code> nurodo, kur sąraše yra pirmoji elemento vieta. Atkreipk dėmesį, kaip <code>demoSąrašas.index(42)</code> pateikia 1, o paleidus <code>demoSąrašas[1]</code> grąžina 42. Norint gauti pagalbos dėl visų sąrašo funkcijų, įvykdyk komandą <code> help(list)</code> interaktyviajame Python'o interpretatoriuje.

Eilutė <code># o dabar mes pereisime per visą sąrašą <code>for</code> ciklu</code> yra tik priminimas programuotojui (dar vadinamas kaip „komentaras“). Python'as ignoruoja viską, kas parašyta esamoje eilutėje po simbolio <code>#</code>. Toliau eilutės:
<syntaxhighlight lang="python">
for c in range(len(demoSąrašas)):
print("demoSąrašas[", c, "] =", demoSąrašas[c])
</syntaxhighlight>
sukuria kintamajį <code>c</code>, kuris prasideda nuo 0 ir didinamas vienetu, kol pasiekia paskutinį sąrašo indeksą. Tuo tarpu <code>print</code> komanda išspausdina kiekvieną sąrašo elementą.

Daug geresnis būdas tai padaryti:
<syntaxhighlight lang="python">
for c, x in enumerate(demoSąrašas):
print("demoSąrašas[", c, "] =", x)
</syntaxhighlight>

Komanda <code>del</code> gali būti naudojama tam tikram sąrašo elementui pašalinti. Kitos kelios eilutės naudoja <code>in</code> operatorių, kad patikrintų, ar elementas yra sąraše, ar ne. Funkcija <code>sort</code> rūšiuoja sąrašą. Tai naudinga, jei tau reikia sąrašo nuo mažiausio iki didžiausio arba abėcėlės tvarka. Atmink, kad tai pakeičia sąrašą. Apibendrinant, su sąrašu yra atliekami šie veiksmai:

{| class="wikitable"
!pavyzdys
!paaiškinimas
|-
|<code>demoSąrašas[2]</code>
|grąžina 2 sąrašo demoSąrašas elementą
|-
|<code>demoSąrašas[2] = 3</code>
|į sąrašo demoSąrašas 2 poziciją (numeruojama nuo 0) įrašo reikšmę 3
|-
|<code>del demoSąrašas[2]</code>
|pašalina sąrašo demoSąrašas elementą, esantį 2 pozicijoje
|-
|<code>len(demoSąrašas)</code>
|grąžina <code>demoSąrašas</code> sąrašo ilgį, t.y. elementų skaičių
|-
|<code>"reikšmė" in demoSąrašas</code>
|yra ''True'' jeigu <tt>"reikšmė"</tt> yra elementas, priklausantis <code>demoSąrašas</code>
|-
|<code>"reikšmė" not in demoSąrašas</code>
|yra ''True'' jeigu <code>"reikšmė"</code> nėra elementas, priklausantis <code>demoSąrašas</code>
|-
|<code>kitasSąrašas.sort()</code>
|surūšiuoja <code>kitasSąrašas</code>. Atmink, kad rūšiavimas pavyktų, visi sąrašo elementai turi būti arba skaičiai, arba eilutės (string).
|-
|<code>demoSąrašas.index("reikšmė")</code>
|grąžina pirmosios vietos, kurioje atsiranda <code>"reikšmė"</code>, indeksą
|-
|<code>demoSąrašas.append("reikšmė")</code>
|sąrašo pabaigoje prideda elementą <code>"reikšmė"</code>
|-
|<code>demoSąrašas.remove("reikšmė")</code>
|pašalina pirmą rastą elementą su nurodyta reikšme iš <code>demoSąrašas</code> (taip pat, kaip <code>del demoSąrašas[demoSąrašas.index("reikšmė")]</code>)
|}

Pavyzdžiai, kur praktiškai naudojamos šios funkcijos:
<syntaxhighlight lang="python">
meniuElementas = 0
vardųSarašas = []
while meniuElementas != 9:
print("--------------------")
print("1. Spausdinti sąrašą")
print("2. Pridėti vardą prie sąrašo")
print("3. Pašalinti vardą iš sąrašo")
print("4. Pakeisti elementą sąraše")
print("9. Išeiti")
meniuElementas = int(input("Pasirinkite elementą iš meniu: "))
if meniuElementas == 1:
dabartinis = 0
if len(vardųSarašas) > 0:
while dabartinis < len(vardųSarašas):
print(dabartinis, ".", vardųSarašas[dabartinis])
dabartinis = dabartinis + 1
else:
print("Sąrašas tuščias")
elif meniuElementas == 2:
vardas = input("Įveskite vardą, kurį norite pridėti: ")
vardųSarašas.append(vardas)
elif meniuElementas == 3:
šalinamasVardas = input("Kokį vardą norėtumėte pašalinti:")
if šalinamasVardas in vardųSarašas:
# vardųSarašas.remove(šalinamasVardas) veiktų taip pat gerai
elementoIndeksas = vardųSarašas.index(šalinamasVardas)
del vardųSarašas[elementoIndeksas]
# Aukščiau pateiktas kodas pašalina tik pirmąjį surasta vardą.
# Žemiau esantis kodas pašalina visus.
# while šalinamasVardas in vardųSarašas:
# elementoIndeksas = vardųSarašas.index(šalinamasVardas)
# del vardųSarašas[elementoIndeksas]
else:
print(šalinamasVardas, "nerastas")
elif meniuElementas == 4:
senasVardas = input("Kokį vardą norėtumėte pakeisti:")
if senasVardas in vardųSarašas:
elementoIndeksas = vardųSarašas.index(senasVardas)
naujasVardas = input("Koks yra naujas vardas: ")
vardųSarašas[elementoIndeksas] = naujasVardas
else:
print(senasVardas, "nerastas")

print("Iki pasimatymo")
</syntaxhighlight>

Ir čia yra išvesties dalis:

--------------------
1. Spausdinti sąrašą
2. Pridėti vardą prie sąrašo
3. Pašalinti vardą iš sąrašo
4. Pakeisti elementą sąraše
9. Išeiti

Pasirinkite elementą iš meniu: '''2'''
Įveskite vardą, kurį norite pridėti: '''Benas'''

Pasirinkite elementą iš meniu: '''2'''
Įveskite vardą, kurį norite pridėti: '''Liepa'''

Pasirinkite elementą iš meniu: '''1'''
0. Benas
1. Liepa

Pasirinkite elementą iš meniu: '''3'''
Kokį vardą norėtumėte pašalinti: '''Benas'''

Pasirinkite elementą iš meniu: '''4'''
Kokį vardą norėtumėte pakeisti: '''Liepa'''
Koks yra naujas vardas: '''Liepa Petraitė'''

Pasirinkite elementą iš meniu: '''1'''
0. Liepa Petraitė

Pasirinkite elementą iš meniu: '''9'''
Iki pasimatymo

Tai buvo ilga programa. Panagrinėkime pirminį programos tekstą. Eilutė <code>vardųSarašas = []</code> sukuria kintamajį <code>vardųSarašas</code>, tuščia sąrašą, be elementų. Kita svarbi eilutė yra <code>while meniuElementas != 9:</code>. Ši eilutė pradeda ciklą, leidžiantį šios programos meniu sistemai veikti. Kitos eilutės parodo meniu ir nusprendžia, kurią programos dalį paleisti.

Ši dalis:
<syntaxhighlight lang="python">
dabartinis = 0
if len(vardųSarašas) > 0:
while dabartinis < len(vardųSarašas):
print(dabartinis, ".", vardųSarašas[dabartinis])
dabartinis = dabartinis + 1
else:
print("Sąrašas tuščias")
</syntaxhighlight>
eina per sąrašą ir spausdina kiekvieną vardą. <code>len(vardųSarašas)</code> nurodo, kiek elementų yra sąraše. Jei <code>len</code> grąžina <code>0</code>, tai reiškia sąrašas tuščias.

Toliau po kelių eilučių matysi sakinį <code>vardųSarašas.append(vardas)</code>. Jis naudoja funkciją <code>append</code>, kad pridėtų elementą į sąrašo pabaigą. Peršokus dar dvi eilutes, pastebėsi šią kodo dalį:
<syntaxhighlight lang="python">
elementoIndeksas = vardųSarašas.index(šalinamasVardas)
del vardųSarašas[elementoIndeksas]
</syntaxhighlight>
Čia funkcija <code>index</code> yra naudojama norint rasti indekso reikšmę, kuri vėliau bus naudojama elementui pašalinti. <code>del vardųSarašas[elementoIndeksas]</code> naudojamas sąrašo elementui pašalinti.

Kitoje kodo dalyje
<syntaxhighlight lang="python">
senasVardas = input("Kokį vardą norėtumėte pakeisti:")
if senasVardas in vardųSarašas:
elementoIndeksas = vardųSarašas.index(senasVardas)
naujasVardas = input("Koks yra naujas vardas: ")
vardųSarašas[elementoIndeksas] = naujasVardas
else:
print(senasVardas, "nerastas")
</syntaxhighlight>
naudojamas <code>index</code>, kad surastų <code>elementoIndeksas</code> ir tada įdėtų <code>naujasVardas</code> ten, kur buvo <code>senasVardas</code>.

Sveikinu, perpratus sąrašus, dabar tu pakankamai žinai kalbą, kad galėtum atlikti bet kokius skaičiavimus, kuriuos gali atlikti kompiuteris (tai techniškai žinoma kaip [[Wikipedia:Turing_completeness|Turing-Completeness]]). Žinoma, vis dar yra daug funkcijų, kurias naudojant tu pasilengvinsi sau gyvenimą.

=== Pavyzdžiai ===
'''testas.py'''
<syntaxhighlight lang="python">
## Ši programa atlieka žinių patikrinimą

# Pirmiausia surenkame testo klausimus.
# Vėliau šią dalį pakeisime, kad būtų naudojama failinė sistema.
def gauti_klausimus():
# atkreipk dėmesį, kad duomenys saugomi kaip sąrašų sąrašas
return [["Kokios spalvos yra dangus giedrą dieną? ", "mėlynas"],
["Koks atsakymas į gyvenimą, visatą ir viską? ", "42"],
["Kas yra keturių raidžių žodis pelės gaudyklei? ", "katė"]]

# Ši dalis patikrins vieną klausimą
# pateikiamas vienas klausimas
# grąžinama teisinga (True), jei vartotojas įvedė teisingą atsakymą, kitu atveju - klaidinga (False)

def pateik_klausimą(klausimas_ir_atsakymas):
# ištraukiame klausimą ir atsakymą iš sąrašo
# Ši funkcija priima dviejų elementų sąrašą, klausimą ir atsakymą.
klausimas = klausimas_ir_atsakymas[0]
atsakymas = klausimas_ir_atsakymas[1]
# užduodame klausimą vartotojui
duotas_atsakymas = input(klausimas)
# palyginame vartotojo atsakymą su teisingu atsakymu
if atsakymas == duotas_atsakymas:
print("Teisingai")
return True
else:
print("Neteisingai. Teisingas atsakymas: ", atsakymas)
return False

# Šis kodas apims visus klausimus
def atlikti_testus(klausimai):
if len(klausimai) == 0:
print("Nepateiktas nei vienas klausimas.")
# `return` išeis iš funkcijos
return
indeksas = 0
teisingai = 0
while indeksas < len(klausimai):
# patikriname klausimą
# Atkreipk dėmesį, kad tai yra klausimų ir atsakymų sąrašo ištraukimas iš sąrašų sąrašo.
if pateik_klausimą(klausimai[indeksas]):
teisingai = teisingai + 1
# pareiname prie kito klausimo
indeksas = indeksas + 1
# atkreipk dėmesį į skaičiavimo tvarką: pirmiausia padaugini, tada padalini
print("Atsakei teisingai į ", teisingai * 100 / len(klausimai),\
"% klausimų iš ", len(klausimai))

# dabar paimkime klausimus iš funkcijos gauti_klausimus ir
# paduokime grąžintą sąrašų sąrašą kaip argumentą funkcijai atlikti_testus.

atlikti_testus(gauti_klausimus())

</syntaxhighlight>

Reikšmės <code>True</code> ir <code>False</code> turi reikšmes atitinkamai 1 ir 0. Jie dažnai naudojami loginės sekos patikrinimui, ciklo sąlygoms ir pan. Daugiau apie tai sužinosi šiek tiek vėliau (skyrius [[Vadovėlis/Loginiai reiškiniai|Loginiai reiškiniai]]).
Atkreipk dėmesį, kad gauti_klausimus() iš esmės yra sąrašas, nors tai techniškai yra funkcija - sąrašų grąžinimas yra vienintelis dalykas, kurį jis daro.

Pavyzdžio išvestis:

Kokios spalvos yra dangus giedrą dieną? '''žalias'''
Neteisingai. Teisingas atsakymas: mėlynas
Koks atsakymas į gyvenimą, visatą ir viską? '''42'''
Teisingai
Kas yra keturių raidžių žodis pelės gaudyklei? '''katė'''
Teisingai
Atsakei teisingai į 66% klausimų iš 3

=== Pratimai ===

Išplėsk testas.py programą, kad ji turėtų meniu, kuriame būtų galima atlikti testą,
peržiūrėti klausimų ir atsakymų sąrašą ir pasirinkti išeiti iš programos. Taip pat, pridėk naują klausimą:
„Kokį triukšmą kelia tikrai pažangi mašina?“ su teisingu atsakymu „ping“.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
## Ši programa atlieka žinių patikrinimą

klausimai = [["Kokios spalvos yra dangus giedrą dieną? ", "mėlynas"],
["Koks atsakymas į gyvenimą, visatą ir viską? ", "42"],
["Kas yra keturių raidžių žodis pelės gaudyklei? ", "katė"],
["Kokį triukšmą kelia tikrai pažangi mašina?", "ping"]]

# Ši dalis patikrins vieną klausimą
# pateikiamas vienas klausimas
# grąžinama teisinga (True), jei vartotojas įvedė teisingą atsakymą, kitu atveju - klaidinga (False)

def pateik_klausimą(klausimas_ir_atsakymas):
# ištraukiame klausimą ir atsakymą iš sąrašo
# Ši funkcija priima dviejų elementų sąrašą, klausimą ir atsakymą.
klausimas = klausimas_ir_atsakymas[0]
atsakymas = klausimas_ir_atsakymas[1]
# užduodame klausimą vartotojui
duotas_atsakymas = input(klausimas)
# palyginame vartotojo atsakymą su teisingu atsakymu
if atsakymas == duotas_atsakymas:
print("Teisingai")
return True
else:
print("Neteisingai. Teisingas atsakymas: ", atsakymas)
return False

# Šis kodas apims visus klausimus
def atlikti_testus(klausimai):
if len(klausimai) == 0:
print("Nepateiktas nei vienas klausimas.")
# `return` išeis iš funkcijos
return
indeksas = 0
teisingai = 0
while indeksas < len(klausimai):
# patikriname klausimą
# Atkreipk dėmesį, kad tai yra klausimų ir atsakymų sąrašo ištraukimas iš sąrašų sąrašo.
if pateik_klausimą(klausimai[indeksas]):
teisingai = teisingai + 1
# pareiname prie kito klausimo
indeksas = indeksas + 1
# atkreipk dėmesį į skaičiavimo tvarką: pirmiausia padaugini, tada padalini
print("Atsakei teisingai į ", teisingai * 100 / len(klausimai),\
"% klausimų iš ", len(klausimai))

#rodomas klausimų ir atsakymų sąrašas
def rodyk_klausimus():
k = 0
while k < len(klausimai):
a = 0
print("K:" , klausimai[k][a])
a = 1
print("A:" , klausimai[k][a])
k = k + 1

# dabar apibrėžiu meniu funkciją
def meniu():
print("-----------------")
print("Meniu:")
print("1 - Atlikti testą")
print("2 - Peržiūrėti klausimų ir atsakymų sąrašą")
print("3 - Peržiūrėti meniu")
print("5 - Išeiti")
print("-----------------")

pasirinkimas = "3"
while pasirinkimas != "5":
if pasirinkimas == "1":
atlikti_testus(klausimai)
elif pasirinkimas == "2":
rodyk_klausimus()
elif pasirinkimas == "3":
meniu()
print()
pasirinkimas = input("Pasirinkite savo parinktį iš aukščiau pateikto meniu: ")

</syntaxhighlight>
|-
|}

{{navigation |previous=Pažangių funkcijų pavyzdys |next=Ciklai For}}
{{BookCat}}

Python Vadovėlis/Sąrašai

2022-02-07T17:20:02Z

Juratevalat: /* Kintamieji, turintys daugiau nei vieną reikšmę */

=== Kintamieji, turintys daugiau nei vieną reikšmę ===
Tu jau žinai įprastus kintamuosius, kuriuose saugoma viena reikšmė. Tačiau kiti kintamųjų tipai gali turėti daugiau nei vieną reikšmę. Jie vadinami konteineriais (containers), nes juose gali būti daugiau nei vienas objektas. Paprasčiausias tipas vadinamas sąrašu (list). Sąrašo pavyzdys:
<syntaxhighlight lang="python">
kuris = int(input("Kuris mėnuo (1-12)? "))
mėnesiai = ["Sausis", "Vasaris", "Kovas", "Balandis", "Gegužė", "Birželis", "Liepa",
"Rugpjūtis", "Rugsėjis", "Spalis", "Lapkritis", "Gruodis"]

if 1 <= kuris <= 12:
print("Mėnuo yra ", mėnesiai[kuris - 1])
</syntaxhighlight>

pavyzdžio išvestis būtų:

Kuris mėnuo (1-12)? '''3'''
Mėnuo yra Kovas

Šiame pavyzdyje <code>mėnesiai</code> yra sąrašas. Kintamasis <code>mėnesiai</code> yra apibrėžtas šia eilute <code>mėnesiai = ["Sausis", "Vasaris", "Kovas", "Balandis", "Gegužė", "Birželis", "Liepa",</code> ir <code>"Rugpjūtis", "Rugsėjis", "Spalis", "Lapkritis", "Gruodis"]</code> (atkreipk dėmesį, kad viena komanda parašyta per dvi eilutes; paprastai keliant eilutę yra naudojamas simbolis / tačiau šiuo atveju jis nėra būtinas, nes Python'as supranta, kad viskas, kas yra laužtiniuose skliaustuose yra kartu). <code>[</code> ir <code>]</code> pradeda ir užbaigia sąrašą, o kableliai (<code>,</code>) atskiria sąrašo elementus. Sąrašas naudojamas šioje dalyje: <code>mėnesiai[kuris - 1]</code>. Sąrašas susideda iš elementų, kurie sunumeruoti pradedant nuo 0. Kitaip tariant, norint sąraše pasiekti elementą "Sausis", turėtum rašyti <code>mėnesiai[0]</code>. Nurodant sąrašui skaičių, tu gauni reikšmę išsaugotą toje sąrašo pozicijoje.

Sąlyginis sakinys <code> if 1 <= kuris <= 12:</code> tikrina, ar skaičius kintamajame <code>kuris</code> yra tarp vieno ir dvylikos imtinai (tiek yra mėnesių ir taip jie numeruojami).

Viename sąraše gali būti saugomi ir skirtingų tipų duomenys. Kiekvienas elementas saugo vis kitą reikšmę. Pavyzdžiui, sąrašas sukurtas šiuo kodu: <code>demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]</code> atrodytų taip:

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

Kiekvienas elementas pasiekiamas per jo eilės numerį – indeksą, todėl komanda <code>demoSąrašas[0]</code> pateiktų reikšmę: <code>"gyvybė"</code>, o komanda <code>demoSąrašas[1]</code> – reikšmę <code>42</code> ir taip toliau iki kol <code>demoSąrašas[5]</code> pateikia reikšmę <code>9</code>.

=== Daugiau sąrašų funkcijų ===
Kitas pavyzdys yra skirtas parodyti daugybę kitų dalykų, kuriuos gali padaryti sąrašai (šį kartą nesitikiu, kad viską susivesi į programą, bet tikriausiai turėtum šiek tiek pažaisti su sąrašais interaktyviame režime, kol apsiprasi su jais). Pavyzdys:
<syntaxhighlight lang="python">
demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]
print("demoSąrašas = ",demoSąrašas)
demoSąrašas.append("oras")
print("po 'oras' pridėjimo, demoSąrašas atrodo taip:")
print(demoSąrašas)
print("len(demoSąrašas) =", len(demoSąrašas))
print("demoSąrašas.index(42) =", demoSąrašas.index(42))
print("demoSąrašas[1] =", demoSąrašas[1])

# o dabar mes pereisime per visą sąrašą "for" ciklu
for c in range(len(demoSąrašas)):
print("demoSąrašas[", c, "] =", demoSąrašas[c])

del demoSąrašas[2]
print("Po 'visata' pašalinimo, demoSąrašas atrodo taip:")
print(demoSąrašas)
if "gyvybė" in demoSąrašas:
print("'gyvybė' buvo rasta kintamajame demoSąrašas")
else:
print("'gyvybė' nebuvo rasta kintamajame demoSąrašas")

if "ameba" in demoSąrašas:
print("'ameba' buvo rasta kintamajame demoSąrašas")

if "ameba" not in demoSąrašas:
print("'ameba' nebuvo rasta kintamajame demoSąrašas")

kitasSąrašas = [42,7,0,123]
kitasSąrašas.sort()
print("Išrikiuotas kitasSąrašas atrodo taip", kitasSąrašas)
</syntaxhighlight>

Kodo išvestis būtų tokia:

demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]
po "oras" pridėjimo, demoSąrašas atrodo taip:
["gyvybė", 42, "visata", 6, "ir", 9, "oras"]
len(demoSąrašas) = 7
demoSąrašas.index(42) = 1
demoSąrašas[1] = 42
demoSąrašas[ 0 ] = gyvybė
demoSąrašas[ 1 ] = 42
demoSąrašas[ 2 ] = visata
demoSąrašas[ 3 ] = 6
demoSąrašas[ 4 ] = ir
demoSąrašas[ 5 ] = 9
demoSąrašas[ 6 ] = oras
Po 'visata' pašalinimo, demoSąrašas atrodo taip:
["gyvybė", 42, 6, "ir", 9, "oras"]
"gyvybė" buvo rasta kintamajame demoSąrašas
"ameba" nebuvo rasta kintamajame demoSąrašas
Išrikiuotas kitasSąrašas atrodo taip [0, 7, 42, 123]

Šiame pavyzdyje naudojama visa krūva naujų funkcijų. Atkreipk dėmesį, kad gali tiesiog atspausdinti (<code>print</code>) visą sąrašą. Toliau funkcija <code>append</code> naudojama tam, kad pridėtum naują elementą į sąrašo pabaigą. <code>len</code> grąžina kiek elementų yra sąraše. Tinkami sąrašo indeksai (skaičiai kuriuos naudojame viduje laužtinių skliaustų <code>[]</code>) yra nuo 0 iki <code>len - 1</code>. Funkcija <code>index</code> nurodo, kur sąraše yra pirmoji elemento vieta. Atkreipk dėmesį, kaip <code>demoSąrašas.index(42)</code> pateikia 1, o paleidus <code>demoSąrašas[1]</code> grąžina 42. Norint gauti pagalbos dėl visų sąrašo funkcijų, įvesk <code> help(list)</code> interaktyviajame Python'o interpretatoriuje.

Eilutė <code># o dabar mes pereisime per visą sąrašą <code>for</code> ciklu</code> yra tik priminimas programuotojui (dar vadinamas kaip „komentaras“). Python'as ignoruoja viską, kas parašyta esamoje eilutėje iškarto po simbolio <code>#</code>. Toliau eilutės:
<syntaxhighlight lang="python">
for c in range(len(demoSąrašas)):
print("demoSąrašas[", c, "] =", demoSąrašas[c])
</syntaxhighlight>
sukuria kintamajį <code>c</code>, kuris prasideda nuo 0 ir didinamas, kol pasiekia paskutinį sąrašo indeksą. Tuo tarpu <code>print</code> teiginys išspausdina kiekvieną sąrašo elementą.

Daug geresnis būdas tai padaryti:
<syntaxhighlight lang="python">
for c, x in enumerate(demoSąrašas):
print("demoSąrašas[", c, "] =", x)
</syntaxhighlight>

Komanda <code>del</code> gali būti naudojama tam tikram sąrašo elementui pašalinti. Kitos kelios eilutės naudoja <code>in</code> operatorių, kad patikrintų, ar elementas yra sąraše, ar ne. Funkcija <code>sort</code> rūšiuoja sąrašą. Tai naudinga, jei tau reikia sąrašo nuo mažiausio iki didžiausio arba abėcėlės tvarka. Atmink, kad tai pakeičia sąrašą. Apibendrinant, su sąrašu yra atliekami šie veiksmai:

{| class="wikitable"
!pavyzdys
!paaiškinimas
|-
|<code>demoSąrašas[2]</code>
|pasiekia elementą ties indeksu 2
|-
|<code>demoSąrašas[2] = 3</code>
|nustato elementą ties indeksu 2 kaip 3
|-
|<code>del demoSąrašas[2]</code>
|pašalina elementą, esantį 2 indekse
|-
|<code>len(demoSąrašas)</code>
|grąžina <code>demoSąrašas</code> ilgį
|-
|<code>"reikšmė" in demoSąrašas</code>
|yra ''True'' jeigu <tt>"reikšmė"</tt> yra elementas, priklausantis <code>demoSąrašas</code>
|-
|<code>"reikšmė" not in demoSąrašas</code>
|yra ''True'' jeigu <code>"reikšmė"</code> nėra elementas, priklausantis <code>demoSąrašas</code>
|-
|<code>kitasSąrašas.sort()</code>
|surūšiuoja <code>kitasSąrašas</code>. Atmink, kad rūšiavimas pavyktų, visi sąrašo elementai turi būti arba skaičiai, arba eilutės (string).
|-
|<code>demoSąrašas.index("reikšmė")</code>
|grąžina pirmosios vietos, kurioje atsiranda <code>"reikšmė"</code>, indeksą
|-
|<code>demoSąrašas.append("reikšmė")</code>
|sąrašo pabaigoje prideda elementą <code>"reikšmė"</code>
|-
|<code>demoSąrašas.remove("reikšmė")</code>
|pašalina pirmą rastą elementą su nurodyta reišme iš <code>demoSąrašas</code> (taip pat, kaip <code>del demoSąrašas[demoSąrašas.index("reikšmė")]</code>)
|}

Šiame kitame pavyzdyje šios funkcijos naudojamos naudingiau:
<syntaxhighlight lang="python">
meniuElementas = 0
vardųSarašas = []
while meniuElementas != 9:
print("--------------------")
print("1. Spausdinti sąrašą")
print("2. Pridėti vardą prie sąrašo")
print("3. Pašalinti vardą iš sąrašo")
print("4. Pakeisti elementą sąraše")
print("9. Išeiti")
meniuElementas = int(input("Pasirinkite elementą iš meniu: "))
if meniuElementas == 1:
dabartinis = 0
if len(vardųSarašas) > 0:
while dabartinis < len(vardųSarašas):
print(dabartinis, ".", vardųSarašas[dabartinis])
dabartinis = dabartinis + 1
else:
print("Sąrašas tuščias")
elif meniuElementas == 2:
vardas = input("Įveskite vardą, kurį norite pridėti: ")
vardųSarašas.append(vardas)
elif meniuElementas == 3:
šalinamasVardas = input("Kokį vardą norėtumėte pašalinti:")
if šalinamasVardas in vardųSarašas:
# vardųSarašas.remove(šalinamasVardas) veiktų taip pat gerai
elementoIndeksas = vardųSarašas.index(šalinamasVardas)
del vardųSarašas[elementoIndeksas]
# Aukščiau pateiktas kodas pašalina tik pirmąjį surasta vardą.
# Žemiau esantis kodas pašalina visus.
# while šalinamasVardas in vardųSarašas:
# elementoIndeksas = vardųSarašas.index(šalinamasVardas)
# del vardųSarašas[elementoIndeksas]
else:
print(šalinamasVardas, "nerastas")
elif meniuElementas == 4:
senasVardas = input("Kokį vardą norėtumėte pakeisti:")
if senasVardas in vardųSarašas:
elementoIndeksas = vardųSarašas.index(senasVardas)
naujasVardas = input("Koks yra naujas vardas: ")
vardųSarašas[elementoIndeksas] = naujasVardas
else:
print(senasVardas, "nerastas")

print("Iki pasimatymo")
</syntaxhighlight>

Ir čia yra išvesties dalis:

--------------------
1. Spausdinti sąrašą
2. Pridėti vardą prie sąrašo
3. Pašalinti vardą iš sąrašo
4. Pakeisti elementą sąraše
9. Išeiti

Pasirinkite elementą iš meniu: '''2'''
Įveskite vardą, kurį norite pridėti: '''Benas'''

Pasirinkite elementą iš meniu: '''2'''
Įveskite vardą, kurį norite pridėti: '''Liepa'''

Pasirinkite elementą iš meniu: '''1'''
0. Benas
1. Liepa

Pasirinkite elementą iš meniu: '''3'''
Kokį vardą norėtumėte pašalinti: '''Benas'''

Pasirinkite elementą iš meniu: '''4'''
Kokį vardą norėtumėte pakeisti: '''Liepa'''
Koks yra naujas vardas: '''Liepa Petraitė'''

Pasirinkite elementą iš meniu: '''1'''
0. Liepa Petraitė

Pasirinkite elementą iš meniu: '''9'''
Iki pasimatymo

Tai buvo ilga programa. Panagrinėkime pirminį programos tekstą. Eilutė <code>vardųSarašas = []</code> sukuria kintamajį <code>vardųSarašas</code>, tuščia sąrašą, be elementų. Kita svarbi eilutė yra <code>while meniuElementas != 9:</code>. Ši eilutė pradeda ciklą, leidžiantį šios programos meniu sistemai veikti. Kitos eilutės parodo meniu ir nusprendžia, kurią programos dalį paleisti.

Ši dalis:
<syntaxhighlight lang="python">
dabartinis = 0
if len(vardųSarašas) > 0:
while dabartinis < len(vardųSarašas):
print(dabartinis, ".", vardųSarašas[dabartinis])
dabartinis = dabartinis + 1
else:
print("Sąrašas tuščias")
</syntaxhighlight>
eina per sąrašą ir spausdina kiekvieną vardą. <code>len(vardųSarašas)</code> nurodo, kiek elementų yra sąraše. Jei <code>len</code> grąžina <code>0</code>,tai reiškia sąrašas tuščias.

Toliau po kelių eilučių matysi teiginį <code>vardųSarašas.append(vardas)</code>. Jis naudoja funkciją <code>append</code>, kad pridėtų elementą į sąrašo pabaigą. Peršokus dar dvi eilutes, pastebėsi šią kodo dalį:
<syntaxhighlight lang="python">
elementoIndeksas = vardųSarašas.index(šalinamasVardas)
del vardųSarašas[elementoIndeksas]
</syntaxhighlight>
Čia funkcija <code>index</code> yra naudojama norint rasti indekso reikšmę, kuri vėliau bus naudojama elementui pašalinti. <code>del vardųSarašas[elementoIndeksas]</code> naudojamas sąrašo elementui pašalinti.

Kitoje kodo dalyje
<syntaxhighlight lang="python">
senasVardas = input("Kokį vardą norėtumėte pakeisti:")
if senasVardas in vardųSarašas:
elementoIndeksas = vardųSarašas.index(senasVardas)
naujasVardas = input("Koks yra naujas vardas: ")
vardųSarašas[elementoIndeksas] = naujasVardas
else:
print(senasVardas, "nerastas")
</syntaxhighlight>
naudojamas <code>index</code>, kad surastų <code>elementoIndeksas</code> ir tada įdėtų <code>naujasVardas</code> ten, kur buvo <code>senasVardas</code>.

Sveikinu, perpratus sąrašus, dabar tu pakankamai žinai kalbą, kad galėtum atlikti bet kokius skaičiavimus, kuriuos gali atlikti kompiuteris (tai techniškai žinoma kaip [[Wikipedia:Turing_completeness|Turing-Completeness]]). Žinoma, vis dar yra daug funkcijų, kurias naudojant tu pasilengvinsi sau gyvenimą.

=== Pavyzdžiai ===
'''testas.py'''
<syntaxhighlight lang="python">
## Ši programa atlieka žinių patikrinimą

# Pirmiausia surenkame testo klausimus.
# Vėliau šią dalį pakeisime, kad būtų naudojama failinė sistema.
def gauti_klausimus():
# atkreipk dėmesį, kad duomenys saugomi kaip sąrašų sąrašas
return [["Kokios spalvos yra dangus giedrą dieną? ", "mėlynas"],
["Koks atsakymas į gyvenimą, visatą ir viską? ", "42"],
["Kas yra keturių raidžių žodis pelės gaudyklei? ", "katė"]]

# Ši dalis patikrins vieną klausimą
# pateikiamas vienas klausimas
# grąžinama teisinga (True), jei vartotojas įvedė teisingą atsakymą, kitu atveju - klaidinga (False)

def pateik_klausimą(klausimas_ir_atsakymas):
# ištraukiame klausimą ir atsakymą iš sąrašo
# Ši funkcija priima dviejų elementų sąrašą, klausimą ir atsakymą.
klausimas = klausimas_ir_atsakymas[0]
atsakymas = klausimas_ir_atsakymas[1]
# užduodame klausimą vartotojui
duotas_atsakymas = input(klausimas)
# palyginame vartotojo atsakymą su teisingu atsakymu
if atsakymas == duotas_atsakymas:
print("Teisingai")
return True
else:
print("Neteisingai. Teisingas atsakymas: ", atsakymas)
return False

# Šis kodas apims visus klausimus
def atlikti_testus(klausimai):
if len(klausimai) == 0:
print("Nepateiktas nei vienas klausimas.")
# `return` išeis iš funkcijos
return
indeksas = 0
teisingai = 0
while indeksas < len(klausimai):
# patikriname klausimą
# Atkreipk dėmesį, kad tai yra klausimų ir atsakymų sąrašo ištraukimas iš sąrašų sąrašo.
if pateik_klausimą(klausimai[indeksas]):
teisingai = teisingai + 1
# pareiname prie kito klausimo
indeksas = indeksas + 1
# atkreipk dėmesį į skaičiavimo tvarką: pirmiausia padaugini, tada padalini
print("Atsakei teisingai į ", teisingai * 100 / len(klausimai),\
"% klausimų iš ", len(klausimai))

# dabar paimkime klausimus iš funkcijos gauti_klausimus ir
# paduokime grąžintą sąrašų sąrašą kaip argumentą funkcijai atlikti_testus.

atlikti_testus(gauti_klausimus())

</syntaxhighlight>

Reikšmės <code>True</code> ir <code>False</code> turi reikšmes atitinkamai 1 ir 0. Jie dažnai naudojami loginės sekos patikrinimui, ciklo sąlygoms ir pan. Daugiau apie tai sužinosi šiek tiek vėliau (skyrius [[Vadovėlis/Loginiai reiškiniai|Loginiai reiškiniai]]).
Atkreipk dėmesį, kad gauti_klausimus() iš esmės yra sąrašas, nors tai techniškai yra funkcija - sąrašų grąžinimas yra vienintelis dalykas, kurį jis daro.

Pavyzdžio išvestis:

Kokios spalvos yra dangus giedrą dieną? '''žalias'''
Neteisingai. Teisingas atsakymas: mėlynas
Koks atsakymas į gyvenimą, visatą ir viską? '''42'''
Teisingai
Kas yra keturių raidžių žodis pelės gaudyklei? '''katė'''
Teisingai
Atsakei teisingai į 66% klausimų iš 3

=== Pratimai ===

Išplėsk testas.py programą, kad ji turėtų meniu, kuriame būtų galima atlikti testą,
peržiūrėti klausimų ir atsakymų sąrašą ir pasirinkti išeiti iš programos. Taip pat, pridėk naują klausimą:
„Kokį triukšmą kelia tikrai pažangi mašina?“ su teisingu atsakymu „ping“.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
## Ši programa atlieka žinių patikrinimą

klausimai = [["Kokios spalvos yra dangus giedrą dieną? ", "mėlynas"],
["Koks atsakymas į gyvenimą, visatą ir viską? ", "42"],
["Kas yra keturių raidžių žodis pelės gaudyklei? ", "katė"],
["Kokį triukšmą kelia tikrai pažangi mašina?", "ping"]]

# Ši dalis patikrins vieną klausimą
# pateikiamas vienas klausimas
# grąžinama teisinga (True), jei vartotojas įvedė teisingą atsakymą, kitu atveju - klaidinga (False)

def pateik_klausimą(klausimas_ir_atsakymas):
# ištraukiame klausimą ir atsakymą iš sąrašo
# Ši funkcija priima dviejų elementų sąrašą, klausimą ir atsakymą.
klausimas = klausimas_ir_atsakymas[0]
atsakymas = klausimas_ir_atsakymas[1]
# užduodame klausimą vartotojui
duotas_atsakymas = input(klausimas)
# palyginame vartotojo atsakymą su teisingu atsakymu
if atsakymas == duotas_atsakymas:
print("Teisingai")
return True
else:
print("Neteisingai. Teisingas atsakymas: ", atsakymas)
return False

# Šis kodas apims visus klausimus
def atlikti_testus(klausimai):
if len(klausimai) == 0:
print("Nepateiktas nei vienas klausimas.")
# `return` išeis iš funkcijos
return
indeksas = 0
teisingai = 0
while indeksas < len(klausimai):
# patikriname klausimą
# Atkreipk dėmesį, kad tai yra klausimų ir atsakymų sąrašo ištraukimas iš sąrašų sąrašo.
if pateik_klausimą(klausimai[indeksas]):
teisingai = teisingai + 1
# pareiname prie kito klausimo
indeksas = indeksas + 1
# atkreipk dėmesį į skaičiavimo tvarką: pirmiausia padaugini, tada padalini
print("Atsakei teisingai į ", teisingai * 100 / len(klausimai),\
"% klausimų iš ", len(klausimai))

#rodomas klausimų ir atsakymų sąrašas
def rodyk_klausimus():
k = 0
while k < len(klausimai):
a = 0
print("K:" , klausimai[k][a])
a = 1
print("A:" , klausimai[k][a])
k = k + 1

# dabar apibrėžiu meniu funkciją
def meniu():
print("-----------------")
print("Meniu:")
print("1 - Atlikti testą")
print("2 - Peržiūrėti klausimų ir atsakymų sąrašą")
print("3 - Peržiūrėti meniu")
print("5 - Išeiti")
print("-----------------")

pasirinkimas = "3"
while pasirinkimas != "5":
if pasirinkimas == "1":
atlikti_testus(klausimai)
elif pasirinkimas == "2":
rodyk_klausimus()
elif pasirinkimas == "3":
meniu()
print()
pasirinkimas = input("Pasirinkite savo parinktį iš aukščiau pateikto meniu: ")

</syntaxhighlight>
|-
|}

{{navigation |previous=Pažangių funkcijų pavyzdys |next=Ciklai For}}
{{BookCat}}

Python Vadovėlis/Rekursinės funkcijos

2022-02-07T17:07:03Z

Juratevalat:

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

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

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

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

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

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

Rezultatas:

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

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

atgalinis_skaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



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

Python Vadovėlis/Rekursinės funkcijos

2022-02-07T17:05:10Z

Juratevalat:

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

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

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

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

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

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

Rezultatas:

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

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

atgalinis_kaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



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

Python Vadovėlis/Rekursinės funkcijos

2022-02-07T17:04:39Z

Juratevalat:

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

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

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

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

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

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

Rezultatas:

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

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

atgalinis_kaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



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

Python Vadovėlis/Rekursinės funkcijos

2022-02-07T15:26:07Z

Juratevalat:

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>reiksme = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reiksme = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return 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> nustato <code>reikšmė</code> į <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradeda veikti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>rezultatas = daug(3, 2)</code>, kuriai dabar galima priskirti reikšmę 6 kintamajam <code>rezultatas</code>
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", rezultatas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>rezultatas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmam skaičiui ir pirmas skaičius yra vienu skaitmeniu mažesnis už antrajį skaičių <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Tuomet galime apskaičiuoti, kad <code>3 + 3 * 0</code> yra <code>3 + 0</code> arba kitaip tariant tiesiog <code>3</code>. Tuomet mes žinome, kas yra <code>3 * 1</code>, todėl galime apskaičiuoti, kad <code>3 + 3 * 1</code> yra <code>3 + 3</code> arba kitaip tariant <code>6</code>.

Štai kaip viskas veikia:

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

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

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

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

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

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

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

Rezultatas:

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

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

atgalinis_kaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



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

Python Vadovėlis/Rekursinės funkcijos

2022-02-07T15:18:36Z

Juratevalat:

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

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

; ''Klausimas:'' Ką pirmiausia daro programa?
: ''Atsakymas:'' Pirmiausia yra aprašyta daugybos funkcija:
<syntaxhighlight lang="python">
def daug(a, b):
if b == 0:
return 0
lik = daug(a, b - 1)
reiksme = a + lik
return reiksme
</syntaxhighlight>
: Š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ė.
; Ką daro ši reikšmė?
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> – 0.
; Kas vyksta toliau?
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code>
; Ką daro <code>return 0</code> eilutė?
: Ši eilutė grąžina funkcijos reikšmę lygią 0.
; Kas iš to?
: Dabar mes žinome, kad <code>daug(3, 0)</code> 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 vertė 0.
; Kurią eilutę kompiuteris skaito po to?
: Toliau vykdoma eilutė <code>reiksme = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reiksme = 3</code>.
; Kas nutinka toliau?
: Vykdoma eilutė <code>return reiksme</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.
; Kur yra <code>daug(3, 2)</code>?
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.
; Kas įvyksta?
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reiksme = a + lik</code> nustato <code>reiksme</code> į <code>3 + 3</code> arba 6.
; Kas įvyksta toliau?
: Pradeda veikti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>rezultatas = daug(3, 2)</code>, kuriai dabar galima priskirti reikšmę 6 kintamajam <code>rezultatas</code>
; Kas nutinka toliau?
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", rezultatas)</code>.
; Ką ji daro?
: Ji spausdina <code>3 * 2 =</code> ir <code>rezultatas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.
; Taigi, kas čia įvyko apskritai?
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmam skaičiui ir pirmas skaičius yra vienu skaitmeniu mažesnis už antrajį skaičių <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Tuomet galime apskaičiuoti, kad <code>3 + 3 * 0</code> yra <code>3 + 0</code> arba kitaip tariant tiesiog <code>3</code>. Tuomet mes žinome, kas yra <code>3 * 1</code>, todėl galime apskaičiuoti, kad <code>3 + 3 * 1</code> yra <code>3 + 3</code> arba kitaip tariant <code>6</code>.

Štai kaip viskas veikia:

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

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

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

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

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

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

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

Rezultatas:

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

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

atgalinis_kaičiavimas(5)
</syntaxhighlight>

Rezultatas:
5
4
3
2
1
0



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

Python Vadovėlis/Funkcijų apibrėžimas

2022-02-07T14:19:17Z

Juratevalat: /* Užduotis */

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

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

Programos rezultatas:

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

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

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

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

Programos rezultatas:

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

Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. pabandykime patyrinėti dar kelias naujas funkcijas.

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

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

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

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

labas()
labas()

rašyk_mano_vardas("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. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.



=== Kintamieji funkcijose ===
Dažnai pasitaiko, kad pasikartojančiam kode yra kintamųjų, todėl į juos reikia atkreipti dėmesį, kai šaliname pakartotiną kodą. Iki šiol visi kintamieji, kuriuos matėme 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, kai kviečiama funkcija <code>funkcija(15)</code>, globalus <code> b_var</code> yra 15. Taigi <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 funkcijos visuja, jai pasibaigus dingo. Tad komanda <code>print ("a_var =", a_var)</code> atspausdina reikšmę <code>10</code>, t. y. globaliojo kintamojo <code>a_var</code> 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>. Pasibaigus funkcijai, visi lokalūs kintamieji ištrinami. Jeigu nori, ką nors gauti iš funkcijos, turėsi naudoti komandą <code>return</code>.

Paskutinis dalykas, į kurį reikia atkreipti dėmesį, yra tai, kad funkcijos viduje <code>e_var</code> reikšmė išlieka nepakitusi, nes tai nėra nei parametras, nei lokalus kintamasis – jis niekada nerodomas kairėje lygybės pusėje. Kai funkcijos viduje kreipiamasi į globalų kintamąjį, tai jis naudoja reikšmę, įgytą už funkcijos ribų.

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

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

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

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

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

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

Kaip tai veikia?:

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

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

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

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

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

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

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

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

Kaip veikia ši programa?

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

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

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

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

Pasirinkimai:
s = skaičiuoti kvadrato plotą.
c = skaičiuoti apskritimo plotą.
r = skaičiuoti stačiakampio plotą.
q = išeiti.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

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

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

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

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

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

Python Vadovėlis/Funkcijų apibrėžimas

2022-02-07T14:18:02Z

Juratevalat: /* Užduotis */

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

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

Programos rezultatas:

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

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

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

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

Programos rezultatas:

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

Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. pabandykime patyrinėti dar kelias naujas funkcijas.

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

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

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

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

labas()
labas()

rašyk_mano_vardas("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. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.



=== Kintamieji funkcijose ===
Dažnai pasitaiko, kad pasikartojančiam kode yra kintamųjų, todėl į juos reikia atkreipti dėmesį, kai šaliname pakartotiną kodą. Iki šiol visi kintamieji, kuriuos matėme 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, kai kviečiama funkcija <code>funkcija(15)</code>, globalus <code> b_var</code> yra 15. Taigi <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 funkcijos visuja, jai pasibaigus dingo. Tad komanda <code>print ("a_var =", a_var)</code> atspausdina reikšmę <code>10</code>, t. y. globaliojo kintamojo <code>a_var</code> 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>. Pasibaigus funkcijai, visi lokalūs kintamieji ištrinami. Jeigu nori, ką nors gauti iš funkcijos, turėsi naudoti komandą <code>return</code>.

Paskutinis dalykas, į kurį reikia atkreipti dėmesį, yra tai, kad funkcijos viduje <code>e_var</code> reikšmė išlieka nepakitusi, nes tai nėra nei parametras, nei lokalus kintamasis – jis niekada nerodomas kairėje lygybės pusėje. Kai funkcijos viduje kreipiamasi į globalų kintamąjį, tai jis naudoja reikšmę, įgytą už funkcijos ribų.

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

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

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

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

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

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

Kaip tai veikia?:

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

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

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

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

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

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

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

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

Kaip veikia ši programa?

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

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

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

=== Užduotis ===
Perrašyk programą plotas2.py, kuri yra aukščiau pateiktame pavyzdyje, taip, kad būtų parašytos atskiros kvadrato, stačiakampio ir apskritimo ploto funkcijos ((<code>3.14 * spindulys**2</code>). Taip pat šioje programoje turėtų būti sukurtas toks pasirinkimų meniu:
Pasirinkimai:
s = skaičiuoti kvadrato plotą.
c = skaičiuoti apskritimo plotą.
r = skaičiuoti stačiakampio plotą.
q = išeiti.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

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

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

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

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

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

Python Vadovėlis/Funkcijų apibrėžimas

2022-02-07T14:17:17Z

Juratevalat: /* Užduotis */

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

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

Programos rezultatas:

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

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

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

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

Programos rezultatas:

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

Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. pabandykime patyrinėti dar kelias naujas funkcijas.

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

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

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

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

labas()
labas()

rašyk_mano_vardas("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. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.



=== Kintamieji funkcijose ===
Dažnai pasitaiko, kad pasikartojančiam kode yra kintamųjų, todėl į juos reikia atkreipti dėmesį, kai šaliname pakartotiną kodą. Iki šiol visi kintamieji, kuriuos matėme 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, kai kviečiama funkcija <code>funkcija(15)</code>, globalus <code> b_var</code> yra 15. Taigi <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 funkcijos visuja, jai pasibaigus dingo. Tad komanda <code>print ("a_var =", a_var)</code> atspausdina reikšmę <code>10</code>, t. y. globaliojo kintamojo <code>a_var</code> 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>. Pasibaigus funkcijai, visi lokalūs kintamieji ištrinami. Jeigu nori, ką nors gauti iš funkcijos, turėsi naudoti komandą <code>return</code>.

Paskutinis dalykas, į kurį reikia atkreipti dėmesį, yra tai, kad funkcijos viduje <code>e_var</code> reikšmė išlieka nepakitusi, nes tai nėra nei parametras, nei lokalus kintamasis – jis niekada nerodomas kairėje lygybės pusėje. Kai funkcijos viduje kreipiamasi į globalų kintamąjį, tai jis naudoja reikšmę, įgytą už funkcijos ribų.

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

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

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

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

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

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

Kaip tai veikia?:

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

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

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

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

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

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

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

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

Kaip veikia ši programa?

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

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

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

=== Užduotis ===
Perrašyk programą plotas2.py, kuri yra aukščiau pateiktame pavyzdyje, taip, kad būtų parašytos atskiros kvadrato, stačiakampio ir apskritimo ploto funkcijos ((<code>3.14 * spindulys**2</code>). Taip pat šioje programoje turėtų būti sukurtas toks pasirinkimų meniu:
Pasirinkimai:
s = skaičiuoti kvadrato plotą.
c = skaičiuoti apskritimo plotą.
r = skaičiuoti stačiakampio plotą.
q = išeiti.
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

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

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

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

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

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

Python Vadovėlis/Funkcijų apibrėžimas

2022-02-07T14:14:14Z

Juratevalat: /* Kintamieji funkcijose */

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

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

Programos rezultatas:

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

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

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

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

Programos rezultatas:

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

Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. pabandykime patyrinėti dar kelias naujas funkcijas.

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

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

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

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

labas()
labas()

rašyk_mano_vardas("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. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.



=== Kintamieji funkcijose ===
Dažnai pasitaiko, kad pasikartojančiam kode yra kintamųjų, todėl į juos reikia atkreipti dėmesį, kai šaliname pakartotiną kodą. Iki šiol visi kintamieji, kuriuos matėme 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, kai kviečiama funkcija <code>funkcija(15)</code>, globalus <code> b_var</code> yra 15. Taigi <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 funkcijos visuja, jai pasibaigus dingo. Tad komanda <code>print ("a_var =", a_var)</code> atspausdina reikšmę <code>10</code>, t. y. globaliojo kintamojo <code>a_var</code> 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>. Pasibaigus funkcijai, visi lokalūs kintamieji ištrinami. Jeigu nori, ką nors gauti iš funkcijos, turėsi naudoti komandą <code>return</code>.

Paskutinis dalykas, į kurį reikia atkreipti dėmesį, yra tai, kad funkcijos viduje <code>e_var</code> reikšmė išlieka nepakitusi, nes tai nėra nei parametras, nei lokalus kintamasis – jis niekada nerodomas kairėje lygybės pusėje. Kai funkcijos viduje kreipiamasi į globalų kintamąjį, tai jis naudoja reikšmę, įgytą už funkcijos ribų.

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

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

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

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

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

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

Kaip tai veikia?:

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

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

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

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

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

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

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

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

Kaip veikia ši programa?

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

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

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

=== Užduotis ===
Perrašyk programą plotas2.py, kuri yra aukščiau pateiktame pavyzdyje, kad turėtum atskiras kvadrato, stačiakampio ir apskritimo ploto funkcijas ((<code>3.14 * spindulys**2</code>). Taip pat šioje programoje turėtų būti sukurtas meniu:
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

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

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

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

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

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

Python Vadovėlis/Funkcijų apibrėžimas

2022-02-07T14:02:03Z

Juratevalat: /* Funkcijų kūrimas */

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

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

Programos rezultatas:

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

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

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

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

Programos rezultatas:

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

Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. pabandykime patyrinėti dar kelias naujas funkcijas.

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

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

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

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

labas()
labas()

rašyk_mano_vardas("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. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.



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

<syntaxhighlight lang="python">
a = 4

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

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

Gaunamas rezultatas
Mano funkcijoje a = 17
a = 4

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

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

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

c_var = funkcija(b_var)

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

</syntaxhighlight>

rezultatas:

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

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

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

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

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

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

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

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

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

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

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

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

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

Kaip tai veikia?:

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

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

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

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

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

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

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

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

Kaip veikia ši programa?

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

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

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

=== Užduotis ===
Perrašyk programą plotas2.py, kuri yra aukščiau pateiktame pavyzdyje, kad turėtum atskiras kvadrato, stačiakampio ir apskritimo ploto funkcijas ((<code>3.14 * spindulys**2</code>). Taip pat šioje programoje turėtų būti sukurtas meniu:
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

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

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

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

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

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

Python Vadovėlis/Funkcijų apibrėžimas

2022-02-04T08:28:48Z

Juratevalat: /* Funkcijų kūrimas */

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

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

Programos rezultatas:

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

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

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

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

Programos rezultatas:

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

Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>.
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. Na, o dabar galime patys kurti naujas funkcijas.

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

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

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

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

labas()
labas()

rašyk_mano_vardas("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. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.



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

<syntaxhighlight lang="python">
a = 4

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

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

Gaunamas rezultatas
Mano funkcijoje a = 17
a = 4

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

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

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

c_var = funkcija(b_var)

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

</syntaxhighlight>

rezultatas:

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

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

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

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

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

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

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

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

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

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

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

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

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

Kaip tai veikia?:

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

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

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

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

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

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

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

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

Kaip veikia ši programa?

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

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

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

=== Užduotis ===
Perrašyk programą plotas2.py, kuri yra aukščiau pateiktame pavyzdyje, kad turėtum atskiras kvadrato, stačiakampio ir apskritimo ploto funkcijas ((<code>3.14 * spindulys**2</code>). Taip pat šioje programoje turėtų būti sukurtas meniu:
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def kvadratas(L):
return L * L

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

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

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

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

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

Python Vadovėlis/Derinimas

2022-02-01T16:13:47Z

Juratevalat: /* Ką daro programa? */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

=== Ką daro programa? ===

Kitas dalykas, ką reikia padaryti, tai peržiūrėti pirminį programos tekstą. Tai vienas iš svarbiausių dalykų programavime. Pagrindinis būdas, kaip tai daroma - tai kodo peržiūros.

Kodo peržiūra prasideda pirma eilute ir tęsiasi iki programos galo. <code>while</code> ciklai ir <code>if</code> sakiniai reiškia, kad kai kurios eilutės gali būti nekviečiamos niekada, o kai kurios - vykdomos keletą kartų. Kiekvienoje eilutėje turi suprasti, ką daro Python'as.

Pradėkime su paprasta parametro programa. Šios programos nerašyk. Tau reikės ją tik skaityti, ne vykdyti. Programos pirminis tekstas:

<syntaxhighlight lang="python">
aukstis = int(input("Aukštis: "))
plotis = int(input("Plotis: "))
print("perimetras =", plotis + aukstis + plotis + plotis)
</syntaxhighlight>

; ''Klausimas:'' Kuri eilutė vykdoma pirma?
: ''Atsakymas:'' Pirmoji kodo eilutė visada yra vykdoma pirma. Šiuo atveju tai: <code>aukstis = int(input("Aukštis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Aukštis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>aukstis</code>.
; Kuri eilutė vykdoma po to?
: Bendrai, tai yra kita eilutė, kuri yra <code>plotis = int(input("Plotis: "))</code>
; Ką daro ši eilutė?
: Spausdina <code>Plotis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>plotis</code>.
; Kuri eilutė vykdoma po to?
: Kai kita eilutė nėra daugiau ar mažiau įtraukta, nei esama eilutė, ji ir yra vykdoma. Šiuo atveju tai: <code>print("perimetras =", plotis + aukstis + plotis + plotis)</code> (Taip pat gali būti kviečiama funkcija esamoje eilutėje, bet tai bus paaiškinta tolimesniame skyriuje)
; Ką daro ši eilutė?
: Visų pirma, ji spausdina <code>perimetras = </code>, o tada - sumą, sudarytą iš kintamųjų <code>plotis</code> ir <code>aukstis</code>, kuri užrašoma taip: <code>plotis + aukstis + plotis + plotis</code>.
; Ar kodas <code>plotis + aukstis + plotis + plotis</code> skaičiuoja perimetrą teisingai?
: Pažiūrėk: stačiakampio perimetras yra apatinė kraštinė (plotis), plius kairė (aukstis), plius viršutinė (plotis), plius dešinė kraštinė (a?). Paskutinis kintamasis turėtų būti dešinės kraštinės ilgis, arba kitaip - aukštis.
; Ar supranti, kodėl, kai kuriais atvejais, skaičiuojant perimetrą buvo gaunamas teisingas atsakymas?
: Teisingas atsakymas buvo gaunamas kai aukštis ir plotis buvo lygūs.

Kita programa, kurios kodo peržiūrą darysime, tai programa, kuri turėtų ekrane išvesti 5 taškus. Tačiau, programos išvestis yra:

. . . .

Programa:
<syntaxhighlight lang="python">
skaicius = 5
while skaicius > 1:
print(".", end = " ")
skaicius = skaicius - 1
print()
</syntaxhighlight>

Šios programos peržiūra bus kiek sudėtingesnė, nes joje yra įtrauktų kodo dalių. Pradėk.
; Kuri eilutė vykdoma pirma?
: Pirmoji kodo eilutė: <code>skaicius = 5</code>
; Ką ji daro?
: Priskiria skaičių 5 kintamajam <code>skaicius</code>.
; Kuri eilutė vykdoma po to?
: Kita eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Na, <code>while</code> sakiniai žiūri į juose esančius reiškinius. Jei jie yra tesingi, vykdomas kitas įtrauktas blokas. Jei klaidingi – įtrauktas blokas yra praleidžiamas.
; Tai ką ji daro šiuo atveju?
: Jei <code>skaicius > 1</code> yra ''teisinga'', bus vykdomos kitos dvi eilutės.
; Taigi, ar <code>skaicius > 1</code>?
: Paskutinė vertė, kuri buvo priskirta <code>skaicius</code> buvo <code>5</code> ir <code>5 > 1</code>, taigi – taip.
; O kuri eilutė vykdoma po to?
: Kadangi <code>while</code> buvo teisinga, tai kita eilutė yra: <code>print(".", end = " ")</code>
; Ką daro ši eilutė?
: Spausdina vieną tašką. Kadangi funkcija turi papildomą argumentą <code>end = " "</code>, toliau spausdinamas tekstas nebus pradedamas naujoje eilutėje.
; Kuri eilutė vykdoma po to?
: <code>skaicius = skaicius - 1</code>, nes tai yra kita eilutė ir nėra jokių įtraukos pasikeitimų.
; Ką ji daro?
: Eilutė skaičiuoja <code>skaicius - 1</code>: iš esamos <code>skaicius</code> vertės (5) atimamas 1, ir tai tampa nauja kintamojo <code>skaicius</code> reikšmė. Sutrumpintai, <code>skaicius</code> vertė yra pakeičiama iš 5 į 4.
; Kuri eilutė vykdoma po to?
: Įtraukos lygis keičiasi, todėl turi žiūrėti į tai, kokią valdymo struktūrą turime. Peržiūrėk <code>while</code> ciklą, taigi turi grįžti į <code>while</code> sąlygą, kuri yra <code>while skaicius > 1:</code>
; Ką ji daro?
: Eilutė žiūri į <code>skaicius</code> reikšmę, kuri yra 4, ir lygina ją su 1. Kadangi <code>4 > 1</code>, ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo teisinga, kita eilutė yra: <code>print(".", end = " ")</code>
; Ką ji daro?
: Ekrane išspausdina dar vieną tašką, po jo padėdama tarpą.
; Kuri eilutė vykdoma po to?
: Nėra įtraukos pokyčio, todėl: <code>skaicius = skaicius - 1</code>
; Ir ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (4), atima 1, kas yra lygu 3 ir priskiria 3 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Kadangi turime įtraukos pokytį dėl ciklo, kita eilutė yra: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę <code>skaicius</code> reikšmę (3) su 1. <code>3 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga yra teisinga, kita eilutė: <code>print(".", end = " ")</code>
; O ji daro?
: Trečias taškas yra spausdinamas eilutėje.
; Kuri eilutė vykdoma po to?
: Tai: <code>skaicius = skaicius - 1</code>
; Ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (3), atima 1, kas yra lygu 2 ir priskiria 2 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Vėl grįžtame į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką ji daro?
: Palygina dabartinę <code>skaicius</code> reikšmę (2) su 1. <code>2 > 1</code>, todėl ciklas tęsiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklas tęsiasi: <code>print(".", end = " ")</code>
; Ką ji daro?
: Atranda atsakymą gyvenimui, Visatai, ir viskam. Juokauju (turėjau patikrinti, kad dar neužmigai). Eilutė spausdina ketvirtą tašką ekrane.
; Kuri eilutė vykdoma po to?
: Tai: <code>skaicius = skaicius - 1</code>
; Ką ji daro?
: Ima dabartinę <code>skaicius</code> reikšmę (2), atima 1, kas yra lygu 1 ir priskiria 1 kaip naują <code>skaicius</code> reikšmę.
; Kuri eilutė vykdoma po to?
: Atgal į ciklo pradžią: <code>while skaicius > 1:</code>
; Ką daro ši eilutė?
: Ji palygina <code>skaicius</code> reikšmę (1) to 1. Kadangi <code>1 > 1</code> yra ''klaidinga'' (vienas nėra daugiau nei vienas), ciklas baigiasi.
; Kuri eilutė vykdoma po to?
: Kadangi ciklo sąlyga buvo klaidinga, vykdoma kita eilutė esanti už ciklo. Tai yra: <code>print()</code>
; Ką daro ši eilutė?
: Priverčia teksto žymeklį ekrane peršokti į kitą eilutę.
; Kodėl programa nespausdina 5 taškų?
: Ciklas baigiasi vienu tašku per anksti.
; Kaip tai sutvarkyti?
: Priversti ciklą baigtis vienu tašku vėliau.
; Ir kaip tai padaryti?
: Yra keli būdai. Vienas iš jų yra pakeisti ciklo sąlygą į: <code>while skaicius > 0:</code>. Kitas būdas pakeisti sąlygą į: <code>skaicius >= 1</code>. Yra ir daugiau būdų.

=== Kaip turėčiau taisyti savo programą? ===

Tau reikia suprasti, ką programa daro. Tau reikia suprasti, ką programa turėtų daryti. Suprasti, koks skirtumas tarp šių dviejų dalykų. Derinimas - tai įgūdis, kurį norint išmokti, reikia daug praktikos. Jei po valandos nepavyksta išspręsti problemos, pailsėk, pakalbėk su kuo nors apie tai. Po kurio laiko sugrįžk prie problemos ir greičiausiai turėsi naujų minčių, kaip ją įveikti. Sėkmės.

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

Python Vadovėlis/Pasirinkimai

2022-02-01T15:42:34Z

Juratevalat: /* Pratimai */

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

Štai rezultatas po dviejų programos vykdymų:

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

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

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

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

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

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

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

ir išvestis:

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

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

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

Ir išvestis

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Spėlionių žaidimas daugiau mažiau

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

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

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

Pavyzdinis vykdymas:

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

'''lyginis.py'''

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

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

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

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

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

Python Vadovėlis/Pasirinkimai

2022-02-01T15:41:27Z

Juratevalat: /* Pavyzdžiai */

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

Štai rezultatas po dviejų programos vykdymų:

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

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

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

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

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

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

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

ir išvestis:

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

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

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

Ir išvestis

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Spėlionių žaidimas daugiau mažiau

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

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

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

Pavyzdinis vykdymas:

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

'''lyginis.py'''

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

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

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

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

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

Python Vadovėlis/Pasirinkimai

2022-02-01T15:36:48Z

Juratevalat: /* Pavyzdžiai */

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

Štai rezultatas po dviejų programos vykdymų:

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

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

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

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

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

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

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

ir išvestis:

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

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

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

Ir išvestis

False
False

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

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

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

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

Pavyzdinis vykdymas:

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

'''lyginis.py'''

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

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

Pavyzdiniai vykdymai:

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

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

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

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

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

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

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

Pavyzdiniai vykdymai:

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

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

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

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek numerių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui sekti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Pratimai ===
Parašyk programą, kuri prašo naudotojo įvesti savo vardą. Jei jis įveda tavo vardą, išvesk „Tai puikus vardas“. Jei jie įveda "Jonas Jonaitis“ arba „Petras Petraitis“, išvesk kokį nors juokingą tekstą. Kitu atveju, išvesk „Tavo vardas yra labai gražus“.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
vardas = input("Tavo vardas: ")
if vardas == 'Lukas':
print("Tai puikus vardas.")
elif vardas == 'Jonas Jonaitis':
print("... juokingas tekstas apie Joną.")
elif vardas == 'Petras Petraitis':
print("... juokingas tekstas apie Petrą.")
else:
print("Tavo vardas yra labai gražus.")
</syntaxhighlight>
|-
|}

Pakeisk aukščiau esančią „daugiau_maziau.py“ programą, kad ji papildomai skaičiuotų, kiek kartų naudotojas įvedė neteisingą skaičių. Jei taip nutiko daugiau, nei tris kartus, programos pabaigoje išvesk „Tai buvo sudėtinga.“, o kitu atveju - „Gerai padirbėjai!“

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
skaicius = 7
spejimas = -1
kiekis = 0

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))
kiekis = kiekis + 1
if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")

if kiekis > 3:
print("Tai buvo sudėtinga.")
else:
print("Gerai padirbėjai!")
</syntaxhighlight>
|-
|}

Parašyk programą, kuri prašo įvesti du skaičius. Jei skaičių suma yra didesnė nei 100, išvesk „Tai yra didelis skaičius“.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
skaicius1 = float(input("Pirmas skaičius: "))
skaicius2 = float(input("Antras skaičius: "))
if skaicius1 + skaicius2 > 100:
print("Skaičių suma yra didelis skaičius.")
</syntaxhighlight>
|-
|}

{{navigation |previous=Suskaičiuoti iki 10 |next=Derinimas}}

Python Vadovėlis/Pasirinkimai

2022-02-01T15:36:02Z

Juratevalat: /* If sakinys */

=== <code>If</code> sakinys ===
Aš manau, kad kiekvieną skyrių turėčiau pradėti nuo apšilimo pratimo. Taigi, žemiau turime trumpą programą, kuri apskaičiuoja absoliučią sveikojo skaičiaus reikšmę:
<syntaxhighlight lang="python">
n = int(input("Skaičius? "))
if n < 0:
print("Absoliuti", n, "reikšmė yra", -n)
else:
print("Absoliuti", n, "reikšmė yra", n)
</syntaxhighlight>

Štai rezultatas po dviejų programos vykdymų:

Skaičius? '''-34'''
Absoliuti -34 reikšmė yra 34

Skaičius? '''1'''
Absoliuti 1 reikšmė yra 1

Taigi, ką kompiuteris daro, kai pamato šį kodą? Visų pirma, jis kviečia įvesti skaičių su šiuo sakiniu <code>n = int(input("Skaičius? "))</code>. Tada jis skaito eilutę <code>if n < 0:</code>. Jei <code>n</code> yra mažiau už nulį, Python'as vykdo eilutę <code>print("Absoliuti", n, "reikšmė yra", -n)</code>. Kitu atveju, jis vykdo eilutę <code>print("Absoliuti", n, "reikšmė yra", n)</code>.

Kalbant formaliau, Python'as tikrina, ar „reiškinio“ <code>n < 0</code> reikšmė yra teisinga ar klaidinga. Sakinys <code>if</code> yra lydimas įtraukto sakinių „bloko“, kuris vykdomas tik jei reiškinio reikšmė yra teisinga. Pasirinktinai, po <code>if</code> sakinio gali būti <code>else</code> sakinys ir dar vienas įtrauktas sakinių „blokas“. Antrasis sakinių blokas yra vykdomas tik jei reiškinio reikšmė yra klaidinga.

Reiškinys gali turėti įvairių sąlygų. Žemiau yra visų jų lentelė:

{| class="wikitable"
!Operatorius
!Funkcija
|-
|<code><</code>
|mažiau nei
|-
|<code><=</code>
|mažiau nei arba lygu
|-
|<code>></code>
|daugiau nei
|-
|<code>>=</code>
|daugiau nei arba lygu
|-
|<code>==</code>
|lygu
|-
|<code>!=</code>
|nelygu
|}

Dar viena sakinio <code>if</code> ypatybė yra <code>elif</code> dalis. Tai <code>else if</code> sutrumpinimas ir reiškia, kad jei originali <code>if</code> sakinio reikšmė yra klaidinga, bet <code>elif</code> dalis yra teisinga, yra vykdoma <code>elif</code> kodo dalis. Ir jei nei <code>if</code>, nei <code>elif</code> reiškiniai nėra tiesa, tada vykdomas <code>else</code> blokas. Pavyzdžiui:
<syntaxhighlight lang="python">
a = 0
while a < 10:
a = a + 1
if a > 5:
print(a, ">", 5)
elif a <= 3:
print(a, "<=", 3)
else:
print("Nei vienas iš testų nėra teisingas")
</syntaxhighlight>

ir išvestis:

1 <= 3
2 <= 3
3 <= 3
Nei vienas iš testų nėra teisingas
Nei vienas iš testų nėra teisingas
6 > 5
7 > 5
8 > 5
9 > 5
10 > 5

Gali pastebėti, kad <code>elif a <= 3</code> dalis yra tikrinama tik tada, jei <code>if</code> reiškinio reikšmė nėra tiesa. Galima rašyti daugiau nei vieną <code>elif</code> reiškinį, tokiu būdu leidžiant tikrinti kelias sąlygas viename <code>if</code> sakinyje.

=== Pavyzdžiai ===
<syntaxhighlight lang="python">
# Ši programa parodo, kaip galima naudoti == operatorių
# naudojant numerius
print(5 == 6)
# naudojant kintamuosius
x = 5
y = 8
print(x == y)
</syntaxhighlight>

Ir išvestis

False
False

'''daugiau_maziau.py'''
<syntaxhighlight lang="python">
# Žaidžia spėlionių žaidimą daugiau mažiau

# Iš tiesų, čia turėtų būti naudojami pusiau atsitiktiniai skaičiai,
# pavyzdžiui paskutinis laiko skaitmuo, ar kažkas panašaus. Bet tai
# palauks iki vėlesnės dalies. (Papildoma užduotis: po Modulių dalies, pakeisk šį kodą,
# kad būtų naudojami atsitiktiniai skaičiai)
skaicius = 7
spejimas = -1

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))

if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")
</syntaxhighlight>

Pavyzdinis vykdymas:

Atspėk skaičių!
Ar tai yra... '''2'''
Skaičius yra didesnis...
Ar tai yra... '''5'''
Skaičius yra didesnis...
Ar tai yra... '''10'''
Skaičius yra ne toks didelis.
Ar tai yra... '''7'''
Valio! Atspėjai teisingai!

'''lyginis.py'''

<syntaxhighlight lang="python">
# Prašo įvesti skaičių.
# Išveda, ar skaičius yra lyginis, ar ne

skaicius = float(input("Pasakyk man skaičių: "))
if skaicius % 2 == 0:
print(int(skaicius), "yra lyginis.")
elif skaicius % 2 == 1:
print(int(skaicius), "yra nelyginis.")
else:
print(skaicius, "yra labai keistas.")
</syntaxhighlight>

Pavyzdiniai vykdymai:

Pasakyk man skaičių: '''3'''
3 yra nelyginis.

Pasakyk man skaičių: '''2'''
2 yra lyginis.

Pasakyk man skaičių: '''3.4895'''
3.4895 yra labai keistas.

'''vidurkis1.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol įvedamas 0
# Išveda skaičių vidurkį

kiekis = 0
suma = 0.0
skaicius = 1 # nurodomas tam, kad nebūtų iškart išeinama iš ciklo.

print("Įvesk 0, kad sustabdytum ciklą")

while skaicius != 0:
skaicius = float(input("Įvesk skaičių: "))
if skaicius != 0:
kiekis = kiekis + 1
suma = suma + skaicius
if skaicius == 0:
print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''3'''
Įvesk skaičių: '''5'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 4.0

Įvesk 0, kad sustabdytum ciklą
Įvesk skaičių: '''1'''
Įvesk skaičių: '''4'''
Įvesk skaičių: '''3'''
Įvesk skaičių: '''0'''
Skaičių vidurkis yra: 2.66666666667

'''vidurkis2.py'''
<syntaxhighlight lang="python">
# Prašo įvesti skaičių iki tol, kol bus įvestas tam tikras kiekis skaičių
# Išveda skaičių vidurkį.

# Gali pastebėti, kad naudojame sveikąjį skaičių sekti, kiek numerių
# buvo įvesta, bet slankiojo kablelio skaičių, kiekvienam įvestam
# skaičiui sekti
suma = 0.0

print("Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį")
kiekis = int(input("Kelių skaičių vidurkį norėtum suskaičiuoti: "))
esamasis_kiekis = 0

while esamasis_kiekis < kiekis:
esamasis_kiekis = esamasis_kiekis + 1
print("Skaičius", esamasis_kiekis)
skaicius = float(input("Įvesk skaičių: "))
suma = suma + skaicius

print("Skaičių vidurkis yra:", suma / kiekis)
</syntaxhighlight>

Pavyzdiniai vykdymai:

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''2'''
Skaičius 1
Įvesk skaičių: '''3'''
Skaičius 2
Įvesk skaičių: '''5'''
Skaičių vidurkis yra: 4.0

Ši programa paprašys įvesti kelis skaičius ir suskaičiuos jų vidurkį
Kelių skaičių vidurkį norėtum suskaičiuoti: '''3'''
Skaičius 1
Įvesk skaičių: '''1'''
Skaičius 2
Įvesk skaičių: '''4'''
Skaičius 3
Įvesk skaičių: '''3'''
Skaičių vidurkis yra: 2.66666666667

=== Pratimai ===
Parašyk programą, kuri prašo naudotojo įvesti savo vardą. Jei jis įveda tavo vardą, išvesk „Tai puikus vardas“. Jei jie įveda "Jonas Jonaitis“ arba „Petras Petraitis“, išvesk kokį nors juokingą tekstą. Kitu atveju, išvesk „Tavo vardas yra labai gražus“.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
vardas = input("Tavo vardas: ")
if vardas == 'Lukas':
print("Tai puikus vardas.")
elif vardas == 'Jonas Jonaitis':
print("... juokingas tekstas apie Joną.")
elif vardas == 'Petras Petraitis':
print("... juokingas tekstas apie Petrą.")
else:
print("Tavo vardas yra labai gražus.")
</syntaxhighlight>
|-
|}

Pakeisk aukščiau esančią „daugiau_maziau.py“ programą, kad ji papildomai skaičiuotų, kiek kartų naudotojas įvedė neteisingą skaičių. Jei taip nutiko daugiau, nei tris kartus, programos pabaigoje išvesk „Tai buvo sudėtinga.“, o kitu atveju - „Gerai padirbėjai!“

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
skaicius = 7
spejimas = -1
kiekis = 0

print("Atspėk skaičių!")
while spejimas != skaicius:
spejimas = int(input("Ar tai yra... "))
kiekis = kiekis + 1
if spejimas == skaicius:
print("Valio! Atspėjai teisingai!")
elif spejimas < skaicius:
print("Skaičius yra didesnis...")
elif spejimas > skaicius:
print("Skaičius yra ne toks didelis.")

if kiekis > 3:
print("Tai buvo sudėtinga.")
else:
print("Gerai padirbėjai!")
</syntaxhighlight>
|-
|}

Parašyk programą, kuri prašo įvesti du skaičius. Jei skaičių suma yra didesnė nei 100, išvesk „Tai yra didelis skaičius“.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
skaicius1 = float(input("Pirmas skaičius: "))
skaicius2 = float(input("Antras skaičius: "))
if skaicius1 + skaicius2 > 100:
print("Skaičių suma yra didelis skaičius.")
</syntaxhighlight>
|-
|}

{{navigation |previous=Suskaičiuoti iki 10 |next=Derinimas}}

Python Vadovėlis/Suskaičiuoti iki 10

2022-02-01T15:25:12Z

Juratevalat: /* Fibonačio seka */

=== Ciklai kol (While loops) ===
Šiame skyriuje susipažinsi su ciklu <code>while</code> - lietuviškas atitikmuo būtų ciklas kol. Kaip jau sužinojai praeitame skyriuje, kompiuteris įprastai programą pradeda skaityti ir vykdyti nuo pirmos eilutės ir taip eilutė po eilutės keliauja žemyn per visas duoto kodo eilutes. Tačiau ciklas <code>while</code> šią tvarką pakeičia ir dėl to kompiuteris priėjęs šią kodo vietą eilutes skaito iki galo, pagal šio ciklo nustatytą tvarką. Štai čia yra programos su ciklo <code>while</code> pavyzdžiu:

<syntaxhighlight lang="python">
a = 0 # PIRMA, nustatome pradinio kintamojo a reikšmę 0 (nuliui).
while a < 10: # Kol kintamojo a vertė yra mažesnė nei 10, programa atlieka šiuos veiksmus:
a = a + 1 # Padidina kintamojo a reikšmę 1 (vienu), visai taip kaip nurodyta: a = a + 1!
print(a) # Tuomet nurodome, kad spausdintų. Viskas tam, kad pamatytumėte, kokia yra dabartinė kintamojo a vertė.
# Ir visą šitą ciklą programa vykdo tol, kol kintamojo a reikšmė bus lygi 9!? Žr. Pastabą.

# PASTABA:
# Kintamojo a vertė padidės 1
# su kiekvienu pakartojimu ar ciklu, kol pasieks nustatytą sąlygą ir sustos.
# pvz. a = 1, tada a = 2, tada a = 3 ir t.t., kol a bus lygus 9 (a = 9), tada...
# kodas baigs pridėjinėti po 1 prie a, nes taps lygus 10 (a = 10) kaip ir numatyta mūsų parašytoje sąlygoje.
# O kai mūsų nurodyta sąlyga yra patenkinama, programa atspausdina rezultatą.
# --
# While a < 10: |
# a = a + 1 |<--[ Ciklo Kol sąlygos blokas ]
# print (a) |
# --
</syntaxhighlight>

Na, o jeigu paleidžiame programą, tai turime štai tokį įdomų rezultatą:

1
2
3
4
5
6
7
8
9
10

(Tikriausiai iki šios pamokos net nesusimąstei, kad kompiuterį gali paversti pigiu skaičiuotuvu...)

Na, o dabar pasiaiškinkime kaip veikia ši programa. Pirmiausia kompiuteris mato eilutę <code>a = 0</code> ir nustato <code>a</code> reikšmę lygią nuliui. Tada programa mato sąlygą <code>while a < 10:</code>, todėl kompiuteris patikrina, ar <code>a < 10</code>. Kompiuteriui pirmą kartą matant šį teiginį, <code>a</code> yra lygus 0, ir akivaizdu, kad turima reikšmė yra mažesnė nei 10. Kitaip tariant, kol <code>a</code> yra mažesnis skaičius nei dešimt, tol kompiuteris tikrins teiginį ir kartos jį (t.y. pridėjinės po 1). Ciklas baigsis, kai <code>a</code> bus lygus dešimčiai. Kadangi šiame kode daugiau nieko nėra, tai programa sustoja.

ĮSIDĖMĖK: Nepamiršk parašyti dvitaškio <code>:</code> eilutės pabaigoje, tik taip kompiuteris supras, kad čia yra komanda!

Kitas ciklo <code>while</code> pavyzdys:
<syntaxhighlight lang="python">
a = 1
s = 0
print('Įvesk skaičius, kuriuos nori pridėti prie sumos.')
print('Norint išeiti, įvesk 0.')
while a != 0:
print('Dabartinė suma:', s)
a = float(input('Skaičius? '))
s = s + a
print('Galutinė suma =', s)
</syntaxhighlight>

Galimas programos scenarijus:

Įvesk skaičius, kuriuos nori pridėti prie sumos.
Norint išeiti, įveskite 0.
Dabartinė suma: 0
Skaičius? '''200'''
Dabartinė suma: 200.0
Skaičius? '''-15.25'''
Dabartinė suma: 184.75
Skaičius? '''-151.85'''
Dabartinė suma: 32.9
Skaičius? '''10.00'''
Dabartinė suma: 42.9
Skaičius? '''0'''
Galutinė suma = 42.9

Atkreipk dėmesį, kad <code>print('Galutinė suma =', s)</code> yra įvykdoma tik pačioje pabaigoje, kai jau ciklas būna nutrauktas. Komanda <code>while</code> veikia tik tas eilutes, kurios yra atitrauktos nuo krašto ir priklauso ciklo <code>while</code> blokui. <code>!=</code> reiškia nelygu, taigi <code>while a! = 0:</code> reiškia tol, kol <code>a</code> nėra nulis, programa vykdo kodą.

Ar pastebėjai, kad šiuo atveju <code>a</code> yra skaičius su reikšme po kablelio ir ne visi tokie skaičiai gali būti tiksliai atvaizduoti, kai naudojamas <code>!=</code>. Pabandyk paleidęs programą įvesti 1.1

==== Begaliniai ciklai (infinitive loops) arba niekada nesibaigaintys ciklai (Never Ending Loop)====
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis:
<syntaxhighlight lang="python">
while True:
print("Padėk! Užstrigau cikle!")
</syntaxhighlight>
Operatorius <code>== </code> naudojamas abiejų operatoriaus pusių išraiškų lygybei patikrinti, kaip ir <code> < </code> buvo naudojami norint pasakyt „mažiau nei“ (kitame skyriuje rasi išsamų visų palyginimo operatorių sąrašą).

Ši mūsų sukurta programa spausdins <code>Padėk! Užstrigau cikle!</code> visą amžinybę... Tol, kol pats ją sustabdysi, todėl kad ji visą laiką yra <code>True</code> (visada atitinka teigiamą reikšmę) ir niekada nesikeičia (True paprastai programavime dar rašomas kaip 1). Kaip programą sustabdyti? Paprasčiausiai paspausk ctrl + c mygtukus.

=== Pavyzdžiai ===
==== Fibonačio seka ====
'''Fibonacci-metodas1.py'''
<syntaxhighlight lang="python">
# Ši programa skaičiuoja Fibonačio seką
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 20

while pradinis_skačius < maksimalus_skaičius:
pradinis_skačius = pradinis_skačius + 1
print(a, end = " ") # Atkreipkite dėmesį į end = " " spausdinimo funkcijos argumentuose
# būtent tai neleidžia sukurti naujos eilutės.
senas_a = a # turime sekti, nes mes jį keičiame.
a = b
b = senas_a + b
print() # gauna naują (tuščią) eilutę.
</syntaxhighlight>
Išvestis :
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

Įsidėmėk, kad išvestis yra vienoje eilutėje dėl papildomų argumentų <code>end = " "</code> funkcijos <code>print</code> argumentuose.

'''Fibonacci-metodas2.py'''
<syntaxhighlight lang="python">
# Supaprastintas ir greitesnis Fibonačio sekos apskaičiavimo metodas
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 10

while pradinis_skačius < maksimalus_skaičius:
pradinis_skačius = pradinis_skačius + 1
print(a, b, end=" ") # Įsidėmėk end=" "
a = a + b
b = a + b
print() # gauna naują (tuščią) eilutę.
</syntaxhighlight>

Išvestis:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

'''Fibonacci-metodas3.py'''
<syntaxhighlight lang="python">
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 20

#kai ciklas prasideda, mes jame pasiliekame
while pradinis_skačius < maksimalus_skaičius:
pradinis_skačius += 1
senas_a = a
a = a + b
b = senas_a
print(senas_a,end=" ")
print()
</syntaxhighlight>

Išvestis:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

==== Įvesk slaptažodį ====
'''Slaptaždis.py'''
<syntaxhighlight lang="python">
# Laukia, kol bus įvestas slaptažodis. Naudok „ctrl+ C“, kad sustabdytum programą
# be slaptažodžio

#atkreipk dėmesį, kad tai neturi būti slaptažodis, kad
# ciklas while turi prasisukti bent kartą.
slaptažodis= str()

# įsidėmėk != reiškia nelygu
while slaptažodis!= "Angis":
slaptažodis = input("Slaptažodis: ")
print("Prisijungimas sėkmingas")
</syntaxhighlight>

Kaip programa veikia:
Slaptažodis: '''auo'''
Slaptažodis: '''y22'''
Slaptažodis: '''slaptažodis'''
Slaptažodis: '''Sezamai atsiverk''
Slaptažodis: '''Angis'''
Prisijungimas sėkmingas

=== Užduotis===
Parašyk programą, kuri prašo: vartotojo prisijungimo vardo ir slaptažodžio. Tada, kai vartotojas įveda „užrakinti“, jis turi įvesti savo vardą ir slaptažodį, kad atrakintų programą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
vardas = input("Koks tavo prisijungimo vardas?: ")
slaptažodis = input("Koks tavo slaptažodis: ")
print("Kad užrakintum kompiuterį, parašyk: užrakinti")
įvesta_komanda = None
input1 = None
input2 = None
while įvesta_komanda != "užrakinti":
įvesta_komanda = input("Kokia tavo komanda: ")

while input1 != vardas:
input1 = input("Tavo prisijungimo vardas: ")

while input2 != slaptažodis:
input2 = input("Tavo slaptažodis: ")

print("Prisijungimas sėkmingas")
</syntaxhighlight>

Jei nori, kad programa veiktų nepertraukiamai, tiesiog pridėk <code>while 1 == 1: </code>prieš visą programą. Tik nepamiršk, kad reikia visą likusią programos dalį, t.y. ciklo bloką reikia atitraukti nuo krašto.

Kitas sprendimo būdas
<syntaxhighlight lang="python">
vardas = input('Nustatyti vardą: ')
slaptažodis = input('Nustatyti slaptažodį: ')
while 1 == 1:
vardospėjimas=""
slaptažodžiospėjimas=""
raktas=""
while (vardospėjimas!= vardas) or (slaptažodžiospėjimas!= slaptažodis):
vardospėjimas = input('Vardas? ')
slaptažodžiospėjimas= input('Slaptažodis? ')
print("Labas,", vardas, ". Parašyk užrakinti, kad užrakintum.")
while raktas != "užrakinti":
raktas = input("")
</syntaxhighlight>

Atkreipk dėmesį į <code>or</code>, kuris yra prie <code>(vardospėjimas!= vardas) or (slaptažodžiospėjimas!= slaptažodis)</code>, kurių dar neįvedėme. Pabandyk suprasti šią logiką ir kaip ji veikia.
|-
|}

{{navigation |previous=Kas čia eina? |next=Pasirinkimai}}

Python Vadovėlis/Suskaičiuoti iki 10

2022-02-01T15:17:39Z

Juratevalat: /* Ciklai kol (While loops) */

=== Ciklai kol (While loops) ===
Šiame skyriuje susipažinsi su ciklu <code>while</code> - lietuviškas atitikmuo būtų ciklas kol. Kaip jau sužinojai praeitame skyriuje, kompiuteris įprastai programą pradeda skaityti ir vykdyti nuo pirmos eilutės ir taip eilutė po eilutės keliauja žemyn per visas duoto kodo eilutes. Tačiau ciklas <code>while</code> šią tvarką pakeičia ir dėl to kompiuteris priėjęs šią kodo vietą eilutes skaito iki galo, pagal šio ciklo nustatytą tvarką. Štai čia yra programos su ciklo <code>while</code> pavyzdžiu:

<syntaxhighlight lang="python">
a = 0 # PIRMA, nustatome pradinio kintamojo a reikšmę 0 (nuliui).
while a < 10: # Kol kintamojo a vertė yra mažesnė nei 10, programa atlieka šiuos veiksmus:
a = a + 1 # Padidina kintamojo a reikšmę 1 (vienu), visai taip kaip nurodyta: a = a + 1!
print(a) # Tuomet nurodome, kad spausdintų. Viskas tam, kad pamatytumėte, kokia yra dabartinė kintamojo a vertė.
# Ir visą šitą ciklą programa vykdo tol, kol kintamojo a reikšmė bus lygi 9!? Žr. Pastabą.

# PASTABA:
# Kintamojo a vertė padidės 1
# su kiekvienu pakartojimu ar ciklu, kol pasieks nustatytą sąlygą ir sustos.
# pvz. a = 1, tada a = 2, tada a = 3 ir t.t., kol a bus lygus 9 (a = 9), tada...
# kodas baigs pridėjinėti po 1 prie a, nes taps lygus 10 (a = 10) kaip ir numatyta mūsų parašytoje sąlygoje.
# O kai mūsų nurodyta sąlyga yra patenkinama, programa atspausdina rezultatą.
# --
# While a < 10: |
# a = a + 1 |<--[ Ciklo Kol sąlygos blokas ]
# print (a) |
# --
</syntaxhighlight>

Na, o jeigu paleidžiame programą, tai turime štai tokį įdomų rezultatą:

1
2
3
4
5
6
7
8
9
10

(Tikriausiai iki šios pamokos net nesusimąstei, kad kompiuterį gali paversti pigiu skaičiuotuvu...)

Na, o dabar pasiaiškinkime kaip veikia ši programa. Pirmiausia kompiuteris mato eilutę <code>a = 0</code> ir nustato <code>a</code> reikšmę lygią nuliui. Tada programa mato sąlygą <code>while a < 10:</code>, todėl kompiuteris patikrina, ar <code>a < 10</code>. Kompiuteriui pirmą kartą matant šį teiginį, <code>a</code> yra lygus 0, ir akivaizdu, kad turima reikšmė yra mažesnė nei 10. Kitaip tariant, kol <code>a</code> yra mažesnis skaičius nei dešimt, tol kompiuteris tikrins teiginį ir kartos jį (t.y. pridėjinės po 1). Ciklas baigsis, kai <code>a</code> bus lygus dešimčiai. Kadangi šiame kode daugiau nieko nėra, tai programa sustoja.

ĮSIDĖMĖK: Nepamiršk parašyti dvitaškio <code>:</code> eilutės pabaigoje, tik taip kompiuteris supras, kad čia yra komanda!

Kitas ciklo <code>while</code> pavyzdys:
<syntaxhighlight lang="python">
a = 1
s = 0
print('Įvesk skaičius, kuriuos nori pridėti prie sumos.')
print('Norint išeiti, įvesk 0.')
while a != 0:
print('Dabartinė suma:', s)
a = float(input('Skaičius? '))
s = s + a
print('Galutinė suma =', s)
</syntaxhighlight>

Galimas programos scenarijus:

Įvesk skaičius, kuriuos nori pridėti prie sumos.
Norint išeiti, įveskite 0.
Dabartinė suma: 0
Skaičius? '''200'''
Dabartinė suma: 200.0
Skaičius? '''-15.25'''
Dabartinė suma: 184.75
Skaičius? '''-151.85'''
Dabartinė suma: 32.9
Skaičius? '''10.00'''
Dabartinė suma: 42.9
Skaičius? '''0'''
Galutinė suma = 42.9

Atkreipk dėmesį, kad <code>print('Galutinė suma =', s)</code> yra įvykdoma tik pačioje pabaigoje, kai jau ciklas būna nutrauktas. Komanda <code>while</code> veikia tik tas eilutes, kurios yra atitrauktos nuo krašto ir priklauso ciklo <code>while</code> blokui. <code>!=</code> reiškia nelygu, taigi <code>while a! = 0:</code> reiškia tol, kol <code>a</code> nėra nulis, programa vykdo kodą.

Ar pastebėjai, kad šiuo atveju <code>a</code> yra skaičius su reikšme po kablelio ir ne visi tokie skaičiai gali būti tiksliai atvaizduoti, kai naudojamas <code>!=</code>. Pabandyk paleidęs programą įvesti 1.1

==== Begaliniai ciklai (infinitive loops) arba niekada nesibaigaintys ciklai (Never Ending Loop)====
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis:
<syntaxhighlight lang="python">
while True:
print("Padėk! Užstrigau cikle!")
</syntaxhighlight>
Operatorius <code>== </code> naudojamas abiejų operatoriaus pusių išraiškų lygybei patikrinti, kaip ir <code> < </code> buvo naudojami norint pasakyt „mažiau nei“ (kitame skyriuje rasi išsamų visų palyginimo operatorių sąrašą).

Ši mūsų sukurta programa spausdins <code>Padėk! Užstrigau cikle!</code> visą amžinybę... Tol, kol pats ją sustabdysi, todėl kad ji visą laiką yra <code>True</code> (visada atitinka teigiamą reikšmę) ir niekada nesikeičia (True paprastai programavime dar rašomas kaip 1). Kaip programą sustabdyti? Paprasčiausiai paspausk ctrl + c mygtukus.

=== Pavyzdžiai ===
==== Fibonačio seka ====
'''Fibonacci-metodas1.py'''
<syntaxhighlight lang="python">
# Ši programa skaičiuoja Fibonačio seką
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 20

while pradinis_skačius < maksimalus_skaičius:
pradinis_skačius = pradinis_skačius + 1
print(a, end=" ") # Atkreipkite dėmesį į end=" " spausdinimo funkcijos argumentuose
# tai neleidžia sukurti naujos eilutės.
senas_a = a # turime sekti, nes mes jį keičiame.
a = b
b = senas_a + b
print() # gauna naują (tuščią) eilutę.
</syntaxhighlight>
Išvestis :
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

Įsidėmėk, kad išvestis yra vienoje eilutėje dėl papildomų argumentų <code>pabaiga=" "</code> argumentuose <code>print</code>.

'''Fibonacci-metodas2.py'''
<syntaxhighlight lang="python">
# Supaprastintas ir greitesnis Fibonačio sekos apskaičiavimo metodas
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 10

while pradinis_skačius < maksimalus_skaičius:
pradinis_skačius = pradinis_skačius + 1
print(a, b, end=" ") # Įsidėmėk end=" "
a = a + b
b = a + b
print() # gauna naują (tuščią) eilutę.
</syntaxhighlight>

Išvestis:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

'''Fibonacci-metodas3.py'''
<syntaxhighlight lang="python">
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 20

#kai ciklas prasideda, mes jame pasiliekame
while pradinis_skačius < maksimalus_skaičius:
pradinis_skačius += 1
senas_a = a
a = a + b
b = senas_a
print(senas_a,end=" ")
print()
</syntaxhighlight>

Išvestis:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181

==== Įvesk slaptažodį ====
'''Slaptaždis.py'''
<syntaxhighlight lang="python">
# Laukia, kol bus įvestas slaptažodis. Naudok „ctrl+ C“, kad sustabdytum programą
# be slaptažodžio

#atkreipk dėmesį, kad tai neturi būti slaptažodis, kad
# ciklas while turi prasisukti bent kartą.
slaptažodis= str()

# įsidėmėk != reiškia nelygu
while slaptažodis!= "Angis":
slaptažodis = input("Slaptažodis: ")
print("Prisijungimas sėkmingas")
</syntaxhighlight>

Kaip programa veikia:
Slaptažodis: '''auo'''
Slaptažodis: '''y22'''
Slaptažodis: '''slaptažodis'''
Slaptažodis: '''Sezamai atsiverk''
Slaptažodis: '''Angis'''
Prisijungimas sėkmingas

=== Užduotis===
Parašyk programą, kuri prašo: vartotojo prisijungimo vardo ir slaptažodžio. Tada, kai vartotojas įveda „užrakinti“, jis turi įvesti savo vardą ir slaptažodį, kad atrakintų programą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
vardas = input("Koks tavo prisijungimo vardas?: ")
slaptažodis = input("Koks tavo slaptažodis: ")
print("Kad užrakintum kompiuterį, parašyk: užrakinti")
įvesta_komanda = None
input1 = None
input2 = None
while įvesta_komanda != "užrakinti":
įvesta_komanda = input("Kokia tavo komanda: ")

while input1 != vardas:
input1 = input("Tavo prisijungimo vardas: ")

while input2 != slaptažodis:
input2 = input("Tavo slaptažodis: ")

print("Prisijungimas sėkmingas")
</syntaxhighlight>

Jei nori, kad programa veiktų nepertraukiamai, tiesiog pridėk <code>while 1 == 1: </code>prieš visą programą. Tik nepamiršk, kad reikia visą likusią programos dalį, t.y. ciklo bloką reikia atitraukti nuo krašto.

Kitas sprendimo būdas
<syntaxhighlight lang="python">
vardas = input('Nustatyti vardą: ')
slaptažodis = input('Nustatyti slaptažodį: ')
while 1 == 1:
vardospėjimas=""
slaptažodžiospėjimas=""
raktas=""
while (vardospėjimas!= vardas) or (slaptažodžiospėjimas!= slaptažodis):
vardospėjimas = input('Vardas? ')
slaptažodžiospėjimas= input('Slaptažodis? ')
print("Labas,", vardas, ". Parašyk užrakinti, kad užrakintum.")
while raktas != "užrakinti":
raktas = input("")
</syntaxhighlight>

Atkreipk dėmesį į <code>or</code>, kuris yra prie <code>(vardospėjimas!= vardas) or (slaptažodžiospėjimas!= slaptažodis)</code>, kurių dar neįvedėme. Pabandyk suprasti šią logiką ir kaip ji veikia.
|-
|}

{{navigation |previous=Kas čia eina? |next=Pasirinkimai}}

Python Vadovėlis/Kas čia eina?

2022-02-01T14:42:06Z

Juratevalat: /* Priskyrimai */

=== Įvestis ir kintamieji ===
Jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:
<syntaxhighlight lang="python">
print("Stop!")
vartotojo_įvestis = input("Kas čia eina? ")
print("Gali praeiti,", vartotojo_įvestis )
</syntaxhighlight>

Kai '''aš''' paleidau programą, štai ką '''mano''' ekranas parodė:

Stop!
Kas čia eina? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

Stop!
Kas čia eina?

''Tu turi įvesti savo vardą į python shell ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''

Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.
Kai paleidai programą (juk paleidai, tiesa?), tu turėjai surinkti savo vardą ir tada paspausti Enter.
Programa atspausdino dalį teksto ir tavo vardą. Taip atrodo ''įvesties'' pavyzdys.
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojo įvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.

Žinoma, gauti informaciją iš vartotojo pasaulio nieko verta, jei tos informacijos nėra kur padėti. Ir šioje vietoje atsiranda kintamieji.

Pavyzdinėje programoje <code>vartotojo_įvestis</code> yra ''kintamasis''. Kintamieji yra kaip dėžės, į kurias galima įdėti norimas informacijos dalis.

Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
b = 432
c = a + b
print("a + b yra", c)
print("vardas yra", vardas)
print("Rūšiuotos dalys, Po vidurnakčio ar", b23)
</syntaxhighlight>

Štai kokia išvestis:

a + b yra 555.4
vardas yra Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji laiko duomenis. Viršuje aprašytoje programoje kintamieji yra <code>a</code>, <code>b23</code>, <code>vardas</code>, <code>b</code> ir <code>c</code>. Pagrindiniai du kintamųjų tipai yra ''tekstas'' ir ''skaičius''. Tekstas yra raidžių, skaičių ir kitų simbolių seka. Šiame pavyzdyje <code>b23</code> ir <code>vardas</code> yra tekstinio tipo kintamieji. <code>Šlamštas</code>, <code>Jonas</code>, <code>a + b yra</code>, <code>vardas yra</code>, ir <code>Rūšiuotos dalys, Po vidurnakčio ar</code> šioje programoje yra tiesiog tekstinės reikšmės. Paprastas tekstas yra apsuptas kabučių <code>"</code> arba <code>'</code>.

Kitas kintamojo tipas yra skaičius. Atkreipkite dėmesį, kad kintamieji, kurie naudojami saugoti reikšmes, nenaudoja kabučių (" ir '). Jei norite naudoti realias ''reikšmes'', privalote naudoti kabutes.

<syntaxhighlight lang="python">
reikšmė1 == Oho
reikšmė2 == "Oho"
</syntaxhighlight>

Abu pavyzdžiai atrodo vienodai, bet pirmu atveju Python tikrins ar reikšmė, patalpinta kintamajame <code>reikšmė1</code>, yra tokia pati kaip ''kintamojo'' <code>Oho</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>h</code> ir <code>o</code>) yra tokios pat kaip ir <code>reikšmė2</code> (toliau daugiau paaiškinsiu apie tekstą ir <code>==</code>).

=== Priskyrimai ===

Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kuri gali būti kintamajame. Kompiuteris pamatys tokią eilutę <code>vardas = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</code> į dėžę (ar kintamąjį) <code>vardas</code>". Vėliau, pamatęs sakinį <code>c = a + b</code> jį perskaitys kaip "padėt sumą <code>a + b</code> arba <code>123.4 + 432</code>, kas lygu <code>555.4</code>, į <code>c</code>". Dešinė sakinio pusė ''konvertuosis'' ir rezultatas bus padėtas į kintamajį kairėje pusėje (<code>c</code>). Tai yra vadinama ''priskyrimu''. Turėtume nemaišyti priskyrimo ir matematinio lygybės ženklo (<code>=</code>). Ką reiškia <code>==</code> aptarsime vėliau.

O štai ir kitas kintamųjų naudojimo pavyzdys:
<syntaxhighlight lang="python">
a = 1
print(a)
a = a + 1
print(a)
a = a * 2
print(a)
</syntaxhighlight>

Ir žinoma štai tokį rezultatą gausime:

1
2
4

Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), kompiuteris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"

Dar viena programa prieš man pabangiant šį skyrių:
<syntaxhighlight lang="python">
skaičius = float(input("Įvesk skaičių: "))
sveikasSkaičius = int(input("Įvesk sveiką skaičių: "))
tekstas = input("Įvesk tekstą: ")
print("skaičius =", skaičius)
print("skaičius yra", type(skaičius))
print("skaičius * 2 =", skaičius * 2)
print("sveikas skaičius =", sveikasSkaičius)
print("sveikas skaičius yra", type(sveikasSkaičius))
print("sveikasSkaičius * 2 =", sveikasSkaičius * 2)
print("tekstas =", tekstas)
print("tekstas yra", type(tekstas))
print("tekstas * 2 =", tekstas * 2)

</syntaxhighlight>

Rezultatas:

Įvesk skaičių: '''12.34'''
Įvesk sveiką skaičių: '''-3'''
Įvesk tekstą: '''Labas'''
skaičius = 12.34
skaičius yra <class 'float'>
skaičius * 2 = 24.68
sveikas skaičius = -3
sveikas skaičius yra <class 'int'>
sveikasSkaičius * 2 = -6
tekstas = Labas
tekstas yra <class 'str'>
tekstas * 2 = LabasLabas

Atkreipk dėmesį, kad kintamasis <code>skaičius</code> buvo sukurtas su <code>float(input())</code>, išsaugos, o vėliau atspausdins tokį skaičių, koks buvo įvestas – su kableliu. Kintamasis <code>sveikasSkaičius</code>, kuris buvo sukurtas su <code>int(input())</code>, grąžina sveiką skaičių – reikšmę be kablelio. Tuo tarpu <code>tekstas</code>, kuris buvo sukurtas su <code>input()</code>, grąžino tekstinę eilutę (gali būti aprašoma ir <code>str(input())</code>). Jei tu nori, kad vartotojas įvestų skaičių su kableliu, naudok <code>float(input())</code> kintamojo tipą. Jei nori, kad vartotojas įvestų sveiką skaičių, naudok <code>int(input())</code> (jeigu vartotojas įves skaičių su kabliu – dalį po kabelio programa tiesiog ignoruos), bet jei nori teksto – naudok <code>input()</code>.

Antra pusė programos naudoja <code>type()</code> funkciją, kuri nusako, kokio tipo kintamasis yra. Skaičius yra <code>int</code> arba <code>float</code> tipo. Tai yra angliškų žodžių ''integer'' (sveikas skaičius) ir ''floating point'' (slankusis kablelis, naudojamas daugiausiai skaičiams su kableliu) trumpiniai. Tekstinė eilutė yra <code>str</code>, trumpinys ''string'' (tekstinė eilutė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas – ne. Atkreipk dėmesį, kai Python'as daugina skaičių iš sveiko skaičiaus gaunamas rezultatas, kurio ir galima tikėtis, tačiau jei tekstas padauginamas iš sveiko skaičiaus – sukuriamos kelios teksto kopijos (pavyzdžiui, <code>tekstas * 2 = LabasLabas</code>)

Tos pačios operacijos su teksto tipu daro kitokius dalykus nei su skaičiais. Taip pat, kai kurios operacijos veikia tik su skaičiais ir grąžina klaidą, jei bus bandoma panaudoti tesktą. Štai keletas interaktyvių pavyzdžių:

<pre>
>>> print("Čia" + " " + "yra" + " junginys.")
Čia yra junginys.
>>> print("Ha, " * 5)
Ha, Ha, Ha, Ha, Ha,
>>> print("Ha, " * 5 + "ha!")
Ha, Ha, Ha, Ha, Ha, ha!
>>> print(3 - 1)
2
>>> print("3" - "1")
Traceback (most recent call last):
File "<string>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operacija
!Symbolis
!Pavyzdys
|-
|Pakartojimas
|<code>*</code>
|<code>"i" * 5 == "iiiii"</code>
|-
|Sujungimas
|<code>+</code>
|<code>"Hello, " + "World!" == "Hello, World!"</code>
|}

=== Pavyzdžiai ===

'''Laikas.py'''
<syntaxhighlight lang="python">
# ši programa apskaičiuoja laiko priklausomybę nuo greičio ir atstumo
print("Įvesk greitį ir atstumą")
greitis = float(input("Greitis: "))
atstumas = float(input("Atstumas: "))
laikas = (atstumas / greitis)
print("Laikas:", laikas)

</syntaxhighlight>

Rezultatas:

Įvesk greitį ir atstumą
Greitis: '''5'''
Atstumas: '''10'''
Laikas: 2.0

Įvesk greitį ir atstumą
Greitis: '''3.52'''
Atstumas: '''45.6'''
Laikas: 12.9545454545

'''Plotas.py'''
<syntaxhighlight lang="python">
# Ši programa apskaičiuoja stačiakampio perimetrą ir plotą
print("Įveskite stačiakampio informaciją")
ilgis = float(input("Ilgis: "))
plotis = float(input("Plotis: "))
perimetras = (2 * ilgis + 2 * plotis)
print("Plotas:", ilgis * plotis)
print("Perimetras:", perimetras)
</syntaxhighlight>

Pavyzdžio rezultatas:

Įveskite stačiakampio informaciją
Ilgis: '''4'''
Plotis: '''3'''
Plotas: 12.0
Perimetras: 14.0

Įveskite stačiakampio informaciją
Ilgis: '''2.53'''
Plotis: '''5.2'''
Plotas: 13.156
Perimetras: 15.46

'''temperatura.py'''
<syntaxhighlight lang="python">
# Ši programa konvertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatūra Farenheitais: "))
cels_temp = (far_temp - 32.0) * (5.0 / 9.0)
print("Temperatūra Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatūra Farenheitais: '''32'''
Temperatūra Celsijaus laipsniais: 0.0

Temperatūra Farenheitais: '''-40'''
Temperatūra Celsijaus laipsniais: -40.0

Temperatūra Farenheitais: '''212'''
Temperatūra Celsijaus laipsniais: 100.0

Temperatūra Farenheitais: '''98.6'''
Temperatūra Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programą, kuri priima 2 tekstines reikšmes ir 2 skaičius iš vartotojo įvesties, sujungia tekstus be tarpų ir atvaizduoja gautą rezultatą, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
tekstas1 = input('Tekstas 1: ')
tekstas2 = input('Tekstas 2: ')
skaičius1 = float(input('Skaičius 1: '))
skaičius2 = float(input('Skaičius 2: '))
print(tekstas1 + tekstas2)
print(skaičius1 * skaičius2)
</syntaxhighlight>
|-
|}

{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}

Python Vadovėlis/Kas čia eina?

2022-02-01T14:33:10Z

Juratevalat: /* Įvestis ir kintamieji */

=== Įvestis ir kintamieji ===
Jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:
<syntaxhighlight lang="python">
print("Stop!")
vartotojo_įvestis = input("Kas čia eina? ")
print("Gali praeiti,", vartotojo_įvestis )
</syntaxhighlight>

Kai '''aš''' paleidau programą, štai ką '''mano''' ekranas parodė:

Stop!
Kas čia eina? '''Jonas'''
Gali praeiti, Jonas

''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''

Stop!
Kas čia eina?

''Tu turi įvesti savo vardą į python shell ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''

Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.
Kai paleidai programą (juk paleidai, tiesa?), tu turėjai surinkti savo vardą ir tada paspausti Enter.
Programa atspausdino dalį teksto ir tavo vardą. Taip atrodo ''įvesties'' pavyzdys.
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojo įvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.

Žinoma, gauti informaciją iš vartotojo pasaulio nieko verta, jei tos informacijos nėra kur padėti. Ir šioje vietoje atsiranda kintamieji.

Pavyzdinėje programoje <code>vartotojo_įvestis</code> yra ''kintamasis''. Kintamieji yra kaip dėžės, į kurias galima įdėti norimas informacijos dalis.

Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Jonas"
b = 432
c = a + b
print("a + b yra", c)
print("vardas yra", vardas)
print("Rūšiuotos dalys, Po vidurnakčio ar", b23)
</syntaxhighlight>

Štai kokia išvestis:

a + b yra 555.4
vardas yra Jonas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas

Kintamieji laiko duomenis. Viršuje aprašytoje programoje kintamieji yra <code>a</code>, <code>b23</code>, <code>vardas</code>, <code>b</code> ir <code>c</code>. Pagrindiniai du kintamųjų tipai yra ''tekstas'' ir ''skaičius''. Tekstas yra raidžių, skaičių ir kitų simbolių seka. Šiame pavyzdyje <code>b23</code> ir <code>vardas</code> yra tekstinio tipo kintamieji. <code>Šlamštas</code>, <code>Jonas</code>, <code>a + b yra</code>, <code>vardas yra</code>, ir <code>Rūšiuotos dalys, Po vidurnakčio ar</code> šioje programoje yra tiesiog tekstinės reikšmės. Paprastas tekstas yra apsuptas kabučių <code>"</code> arba <code>'</code>.

Kitas kintamojo tipas yra skaičius. Atkreipkite dėmesį, kad kintamieji, kurie naudojami saugoti reikšmes, nenaudoja kabučių (" ir '). Jei norite naudoti realias ''reikšmes'', privalote naudoti kabutes.

<syntaxhighlight lang="python">
reikšmė1 == Oho
reikšmė2 == "Oho"
</syntaxhighlight>

Abu pavyzdžiai atrodo vienodai, bet pirmu atveju Python tikrins ar reikšmė, patalpinta kintamajame <code>reikšmė1</code>, yra tokia pati kaip ''kintamojo'' <code>Oho</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>h</code> ir <code>o</code>) yra tokios pat kaip ir <code>reikšmė2</code> (toliau daugiau paaiškinsiu apie tekstą ir <code>==</code>).

=== Priskyrimai ===

Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kuri gali būti kintamajame. Kompiuteris pamatys tokią eilutę <code>vardas = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</code> į dėžę (ar kintamąjį) <code>vardas</code>". Vėliau, pamatęs sakinį <code>c = a + b</code> jį perskaitys kaip "padėt sumą <code>a + b</code> arba <code>123.4 + 432</code>, kas lygu <code>555.4</code>, į <code>c</code>". Dešinė sakinio pusė ''konvertuosis'' ir rezultatas bus padėtas į kintamajį kairėje pusėje (<code>c</code>). Tai yra vadinama ''priskyrimu''. Turėtume nemaišyti priskyrimo ir matematinio lygybės ženklo (<code>=</code>). Ką reiškia <code>==</code> aptarsime vėliau.

O štai ir kitas kintamųjų naudojimo pavyzdys:
<syntaxhighlight lang="python">
a = 1
print(a)
a = a + 1
print(a)
a = a * 2
print(a)
</syntaxhighlight>

Ir žinoma štai tokį rezultatą gausime:

1
2
4

Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), kompiuteris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"

Dar viena programa prieš man pabangiant šį skyrių:
<syntaxhighlight lang="python">
skaičius = float(input("Įvesk skaičių: "))
sveikasSkaičius = int(input("Įvesk sveiką skaičių: "))
tekstas = input("Įvesk tekstą: ")
print("skaičius =", skaičius)
print("skaičius yra", type(skaičius))
print("skaičius * 2 =", skaičius * 2)
print("sveikas skaičius =", sveikasSkaičius)
print("sveikas skaičius yra", type(sveikasSkaičius))
print("sveikasSkaičius * 2 =", sveikasSkaičius * 2)
print("tekstas =", tekstas)
print("tekstas yra", type(tekstas))
print("tekstas * 2 =", tekstas * 2)

</syntaxhighlight>

Rezultatas:

Įvesk skaičių: '''12.34'''
Įvesk sveiką skaičių: '''-3'''
Įvesk tekstą: '''Labas'''
skaičius = 12.34
skaičius yra <class 'float'>
skaičius * 2 = 24.68
sveikas skaičius = -3
sveikas skaičius yra <class 'int'>
sveikasSkaičius * 2 = -6
tekstas = Labas
tekstas yra <class 'str'>
tekstas * 2 = LabasLabas

Atkreipk dėmesį, kad <code>skaičius</code> buvo sukurtas su <code>float(input())</code>, <code>int(input())</code> grąžina sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> grąžino tekstinę eilutę (gali būti aprašoma ir <code>str(input())</code>). Jei tu nori, kad vartotojas įvestų skaičių su kableliu, naudok <code>float(input())</code> kintamojo tipą. Jei nori, kad vartotojas įvestų sveiką skaičių, naudok <code>int(input())</code>, bet jei nori teksto - naudok <code>input()</code>.

Antra pusė programos naudoja <code>type()</code> funkciją, kuri nusako, kokio tipo kintamasis yra. Skaičius yra <code>int</code> arba <code>float</code> tipo. Tai yra angliškų žodžių ''integer'' (sveikas skaičius) ir ''floating point'' (slankusis kablelis, naudojamas daugiausiai skaičiams su kableliu) trumpiniai. Tekstinė eilutė yra <code>str</code>, trumpinys ''string'' (tekstinė eilutė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas - ne. Atkreipk dėmesį, kai Python'as daugina skaičių iš sveiko skaičiaus gaunamas rezultatas, kurio ir galima tikėtis, tačiau jei tekstas padauginamas iš sveiko skaičiaus - sukuriamos kelios teksto kopijos (pavyzdžiui, <code>tekstas * 2 = LabasLabas</code>)

Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiais ir grąžina klaidą, jei bus bandoma panaudoti tesktą. Štai keletas interaktyvių pavyzdžių:

<pre>
>>> print("Čia" + " " + "yra" + " junginys.")
Čia yra junginys.
>>> print("Ha, " * 5)
Ha, Ha, Ha, Ha, Ha,
>>> print("Ha, " * 5 + "ha!")
Ha, Ha, Ha, Ha, Ha, ha!
>>> print(3 - 1)
2
>>> print("3" - "1")
Traceback (most recent call last):
File "<string>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

Štai sąrašas kelių operacijų su tekstu:

{| class="wikitable"
!Operation
!Symbol
!Example
|-
|Pakartojimas
|<code>*</code>
|<code>"i" * 5 == "iiiii"</code>
|-
|Sujungimas
|<code>+</code>
|<code>"Hello, " + "World!" == "Hello, World!"</code>
|}

=== Pavyzdžiai ===

'''Laikas.py'''
<syntaxhighlight lang="python">
# ši programa apskaičiuoja laiko priklausomybę nuo greičio ir atstumo
print("Įvesk greitį ir atstumą")
greitis = float(input("Greitis: "))
atstumas = float(input("Atstumas: "))
laikas = (atstumas / greitis)
print("Laikas:", laikas)

</syntaxhighlight>

Rezultatas:

Įvesk greitį ir atstumą
Greitis: '''5'''
Atstumas: '''10'''
Laikas: 2.0

Įvesk greitį ir atstumą
Greitis: '''3.52'''
Atstumas: '''45.6'''
Laikas: 12.9545454545

'''Plotas.py'''
<syntaxhighlight lang="python">
# Ši programa apskaičiuoja stačiakampio perimetrą ir plotą
print("Įveskite stačiakampio informaciją")
ilgis = float(input("Ilgis: "))
plotis = float(input("Plotis: "))
perimetras = (2 * ilgis + 2 * plotis)
print("Plotas:", ilgis * plotis)
print("Perimetras:", perimetras)
</syntaxhighlight>

Pavyzdžio rezultatas:

Įveskite stačiakampio informaciją
Ilgis: '''4'''
Plotis: '''3'''
Plotas: 12.0
Perimetras: 14.0

Įveskite stačiakampio informaciją
Ilgis: '''2.53'''
Plotis: '''5.2'''
Plotas: 13.156
Perimetras: 15.46

'''temperatura.py'''
<syntaxhighlight lang="python">
# Ši programa konvertuoja temperatūra iš Farenheitų į Celsijų
far_temp = float(input("Temperatūra Farenheitais: "))
cels_temp = (far_temp - 32.0) * (5.0 / 9.0)
print("Temperatūra Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>

Pavyzdžio rezultatas:

Temperatūra Farenheitais: '''32'''
Temperatūra Celsijaus laipsniais: 0.0

Temperatūra Farenheitais: '''-40'''
Temperatūra Celsijaus laipsniais: -40.0

Temperatūra Farenheitais: '''212'''
Temperatūra Celsijaus laipsniais: 100.0

Temperatūra Farenheitais: '''98.6'''
Temperatūra Celsijaus laipsniais: 37.0

=== Užduotis ===
Parašyti programą, kuri priima 2 tekstines reikšmes ir 2 skaičius iš vartotojo įvesties, sujungia tekstus be tarpų ir atvaizduoja gautą rezultatą, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
tekstas1 = input('Tekstas 1: ')
tekstas2 = input('Tekstas 2: ')
skaičius1 = float(input('Skaičius 1: '))
skaičius2 = float(input('Skaičius 2: '))
print(tekstas1 + tekstas2)
print(skaičius1 * skaičius2)
</syntaxhighlight>
|-
|}

{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}

Python Vadovėlis/Labas, Pasauli

2022-01-30T14:45:33Z

Juratevalat:

=== Ką sužinosi? ===
Perskaitęs šį skyrių, turėtum suprasti kaip teksto redaktoriumi rašyti programas, kaip parašytas programas išsaugoti kompiuterio atmintyje ir kaip jas paleisti.

=== Spausdinimas ===
Istoriškai taip jau susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programėlės pavadinimu „Hello, World!“ arba lietuviškai [[„Labas, Pasauli!“]].

Python'o programavimo kalboje programa atrodytų taip:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

==== Programavimas kodo redaktoriumi ====

Programavimui rekomenduojame naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Non-Programmer's Tutorial for Python 3/Intro#Creating_and_Running_Programs|Programų kūrimas ir paleidimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save) pavadinimu <code>hello.py</code>.

TODO: gif

Sveikiname! Sukūrei savo pirmą Python programą.

(Jeigu tokios programavimo aplinkos įsidiegti savo kompiuteryje negali, žr. kitą žingsnį).

Dabar parašytą programą paleisk vykdyti: tiesiog paspausk žalią mygtuką dešinėje viršuje.

Kai paleisi šią programą, ji suveiks ir terminale atsiras užrašas:

TODO: gif

Labas, Pasauli!

==== Alternatyvus būdas: Programavimas paprastu teksto redaktoriumi ====

Jeigu kodo redaktoriaus negali įsidiegti savo kompiuteryje dėl kokių nors priežasčių, programuoti galima ir tiesiog paprasčiausiu teksto redaktoriumi, pvz., Notepad.

Tiesiog sukurk naują paprastą tekstinį failą (.txt), jame įrašyk programinį kodą <code>print("Labas, Pasauli!")</code>, failą išsaugok pavadinimu <code>hello.py</code>.

TODO: gif

Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 hello.py</code>

Tavo programa parašys:

Labas, Pasauli!

TODO: gif

=== Eime toliau ===

Labai rekomenduojame kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. Mūsų praktikoje toks mokymosi procesas yra pats efektyviausias ir veiksmingiausias.

Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:

<syntaxhighlight lang="python">
print("Benas ir Liepa lipo į kalną")
print("Parsinešti puodą vandens.")
print("Benas nukrito ir susidaužė karūną,")
print("Ir Liepa suklupo taip pat.")
</syntaxhighlight>

Kai paleidi šią programą, ji parašo trumpą istoriją:

Benas ir Liepa lipo į kalną
Parsinešti puodą vandens.
Benas nukrito ir susidaužė karūną,
Ir Liepa suklupo taip pat.

Kai kompiuteris paleidžia programą, pirmiausia jis mato:

<syntaxhighlight lang="python">
print("Benas ir Liepa lipo į kalną")
</syntaxhighlight>

Todėl kompiuteris užrašo:

Benas ir Liepa lipo į kalną

Tada kompiuteris skaito kitą eilutę ir mato:

<syntaxhighlight lang="python">
print("Parsinešti puodą vandens.")
</syntaxhighlight>

Todėl ir ją užrašo kompiuterio ekrane:

Parsinešti puodą vandens.

Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs ir eina toliau: skaito kitą eilutę, ją įvykdo ir t.t. Taip kompiuteris vykdo visas surašytas komandas, kol pasiekia programos pabaigą.

==== Terminologija ====
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.

Prieš tai rašydami kodą, mes naudojame „funkciją“ pavadinimu <code>print</code>. Po funkcijos pavadinimo <code>print</code> rašomi skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

funkcijai duodamas vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Programuotojai tai vadina „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme). Kitas tekstinės reikšmės pavyzdys yra <code>"Benas ir Liepa lipo į kalną"</code>.

Užrašyta funkcija su argumentais yra „teiginys“, kurį supranta Python'as. Sakinio 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> (escape character), arba nauja eilutė. Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Pabandyk suprasti šią programą:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\nKą turėčiau daryti?")
</syntaxhighlight>

Kurios rezultatas yra toks:

Labas, Pasauli!
Ką turėčiau daryti?

<code>\n</code> naudojamas, kai norime tekstą perkelti į kitą eilutę, bet nenorime naudoti kelių <code>print()</code> komandų.

Spausdinimo komanda automatiškai naudoja <code>\n</code>, t. y. kiekviena komanda tekstą spausdina vis naujoje eilutėje, net jeigu pats <code>\n</code> ir neužrašai. Paprasčiau suprasti bus pamačius pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

iš tikrųjų yra:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\n")
</syntaxhighlight>

=== Aritmetinės operacijos ===
Programos pavyzdys:

<syntaxhighlight lang="python">
print("2 + 2 yra", 2 + 2)
print("3 * 4 yra", 3 * 4)
print("100 - 1 yra", 100 - 1)
print("((33 + 2) / 5 + 11.5 yra", (33 + 2) / 5 + 11.5)
</syntaxhighlight>

Rezultatas:

2 + 2 yra 4
3 * 4 yra 12
100 - 1 yra 99
(33 + 2) / 5 + 11.5 yra 18.5

==== Aritmetinės išraiškos ====

Šiame pavyzdyje, rašymo funkcija <code>print()</code> yra su dvejais argumentais, kurie atskirti kableliu. Panagrinėkime pirmoje eilutėje užrašytą komandą:

<syntaxhighlight lang="python">
print("2 + 2 yra", 2 + 2)
</syntaxhighlight>

Pirmas argumentas yra teksto eilutė <code>"2 + 2 yra"</code> ir antras argumentas yra aritmetinė išraiška <code>2 + 2</code>, tiksliau tariant viena iš aritmetinių operacijų.

Atkreipk dėmesį, kad eilutė, kuri yra užrašyta kabutėse yra atspausdinama kaip tekstas, o išraiška užrašyta be kabučių yra apskaičiuojama ir užrašomas atsakymas.

Python'o programavimo kalba turi septynias pagrindines skaičių operacijas.

{| class="wikitable"
! Operacija
! Simbolis
! Pavyzdys
|-
|Kėlimas laipsniu
| <code>**</code>
| <code>5 ** 2 == 25</code>
|-
|Daugyba
| <code>*</code>
|<code>2 * 3 == 6</code>
|-
|Dalyba
| <code>/</code>
| <code>14 / 3 == 4.666666666666667</code>
|-
|Sveikųjų skaičių dalyba
| <code>//</code>
| <code>14 // 3 == 4</code>
|-
|Liekana
| <code>%</code>
| <code>14 % 3 == 2</code>
|-
|Sudėtis
| <code>+</code>
| <code>1 + 2 == 3</code>
|-
|Atimtis
| <code>-</code>
| <code>4 - 3 == 1</code>
|}

Atkreipk dėmesį, kad yra trys dalybos būdai: vienas grąžina dešimtainį skaičių, antras – tik dalybos sveikąją dalį, o trečias – liekaną.
Operacijų tvarka tokia pati kaip matematikoje:
* pirmiausiai atliekami veiksmai skliausteliuose <code>()</code>
* kėlimas laipsniu <code>**</code>
* iš karės į dešinę: daugyba <code>*</code>, dalyba<code>/</code>, sveikoji dalyba <code>//</code>, dalybos liekana <code>%</code>
* iš kairės į dešinę: sudėtis <code>+</code> ir atimtis <code>-</code>

Taigi, užrašydamas formules, nepamiršk skliaustelių.

=== Komentarai ===

Rašant daug kodo, ateityje tikrai ne viską atsiminsi. Todėl programoje gali naudoti komentarus, kurie yra tiesiog pastabos/paaiškinimai sau pačiam arba kitiems programuotojams. Pavyzdžiui:

<syntaxhighlight lang="python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22 / 7)
</syntaxhighlight>

Rezultatas:

3.14285714286

Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra skirti žmonėms, pagerinti programos skaitomumą.

Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris visą šį tekstą ignoruos iki pat eilutės galo.

<syntaxhighlight lang = "python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22/7) # tokiu būdu gauname tik apytikslę PI reikšmę
</syntaxhighlight>

=== Pavyzdžiai ===
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python 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ą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #1  
|-
|
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>
|-
|}

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #2  
|-
|
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/Labas, Pasauli

2022-01-30T14:32:05Z

Juratevalat:

=== Ką sužinosi? ===
Perskaitęs šį skyrių, turėtum suprasti kaip teksto redaktoriumi rašyti programas, kaip parašytas programas išsaugoti kompiuterio atmintyje ir kaip jas paleisti.

=== Spausdinimas ===
Istoriškai taip jau susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programėlės pavadinimu „Hello, World!“ arba lietuviškai [[„Labas, Pasauli!“]].

Python'o programavimo kalboje programa atrodytų taip:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

==== Programavimas kodo redaktoriumi ====

Programavimui rekomenduojame naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Non-Programmer's Tutorial for Python 3/Intro#Creating_and_Running_Programs|Programų kūrimas ir paleidimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save) pavadinimu <code>hello.py</code>.

TODO: gif

Sveikiname! Sukūrei savo pirmą Python programą.

(Jeigu tokios programavimo aplinkos įsidiegti savo kompiuteryje negali, žr. kitą žingsnį).

Dabar parašytą programą paleisk vykdyti: tiesiog paspausk žalią mygtuką dešinėje viršuje.

Kai paleisi šią programą, ji suveiks ir terminale atsiras užrašas:

TODO: gif

Labas, Pasauli!

==== Alternatyvus būdas: Programavimas paprastu teksto redaktoriumi ====

Jeigu kodo redaktoriaus negali įsidiegti savo kompiuteryje dėl kokių nors priežasčių, programuoti galima ir tiesiog paprasčiausiu teksto redaktoriumi, pvz., Notepad.

Tiesiog sukurk naują paprastą tekstinį failą (.txt), jame įrašyk programinį kodą <code>print("Labas, Pasauli!")</code>, failą išsaugok pavadinimu <code>hello.py</code>.

TODO: gif

Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 hello.py</code>

Tavo programa parašys:

Labas, Pasauli!

TODO: gif

=== Eime toliau ===

Labai rekomenduojame kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. Mūsų praktikoje toks mokymosi procesas yra pats efektyviausias ir veiksmingiausias.

Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:

<syntaxhighlight lang="python">
print("Benas ir Liepa lipo į kalną")
print("Parsinešti puodą vandens.")
print("Benas nukrito ir susidaužė karūną,")
print("Ir Liepa suklupo taip pat.")
</syntaxhighlight>

Kai paleidi šią programą, ji parašo trumpą istoriją:

Benas ir Liepa lipo į kalną
Parsinešti puodą vandens.
Benas nukrito ir susidaužė karūną,
Ir Liepa suklupo taip pat.

Kai kompiuteris paleidžia programą, pirmiausia jis mato:

<syntaxhighlight lang="python">
print("Benas ir Liepa lipo į kalną")
</syntaxhighlight>

Todėl kompiuteris užrašo:

Benas ir Liepa lipo į kalną

Tada kompiuteris skaito kitą eilutę ir mato:

<syntaxhighlight lang="python">
print("Parsinešti puodą vandens.")
</syntaxhighlight>

Todėl ir ją užrašo kompiuterio ekrane:

Parsinešti puodą vandens.

Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs ir eina toliau: skaito kitą eilutę, ją įvykdo ir t.t. Taip kompiuteris vykdo visas surašytas komandas, kol pasiekia programos pabaigą.

==== Terminologija ====
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.

Prieš tai rašydami kodą, mes naudojame „funkciją“ pavadinimu <code>print</code>. Po funkcijos pavadinimo <code>print</code> rašomi skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

funkcijai duodamas vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Programuotojai tai vadina „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme). Kitas tekstinės reikšmės pavyzdys yra <code>"Benas ir Liepa lipo į kalną"</code>.

Užrašyta funkcija su argumentais yra „teiginys“, kurį supranta Python'as. Sakinio 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> (escape character), arba nauja eilutė. Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Pabandyk suprasti šią programą:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\nKą turėčiau daryti?")
</syntaxhighlight>

Kurios rezultatas yra toks:

Labas, Pasauli!
Ką turėčiau daryti?

<code>\n</code> naudojamas, kai norime tekstą perkelti į kitą eilutę, bet nenorime naudoti kelių <code>print()</code> komandų.

Spausdinimo komanda automatiškai naudoja <code>\n</code>, t. y. kiekviena komanda tekstą spausdina vis naujoje eilutėje, net jeigu pats <code>\n</code> ir neužrašai. Paprasčiau suprasti bus pamačius pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

iš tikrųjų yra:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\n")
</syntaxhighlight>

=== 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>

Rezultatas:

2 + 2 yra 4
3 * 4 yra 12
100 - 1 yra 99
(33 + 2) / 5 + 11.5 yra 18.5

==== Aritmetinės išraiškos ====

Šiame pavyzdyje, rašymo funkcija <code>print()</code> yra su dvejais argumentais, kurie atskirti kableliu. 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
| <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>
* kėlimas laipsniu <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, užrašydamas formules, nepamiršk skliaustelių.

=== Komentarai ===

Rašant daug kodo, ateityje tikrai ne viską atsiminsi. Todėl programoje gali naudoti komentarus, kurie yra tiesiog pastabos/paaiškinimai sau pačiam arba kitiems programuotojams. Pavyzdžiui:

<syntaxhighlight lang="python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22 / 7)
</syntaxhighlight>

Rezultatas:

3.14285714286

Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra skirti žmonėms, pagerinti programos skaitomumą.

Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris visą šį tekstą ignoruos iki pat eilutės galo.

<syntaxhighlight lang = "python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22/7) # tokiu būdu gauname tik apytikslę PI reikšmę
</syntaxhighlight>

=== Pavyzdžiai ===
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python 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ą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #1  
|-
|
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>
|-
|}

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #2  
|-
|
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/Labas, Pasauli

2022-01-30T14:31:42Z

Juratevalat:

=== Ką sužinosi? ===
Perskaitęs šį skyrių, turėtum suprasti kaip teksto redaktoriumi rašyti programas, kaip parašytas programas išsaugoti kompiuterio atmintyje ir kaip jas paleisti.

=== Spausdinimas ===
Istoriškai taip jau susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programėlės pavadinimu „Hello, World!“ arba lietuviškai [[„Labas, Pasauli!“]].

Python'o programavimo kalboje programa atrodytų taip:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

==== Programavimas kodo redaktoriumi ====

Programavimui rekomenduojame naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Non-Programmer's Tutorial for Python 3/Intro#Creating_and_Running_Programs|Programų kūrimas ir paleidimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save) pavadinimu <code>hello.py</code>.

TODO: gif

Sveikiname! Sukūrei savo pirmą Python programą.

(Jeigu tokios programavimo aplinkos įsidiegti savo kompiuteryje negali, žr. kitą žingsnį).

Dabar parašytą programą paleisk vykdyti: tiesiog paspausk žalią mygtuką dešinėje viršuje.

Kai paleisi šią programą, ji suveiks ir terminale atsiras užrašas:

TODO: gif

Labas, Pasauli!

==== Alternatyvus būdas: Programavimas paprastu teksto redaktoriumi ====

Jeigu kodo redaktoriaus negali įsidiegti savo kompiuteryje dėl kokių nors priežasčių, programuoti galima ir tiesiog paprasčiausiu teksto redaktoriumi, pvz., Notepad.

Tiesiog sukurk naują paprastą tekstinį failą (.txt), jame įrašyk programinį kodą <code>print("Labas, Pasauli!")</code>, failą išsaugok pavadinimu <code>hello.py</code>.

TODO: gif

Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 hello.py</code>

Tavo programa parašys:

Labas, Pasauli!

TODO: gif

=== Eime toliau ===

Labai rekomenduojame kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. Mūsų praktikoje toks mokymosi procesas yra pats efektyviausias ir veiksmingiausias.

Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:

<syntaxhighlight lang="python">
print("Benas ir Liepa lipo į kalną")
print("Parsinešti puodą vandens.")
print("Benas nukrito ir susidaužė karūną,")
print("Ir Liepa suklupo taip pat.")
</syntaxhighlight>

Kai paleidi šią programą, ji parašo trumpą istoriją:

Benas ir Liepa lipo į kalną
Parsinešti puodą vandens.
Benas nukrito ir susidaužė karūną,
Ir Liepa suklupo taip pat.

Kai kompiuteris paleidžia programą, pirmiausia jis mato:

<syntaxhighlight lang="python">
print("Benas ir Liepa lipo į kalną")
</syntaxhighlight>

Todėl kompiuteris užrašo:

Benas ir Liepa lipo į kalną

Tada kompiuteris skaito kitą eilutę ir mato:

<syntaxhighlight lang="python">
print("Parsinešti puodą vandens.")
</syntaxhighlight>

Todėl ir ją užrašo kompiuterio ekrane:

Parsinešti puodą vandens.

Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs ir eina toliau: skaito kitą eilutę, ją įvykdo ir t.t. Taip kompiuteris vykdo visas surašytas komandas, kol pasiekia programos pabaigą.

==== Terminologija ====
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.

Prieš tai rašydami kodą, mes naudojame „funkciją“ pavadinimu <code>print</code>. Po funkcijos pavadinimo <code>print</code> rašomi skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

funkcijai duodamas vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Programuotojai tai vadina „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme). Kitas tekstinės reikšmės pavyzdys yra <code>"Benas ir Liepa lipo į kalną"</code>.

Užrašyta funkcija su argumentais yra „teiginys“, kurį supranta Python'as. Sakinio 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> (escape character), arba nauja eilutė . Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Pabandyk suprasti šią programą:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\nKą turėčiau daryti?")
</syntaxhighlight>

Kurios rezultatas yra toks:

Labas, Pasauli!
Ką turėčiau daryti?

<code>\n</code> naudojamas, kai norime tekstą perkelti į kitą eilutę, bet nenorime naudoti kelių <code>print()</code> komandų.

Spausdinimo komanda automatiškai naudoja <code>\n</code>, t. y. kiekviena komanda tekstą spausdina vis naujoje eilutėje, net jeigu pats <code>\n</code> ir neužrašai. Paprasčiau suprasti bus pamačius pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

iš tikrųjų yra:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\n")
</syntaxhighlight>

=== 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>

Rezultatas:

2 + 2 yra 4
3 * 4 yra 12
100 - 1 yra 99
(33 + 2) / 5 + 11.5 yra 18.5

==== Aritmetinės išraiškos ====

Šiame pavyzdyje, rašymo funkcija <code>print()</code> yra su dvejais argumentais, kurie atskirti kableliu. 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
| <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>
* kėlimas laipsniu <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, užrašydamas formules, nepamiršk skliaustelių.

=== Komentarai ===

Rašant daug kodo, ateityje tikrai ne viską atsiminsi. Todėl programoje gali naudoti komentarus, kurie yra tiesiog pastabos/paaiškinimai sau pačiam arba kitiems programuotojams. Pavyzdžiui:

<syntaxhighlight lang="python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22 / 7)
</syntaxhighlight>

Rezultatas:

3.14285714286

Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra skirti žmonėms, pagerinti programos skaitomumą.

Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris visą šį tekstą ignoruos iki pat eilutės galo.

<syntaxhighlight lang = "python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22/7) # tokiu būdu gauname tik apytikslę PI reikšmę
</syntaxhighlight>

=== Pavyzdžiai ===
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python 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ą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #1  
|-
|
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>
|-
|}

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #2  
|-
|
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/Labas, Pasauli

2022-01-30T14:28:55Z

Juratevalat:

=== Ką sužinosi? ===
Perskaitęs šį skyrių, turėtum suprasti kaip teksto redaktoriumi rašyti programas, kaip parašytas programas išsaugoti kompiuterio atmintyje ir kaip jas paleisti.

=== Spausdinimas ===
Istoriškai taip jau susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programėlės pavadinimu „Hello, World!“ arba lietuviškai [[„Labas, Pasauli!“]].

Python'o programavimo kalboje programa atrodytų taip:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

==== Programavimas kodo redaktoriumi ====

Programavimui rekomenduojame naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Non-Programmer's Tutorial for Python 3/Intro#Creating_and_Running_Programs|Programų kūrimas ir paleidimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save) pavadinimu <code>hello.py</code>.

TODO: gif

Sveikiname! Sukūrei savo pirmą Python programą.

(Jeigu tokios programavimo aplinkos įsidiegti savo kompiuteryje negali, žr. kitą žingsnį).

Dabar parašytą programą paleisk vykdyti: tiesiog paspausk žalią mygtuką dešinėje viršuje.

Kai paleisi šią programą, ji suveiks ir terminale atsiras užrašas:

TODO: gif

Labas, Pasauli!

==== Alternatyvus būdas: Programavimas paprastu teksto redaktoriumi ====

Jeigu kodo redaktoriaus negali įsidiegti savo kompiuteryje dėl kokių nors priežasčių, programuoti galima ir tiesiog paprasčiausiu teksto redaktoriumi, pvz., Notepad.

Tiesiog sukurk naują paprastą tekstinį failą (.txt), jame įrašyk programinį kodą <code>print("Labas, Pasauli!")</code>, failą išsaugok pavadinimu <code>hello.py</code>.

TODO: gif

Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 hello.py</code>

Tavo programa parašys:

Labas, Pasauli!

TODO: gif

=== Eime toliau ===

Labai rekomenduojame kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. Mūsų praktikoje toks mokymosi procesas yra pats efektyviausias ir veiksmingiausias.

Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:

<syntaxhighlight lang="python">
print("Benas ir Liepa lipo į kalną")
print("Parsinešti puodą vandens.")
print("Benas nukrito ir susidaužė karūną,")
print("Ir Liepa suklupo taip pat.")
</syntaxhighlight>

Kai paleidi šią programą, ji parašo trumpą istoriją:

Benas ir Liepa lipo į kalną
Parsinešti puodą vandens.
Benas nukrito ir susidaužė karūną,
Ir Liepa suklupo taip pat.

Kai kompiuteris paleidžia programą, pirmiausia jis mato:

<syntaxhighlight lang="python">
print("Benas ir Liepa lipo į kalną")
</syntaxhighlight>

Todėl kompiuteris užrašo:

Benas ir Liepa lipo į kalną

Tada kompiuteris skaito kitą eilutę ir mato:

<syntaxhighlight lang="python">
print("Parsinešti puodą vandens.")
</syntaxhighlight>

Todėl ir ją užrašo kompiuterio ekrane:

Parsinešti puodą vandens.

Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs ir eina toliau: skaito kitą eilutę, ją įvykdo ir t.t. Taip kompiuteris vykdo visas surašytas komandas, kol pasiekia programos pabaigą.

==== Terminologija ====
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.

Prieš tai rašydami kodą, mes naudojame „funkciją“ pavadinimu <code>print</code>. Po funkcijos pavadinimo <code>print</code> rašomi skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:

<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

funkcijai duodamas vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Programuotojai tai vadina „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme). Kitas tekstinės reikšmės pavyzdys yra <code>"Benas ir Liepa lipo į kalną"</code>.

Užrašyta funkcija su argumentais yra „teiginys“, kurį supranta Python'as. Sakinio 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> (escape character), arba nauja eilutė . Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Pabandyk suprasti šią programą:

<syntaxhighlight lang="python">
print("Labas, Pasauli!\nKą turėčiau daryti?")
</syntaxhighlight>

Kurios rezultatas yra toks:

Labas, Pasauli!
Ką turėčiau daryti?

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>

Rezultatas:

2 + 2 yra 4
3 * 4 yra 12
100 - 1 yra 99
(33 + 2) / 5 + 11.5 yra 18.5

==== Aritmetinės išraiškos ====

Šiame pavyzdyje, rašymo funkcija <code>print()</code> yra su dvejais argumentais, kurie atskirti kableliu. 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
| <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>
* kėlimas laipsniu <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, užrašydamas formules, nepamiršk skliaustelių.

=== Komentarai ===

Rašant daug kodo, ateityje tikrai ne viską atsiminsi. Todėl programoje gali naudoti komentarus, kurie yra tiesiog pastabos/paaiškinimai sau pačiam arba kitiems programuotojams. Pavyzdžiui:

<syntaxhighlight lang="python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22 / 7)
</syntaxhighlight>

Rezultatas:

3.14285714286

Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra skirti žmonėms, pagerinti programos skaitomumą.

Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris visą šį tekstą ignoruos iki pat eilutės galo.

<syntaxhighlight lang = "python">
# Skaičiaus PI išraiška kompiuterio ekrane
print(22/7) # tokiu būdu gauname tik apytikslę PI reikšmę
</syntaxhighlight>

=== Pavyzdžiai ===
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python 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ą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #1  
|-
|
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>
|-
|}

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #2  
|-
|
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/Įvadas

2022-01-30T14:02:53Z

Juratevalat:

{{navigation |previous=Įžanga |next=Labas, Pasauli}}

=== Įvadas ===
Šis vadovėlis skirtas visiems norintiems išmokti Python: tiek pirmą kartą bandantiems programuoti, tiek bandžiusiems programuoti kitomis programavimo kalbomis ir norintiems išmokti Python, tiek jau pramokusiems Python, bei norintiems praplėsti žinias.

Tėra vienintelis būdas išmokti programuoti. '''Tu''' turi skaityti ''kodą'' ir rašyti ''kodą''.
Vadovėlyje parodysiu tau daug kodo. Bandyk vykdyti šį kodą kompiuteriu ir išbandyti pats kaip jis veikia. Ekperimentuok ir bandyk daryti pakeitimus. Nebijok kažką sugandinti, blogiausiu atveju tavo kodas tiesiog neveiks. Kai aš pats rašysiu kodą knygoje, jį suformatuosiu šitaip:

<syntaxhighlight lang="python">
# Python kalbą lengva išmokti
print("Sveikas, pasauli!")
</syntaxhighlight>

Prieš komentarą – paparastą tekatą – dėsiu groteles. Šitaip lengvai atskirsi kodo pavyzdžius nuo teksto. Jei skaitai internetinį knygos variantą, atkreipk dėmesį į kodo spalvą – ji kitokia, tam kad tam tikros kodo dalys išsiskirtų. Tau vedant kodą kompiuteriu redagavimo programa jį gali nuspalvinti kitokiomis spalvomis arba iš viso nenuspalvinti. Kodo nuspalvinimas gali skirtis, bet jei įvesi kodą, taip kaip nurodyta pavyzdžiuose jis veiks taip kaip ir aprašyta vadovėlyje.

Pavyzdžiui, vykdant anksčiau parašytą kodo pavyzdį kompiuteris ekrane išves tokį tekstą:

Sveikas, pasauli!

Šis vadovėlis skirtas Python 3 versijai. Bandant kodo pavyzdžius vykdyti su Python 2.7 ir ankstesnėmis versijomis jis gali neveikti. Skirtumai tarp Python 2 ir 3 versijos nėra itin dideli, tad išmokęs Python 3 galėsi be didelių pastangų skaityti ir ankstenėms versijoms skirtą kodą.

Pavyzdžiuose dažnai parodysiu programos vykdymo metu tavo įvedamą tekstą (jis bus '''paryškintas''') ir programos į ekraną išvedamą tekstą. Pavyzdžiui:

Stok!
Kas eina? '''Benas'''
Benai, gali eiti toliau

Vadovėlyje tave supažindinsiu ir su programavimo terminologiją. Tai ne tik tau padės suprasti apie ką kalba programuotojai, bet ir padės mokytis.

Kad galėtum pradėti kurti Python programas tau reikės Python 3 programinės įrangos, bei kodo redaktoriaus. Rekomenduojame naudoti "LR NŠA Python" programą, kurią gali parsisiųsti iš https://www.visma.lt/python-diegimas/. Ši diegimo programa įdiegs Python interpretatorių, Visual Studio Code kodo redaktorių, bei sukonfiguruos tavo kompiuterį, kad galėtum iš karto rašyti ir vykdyti kodą.

=== Python ir Visual Studio Code diegimas ===
==== Diegimas Windows operacinėse sistemose ====
LR NŠA Python diegimo programa yra skirta Windows operacinės sistemos naudotojams.

1. Parsisiųsk diegimo programą iš https://www.visma.lt/python-diegimas/. Rekomeduojama rinktis 64 bitų versiją, nebent naudoji 32 bitų operacinės sistemą.

2. Paleisk parsisiųstą programą

3. Atsivers diegimo programos langas. Kad pradėtum diegimą spausk mygtuką '''Next'''.

[[Vaizdas:Vadovelis 1Sk 1.jpg|frame|center]]

4. Atsivers naujas langas, kuriame galima pasirinkti kokias dalis norima įdiegti. Rekomenduojama nieko nekeisti ir spausti mygtuką '''Install'''.

[[Vaizdas:Vadovelis 1Sk 2.jpg|frame|center]]

5. Palauk kol baigsis diegimas

6. Baigus diegimą pamtysi langą su pirmo paleidimo instrukcijomis. Šiame lange paspausk mygtuką '''OK'''.

[[Vaizdas:Vadovelis 1Sk 3.jpg|frame|center]]

7. Paspausk mygtuką '''Finish''', kad užbaigtum diegimą.

[[Vaizdas:Vadovelis 1Sk 4.jpg|frame|center]]

==== Linux, BSD, bei Unix operacinėse sistemose ====
Jei naudoji ne Windows operacinę sistemą Python ir kodo redaktorių reikės įsidiegti atskirai.
Linux, BSD, bei Unix operacinėse sistemose Python dažnai bus įdiegtas kartu su operacine sistema. Patikrinti ar Python įdiegtas ir kuri versija įdiegta galima įvykdžius komandą:

python3 --version

Jei Python nėra įdiegtas, tai jį įsidiegti galima naudojantis instrukcija anglų kalba: https://docs.python-guide.org/starting/install3/linux/

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download

==== Mac operacinėse sistemose ====
Nuo Mac OS X Tiger (10.4) versijos, Python 2 yra instaliuojama kartu su operacine sistema. Tad Python 3 reikia įdiegti atskirai (Nebent vėlesnėse versijose pasikeis su operacine sistema diegiamo Python versija). Parsisiųsti Python 3 MAC operacinėms sistemoms galima iš https://www.python.org/downloads/macos/.

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download

=== Pirmas paleidimas ===
Windows operacinėse sistemose Visual Studio Code kodo redaktorių gali paleisti paspaudžiant ant darbalaukio atsiradusios ikonėlės.

[[Vaizdas:Vadovelis 1Sk 5.jpg|miniatiūra]]

Pirmo paleidimo metu programa atliks reikiamus konfigūravimo veiksmus, kad būtų galima pilnai naudotis reikiamais įskiepiais. Todėl pirmo paleidimo metu reikia palaukti kelias minutes kol konfigūravimas bus baigtas.

==== Pirmosios programos sukūrimas ====
Sukurti pirmąją programą gali vykdydamas šiuos žingsnius Visual Studio Code redaktoriuje:

1. Meniu pasirink Failas >> Atverti aplanką

2. Pasirink ar susikurk aplanką kuriame laikysi Python programų kodo failus.

3. Skyriuje '''NARŠYKLĖ''' prie aplanko paspausk ant naujo failo ikonėlės.

[[Vaizdas:Vadovelis 1Sk 6.jpg|frame|center]]

4. Pavadink failą "Sveikas.py"

5. Automatiškai atsivers failo redagavimo langas. Jame įrašyk

<syntaxhighlight lang="python">
print("Sveikas, pasauli!")
</syntaxhighlight>

6. Paspausk klavišus ctrl + F5, kad paleistum programą

7. Apatinėje skiltyje išvysi programos vykdymo langą, kur matysi ir savo programos vykdymo rezultatą:

[[Vaizdas:Vadovelis 1Sk 7.jpg|frame|kairėje]]

Tokiu pat principu galėsi kurti ir kitas programas.

==== Programų failų pavadinimai ====
Kuriant naujus Python kodo failus labai naudinga laikytis taisyklių, pavadinant savo programas. Nesilaikant šių taisyklių gali atsitkti taip kad programa "netikėtai" neveiks.
# Visada naudok failo plėtinį <tt>.py</tt>.
# Naudok vieintelį tašką - plėtinio atskyrimui
# Naudok tik: raides, skaičius, brūkšnį (<tt>-</tt>) ir pabraukimo simbolį (<tt>_</tt>)
# Nenaudok tarpų (zodziams atskirti galima naudoti pabraukimo simbolį (<tt>_</tt>).
# Failo pavadinimas turi prasidėti raide
# Nenaudok standartinių Python modulių pavadinimų (pvz. <tt>print.py</tt>, <tt>math.py</tt>, <tt>list.py</tt>)

=== Python paleidimas per komandinę eilutę ===
Python programinį kodą galima vykdyti ir naudojant komandinę eilutę. Sukūrus failą su programos kodu ją įvykdyti galima komandinėj eilutėj vykdant komandą: <code>python ''failo_pavadinimas''</code>

[[Vaizdas:Vadovelis 1Sk 8.jpg|frame|kairėje]]

Python Vadovėlis/Įvadas

2022-01-30T13:52:24Z

Juratevalat:

{{navigation |previous=Įžanga |next=Labas, Pasauli}}

=== Įvadas ===
Šis vadovėlis skirtas visiems norintiems išmokti Python: tiek pirmą kartą bandantiems programuoti, tiek bandžiusiems programuoti kitomis programavimo kalbomis ir norintiems išmokti Python, tiek jau pramokusiems Python, bei norintiems praplėsti žinias.

Tėra vienintelis būdas išmokti programuoti. '''Tu''' turi skaityti ''kodą'' ir rašyti ''kodą''.
Vadovėlyje parodysiu tau daug kodo. Bandyk vykdyti šį kodą kompiuteriu ir išbandyti pats kaip jis veikia. Ekperimentuok ir bandyk daryti pakeitimus. Nebijok kažką sugandinti, blogiausiu atveju tavo kodas tiesiog neveiks. Kai aš pats rašysiu kodą knygoje, jį suformatuosiu šitaip:

<syntaxhighlight lang="python">
# Python kalbą lengva išmokti
print("Sveikas, pasauli!")
</syntaxhighlight>

Prieš komentarą – paparastą tekatą – dėsiu groteles. Šitaip lengvai atskirsi kodo pavyzdžius nuo teksto. Jei skaitai internetinį knygos variantą, atkreipk dėmesį į kodo spalvą – ji kitokia, tam kad tam tikros kodo dalys išsiskirtų. Tau vedant kodą kompiuteriu redagavimo programa jį gali nuspalvinti kitokiomis spalvomis arba iš viso nenuspalvinti. Kodo nuspalvinimas gali skirtis, bet jei įvesi kodą, taip kaip nurodyta pavyzdžiuose jis veiks taip kaip ir aprašyta vadovėlyje.

Pavyzdžiui, vykdant anksčiau parašytą kodo pavyzdį kompiuteris ekrane išves tokį tekstą:

Sveikas, pasauli!

Šis vadovėlis skirtas Python 3 versijai. Bandant kodo pavyzdžius vykdyti su Python 2.7 ir ankstesnėmis versijomis jis gali neveikti. Skirtumai tarp Python 2 ir 3 versijos nėra itin dideli, tad išmokęs Python 3 galėsi be didelių pastangų skaityti ir ankstenėms versijoms skirtą kodą.

Pavyzdžiuose dažnai parodysiu programos vykdymo metu tavo įvedamą tekstą (jis bus '''paryškintas''') ir programos į ekraną išvedamą tekstą. Pavyzdžiui:

Stok!
Kas eina? '''Benas'''
Benai, gali eiti toliau

Vadovėlyje tave supažindinsiu ir su programavimo terminologiją. Tai ne tik tau padės suprasti apie ką kalba programuotojai, bet ir padės mokytis.

Kad galėtum pradėti kurti Python programas tau reikės Python 3 programinės įrangos, bei kodo redaktoriaus. Rekomenduojame naudoti "LR NŠA Python" programą, kurią gali parsisiųsti iš https://www.visma.lt/python-diegimas/. Ši diegimo programa įdiegs Python interpretatorių, Visual Studio Code kodo redaktorių, bei sukonfiguruos tavo kompiuterį, kad galėtum iš karto rašyti ir vykdyti kodą.

=== Python ir Visual Studio Code diegimas ===
==== Diegimas Windows operacinėse sistemose ====
LR NŠA Python diegimo programa yra skirta Windows operacinės sistemos naudotojams.

1. Parsisiųsk diegimo programą iš https://www.visma.lt/python-diegimas/. Rekomeduojama rinktis 64 bitų versiją, nebent naudoji 32 bitų operacinės sistemą.

2. Paleisk parsisiųstą programą

3. Atsivers diegimo programos langas. Kad pradėtum diegimą spausk mygtuką '''Next'''.

[[Vaizdas:Vadovelis 1Sk 1.jpg|frame|center]]

4. Atsivers naujas langas, kuriame galima pasirinkti kokias dalis norima įdiegti. Rekomenduojama nieko nekeisti ir spausti mygtuką '''Install'''.

[[Vaizdas:Vadovelis 1Sk 2.jpg|frame|center]]

5. Palauk kol baigsis diegimas

6. Baigus diegimą pamtysi langą su pirmo paleidimo instrukcijomis. Šiame lange paspausk mygtuką '''OK'''.

[[Vaizdas:Vadovelis 1Sk 3.jpg|frame|center]]

7. Paspausk mygtuką '''Finish''', kad užbaigtum diegimą.

[[Vaizdas:Vadovelis 1Sk 4.jpg|frame|center]]

==== Linux, BSD, bei Unix operacinėse sistemose ====
Jei naudoji ne windows operacinę sistemą Python ir kodo redaktorių reikės įsidiegti atskirai.
Linux, BSD, bei Unix operacinėse sistemose Python dažnai bus įdiegtas kartu su operacine sistema. Patikrinti ar Python įdiegtas ir kuri versija įdiegta galima įvykdžius komandą:

python3 --version

Jei Python nėra įdiegtas, tai jį įsidiegti galima naudojantis instrukcija anglų kalba: https://docs.python-guide.org/starting/install3/linux/

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download

==== Mac operacinėse sistemose ====
Nuo Mac OS X Tiger (10.4) versijos, Python 2 yra instaliuojama kartu su operacine sistema. Tad Python 3 reikia įdiegti atskirai (Nebent vėlesnėse versijose pasikeis su operacine sistema diegiamo Python versija). Parsisiųsti Python 3 MAC operacinėms sistemoms galima iš https://www.python.org/downloads/macos/.

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download

=== Pirmas paleidimas ===
Windows operacinėse sistemose Visual Studio Code kodo redaktorių gali paleisti paspaudžiant ant darbalaukio atsiradusios ikonėlės.

[[Vaizdas:Vadovelis 1Sk 5.jpg|miniatiūra]]

Pirmo paleidimo metu programa atliks reikiamus konfigūravimo veiksmus, kad būtų galima pilnai naudotis reikiamais įskiepiais. Todėl pirmo paleidimo metu reikia palaukti kelias minuites kol konfigūravimas bus baigtas.

==== Pirmosios programos sukūrimas ====
Sukurti pirmąją programą gali vykdydamas šiuos žingsnius Visual Studio Code redaktoriuje
1. Meniu pasirink Failas >> Atverti aplanką

2. Pasirink ar susikurk aplanką kuriame laikysi Python programų kodo failus.

3. Skyriuje '''NARŠYKLĖ''' prie aplanko paspausk ant naujo failo ikonėlės.

[[Vaizdas:Vadovelis 1Sk 6.jpg|frame|center]]

4. Pavadink failą "Sveikas.py"

5. Automatiškai atsivers failo redagavimo langas. Jame įrašyk

<syntaxhighlight lang="python">
print("Sveikas, pasauli!")
</syntaxhighlight>

6. Paspausk klavišus ctrl + F5, kad paleistum programą

7. Apatinėje skiltyje išvysi programos vykdymo langą, kur matysi ir savo programos vykdymo rezultatą:

[[Vaizdas:Vadovelis 1Sk 7.jpg|frame|kairėje]]

Tokiu pat principu galėsi kurti ir kitas programas.

==== Programų failų pavadinimai ====
Kuriant naujus Python kodo failus labai naudinga laikytis taisyklių, pavadinant savo programas. Nesilaikant šių taisyklių gali atsitkti taip kad programa "netikėtai" neveiks.
# Visada naudok failo plėtinį <tt>.py</tt>.
# Naudok vieintelį tašką - plėtinio atskyrimui
# Naudok tik: raides, skaičius, brūkšnį (<tt>-</tt>) ir pabraukimo simbolį (<tt>_</tt>)
# Nenaudok tarpų (zodziams atskirti galima naudoti pabraukimo simbolį (<tt>_</tt>).
# Failo pavadinimas turi prasidėti raide
# Nenaudok standartinių Python modulių pavadinimų (pvz. <tt>print.py</tt>, <tt>math.py</tt>, <tt>list.py</tt>)

=== Python paleidimas per komandinę eilutę ===
Python programinį kodą galima vykdyti ir naudojant komandinę eilutę. Sukūrus failą su programos kodu ją įvykdyti galima komandinėj eilutėj vykdant komandą: <code>python ''programos_pavadinimas''</code>

[[Vaizdas:Vadovelis 1Sk 8.jpg|frame|kairėje]]

Python Vadovėlis/Įvadas

2022-01-30T13:46:47Z

Juratevalat:

{{navigation |previous=Įžanga |next=Labas, Pasauli}}

=== Įvadas ===
Šis vadovėlis skirtas visiems norintiems išmokti Python: tiek pirmą kartą bandantiems programuoti, tiek bandžiusiems programuoti kitomis programavimo kalbomis ir norintiems išmokti Python, tiek jau pramokusiems Python, bei norintiems praplėsti žinias.

Tėra vienintelis būdas išmokti programuoti. '''Tu''' turi skaityti ''kodą'' ir rašyti ''kodą''.
Vadovėlyje parodysiu tau daug kodo. Bandyk vykdyti šį kodą kompiuteriu ir išbandyti pats kaip jis veikia. Ekperimentuok ir bandyk daryti pakeitimus. Nebijok kažką sugandinti, blogiausiu atveju tavo kodas tiesiog neveiks. Kai aš pats rašysiu kodą knygoje, jį suformatuosiu šitaip:

<syntaxhighlight lang="python">
# Python kalbą lengva išmokti
print("Sveikas, pasauli!")
</syntaxhighlight>

Prieš komentarą – paparastą tekatą – dėsiu groteles. Šitaip lengvai atskirsi kodo pavyzdžius nuo teksto. Jei skaitai internetinį knygos variantą, atkreipk dėmesį į kodo spalvą – ji kitokia, tam kad tam tikros kodo dalys išsiskirtų. Tau vedant kodą kompiuteriu redagavimo programa jį gali nuspalvinti kitokiomis spalvomis arba iš viso nenuspalvinti. Kodo nuspalvinimas gali skirtis, bet jei įvesi kodą, taip kaip nurodyta pavyzdžiuose jis veiks taip kaip ir aprašyta vadovėlyje.

Pavyzdžiui, vykdant anksčiau parašytą kodo pavyzdį kompiuteris ekrane išves tokį tekstą:

Sveikas, pasauli!

Šis vadovėlis skirtas Python 3 versijai. Bandant kodo pavyzdžius vykdyti su Python 2.7 ir ankstesnėmis versijomis jis gali neveikti. Skirtumai tarp Python 2 ir 3 versijos nėra itin dideli, tad išmokęs Python 3 galėsi be didelių pastangų skaityti ir ankstenėms versijoms skirtą kodą.

Pavyzdžiuose dažnai parodysiu programos vykdymo metu tavo įvedamą tekstą (jis bus '''paryškintas''') ir programos į ekraną išvedamą tekstą. Pavyzdžiui:

Stok!
Kas eina? '''Benas'''
Benai, gali eiti toliau

Tau taip pat vadovėluyje tave supažindinsiu su programavimo terminologiją. Tai ne tik tau padės suprasti ne tik apie ką kalba programuotojai, bet ir padės mokytis.

Kad galėtum pradėti kurti Python programas tau reikės Python 3 programinės įrangos, bei kodo redaktoriaus. Rekomenduojame naudoti "LR NŠA Python" diegimo programą, kurią gali parsisiųsti iš https://www.visma.lt/python-diegimas/. Ši diegimo programa įdiegs Python interpretatorių, Visual Studio Code kodo redaktorių, bei sukonfiguruos tavo kompiuterį, kad galėtum iš karto rašyti ir vykdyti kodą.

=== Python ir Visual Studio Code diegimas ===
==== Diegimas Windows operacinėse sistemose ====
LR NŠA Python diegimo programa yra skirta Windows operacinės sistemos naudotojams.

1. Parsisiųsk diegimo programą iš https://www.visma.lt/python-diegimas/. Rekomeduojama rinktis 64 bitų versiją, nebent naudoji 32 bitų operacinės sistemą.

2. Paleisk parsisiųstą programą

3. Atsivers diegimo programos langas. Kad pradėtum diegimą spausk mygtuką '''Next'''.

[[Vaizdas:Vadovelis 1Sk 1.jpg|frame|center]]

4. Atsivers naujas langas, kuriame galima pasirinkti kokias dalis norima įdiegti. Rekomenduojama nieko nekeisti ir spausti mygtuką '''Install'''.

[[Vaizdas:Vadovelis 1Sk 2.jpg|frame|center]]

5. Palauk kol baigsis diegimas
6. Baigus diegimą pamtysi langą su pirmo paleidimo instrukcijomis. Šiame lange paspausk mygtuką '''OK'''.

[[Vaizdas:Vadovelis 1Sk 3.jpg|frame|center]]

7. Paspausk mygtuką '''Finish''', kad užbaigtum diegimą.

[[Vaizdas:Vadovelis 1Sk 4.jpg|frame|center]]

==== Linux, BSD, bei Unix operacinėse sistemose ====
Jei naudoji ne windows operacinę sistemą Python ir kodo redaktorių reikės įsidiegti atskirai.
Linux, BSD, bei Unix operacinėse sistemose Python dažnai bus įdiegtas kartu su operacine sistema. Patikrinti ar Python įdiegtas ir kuri versija įdiegta galima įvykdžius komandą:

python3 --version

Jei Python nėra įdiegtas, tai jį įsidiegti galima naudojantis instrukcija anglų kalba: https://docs.python-guide.org/starting/install3/linux/

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download

==== Mac operacinėse sistemose ====
Nuo Mac OS X Tiger (10.4) versijos, Python 2 yra instaliuojama kartu su operacine sistema. Tad Python 3 reikia įdiegti atskirai (Nebent vėlesnėse versijose pasikeis su operacine sistema diegiamo Python versija). Parsisiųsti Python 3 MAC operacinėms sistemoms galima iš https://www.python.org/downloads/macos/.

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download

=== Pirmas paleidimas ===
Windows operacinėse sistemose Visual Studio Code kodo redaktorių gali paleisti paspaudžiant ant darbalaukio atsiradusios ikonėlės.

[[Vaizdas:Vadovelis 1Sk 5.jpg|miniatiūra]]

Pirmo paleidimo metu programa atliks reikiamus konfigūravimo veiksmus, kad būtų galima pilnai naudotis reikiamais įskiepiais. Todėl pirmo paleidimo metu reikia palaukti kelias minuites kol konfigūravimas bus baigtas.

==== Pirmosios programos sukūrimas ====
Sukurti pirmąją programą gali vykdydamas šiuos žingsnius Visual Studio Code redaktoriuje
1. Meniu pasirink Failas >> Atverti aplanką

2. Pasirink ar susikurk aplanką kuriame laikysi Python programų kodo failus.

3. Skyriuje '''NARŠYKLĖ''' prie aplanko paspausk ant naujo failo ikonėlės.

[[Vaizdas:Vadovelis 1Sk 6.jpg|frame|center]]

4. Pavadink failą "Sveikas.py"

5. Automatiškai atsivers failo redagavimo langas. Jame įrašyk

<syntaxhighlight lang="python">
print("Sveikas, pasauli!")
</syntaxhighlight>

6. Paspausk klavišus ctrl + F5, kad paleistum programą

7. Apatinėje skiltyje išvysi programos vykdymo langą, kur matysi ir savo programos vykdymo rezultatą:

[[Vaizdas:Vadovelis 1Sk 7.jpg|frame|kairėje]]

Tokiu pat principu galėsi kurti ir kitas programas.

==== Programų failų pavadinimai ====
Kuriant naujus Python kodo failus labai naudinga laikytis taisyklių, pavadinant savo programas. Nesilaikant šių taisyklių gali atsitkti taip kad programa "netikėtai" neveiks.
# Visada naudok failo plėtinį <tt>.py</tt>.
# Naudok vieintelį tašką - plėtinio atskyrimui
# Naudok tik: raides, skaičius, brūkšnį (<tt>-</tt>) ir pabraukimo simbolį (<tt>_</tt>)
# Nenaudok tarpų (zodziams atskirti galima naudoti pabraukimo simbolį (<tt>_</tt>).
# Failo pavadinimas turi prasidėti raide
# Nenaudok standartinių Python modulių pavadinimų (pvz. <tt>print.py</tt>, <tt>math.py</tt>, <tt>list.py</tt>)

=== Python paleidimas per komandinę eilutę ===
Python programinį kodą galima vykdyti ir naudojant komandinę eilutę. Sukūrus failą su programos kodu ją įvykdyti galima komandinėj eilutėj vykdant komandą: <code>python ''programos_pavadinimas''</code>

[[Vaizdas:Vadovelis 1Sk 8.jpg|frame|kairėje]]

Python Vadovėlis/Įvadas

2022-01-30T13:42:08Z

Juratevalat:

{{navigation |previous=Įžanga |next=Labas, Pasauli}}

=== Įvadas ===
Šis vadovėlis skirtas visiems norintiems išmokti Python: tiek pirmą kartą bandantiems programuoti, tiek bandžiusiems programuoti kitomis programavimo kalbomis ir norintiems išmokti Python, tiek jau pramokusiems Python, bei norintiems praplėsti žinias.

Tėra vienintelis būdas išmokti programuoti. '''Tu''' turi skaityti ''kodą'' ir rašyti ''kodą''.
Vadovėlyje parodysiu tau daug kodo. Bandyk vykdyti šį kodą kompiuteriu ir išbandyti pats kaip jis veikia. Ekperimentuok ir bandyk daryti pakeitimus. Nebijok kažką sugandinti, blogiausiu atveju tavo kodas tiesiog neveiks. Kai aš pats rašysiu kodą knygoje, jį suformatuoju šitaip:

<syntaxhighlight lang="python">
# Python kalbą lengva išmokti
print("Sveikas, pasauli!")
</syntaxhighlight>

Šitaip lengvai atskirsi kodo pavyzdžius nuo teksto. Jei skaitai internetinį knygos variantą, tai gali atkreipti dėmesį į kodo spalvą - ji kitokia, tam kad tam tikros kodo dalys išsiskirtų. Tau vedant kodą kompiuteriu redagavimo programa jį gali nuspalvinti kitokiomis spalvomis arba iš viso nenuspalvinti. Kodo nuspalvinimas gali skirtis, bet jei įvesi kodą, taip kaip nurodyta pavyzdžiuose jis veiks taip kaip ir aprašyta vadovėlyje.

Pavyzdžiui, vykdant anksčiau parašytą kodo pavyzdį kompiuteris ekrane išves tokį tekstą:

Sveikas, pasauli!

Šis vadovėlis skirtas Python 3 versijai. Bandant kodo pavyzdžius vykdyti su Python 2.7 ir ankstesnėmis versijomis jis gali neveikti. Skirtumai tarp Python 2 ir 3 versijos nėra itin dideli, tad išmokęs Python 3 galėsi be didelių pastangų skaityti ir ankstenėms versijoms skirtą kodą.

Pavyzdžiuose dažnai parodysiu programos vykdymo metu tavo įvedamą tekstą (jis bus '''paryškintas''') ir programos į ekraną išvedamą tekstą. Pavyzdžiui:

Stok!
Kas eina? '''Benas'''
Benai, gali eiti toliau

Tau taip pat vadovėluyje tave supažindinsiu su programavimo terminologiją. Tai ne tik tau padės suprasti ne tik apie ką kalba programuotojai, bet ir padės mokytis.

Kad galėtum pradėti kurti Python programas tau reikės Python 3 programinės įrangos, bei kodo redaktoriaus. Rekomenduojame naudoti "LR NŠA Python" diegimo programą, kurią gali parsisiųsti iš https://www.visma.lt/python-diegimas/. Ši diegimo programa įdiegs Python interpretatorių, Visual Studio Code kodo redaktorių, bei sukonfiguruos tavo kompiuterį, kad galėtum iš karto rašyti ir vykdyti kodą.

=== Python ir Visual Studio Code diegimas ===
==== Diegimas Windows operacinėse sistemose ====
LR NŠA Python diegimo programa yra skirta Windows operacinės sistemos naudotojams.

1. Parsisiųsk diegimo programą iš https://www.visma.lt/python-diegimas/. Rekomeduojama rinktis 64 bitų versiją, nebent naudoji 32 bitų operacinės sistemą.

2. Paleisk parsisiųstą programą

3. Atsivers diegimo programos langas. Kad pradėtum diegimą spausk mygtuką '''Next'''.

[[Vaizdas:Vadovelis 1Sk 1.jpg|frame|center]]

4. Atsivers naujas langas, kuriame galima pasirinkti kokias dalis norima įdiegti. Rekomenduojama nieko nekeisti ir spausti mygtuką '''Install'''.

[[Vaizdas:Vadovelis 1Sk 2.jpg|frame|center]]

5. Palauk kol baigsis diegimas
6. Baigus diegimą pamtysi langą su pirmo paleidimo instrukcijomis. Šiame lange paspausk mygtuką '''OK'''.

[[Vaizdas:Vadovelis 1Sk 3.jpg|frame|center]]

7. Paspausk mygtuką '''Finish''', kad užbaigtum diegimą.

[[Vaizdas:Vadovelis 1Sk 4.jpg|frame|center]]

==== Linux, BSD, bei Unix operacinėse sistemose ====
Jei naudoji ne windows operacinę sistemą Python ir kodo redaktorių reikės įsidiegti atskirai.
Linux, BSD, bei Unix operacinėse sistemose Python dažnai bus įdiegtas kartu su operacine sistema. Patikrinti ar Python įdiegtas ir kuri versija įdiegta galima įvykdžius komandą:

python3 --version

Jei Python nėra įdiegtas, tai jį įsidiegti galima naudojantis instrukcija anglų kalba: https://docs.python-guide.org/starting/install3/linux/

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download

==== Mac operacinėse sistemose ====
Nuo Mac OS X Tiger (10.4) versijos, Python 2 yra instaliuojama kartu su operacine sistema. Tad Python 3 reikia įdiegti atskirai (Nebent vėlesnėse versijose pasikeis su operacine sistema diegiamo Python versija). Parsisiųsti Python 3 MAC operacinėms sistemoms galima iš https://www.python.org/downloads/macos/.

Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download

=== Pirmas paleidimas ===
Windows operacinėse sistemose Visual Studio Code kodo redaktorių gali paleisti paspaudžiant ant darbalaukio atsiradusios ikonėlės.

[[Vaizdas:Vadovelis 1Sk 5.jpg|miniatiūra]]

Pirmo paleidimo metu programa atliks reikiamus konfigūravimo veiksmus, kad būtų galima pilnai naudotis reikiamais įskiepiais. Todėl pirmo paleidimo metu reikia palaukti kelias minuites kol konfigūravimas bus baigtas.

==== Pirmosios programos sukūrimas ====
Sukurti pirmąją programą gali vykdydamas šiuos žingsnius Visual Studio Code redaktoriuje
1. Meniu pasirink Failas >> Atverti aplanką

2. Pasirink ar susikurk aplanką kuriame laikysi Python programų kodo failus.

3. Skyriuje '''NARŠYKLĖ''' prie aplanko paspausk ant naujo failo ikonėlės.

[[Vaizdas:Vadovelis 1Sk 6.jpg|frame|center]]

4. Pavadink failą "Sveikas.py"

5. Automatiškai atsivers failo redagavimo langas. Jame įrašyk

<syntaxhighlight lang="python">
print("Sveikas, pasauli!")
</syntaxhighlight>

6. Paspausk klavišus ctrl + F5, kad paleistum programą

7. Apatinėje skiltyje išvysi programos vykdymo langą, kur matysi ir savo programos vykdymo rezultatą:

[[Vaizdas:Vadovelis 1Sk 7.jpg|frame|kairėje]]

Tokiu pat principu galėsi kurti ir kitas programas.

==== Programų failų pavadinimai ====
Kuriant naujus Python kodo failus labai naudinga laikytis taisyklių, pavadinant savo programas. Nesilaikant šių taisyklių gali atsitkti taip kad programa "netikėtai" neveiks.
# Visada naudok failo plėtinį <tt>.py</tt>.
# Naudok vieintelį tašką - plėtinio atskyrimui
# Naudok tik: raides, skaičius, brūkšnį (<tt>-</tt>) ir pabraukimo simbolį (<tt>_</tt>)
# Nenaudok tarpų (zodziams atskirti galima naudoti pabraukimo simbolį (<tt>_</tt>).
# Failo pavadinimas turi prasidėti raide
# Nenaudok standartinių Python modulių pavadinimų (pvz. <tt>print.py</tt>, <tt>math.py</tt>, <tt>list.py</tt>)

=== Python paleidimas per komandinę eilutę ===
Python programinį kodą galima vykdyti ir naudojant komandinę eilutę. Sukūrus failą su programos kodu ją įvykdyti galima komandinėj eilutėj vykdant komandą: <code>python ''programos_pavadinimas''</code>

[[Vaizdas:Vadovelis 1Sk 8.jpg|frame|kairėje]]