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
 
(nerodoma 3 tarpinės versijos, sukurtos 3 naudotojų)
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
5
6
7
8
9
10


''Pastaba: Jei paleisi kodą spausdamas "F5", Python išvestis bus tik tokia:''
(Tikriausiai iki šios pamokos net nesusimąstei, kad kompiuterį gali paversti pigiu skaičiuotuvu...)


Stop!
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.
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ą.''
Į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>


Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.
Galimas programos scenarijus:
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.   
Į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


Pavyzdinėje programoje <code>vartotojo_įvestis</code> yra ''kintamasis''. Kintamieji yra kaip dėžės, į kurias galima įdėti norimas informacijos dalis.
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ą.


Štai programa, parodanti kintamųjų pavyzdžius:
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">
a = 123.4
while True:
b23 = 'Šlamštas'
  print("Padėk! Užstrigau cikle!")
vardas = "Benas"
b = 432
c = a + b
print("a + b yra", c)
print("vardas yra", vardas)
print("Rūšiuotos dalys, Po vidurnakčio ar", b23)
</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šą).


Štai kokia išvestis:
Š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.


a + b yra 555.4
=== Pavyzdžiai ===
vardas yra Benas
==== Fibonačio skaičių seka ====
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas
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ą
MAKSIMALUS_SKAIČIUS = 20
a = 0
b = 1
pradinis_skaičius = 0


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


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.
Į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">
<syntaxhighlight lang="python">
reikšmė1 == Oho
# Supaprastintas ir greitesnis Fibonačio sekos apskaičiavimo metodas
reikšmė2 == "Oho"
MAKSIMALUS_SKAIČIUS = 10
a = 0
b = 1
pradinis_skaičius = 0
 
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>


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


=== Priskyrimai ===
'''Fibonacci-metodas3.py'''
<syntaxhighlight lang="python">
MAKSIMALUS_SKAIČIUS = 20
a = 0
b = 1
pradinis_skaičius = 0


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.
#kai ciklas prasideda, mes jame pasiliekame
 
while pradinis_skaičius < MAKSIMALUS_SKAIČIUS:
 
    pradinis_skaičius += 1
O štai ir kitas kintamųjų naudojimo pavyzdys:
    senas_a = a
<syntaxhighlight lang="python">
    a = a + b
a = 1
    b = senas_a
print(a)
    print(senas_a,end=" ")
a = a + 1
print()
print(a)
a = a * 2
print(a)
</syntaxhighlight>
</syntaxhighlight>


Ir žinoma štai tokį rezultatą gausime:
Išvestis:
0 1 1 2 3 5 8 13 21 34 55 89 144 233 377 610 987 1597 2584 4181


1
==== Įvesk slaptažodį ====
2
'''Slaptaždis.py'''
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">
<syntaxhighlight lang="python">
skaičius = float(input("Įvesk skaičių: "))
# Laukia, kol bus įvestas slaptažodis. Naudok „ctrl+ C“, kad sustabdytum programą
sveikasSkaičius = int(input("Įvesk sveiką skaičių: "))
# be slaptažodžio
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)


#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>
</syntaxhighlight>


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


Įvesk skaičių: '''12.34'''
=== Pratimai ===
Įvesk sveiką skaičių: '''-3'''
1. 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.
Į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


{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas &nbsp;
|-
|
<syntaxhighlight lang="python">
skaičius = -1
skaičių_suma = 0
viso_skaičių = 0


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


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>)
print("Skaičių vidurkis:", skaičių_suma / viso_skaičių)
</syntaxhighlight>
|-
|}


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>
2. Parašyk programą, kuri prašo vartotojo įvesti skaičių ir išveda to skaičiaus, pakelto kubu, reikšmę. Programa turėtų veiksmą kartoti tol, kol vartotojas įveda <code>0</code>.
>>> 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="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas &nbsp;
|-
|
<syntaxhighlight lang="python">
skaičius = 1


{| class="wikitable"
while skaičius != 0:
!Operacija
    skaičius = int(input("Įvesk skaičių: "))
!Symbolis
    if skaičius != 0:
!Pavyzdys
        skaičius_kubu = skaičius * skaičius * skaičius
|-
        print(skaičius, " pakelta kubu yra ", skaičius_kubu)
|Pakartojimas
</syntaxhighlight>
|<code>*</code>
|<code>"i" * 5 == "iiiii"</code>
|-
|-
|Sujungimas
|<code>+</code>
|<code>"Hello, " + "World!" == "Hello, World!"</code>
|}
|}


=== Pavyzdžiai ===


'''Laikas.py'''
3. Parašyk programą, kuri prašo vartotojo įvesti penkis skaičius ir išveda jų sandaugą.
 
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas &nbsp;
|-
|
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
# ši programa apskaičiuoja laiko priklausomybę nuo greičio ir atstumo
sandauga = 1
print("Įvesk greitį ir atstumą")
skaičių_kiekis = 0
greitis = float(input("Greitis: "))
atstumas = float(input("Atstumas: "))
laikas = (atstumas / greitis)
print("Laikas:", laikas)


