Knyga/Ciklai For: Skirtumas tarp puslapio versijų

Iš Pitonas.
Nėra keitimo santraukos
Nėra keitimo santraukos
 
(nerodoma 5 tarpinės versijos, sukurtos vieno naudotojo)
1 eilutė: 1 eilutė:
{{navigation |previous=Loginiai reiškiniai |next=Suskaičiuoti iki 10}}
{{navigation |previous=Loginiai reiškiniai |next=Suskaičiuoti iki 10}}


=== Ciklas <code>for</code> ===
=== Ką išmoksi šiame skyriuje? ===
* Kaip veikia ciklas <code>for</code>
* Kaip naudoti <code>range()</code> funkciją su vienu, dviem ar trim argumentais
* Kaip pasikartojančiai vykdyti tą patį veiksmą
* Kaip naudoti ciklą tam tikrą skaičių kartų
* Kaip filtruoti reikšmes cikle naudojant <code>if</code>
* Kaip generuoti skaičių sekas ir jų intervalus
* Kaip pritaikyti <code>for</code> praktinėms užduotims (pvz., lentelėms, skaičiavimams)
 


[[Vaizdas:Ciklai.png|600px|frameless|center|Ciklai]]
[[Vaizdas:Ff78cef7-79a9-4fe0-8d8a-a33766249c4d 2.png|center|frameless|940x940px|Ciklai]]


Ir štai naujas spausdinimo būdas:
=== Ciklas <code>for</code> ===
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">
<syntaxhighlight lang="python">
nuo_vieno_iki_dešimt = range(1, 11)
nuo_vieno_iki_dešimt = range(1, 11)
25 eilutė: 34 eilutė:
  10
  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:
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. Tai reiškia, kad jei nori spausdinti iki 10, turi rašyti <code>range(1, 11)</code>, nes paskutinis skaičius neįtraukiamas. Atkreipk dėmesį, kad šį kodą galima parašyti ir trumpiau:
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
for skaičius in range(1, 11):
for skaičius in range(1, 11):
31 eilutė: 40 eilutė:
</syntaxhighlight>
</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>.
<code>range</code> funkcija grąžina iteraciją (proceso kartojimas skirtas rezultatų sekos generavimui).  
Š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:
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 skaičius:
<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">
<syntaxhighlight lang="python">
a = 1
a = 1
154 eilutė: 56 eilutė:


  1 1 2 3 5 8 13 21 34
  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.




Pabandykime išspręsti kitą užduotį. Užduoties tikslas - išvesti visus lyginius skaičius mažesnius už n. Kur n - vartotojo įvedamas skaičius. Pirmasis būdas tai realizuoti yra cikle patikrinti ar skaičius lyginis. Tai darome patikrindami kad skaičiaus dalybos iš 2 liekana yra lygi 0. Štai programos kodas:


<syntaxhighlight lang="python">
n = int(input("Pasirink skaičių n"))


for i in range(1,n):
    # Patikriname ar skaičius lyginis
    if i%2==0:
        print (i)
</syntaxhighlight>


Šį uždavinį galime išspręsti kitu būdu. Tam galime pasinaudoti dar viena <code>range</code> funkcijos savybe. Funkcijai range galime paduoti trečią parametrą. Trečias parametras naudojamas sekančio sekos nario generavimui, jis nurodo kiek padidėja sekančio elemento reikšmė Pavyzdžiui:




[[Vaizdas:3 iteracija.png|miniatiūra]]
<code>for i in range(1,10)</code> kintamasis i įgaus reikšmes: 1,2,3,4,5,6,7,8,9
'''Trečia iteracija:'''
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.
* Elementai išdėstyti tinkamai.


<code>for i in range(1,10,2)</code> kintamasis i įgaus reikšmes: 1,3,5,7,9
Trečios iteracijos metu algoritmas neatlieka jokių pakeitimų, tad nustatoma, kad sąrašas yra surūšiuotas, algoritmas baigtas.


<code>for i in range(2,10,2)</code> kintamasis i įgaus reikšmes: 2,4,6,8


