Vadovėlis/Suskaičiuoti iki 10: Skirtumas tarp puslapio versijų

Iš Pitonas.
(Naujas puslapis: {{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}} {{BookCat}} === Įvestis ir kintamieji === 600px|frameless|center|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!...)
 
Nėra keitimo santraukos
1 eilutė: 1 eilutė:
{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}
{{navigation |previous=Kas čia eina? |next=Pasirinkimai}}
{{BookCat}}


=== Įvestis ir kintamieji ===


[[Vaizdas:Kintamieji.png|600px|frameless|center|Kintamieji]]
=== Ciklai kol (While loops) ===
Šiame skyriuje susipažinsi su ciklu <code>while</code>(liet. 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:
 


Jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
print("Stop!")
a = 0            # PIRMA, nustatome pradinio kintamojo a reikšmę 0 (nuliui).
vartotojo_įvestis = input("Kas čia eina? ")
while a < 10:    # Kol kintamojo a vertė yra mažesnė nei 10, programa atlieka šiuos veiksmus:
print("Gali praeiti,", vartotojo_įvestis )
    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>
</syntaxhighlight>


Kai '''aš''' paleidau programą, štai ką '''mano''' ekranas parodė:
Na, o jeigu paleidžiame programą, tai turime štai tokį įdomų rezultatą:  


  Stop!
  1
  Kas čia eina? '''Benas'''
  2
  Gali praeiti, Benas
  3
 
4
''Pastaba: Jei paleisi kodą spausdamas "F5", Python išvestis bus tik tokia:''
5
 
6
  Stop!
  7
  Kas čia eina?
  8
 
9
''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ą.''
10


Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.
(Tikriausiai iki šios pamokos net nesusimąstei, kad kompiuterį gali paversti pigiu skaičiuotuvu...)
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.
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.


Pavyzdinėje programoje <code>vartotojo_įvestis</code> yra ''kintamasis''. Kintamieji yra kaip dėžės, į kurias galima įdėti norimas informacijos dalis. 
ĮSIDĖMĖK: Nepamiršk parašyti dvitaškio <code>:</code> eilutės pabaigoje, tik taip kompiuteris supras, kad čia yra komanda!
 
Štai programa, parodanti kintamųjų pavyzdžius:


Kitas ciklo <code>while</code> pavyzdys:
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
a = 123.4
a = 1
b23 = 'Šlamštas'
s = 0
vardas = "Benas"
print("Įvesk skaičius, kuriuos nori pridėti prie sumos")
b = 432
print("Norint išeiti, įvesk 0.")
c = a + b
while a != 0:                         
print("a + b yra", c)
    print("Dabartinė suma:", s)          
print("vardas yra", vardas)
    a = float(input("Skaičius? "))       
print("Rūšiuotos dalys, Po vidurnakčio ar", b23)
    s = s + a                           
print("Galutinė suma =", s)
</syntaxhighlight>
</syntaxhighlight>


Štai kokia išvestis:
Galimas programos scenarijus:  
 
a + b yra 555.4
vardas yra Benas
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas


Į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


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


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.
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">
<syntaxhighlight lang="python">
reikšmė1 == Oho
while True:
reikšmė2 == "Oho"
  print("Padėk! Užstrigau cikle!")
</syntaxhighlight>
</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šą).


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>).
Š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'', lietuviškai ''teisinga'' arba ''tiesa'', paprastai programavime dar rašomas kaip 1). Kaip programą sustabdyti? Paprasčiausiai paspausk ctrl + c mygtukus.


=== Priskyrimai ===
=== Pavyzdžiai ===
 
==== Fibonačio skaičių seka ====
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.
Fibonačio skaičių seka – sveikųjų skaičių seka. Seka prasideda šiais skaičiais: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233. Kiekvienas šios sekos skaičius lygus dviejų prieš jį einančių skaičių sumai. Toliau parodysiu, kaip gali atvaizduoti pirmus dvidešimt Fibonačio skaičius 3 skirtingais būdais.


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


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


Ir žinoma štai tokį rezultatą gausime:
Įsidėmėk, kad išvestis yra vienoje eilutėje dėl papildomų argumentų <code>end = " "</code> funkcijos <code>print</code> argumentuose.
 
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ų:
'''Fibonacci-metodas2.py'''
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
skaičius = float(input("Įvesk skaičių: "))
# Supaprastintas ir greitesnis Fibonačio sekos apskaičiavimo metodas
sveikasSkaičius = int(input("Įvesk sveiką skaičių: "))
a = 0
tekstas = input("Įvesk tekstą: ")
b = 1
print("skaičius =", skaičius)
pradinis_skaičius = 0
print("skaičius yra", type(skaičius))
maksimalus_skaičius = 10
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)
 


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