while skaičių_kiekis < 5:
    naujas_skaičius = int(input("Įvesk skaičių: "))
    sandauga = sandauga * naujas_skaičius
    skaičių_kiekis = skaičių_kiekis + 1
print("Įvestų skaičių sandauga: ", sandauga)
</syntaxhighlight>
</syntaxhighlight>
|-
|}


Rezultatas:


Įvesk greitį ir atstumą
4. Parašyk programą, kuri prašo vartotojo įvesti skaičių ir išveda to skaičiaus daugybos lentelę nuo 1 iki 10. Pavyzdžiui, jei įvestas skaičius yra 11, išvestis turėtų būti:
Greitis: '''5'''
Atstumas: '''10'''
Laikas: 2.0


Įvesk greitį ir atstumą
11 x 1 = 11
Greitis: '''3.52'''
Atstumas: '''45.6'''
Laikas: 12.9545454545


'''Plotas.py'''
11 x 2 = 22
<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:
11 x 3 = 33


Įveskite stačiakampio informaciją
11 x 4 = 44
Ilgis: '''4'''
Plotis: '''3'''
Plotas: 12.0
Perimetras: 14.0


Įveskite stačiakampio informaciją
11 x 5 = 55
Ilgis: '''2.53'''
Plotis: '''5.2'''
Plotas: 13.156
Perimetras: 15.46


'''temperatura.py'''
11 x 6 = 66
<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:
11 x 7 = 77


Temperatūra Farenheitais: '''32'''
11 x 8 = 88
Temperatūra Celsijaus laipsniais: 0.0


Temperatūra Farenheitais: '''-40'''
11 x 9 = 99
Temperatūra Celsijaus laipsniais: -40.0


Temperatūra Farenheitais: '''212'''
11 x 10 = 110
Temperatūra Celsijaus laipsniais: 100.0
 
Temperatūra Farenheitais: '''98.6'''
Temperatūra Celsijaus laipsniais: 37.0
 
=== 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.


{| 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 = int(input("Įvesk skaičių: "))
tekstas2 = input('Tekstas 2: ')
indeksas = 1
skaičius1 = float(input('Skaičius 1: '))
 
skaičius2 = float(input('Skaičius 2: '))
while indeksas <= 10:
print(tekstas1 + tekstas2)
    print(skaičius, " * ", indeksas, " = ", skaičius * indeksas)
print(skaičius1 * skaičius2)
    indeksas = indeksas + 1
</syntaxhighlight>
</syntaxhighlight>
|-
|-
|}
|}


{{navigation |previous=Labas, Pasauli |next=Suskaičiuoti iki 10}}
 
{{navigation |previous=Kas čia eina? |next=Pasirinkimai}}
[[Category:Python Vadovėlis]]

Dabartinė 11:12, 16 balandžio 2023 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ą
MAKSIMALUS_SKAIČIUS = 20
a = 0
b = 1
pradinis_skaičius = 0

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
MAKSIMALUS_SKAIČIUS = 10
a = 0
b = 1
pradinis_skaičius = 0

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

MAKSIMALUS_SKAIČIUS = 20
a = 0
b = 1
pradinis_skaičius = 0

#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

1. 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ų)


2. Parašyk programą, kuri prašo vartotojo įvesti skaičių ir išveda to skaičiaus, pakelto kubu, reikšmę. Programa turėtų veiksmą kartoti tol, kol vartotojas įveda 0.

Sprendimas  
skaičius = 1

while skaičius != 0:
    skaičius = int(input("Įvesk skaičių: "))
    if skaičius != 0:
        skaičius_kubu = skaičius * skaičius * skaičius
        print(skaičius, " pakelta kubu yra ", skaičius_kubu)


3. Parašyk programą, kuri prašo vartotojo įvesti penkis skaičius ir išveda jų sandaugą.

Sprendimas  
sandauga = 1
skaičių_kiekis = 0

while skaičių_kiekis < 5:
    naujas_skaičius = int(input("Įvesk skaičių: "))
    sandauga = sandauga * naujas_skaičius
    skaičių_kiekis = skaičių_kiekis + 1

print("Įvestų skaičių sandauga: ", sandauga)


4. Parašyk programą, kuri prašo vartotojo įvesti skaičių ir išveda to skaičiaus daugybos lentelę nuo 1 iki 10. Pavyzdžiui, jei įvestas skaičius yra 11, išvestis turėtų būti:

11 x 1 = 11

11 x 2 = 22

11 x 3 = 33

11 x 4 = 44

11 x 5 = 55

11 x 6 = 66

11 x 7 = 77

11 x 8 = 88

11 x 9 = 99

11 x 10 = 110

Sprendimas  
skaičius = int(input("Įvesk skaičių: "))
indeksas = 1

while indeksas <= 10:
    print(skaičius, " * ", indeksas, " = ", skaičius * indeksas)
    indeksas = indeksas + 1