Vaizdas:While2.png

2025-05-29T10:33:16Z

Martynas:

Vaizdas:While.png

2025-05-29T10:31:44Z

Martynas:

2025-05-20T11:59:00Z

Martynas:

Knyga/Ciklai For

2025-05-16T15:10:34Z

Martynas:

{{navigation |previous=Loginiai reiškiniai |next=Suskaičiuoti iki 10}}

=== Ciklas <code>for</code> ===
[[Vaizdas:Ff78cef7-79a9-4fe0-8d8a-a33766249c4d 2.png|center|frameless|940x940px|Ciklai]]
Jei tau reikia atspausdinti skaičius nuo 1 iki 10. Gali tai padaryti 10 kartų parašydamas print komandą. Bet tai galima padaryti daug efektyviau. Ir štai naujas spausdinimo būdas:
<syntaxhighlight lang="python">
nuo_vieno_iki_dešimt = range(1, 11)
for skaičius in nuo_vieno_iki_dešimt:
print(skaičius)
</syntaxhighlight>

ir kodo išvestis būtų tokia:

1
2
3
4
5
6
7
8
9
10

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

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

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

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

Rezultatas yra:

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

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

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

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

o išvestis yra tiesiog:

Suma yra: 20

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

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

ir turime rezultatą:

Dublikatas 7 rastas.

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

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

ir kodo išvestis būtų:

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

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

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

su stebėtinu rezultatu:

1 1 2 3 5 8 13 21 34

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

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

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

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

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

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

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

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

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

Algoritmo kodą galima užrašyti taip:

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

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

print (rezultatas)
</syntaxhighlight >

Programos išvestis:

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

=== Pratimai ===

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

Pvz. Įvestis = 3

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

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

3. Parašyk programą, kuri prašytų vartotojo įvesti skaičių ir išspausdintų to skaičiaus daugybos lentelę iki 10.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def daugybos_lentelė(skaičius):
for indeksas in range(1, 11):
print (skaičius, " * ", indeksas, " = ", skaičius * indeksas)

įvestas_skaičius = int(input("Įvesk skaičių: "))
daugybos_lentelė(įvestas_skaičius)
</syntaxhighlight>
|-
|}
4. Parašyk programą, kuri paprašytų sukurti stiprų slaptažodį. Reikalavimai stipriam slaptažodžiui:

* Jis turėtų būti sudarytas iš daugiau nei 6 simbolių
* Jis turėtų turėti bent vieną skaitmenį
* Jis turėtų turėti bent vieną specialų simbolį iš šio sąrašo: !#$?

Programa turėtų išvesti, ar slaptažodis pakankamai stiprus, ar ne.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan="2" | Sprendimas  
|-
|
<syntaxhighlight lang="python">
def ar_turi_skaičių(slaptažodis):
skaičiai = "0123456789"
rezultatas = False
for raidė in slaptažodis:
if raidė in skaičiai:
rezultatas = True
break
return rezultatas

def ar_turi_simbolį(slaptažodis):
simboliai = "!#$?"
rezultatas = False
for raidė in slaptažodis:
if raidė in simboliai:
rezultatas = True
break
return rezultatas

def ar_slaptažodis_stiprus(slaptažodis):
ar_užtenka_simbolių = len(slaptažodis) > 6
ar_yra_skaitmuo = ar_turi_skaičių(slaptažodis)
ar_yra_simbolis = ar_turi_simbolį(slaptažodis)
return ar_užtenka_simbolių and ar_yra_skaitmuo and ar_yra_simbolis

įvestas_slaptažodis = input("Įvesk slaptažodį: ")
ar_stiprus = ar_slaptažodis_stiprus(įvestas_slaptažodis)

if ar_stiprus:
print ("Slaptažodis pakankamai stiprus")
else:
print ("Slaptažodis nepakankamai stiprus")
</syntaxhighlight>
|-
|}

{{navigation |previous=Loginiai reiškiniai |next=Suskaičiuoti iki 10}}
[[Category:Python Vadovėlis]]

2025-04-03T13:48:59Z

Martynas:

Vaizdas:Bilietai.jpg

2025-04-03T13:47:19Z

Martynas:

Knyga/Pasirinkimai

2025-02-10T13:30:37Z

2025-01-23T13:27:07Z

Martynas: Martynas pervadino puslapį Vaizdas:Pestilencijus a girl standing near a chalk board saying Ar ly bb21f442-1991-400c-8e37-337d411f49f2 0.png į Vaizdas:Ifelse.png

