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

=== 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:

<syntaxhighlight lang="python">
a = 0 # PIRMA, nustatome pradinio kintamojo a reikšmę 0 (nuliui).
while a < 10: # Kol kintamojo a vertė yra mažesnė nei 10, programa atlieka šiuos veiksmus:
a = a + 1 # Padidina kintamojo a reikšmę 1 (vienu), visai taip kaip nurodyta: a = a + 1!
print(a) # Tuomet nurodome, kad spausdintų. Viskas tam, kad pamatytumėte, kokia yra dabartinė kintamojo a vertė.
# Ir visą šitą ciklą programa vykdo tol, kol kintamojo a reikšmė bus lygi 9!? Žr. Pastabą.

# PASTABA:
# Kintamojo a vertė padidės 1
# su kiekvienu pakartojimu ar ciklu, kol pasieks nustatytą sąlygą ir sustos.
# pvz. a = 1, tada a = 2, tada a = 3 ir t.t., kol a bus lygus 9 (a = 9), tada...
# kodas baigs pridėjinėti po 1 prie a, nes taps lygus 10 (a = 10) kaip ir
# numatyta mūsų parašytoje sąlygoje.
# O kai mūsų nurodyta sąlyga yra patenkinama, programa atspausdina rezultatą.
# --
# While a < 10: |
# a = a + 1 |<--[ Ciklo Kol sąlygos blokas ]
# print (a) |
# --
</syntaxhighlight>

Na, o jeigu paleidžiame programą, tai turime štai tokį įdomų rezultatą:

1
2
3
4
5
6
7
8
9
10

(Tikriausiai iki šios pamokos net nesusimąstei, kad kompiuterį gali paversti pigiu skaičiuotuvu...)

Na, o dabar pasiaiškinkime kaip veikia ši programa. Pirmiausia kompiuteris mato eilutę <code>a = 0</code> ir nustato <code>a</code> reikšmę lygią nuliui. Tada programa mato sąlygą <code>while a < 10:</code>, todėl kompiuteris patikrina, ar <code>a < 10</code>. Kompiuteriui pirmą kartą matant šį teiginį, <code>a</code> yra lygus 0, ir akivaizdu, kad turima reikšmė yra mažesnė nei 10. Kitaip tariant, kol <code>a</code> yra mažesnis skaičius nei dešimt, tol kompiuteris tikrins teiginį ir kartos jį (t.y. pridėjinės po 1). Ciklas baigsis, kai <code>a</code> bus lygus dešimčiai. Kadangi šiame kode daugiau nieko nėra, tai programa sustoja.

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

Kitas ciklo <code>while</code> pavyzdys:
<syntaxhighlight lang="python">
a = 1
s = 0
print("Įvesk skaičius, kuriuos nori pridėti prie sumos")
print("Norint išeiti, įvesk 0.")
while a != 0:
print("Dabartinė suma:", s)
a = float(input("Skaičius? "))
s = s + a
print("Galutinė suma =", s)
</syntaxhighlight>

Galimas programos scenarijus:

Įvesk skaičius, kuriuos nori pridėti prie sumos.
Norint išeiti, įveskite 0.
Dabartinė suma: 0
Skaičius? '''200'''
Dabartinė suma: 200.0
Skaičius? '''-15.25'''
Dabartinė suma: 184.75
Skaičius? '''-151.85'''
Dabartinė suma: 32.9
Skaičius? '''10.00'''
Dabartinė suma: 42.9
Skaičius? '''0'''
Galutinė suma = 42.9

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

Ar pastebėjai, kad šiuo atveju <code>a</code> yra skaičius su reikšme po kablelio ir ne visi tokie skaičiai gali būti tiksliai atvaizduoti, kai naudojamas <code>!=</code>. Pabandyk paleidęs programą įvesti 1.1

==== Begaliniai ciklai (infinitive loops) arba niekada nesibaigaintys ciklai (Never Ending Loop)====
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis:
<syntaxhighlight lang="python">
while True:
print("Padėk! Užstrigau cikle!")
</syntaxhighlight>
Operatorius <code>==</code> naudojamas abiejų operatoriaus pusių išraiškų lygybei patikrinti, kaip ir <code> < </code> buvo naudojami norint pasakyt „mažiau nei“ (kitame skyriuje rasi išsamų visų palyginimo operatorių sąrašą).