<code>for i in range(0,30,5)</code> kintamasis i įgaus reikšmes: 0,5,10,15,20,25


 
Tad anksčiau minėtą užduotį galime išspręsti šitaip:
 
 
 
Algoritmo kodą galima užrašyti taip:


<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
def burbuliukoRūšiavimas(sąrašas):
n = int(input("Pasirink skaičių n"))
    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])
for i in range(2,n,2):
    print (i)
</syntaxhighlight>


print (rezultatas)
</syntaxhighlight >


Programos išvestis:
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ų.


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




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


x = [1,2,3,4,5,6,7,8,9,10]
1. Parašyk programą, kuri atspausdintų eglutę, pagal vartotojo įvesta eglutės aukštį.
 
y = [11,12,13,14,15,16,17,18,19,20]
 
{| class="mw-collapsible mw-collapsed wikitable"
! colspan=2 | Sprendimas &nbsp;
|-
|
<syntaxhighlight lang="python">
x = [1,2,3,4,5,6,7,8,9,10]
y = [11,12,13,14,15,16,17,18,19,20]
c = []
for i in x:
if i % 3 == 0:
c.append(i)
for i in y:
if i % 5 == 0:
c.append(i)
print(c)
</syntaxhighlight>
|-
|}
 
 
2. Parašyk programą, kuri atspausdintų eglutę, pagal vartotojo įvesta eglutės aukštį.


Pvz. Įvestis = 3
Pvz. Įvestis = 3
292 eilutė: 121 eilutė:




3. Parašyk programą, kuri prašytų vartotojo įvesti skaičių ir išspausdintų to skaičiaus daugybos lentelę iki 10.
2. 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"
{| class="mw-collapsible mw-collapsed wikitable"
306 eilutė: 135 eilutė:
daugybos_lentelė(įvestas_skaičius)
daugybos_lentelė(įvestas_skaičius)
</syntaxhighlight>
</syntaxhighlight>
|
|-
|-
|}
|}
4. Parašyk programą, kuri paprašytų sukurti stiprų slaptažodį. Reikalavimai stipriam slaptažodžiui:
3. Parašyk programą, kuri atspausdintų visus nelyginius skaičius nuo 1 iki n. Skaičių n turi įvesti vartotojas


* Jis turėtų būti sudarytas iš daugiau nei 6 simbolių
{| class="mw-collapsible mw-collapsed wikitable"
* Jis turėtų turėti bent vieną skaitmenį
! colspan="2" | Sprendimas &nbsp;
* 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.
<syntaxhighlight lang="python">
n = int(input("Pasirink skaičių n"))


for i in range(1,n,2):
    print (i)
</syntaxhighlight>
|
|-
|
|}
4. Parašyk programą, kuri suskaičiuotų visų teigiamų nelyginių skaičių sumą


{| class="mw-collapsible mw-collapsed wikitable"
{| class="mw-collapsible mw-collapsed wikitable"
322 eilutė: 161 eilutė:
|
|
<syntaxhighlight lang="python">
<syntaxhighlight lang="python">
def ar_turi_skaičių(slaptažodis):
suma = 0
    skaičiai = "0123456789"
#Pirmas dviženklis nelyginis skaičius yra 11, sekančius skaičius randame didindami per 2
    rezultatas = False
for i in range(11,100,2):
    for raidė in slaptažodis:
     kvadratas = i*i
        if raidė in skaičiai:
     suma += kvadratas
            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į: ")
print (suma)
ar_stiprus = ar_slaptažodis_stiprus(įvestas_slaptažodis)
 
if ar_stiprus:
    print ("Slaptažodis pakankamai stiprus")
else:
    print ("Slaptažodis nepakankamai stiprus")
</syntaxhighlight>
</syntaxhighlight>
|
|-
|-
|
|}
|}


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

Dabartinė 15:39, 5 rugpjūčio 2025 versija