#PERADRESAVIMAS [[Vaizdas:Ifelse.png]]

Vaizdas:Ifelse.png

2025-01-23T13:27:07Z

Martynas: Martynas pervadino puslapį Vaizdas:Pestilencijus a girl standing near a chalk board saying Ar ly bb21f442-1991-400c-8e37-337d411f49f2 0.png į Vaizdas:Ifelse.png

Vaizdas:Ifelse.png

2025-01-23T13:24:52Z

Martynas:

Knyga/Kas čia eina?

2025-01-16T13:13:34Z

Martynas:

{{navigation |previous=Labas, Pasauli |next=Pasirinkimai}}

=== Įvestis ir kintamieji ===
[[Vaizdas:Kas čia eina.png|center|frameless|600x600px|Kintamieji]]
Jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:
<syntaxhighlight lang="python">
print("Stop!")
vartotojo_įvestis = input("Kas čia eina? ")
print("Gali praeiti,", vartotojo_įvestis )
</syntaxhighlight>

Kai '''aš''' paleidau programą, štai ką '''mano''' ekranas parodė:

Stop!
Kas čia eina? '''Benas'''
Gali praeiti, Benas

''Pastaba: Jei paleisi kodą spausdamas "F5", Python išvestis bus tik tokia:''

Stop!
Kas čia eina?

''Tu turi įvesti savo vardą į Python [http://www.ims.mii.lt/EK%C5%BD/enciklo.html?word=apvalkalas apvalkalą] ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''

Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.
Kai paleidai programą (juk paleidai, tiesa?), tu turėjai surinkti savo vardą ir tada paspausti ''Enter''.
Programa atspausdino dalį teksto ir tavo vardą. Taip atrodo ''įvesties'' pavyzdys.
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojo įvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.

Žinoma, gauta informaciją iš vartotojo nieko verta, jei tos informacijos nėra kur padėti. Ir šioje vietoje atsiranda kintamieji.

Pavyzdinėje programoje <code>vartotojo_įvestis</code> yra ''kintamasis''. Kintamieji yra kaip dėžės, į kurias galima įdėti norimas informacijos dalis.

Štai programa, parodanti kintamųjų pavyzdžius:

<syntaxhighlight lang="python">
a = 123.4
b23 = 'Šlamštas'
vardas = "Benas"
b = 432
c = a + b
print("a + b yra", c)
print("vardas yra", vardas)
print("Gautieji, Svarbūs ar", b23)
</syntaxhighlight>

Štai kokia išvestis:

a + b yra 555.4
vardas yra Benas
Gautieji, Svarbūs ar Šlamštas

Kintamieji laiko duomenis. Viršuje aprašytoje programoje kintamieji yra <code>a</code>, <code>b23</code>, <code>vardas</code>, <code>b</code> ir <code>c</code>. Pagrindiniai du kintamųjų tipai yra ''tekstas'' ir ''skaičius''. Tekstas yra raidžių, skaičių ir kitų simbolių seka. Šiame pavyzdyje <code>b23</code> ir <code>vardas</code> yra tekstinio tipo kintamieji. <code>Šlamštas</code>, <code>Benas</code>, <code>a + b yra</code>, <code>vardas yra</code>, ir <code>Rūšiuotos dalys, Po vidurnakčio ar</code> šioje programoje yra tiesiog tekstinės reikšmės. Paprastas tekstas yra apsuptas kabučių <code>"</code> arba <code>'</code>.

Kitas kintamojo tipas yra skaičius. Atkreipkite dėmesį, kad kintamieji, kurie naudojami saugoti reikšmes, nenaudoja kabučių (" ir '). Jei norite naudoti realias ''reikšmes'', privalote naudoti kabutes.

<syntaxhighlight lang="python">
reikšmė1 == Oho
reikšmė2 == "Oho"
</syntaxhighlight>

Abu pavyzdžiai atrodo vienodai, bet pirmu atveju Python tikrins ar reikšmė, patalpinta kintamajame <code>reikšmė1</code>, yra tokia pati kaip ''kintamojo'' <code>Oho</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>h</code> ir <code>o</code>) yra tokios pat kaip ir <code>reikšmė2</code> (toliau daugiau paaiškinsiu apie tekstą ir <code>==</code>).

=== Priskyrimai ===

Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kuri gali būti kintamajame. Kompiuteris pamatys tokią eilutę <code>vardas = "Benas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Benas</code> į dėžę (ar kintamąjį) <code>vardas</code>". Vėliau, pamatęs sakinį <code>c = a + b</code> jį perskaitys kaip "padėt sumą <code>a + b</code> arba <code>123.4 + 432</code>, kas lygu <code>555.4</code>, į <code>c</code>". Dešinė sakinio pusė ''konvertuosis'' ir rezultatas bus padėtas į kintamajį kairėje pusėje (<code>c</code>). Tai yra vadinama ''priskyrimu''. Turėtume nemaišyti priskyrimo ir matematinio lygybės ženklo (<code>=</code>). Ką reiškia <code>==</code> aptarsime vėliau.

O štai ir kitas kintamųjų naudojimo pavyzdys:
<syntaxhighlight lang="python">
a = 1
print(a)
a = a + 1
print(a)
a = a * 2
print(a)
</syntaxhighlight>

Ir žinoma štai tokį rezultatą gausime:

1
2
4

Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), kompiuteris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"