Rezultatas:
Išvestis:
 
  0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181
  Į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


 
'''Fibonacci-metodas3.py'''
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">
<syntaxhighlight lang="python">
# ši programa apskaičiuoja laiko priklausomybę nuo greičio ir atstumo
a = 0
print("Įvesk greitį ir atstumą")
b = 1
greitis = float(input("Greitis: "))
pradinis_skaičius = 0
atstumas = float(input("Atstumas: "))
maksimalus_skaičius = 20
laikas = (atstumas / greitis)
print("Laikas:", laikas)


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


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


Įvesk greitį ir atstumą
==== Įvesk slaptažodį ====
Greitis: '''5'''
'''Slaptaždis.py'''
Atstumas: '''10'''
Laikas: 2.0
 
Įvesk greitį ir atstumą
Greitis: '''3.52'''
Atstumas: '''45.6'''
Laikas: 12.9545454545
 
'''Plotas.py'''
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
# Ši programa apskaičiuoja stačiakampio perimetrą ir plotą
# Laukia, kol bus įvestas slaptažodis. Naudok „ctrl+ C“, kad sustabdytum programą
print("Įveskite stačiakampio informaciją")
# be slaptažodžio
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ą
#atkreipk dėmesį, kad tai neturi būti slaptažodis, kad
Ilgis: '''2.53'''
# ciklas while turi prasisukti bent kartą.
Plotis: '''5.2'''
slaptažodis= str()
Plotas: 13.156
Perimetras: 15.46


'''temperatura.py'''
# įsidėmėk != reiškia nelygu
<syntaxhighlight lang="python">
while slaptažodis!= "Angis":
# Ši programa konvertuoja temperatūra iš Farenheitų į Celsijų
    slaptažodis = input("Slaptažodis: ")
far_temp = float(input("Temperatūra Farenheitais: "))
print("Prisijungimas sėkmingas")
cels_temp = (far_temp - 32.0) * (5.0 / 9.0)
print("Temperatūra Celsijaus laipsniais:", cels_temp )
</syntaxhighlight>
</syntaxhighlight>


Pavyzdžio rezultatas:
Kaip programa veikia:
 
  Slaptažodis: '''auo'''
  Temperatūra Farenheitais: '''32'''
  Slaptažodis: '''y22'''
  Temperatūra Celsijaus laipsniais: 0.0
  Slaptažodis: '''slaptažodis'''
 
  Slaptažodis: '''Sezamai atsiverk'''
  Temperatūra Farenheitais: '''-40'''
  Slaptažodis: '''Angis'''
  Temperatūra Celsijaus laipsniais: -40.0
  Prisijungimas sėkmingas
 
Temperatūra Farenheitais: '''212'''
  Temperatūra Celsijaus laipsniais: 100.0
 
Temperatūra Farenheitais: '''98.6'''
  Temperatūra Celsijaus laipsniais: 37.0


=== Pratimai ===
=== Pratimai ===
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.
Parašyk programą, kuri prašo vartotojo įvesti skaičius tol, kol jis įveda <code>0</code>. Tada programa turi išvesti skaičių vidurkį. Gali remtis skyriuje aptartu skaičių sumos pavyzdžiu.


{| class="mw-collapsible mw-collapsed wikitable"
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas &nbsp;
! colspan=2 | Sprendimas &nbsp;
|-
|-
|  
|
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
tekstas1 = input('Tekstas 1: ')
skaičius = -1
tekstas2 = input('Tekstas 2: ')
skaičių_suma = 0
skaičius1 = float(input('Skaičius 1: '))
viso_skaičių = 0
skaičius2 = float(input('Skaičius 2: '))
 
print(tekstas1 + tekstas2)
while skaičius != 0:
print(skaičius1 * skaičius2)
    skaičius = int(input("Įveskite skaičių: "))
    if skaičius != 0:
skaičių_suma = skaičių_suma + skaičius
viso_skaičių = viso_skaičių + 1
 
print("Skaičių vidurkis:", skaičių_suma / viso_skaičių)
</syntaxhighlight>
</syntaxhighlight>
|-
|-
|}
|}