Ką išmoksi šiame skyriuje?

  • Kaip veikia ciklas for
  • Kaip naudoti range() funkciją su vienu, dviem ar trim argumentais
  • Kaip pasikartojančiai vykdyti tą patį veiksmą
  • Kaip naudoti ciklą tam tikrą skaičių kartų
  • Kaip filtruoti reikšmes cikle naudojant if
  • Kaip generuoti skaičių sekas ir jų intervalus
  • Kaip pritaikyti for praktinėms užduotims (pvz., lentelėms, skaičiavimams)


Ciklai
Ciklai

Ciklas for

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:

nuo_vieno_iki_dešimt = range(1, 11)
for skaičius in nuo_vieno_iki_dešimt:
    print(skaičius)

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 range. Funkcija range naudoja du argumentus, tokius kaip šie range(pradžia, pabaiga), kurie nurodo intervalo galus. pradžia yra pirmasis intervalo skaičius. pabaiga yra vienu didesnis nei paskutinis intervalo skaičius. Tai reiškia, kad jei nori spausdinti iki 10, turi rašyti range(1, 11), nes paskutinis skaičius neįtraukiamas. Atkreipk dėmesį, kad šį kodą galima parašyti ir trumpiau:

for skaičius in range(1, 11):
    print(skaičius)

range funkcija grąžina iteraciją (proceso kartojimas skirtas rezultatų sekos generavimui).

Kitas būdas naudoti for ciklą yra norint ką nors padaryti tam tikrą skaičių kartų. Štai trumpas kodas, kaip atspausdinti pirmuosius 9 „Fibonacci“ serijos skaičius:

a = 1
b = 1
for c in range(1, 10):
    print(a, end=" ")
    n = a + b
    a = b
    b = n

su stebėtinu rezultatu:

1 1 2 3 5 8 13 21 34


Pabandykime išspręsti kitą užduotį. Užduoties tikslas - išvesti visus lyginius skaičius mažesnius už n. Kur n - vartotojo įvedamas skaičius. Pirmasis būdas tai realizuoti yra cikle patikrinti ar skaičius lyginis. Tai darome patikrindami kad skaičiaus dalybos iš 2 liekana yra lygi 0. Štai programos kodas:

n = int(input("Pasirink skaičių n"))

for i in range(1,n):
    # Patikriname ar skaičius lyginis
    if i%2==0:
        print (i)

Šį uždavinį galime išspręsti kitu būdu. Tam galime pasinaudoti dar viena range funkcijos savybe. Funkcijai range galime paduoti trečią parametrą. Trečias parametras naudojamas sekančio sekos nario generavimui, jis nurodo kiek padidėja sekančio elemento reikšmė Pavyzdžiui:


for i in range(1,10) kintamasis i įgaus reikšmes: 1,2,3,4,5,6,7,8,9

for i in range(1,10,2) kintamasis i įgaus reikšmes: 1,3,5,7,9

for i in range(2,10,2) kintamasis i įgaus reikšmes: 2,4,6,8

for i in range(0,30,5) kintamasis i įgaus reikšmes: 0,5,10,15,20,25

Tad anksčiau minėtą užduotį galime išspręsti šitaip:

n = int(input("Pasirink skaičių n"))

for i in range(2,n,2):
    print (i)


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


Pratimai

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

Pvz. Įvestis = 3

Išvestis:

*
**
***
Sprendimas  
def spausdintiEglutę(aukstis):
    for i in range(1, aukstis + 1):
        print('*'*i)

spausdintiEglutę(3)


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

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

3. Parašyk programą, kuri atspausdintų visus nelyginius skaičius nuo 1 iki n. Skaičių n turi įvesti vartotojas

Sprendimas  
n = int(input("Pasirink skaičių n"))

for i in range(1,n,2):
    print (i)

4. Parašyk programą, kuri suskaičiuotų visų teigiamų nelyginių skaičių sumą

Sprendimas  
suma = 0
#Pirmas dviženklis nelyginis skaičius yra 11, sekančius skaičius randame didindami per 2
for i in range(11,100,2):
    kvadratas = i*i
    suma += kvadratas

print (suma)