Dar viena programa prieš man pabangiant šį skyrių:
<syntaxhighlight lang="python">
skaičius = float(input("Įvesk skaičių: "))
sveikasSkaičius = int(input("Įvesk sveiką skaičių: "))
tekstas = input("Įvesk tekstą: ")
print("skaičius =", skaičius)
print("skaičius yra", type(skaičius))
print("skaičius * 2 =", skaičius * 2)
print("sveikas skaičius =", sveikasSkaičius)
print("sveikas skaičius yra", type(sveikasSkaičius))
print("sveikasSkaičius * 2 =", sveikasSkaičius * 2)
print("tekstas =", tekstas)
print("tekstas yra", type(tekstas))
print("tekstas * 2 =", tekstas * 2)

</syntaxhighlight>

Rezultatas:

Įvesk skaičių: '''12.34'''
Įvesk sveiką skaičių: '''-3'''
Įvesk tekstą: '''Labas'''
skaičius = 12.34
skaičius yra <class 'float'>
skaičius * 2 = 24.68
sveikas skaičius = -3
sveikas skaičius yra <class 'int'>
sveikasSkaičius * 2 = -6
tekstas = Labas
tekstas yra <class 'str'>
tekstas * 2 = LabasLabas

Atkreipk dėmesį, kad kintamasis <code>skaičius</code> buvo sukurtas su <code>float(input())</code>, išsaugos, o vėliau atspausdins tokį skaičių, koks buvo įvestas – su kableliu. Kintamasis <code>sveikasSkaičius</code>, kuris buvo sukurtas su <code>int(input())</code>, grąžina sveiką skaičių – reikšmę be kablelio. Tuo tarpu <code>tekstas</code>, kuris buvo sukurtas su <code>input()</code>, grąžino tekstinę eilutę (gali būti aprašoma ir <code>str(input())</code>). Jei tu nori, kad vartotojas įvestų skaičių su kableliu, naudok <code>float(input())</code> kintamojo tipą. Jei nori, kad vartotojas įvestų sveiką skaičių, naudok <code>int(input())</code> (jeigu vartotojas įves skaičių su kabliu – dalį po kabelio programa tiesiog ignoruos), bet jei nori teksto – naudok <code>input()</code>.