{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}
{{navigation |previous=Kas čia eina? |next=Pasirinkimai}}

22:53, 12 gruodžio 2022 versija


Ciklai kol (While loops)

Šiame skyriuje susipažinsi su ciklu while(liet. 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 while š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 while pavyzdžiu:


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) |
                 #              --

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ę a = 0 ir nustato a reikšmę lygią nuliui. Tada programa mato sąlygą while a < 10:, todėl kompiuteris patikrina, ar a < 10. Kompiuteriui pirmą kartą matant šį teiginį, a yra lygus 0, ir akivaizdu, kad turima reikšmė yra mažesnė nei 10. Kitaip tariant, kol a 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 a bus lygus dešimčiai. Kadangi šiame kode daugiau nieko nėra, tai programa sustoja.

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

Kitas ciklo while pavyzdys:

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)

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 print('Galutinė suma =', s) yra įvykdoma tik pačioje pabaigoje, kai jau ciklas būna nutrauktas. Komanda while veikia tik tas eilutes, kurios yra atitrauktos nuo krašto ir priklauso ciklo while blokui. != reiškia nelygu, taigi while a != 0: reiškia tol, kol a nėra nulis, programa vykdo kodą.

Ar pastebėjai, kad šiuo atveju a yra skaičius su reikšme po kablelio ir ne visi tokie skaičiai gali būti tiksliai atvaizduoti, kai naudojamas !=. 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 while, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis:

while True:
   print("Padėk! Užstrigau cikle!")

Operatorius == naudojamas abiejų operatoriaus pusių išraiškų lygybei patikrinti, kaip ir < buvo naudojami norint pasakyt „mažiau nei“ (kitame skyriuje rasi išsamų visų palyginimo operatorių sąrašą).

Ši mūsų sukurta programa spausdins Padėk! Užstrigau cikle! visą amžinybę... Tol, kol pats ją sustabdysi, todėl kad ji visą laiką yra True (visada atitinka teigiamą reikšmę) ir niekada nesikeičia (True, lietuviškai teisinga arba tiesa, paprastai programavime dar rašomas kaip 1). Kaip programą sustabdyti? Paprasčiausiai paspausk ctrl + c mygtukus.

Pavyzdžiai

Fibonačio skaičių seka

Fibonačio skaičių seka – sveikųjų skaičių seka. Seka prasideda šiais skaičiais: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233. Kiekvienas šios sekos skaičius lygus dviejų prieš jį einančių skaičių sumai. Toliau parodysiu, kaip gali atvaizduoti pirmus dvidešimt Fibonačio skaičius 3 skirtingais būdais.

Fibonacci-metodas1.py

# Ši programa skaičiuoja Fibonačio seką
a = 0
b = 1
pradinis_skaičius = 0
maksimalus_skaičius = 20

while pradinis_skaičius < maksimalus_skaičius:
    pradinis_skaičius = pradinis_skaič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ę.

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ų end = " " funkcijos print argumentuose.

Fibonacci-metodas2.py

# Supaprastintas ir greitesnis Fibonačio sekos apskaičiavimo metodas
a = 0
b = 1
pradinis_skaičius = 0
maksimalus_skaičius = 10

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

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

a = 0
b = 1
pradinis_skaičius = 0
maksimalus_skaičius = 20

#kai ciklas prasideda, mes jame pasiliekame
while pradinis_skaičius < maksimalus_skaičius:
    pradinis_skaičius += 1
    senas_a = a
    a = a + b
    b = senas_a
    print(senas_a,end=" ")
print()

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

# 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")

Kaip programa veikia:

Slaptažodis: auo
Slaptažodis: y22
Slaptažodis: slaptažodis
Slaptažodis: Sezamai atsiverk
Slaptažodis: Angis
Prisijungimas sėkmingas

Pratimai

Parašyk programą, kuri prašo vartotojo įvesti skaičius tol, kol jis įveda 0. Tada programa turi išvesti skaičių vidurkį. Gali remtis skyriuje aptartu skaičių sumos pavyzdžiu.

Sprendimas  
skaičius = -1
skaičių_suma = 0
viso_skaičių = 0

while skaičius != 0:
    skaičius = int(input("Įveskite skaičių: "))
    if skaičius != 0:
		skaičių_suma = skaičių_suma + skaičius
		viso_skaičių = viso_skaičių + 1

print("Skaičių vidurkis:", skaičių_suma / viso_skaičių)