Ši mūsų sukurta programa spausdins <code>Padėk! Užstrigau cikle!</code> visą amžinybę... Tol, kol pats ją sustabdysi, todėl kad ji visą laiką yra <code>True</code> (visada atitinka teigiamą reikšmę) ir niekada nesikeičia (''True'', 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'''
<syntaxhighlight lang="python">
# Ši programa skaičiuoja Fibonačio seką
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 20

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

Įsidėmėk, kad išvestis yra vienoje eilutėje dėl papildomų argumentų <code>end = " "</code> funkcijos <code>print</code> argumentuose.

'''Fibonacci-metodas2.py'''
<syntaxhighlight lang="python">
# Supaprastintas ir greitesnis Fibonačio sekos apskaičiavimo metodas
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 10

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

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

'''Fibonacci-metodas3.py'''
<syntaxhighlight lang="python">
a = 0
b = 1
pradinis_skačius = 0
maksimalus_skaičius = 20

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

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

==== Įvesk slaptažodį ====
'''Slaptaždis.py'''
<syntaxhighlight lang="python">
# Laukia, kol bus įvestas slaptažodis. Naudok „ctrl+ C“, kad sustabdytum programą
# be slaptažodžio

#atkreipk dėmesį, kad tai neturi būti slaptažodis, kad
# ciklas while turi prasisukti bent kartą.
slaptažodis= str()

# įsidėmėk != reiškia nelygu
while slaptažodis!= "Angis":
slaptažodis = input("Slaptažodis: ")
print("Prisijungimas sėkmingas")
</syntaxhighlight>

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

=== Pratimai ===
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"
! colspan=2 | Sprendimas  
|-
|
<syntaxhighlight lang="python">
#
#
#
</syntaxhighlight>
|-
|}

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

Python Bandymai

2022-06-23T05:58:29Z

Artūras: Naujas puslapis: Python pamokos. ==Turinys== {{print version}} {{PDF version}} ;Autoriai : Python pamokų autoriai. ;Įžanga : Įžangini...

Python pamokos.

==Turinys==
{{print version}}
{{PDF version}}
;[[Python_Pamokos/Autoriai|Autoriai]]
: Python pamokų autoriai.
;[[Python_Pamokos/Įžanga|Įžanga]]
: Įžanginiai žodžiai
;[[Python_Pamokos/Įvadas|Įvadas]]
: Įvadas
{{Alphabetical|N}}
__NOTOC__ __NOEDITSECTION__

2022-05-21T09:17:44Z

Artūras: Artūras perkėlė puslapį Vadovėlis/Daugiau apie sąrašus į Python Vadovėlis/Daugiau apie sąrašus be nukreipimo

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

gauk_pastorintą(poema)
</syntaxhighlight>

šios programos išvestis yra:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

































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

Python Vadovėlis/Modulių naudojimas

2022-05-21T09:17:23Z

Artūras: Artūras perkėlė puslapį Vadovėlis/Modulių naudojimas į Python Vadovėlis/Modulių naudojimas be nukreipimo

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

=== Modulių naudojimas ===
Štai šio skyriaus pratimas. Failas, kuriame yra ši užduotis, geriausia būtų pavadinti kalendorius.py, kad nesimaišytų su importuojamu calendar.py moduliu. Modulis iš tiesų yra failas su priesaga .py, kuriame yra papildomų funkcijų rinkinys, kurį norite įtraukti ir naudoti savo programoje. Eilutė <code>import calendar</code> iš tikrųjų ieško failo pavadinimu calendar.py ir jį su jo funkcijomis įtraukia į savo kodą, kad galėtume naudoti <code>prcal</code> funkciją, kuri atspausdins visų metų kalendorių. Jei failas būtų pavadintas calendar.py ir matytų <code>import calendar</code>, jis bandytų skaityti pats save, ir kodas tada neveiktų tinkamai.

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

Ir čia yra gautos programos išvestis:

Įvesk metų skaičių: 2001

2001

Sausis Vasaris Kovas

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

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

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

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

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

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

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

Dalis išvesties yra:

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

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

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

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

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

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

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

print("Būtent tas")

</syntaxhighlight>
|-
|}

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

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

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

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

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

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

arba alternatyvus kodas

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

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

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