Antra pusė programos naudoja <code>type()</code> funkciją, kuri nusako, kokio tipo kintamasis yra. Skaičius yra <code>int</code> arba <code>float</code> tipo. Tai yra angliškų žodžių ''integer'' (sveikas skaičius) ir ''floating point'' (slankusis kablelis, naudojamas daugiausiai skaičiams su kableliu) trumpiniai. Tekstinė eilutė yra <code>str</code>, trumpinys ''string'' (tekstinė eilutė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas – ne. Atkreipk dėmesį, kai Python'as daugina skaičių iš sveiko skaičiaus gaunamas rezultatas, kurio ir galima tikėtis, tačiau jei tekstas padauginamas iš sveiko skaičiaus – sukuriamos kelios teksto kopijos (pavyzdžiui, <code>tekstas * 2 = LabasLabas</code>)

Tos pačios operacijos su teksto tipu daro kitokius dalykus nei su skaičiais. Taip pat, kai kurios operacijos veikia tik su skaičiais ir grąžina klaidą, jei bus bandoma panaudoti tesktą. Štai keletas interaktyvių pavyzdžių:

<pre>
>>> print("Čia" + " " + "yra" + " junginys.")
Čia yra junginys.
>>> print("Ha, " * 5)
Ha, Ha, Ha, Ha, Ha,
>>> print("Ha, " * 5 + "ha!")
Ha, Ha, Ha, Ha, Ha, ha!
>>> print(3 - 1)
2
>>> print("3" - "1")
Traceback (most recent call last):
File "<string>", line 1, in <module>
TypeError: unsupported operand type(s) for -: 'str' and 'str'
>>>
</pre>

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

{| class="wikitable"
!Operacija
!Symbolis
!Pavyzdys
|-
|Pakartojimas
|<code>*</code>
|<code>"i" * 5 == "iiiii"</code>
|-
|Sujungimas
|<code>+</code>
|<code>"Hello, " + "World!" == "Hello, World!"</code>
|}
Pagrindinės tipų konvertavimo operacijos:
{| class="wikitable"
|+
!Operacija
!Funkcija
!Pavyzdys
!Pastabos
|-
|Konvertavimas į sveikąjį skaičių
|int
|int("3") == 3
|
|-
|Konvertavimas į realųjį skaičių
|float
|float("3.14") == 3.14
|
|-
|Konvertavimas į tekstinę eilutę
|str
|str(3) == "3"
|Daugaiu apie tai gali paskaityti skyriuje [[Vadovėlis/Daugiau apie tekstines eilutes|Daugiau apie tekstines eilutes]]
|-
|Konvertavimas į loginį tipą
|bool
|bool(1) == True
|
|-
|Kintamojo tipo gavimas
|type
|print(type(kintamasis))
|
|}

=== Konstantos ===
Konstanta tai tam tikras nekintamas dydis. Rašant kodą nekintančius dydžius naudinga aprašyti, kaip konstantas. Tai padaro kodą lengviau suprantamą ir lengviau skaitomą. Python kalboje, ne taip kaip kai kuriose kitose kalbose konstantų nėra, tad tam reikia naudoti paprastus kintamuosius. Tam kad būtų aišku jog tai yra konstanta Pitone įprasta konstantas pavadinti didžiosiomis raidėmis.

Konstantų pavyzdžiai:
<syntaxhighlight lang="python">
PI = 3.141592653589793

#Oilerio konstanta
E = 2.718281828459045
SEKUNDŽIŲ_VALANDOJE = 3600

#Absoliutis nulis pagal Celsijaus skalę
TEMPERATŪRA_ABSOLIUTUS_NULIS = -273.15
NUORODA = "https://pitonas.lt"

#Apibrėžiant konstantą galime panaudoti ir aritmetinius veiksmus
SEKUNDŽIŲ_PAROJE = 60 * 60 * 24
</syntaxhighlight>

Parašykime programą, kuri skaičiuoja skritulio plotą, panaudodami '''π''' kaip konstantą:

<syntaxhighlight lang="python">
PI = 3.141592653589793

spindulys = float(input("Skritulio spindulys: "))
plotas = PI * spindulys * spindulys
print("Skritulio plotas: ", plotas)
</syntaxhighlight>

=== 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ų
KONVERTAVIMO_KOEFICIENTAS = 5.0 / 9.0

far_temp = float(input("Temperatūra Farenheitais: "))
cels_temp = (far_temp - 32.0) * KONVERTAVIMO_KOEFICIENTAS
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

=== Pratimai ===
1. Parašyk 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>
|-
|}

2. Parašyk programą, kuri paprašytų įvesti savo vardą ir amžių, o ji atspausdintų tekstą “Labas, aš {vardas}. Man {metai} metų.”. Kur {vardas} ir {metai} yra įvesti duomenys.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
vardas = input("Įvesk savo vardą: ")
metai = input("Įvesk savo amžių: ")
print("Labas, aš ", vardas, ". Man ", metai, " metų.")
</syntaxhighlight>
|-
|}

3. Parašyk programą, kuriai įvestum sekundžių skaičių, o ji išvestų, kiek tai yra minučių.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
sekundės = int(input("Įvesk sekundžių skaičių: "))
minutės = sekundės / 60
print(sekundės, "s = ", minutės, "min")
</syntaxhighlight>
|-
|}

{{navigation |previous=Labas, Pasauli |next=Pasirinkimai}}
[[Category:Knyga]]

Vaizdas:Kas čia eina.png

2025-01-16T13:12:57Z

Martynas:

Knyga/Labas, Pasauli

2025-01-02T12:08:43Z

Martynas:

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

=== 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 „Labas, Pasauli!“ arba angliškai „Hello, World!“.
[[Vaizdas:Labas pasauli.png|center|frameless|600x600px]]
Python'o programavimo kalboje programa atrodytų taip:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

==== Programavimas kodo redaktoriumi ====

Programavimui rekomenduoju naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Knyga/Įvadas#Python_ir_Visual_Studio_Code_diegimas|Python ir Visual Studio Code diegimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File arba Failas -> Naujas failas), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save arba Failas -> Išsaugoti) pavadinimu <code>labas.py</code>.

Sveikinu! 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:

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>labas.py</code>.

Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 labas.py</code>

Tavo programa parašys:

Labas, Pasauli!

=== Eime toliau ===

Labai rekomenduoju kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. 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("Gyveno kadaise Paryžiuj bobutė –")
print("Prie Eifelio bokšto turėjo ji butą.")
print("Ji visko pasauly klausytis norėjo,")
print("Bet viena kairiąja ausim tegirdėjo.")
</syntaxhighlight>

Kai paleidi šią programą, ji parašo J. Erlicko eilėraščio Bobutė iš Paryžiaus (2) ištrauką:

Gyveno kadaise Paryžiuj bobutė –
Prie Eifelio bokšto turėjo ji butą.
Ji visko pasauly klausytis norėjo,
Bet viena kairiąja ausim tegirdėjo.

Kai kompiuteris paleidžia programą, pirmiausia jis mato:

<syntaxhighlight lang="python">
print("Gyveno kadaise Paryžiuj bobutė –")
</syntaxhighlight>

Todėl kompiuteris užrašo:

Gyveno kadaise Paryžiuj bobutė –

Tada kompiuteris skaito kitą eilutę ir mato:

<syntaxhighlight lang="python">
print("Prie Eifelio bokšto turėjo ji butą.")
</syntaxhighlight>

Todėl ir ją užrašo kompiuterio ekrane:

Prie Eifelio bokšto turėjo ji butą.

Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs - 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ą (tikiuos pasinaudojai mano patarimu ir rašei jį kartu su manimi), 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, angliškai 'string'). Kitas tekstinės reikšmės pavyzdys yra <code>"Gyveno kadaise Paryžiuj bobutė"</code>.

Užrašyta funkcija su argumentais yra komanda, kurią supranta Python'as. Sakinio pavyzdys:
<syntaxhighlight lang="python">
print("Labas, Pasauli!")
</syntaxhighlight>

Paprasčiau tariant, komandą gali įsivaizduoti kaip vieną programos eilutę.

Kol kas terminologijos pakaks, keliaujam į kitą poskyrį ir mokomės toliau.

====Ženklo \n naudojimas====
<code>\n</code> (kaitos ženklas, angliškai - 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)
# Atkreipk dėmesį, python'e aritmetikoje skaičiai po kablelio rašomi su tašku (.)
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š kairė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'o 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ą.

'''Šekspyras.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, "liekana", 13 % 3)
print()
print("Penktoji klasė")
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>

{{Clickable button 3|label=Išbandyk pats!|url=https://pitonas.lt/ide/bW9reWtsYQ==|class=mw-ui-progressive}}

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 liekana 1

Penktoji klasė
123.56 - 62.12 = 61.44
(4 + 3) * 2 = 14
4 + 3 * 2 = 10
3 ** 2 = 9

=== Pratimai ===

1. Parašyk programą, kuri atspausdintų tavo vardą, pavardę ir gimtadienį kaip atskiras eilutes.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #1  
|-
|
<syntaxhighlight lang="python">
print("Ada Lovelace", "gimusi", "1815 m. gruodžio 10 d.")
</syntaxhighlight>

<syntaxhighlight lang="python">
print("Albertas Einšteinas", "gimęs", "1879 m. kovo 14 d.")
</syntaxhighlight>

<syntaxhighlight lang="python">
print(("Styvas Džobsas"), ("gimęs"), ("1955 m. vasario 24 d."))
</syntaxhighlight>
|-
|}

2. Parašyk programą, kuri parodytų visų 7 [[#Aritmetinės_išraiškos|artimetinių operacijų]] panaudojimą.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #2  
|-
|
<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>
|-
|}

3. Parašyk programą, kuri išvestų reiškinio (2023 - 2000) * (9 + 10) reikšmę.

{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas #3  
|-
|
<syntaxhighlight lang="python">
print("(2023 - 2000) * (9 + 10) =", (2023-2000)*(9+10))
</syntaxhighlight>
|-
|}

----
==== Išnašos====

{{navigation |previous=Įvadas |next=Kas čia eina?}}
[[Category:Knyga]]

Vaizdas:Labas pasauli.png

2025-01-02T12:08:15Z

Martynas: