https://wiki.angis.net/api.php?action=feedcontributions&feedformat=atom&user=Modestawiki.angis.net - Naudotojo indėlis [lt]2026-05-03T09:12:45ZNaudotojo indėlisMediaWiki 1.35.0https://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Funkcij%C5%B3_apibr%C4%97%C5%BEimas&diff=3875Python Vadovėlis/Funkcijų apibrėžimas2022-02-25T12:22:36Z<p>Modesta: </p>
<hr />
<div>=== Funkcijų kūrimas ===<br />
Prieš pradėdami šį skyrių pateiksime tau pavyzdį, kurio gali nepersirašinėti:<br />
<syntaxhighlight lang=python><br />
a = 23<br />
b = -23<br />
<br />
if a < 0:<br />
a = -a<br />
if b < 0:<br />
b = -b<br />
if a == b:<br />
print("Absoliučios", a, "ir", b, "reikšmės yra lygios.")<br />
else:<br />
print("Absoliučios", a, "ir", b, "reikšmės yra skirtingos.")<br />
</syntaxhighlight><br />
<br />
Programos rezultatas:<br />
<br />
Absoliučios 23 ir 23 reikšmės yra lygios.<br />
<br />
Ar neatrodo, kad programa yra šiek tiek pasikartojanti?.. Ir tikriausiai jau numanai, programuotojai nemėgsta pasikartojančių dalykų, nes juk pasikartojantiems dalykams atlikti ir yra sukurti kompiuteriai!! Be to atkreipk dėmesį, kad radus absoliučią reikšmę pasikeitė kintamojo vertė, todėl programa spausdina 23, o ne -23. Mūsų laimei Python'as leidžia sukurti funkcijas, kurios šalina dubliavimą:<br />
<syntaxhighlight lang=python><br />
a = 23<br />
b = -23<br />
<br />
def absoliuti_reikšmė(n):<br />
if n < 0:<br />
n = -n<br />
return n<br />
<br />
if absoliuti_reikšmė(a) == absoliuti_reikšmė(b):<br />
print("Absoliučios", a, "ir", b, "reikšmės yra lygios.")<br />
else:<br />
print("Absoliučios", a, "ir", b, "reikšmės yra skirtingos.")<br />
</syntaxhighlight><br />
<br />
Programos rezultatas:<br />
<br />
Absoliučios 23 ir -23 reikšmės yra lygios.<br />
<br />
Pagrindinis naujai parašomos funkcijos elementas yra žodis <code>def</code>. <br />
<code>def</code> yra angliško žodžio <code>define</code>, kuris reiškia apibrėžti, trumpinys, o juo pradedame apibrėžti savo kuriamą funkciją. Po <code>def</code> eina funkcijos pavadinimas: <code>absoliuti_reikšmė</code>. Vėliau skliausteliuose eina parametras n - <code>(n)</code>, kurio reikšmė yra nurodoma, kai funkcija yra iškviečiama. Vėliau eina dvitaškis <code>:</code>, po kurio esančios komandos yra vykdomos, kai iškviečiama vykdyti ši funkcija. Funkcijos komandos atitrauktos nuo krašto. Jos tęsiasi tol, kol pasibaigia funkcijoje nurodyti veiksmai arba grąžinamas norimas rezultatas nurodytas po <code>return</code>. <code>return</code> komanda grąžina reikšmę į tą pačią vietą, kur buvo iškviesta funkcija. Mūsų pavyzdinėje programoje funkcija <code>absoliuti_reikšmė</code> buvo iškviesta du kartus <code>if</code> sąlygos reiškinyje. pabandykime patyrinėti dar kelias naujas funkcijas.<br />
<br />
Ar pastebėjai, kad <code>a</code> ir <code>b</code> reikšmės nepasikeitė?<br />
<br />
Funkcijos taip pat gali būti naudojamos vykdant užduotis, kurios negrąžina reikšmių. Štai keli pavyzdžiai, kuriuose skirtingai aprašomos funkcijos:<br />
<syntaxhighlight lang="python"><br />
def labas():<br />
print("Labas")<br />
<br />
def plotas(plotis, aukštis):<br />
return plotis * aukštis<br />
<br />
def rašyk_mano_vardas(vardas):<br />
print("Mano vardas", vardas)<br />
<br />
labas()<br />
labas()<br />
<br />
rašyk_mano_vardas("Fredas")<br />
w = 4<br />
h = 5<br />
print("plotis =", w, " aukštis=", h, " plotas=", plotas(w, h))<br />
</syntaxhighlight><br />
<br />
programos rezultatas<br />
<br />
Labas<br />
Labas<br />
Mano vardas Fredas<br />
plotis = 4 aukštis = 5 plotas = 20<br />
<br />
Šis pavyzdys parodo ir daugiau dalykų, kuriuos galima padaryti su funkcijomis. Atkreipk dėmesį, kad galima nenaudoti argumentų arba galima naudoti du argumentus, ar daugiau. Matome ir dar kelis svarbius dalykus, kuriuos gali padaryti naudojant funkcijas. Taip pat atkreipk dėmesį, kad ne kiekviena funkcija grąžina reikšmę – grąžinimas yra neprivalomas.<br />
<br />
<!-- Funkcijos gali būti naudojamos pakartotiniam kodui pašalinti. --><br />
<br />
=== Kintamieji funkcijose ===<br />
Dažnai pasitaiko, kad pasikartojančiam kode yra kintamųjų, todėl į juos reikia atkreipti dėmesį, kai šaliname pakartotiną kodą. Iki šiol visi kintamieji, kuriuos matėme yra globalūs kintamieji, o funkcijose esantys kintamieji yra vadinami specialiu pavadinimu - lokalūs kintamieji. Šie kintamieji egzistuoja tik veikiant funkcijai. Kai lokalus kintamasis turi globalaus kintamojo pavadinimą, tai funkcijoje pirmenybė teikiama ir naudojamas lokalus kintamasis. Skamba painiai? Štai keli pavyzdžiai:<br />
<br />
<syntaxhighlight lang="python"><br />
a = 4<br />
<br />
def manoFunkcija():<br />
a = 17<br />
print("Mano funkcijoje a =", a)<br />
<br />
manoFunkcija()<br />
print("a = ", a)<br />
</syntaxhighlight><br />
<br />
Gaunamas rezultatas<br />
Mano funkcijoje a = 17<br />
a = 4<br />
<br />
Kaip matai pavyzdyje, funkcijos viduje esantis kintamasis nepaiso globalaus kintamojo, nes jis egzistuoja tik funkcijos viduje. Taip pat, turėjai pastebėti, kad funkcijos viduje kintamajam <code>a</code> buvo priskirta nauja reikšmė, bet ji buvo aktuali tik funkcijoje, o ne už jos ribų - globalus kintamasis <code>a</code> liko nepakitęs.<br />
<br />
Kitas kiek sudėtingesnis kodo pavyzdys:<br />
<syntaxhighlight lang="python"><br />
a_var = 10<br />
b_var = 15<br />
e_var = 25<br />
<br />
def funkcija(a_var):<br />
print("funkcijoje a_var =", a_var)<br />
b_var = 100 + a_var<br />
d_var = 2 * a_var<br />
print("funkcijoje b_var =", b_var)<br />
print("funkcijoje d_var =", d_var)<br />
print("funkcijoje e_var =", e_var)<br />
return b_var + 10<br />
<br />
c_var = funkcija(b_var)<br />
<br />
print("a_var =", a_var)<br />
print("b_var =", b_var)<br />
print("c_var =", c_var)<br />
print("d_var =", d_var)<br />
<br />
</syntaxhighlight><br />
<br />
rezultatas:<br />
<br />
funkcijoje a_var = 15<br />
funkcijoje b_var = 115<br />
funkcijoje d_var = 30<br />
funkcijoje e_var = 25<br />
a_var = 10<br />
b_var = 15<br />
c_var = 125<br />
d_var = <br />
<br />
Klaida (paskutinė aptikta klaida):<br />
File "C:\def2.py", eilutė 19, in <module> (modulyje)<br />
print("d_var = ", d_var)<br />
NameError: pavadinimas 'd_var' yra neapibrėžtas<br />
<br />
Šiame pavyzdyje kintamieji <code>a_var</code>, <code>b_var</code> ir <code>d_var</code>, esantys funkcijos viduje, yra lokalūs kintamieji. Po paskutinės funkcijos eilutės <code>return b_var + 10</code> įvykdymo, visi jie nustoja egzistuoti. Kintamasis <code>a_var</code> yra parametro pavadinimas, todėl tai jį automatiškai padaro lokaliu kintamuoju. Kintamieji <code>b_var</code> ir <code>d_var</code> yra lokalūs kintamieji, nes jie rodomi funkcijos lygybės ženklo kairėje pusėje esančiuose teiginiuose <code>b_var = 100 + a_var</code> ir <code>d_var = 2 * a_var</code>.<br />
<br />
Kai funkcija iškviečiama naudojant <code>c_var = funkcija(b_var)</code>, 15 priskiriama kintamajam <code>a_var</code>, nes tuo metu, kai kviečiama funkcija <code>funkcija(b_var)</code>, globalaus <code>b_var</code> reikšmė yra 15. Taigi <code>a_var</code> reikšmė nustatoma į 15, kai jis yra funkcijos <code>funkcija()</code> viduje.<br />
<br />
Kaip matai, pasibaigus funkcijai, lokalūs kintamieji <code>a_var</code> ir <code>b_var</code>, kurie buvo naudojami funkcijos viduje, dingo. Tad komanda <code>print ("a_var =", a_var)</code> atspausdina reikšmę <code>10</code>, t. y. globaliojo kintamojo <code>a_var</code> reikšmę.<br />
<br />
Taip pat, atkreipk dėmesį į klaidą <code> NameError </code>, kuri atsiranda mūsų programos pabaigoje. Tai nutinka, nes kintamasis <code>d_var</code> nebeegzistuoja nuo tada, kai baigėsi <code>funkcija()</code>. Pasibaigus funkcijai, visi lokalūs kintamieji ištrinami. Jeigu nori, ką nors gauti iš funkcijos, turėsi naudoti komandą <code>return</code>.<br />
<br />
Paskutinis dalykas, į kurį reikia atkreipti dėmesį, yra tai, kad funkcijos viduje <code>e_var</code> reikšmė išlieka nepakitusi, nes tai nėra nei parametras, nei lokalus kintamasis – jis niekada nerodomas kairėje lygybės pusėje. Kai funkcijos viduje kreipiamasi į globalų kintamąjį, tai jis naudoja reikšmę, įgytą už funkcijos ribų.<br />
<br />
Funkcijos naudoja lokalius kintamuosius, kurie egzistuoja tik funkcijos viduje, ir gali ignoruoti kitus kintamuosius, kurie yra už funkcijos ribų.<br />
<br />
=== Pavyzdžiai ===<br />
'''temperatūra2.py'''<br />
<syntaxhighlight lang="python"><br />
#! /usr/bin/python<br />
#-*-coding: utf-8 -*-<br />
# konvertuoja temperatūrą į Farenheitus ar Celsijų<br />
<br />
def spausdinti_pasirinkimus():<br />
print("Pasirinkimai:")<br />
print(" 'p' spausdinti pasirinkimus")<br />
print(" 'c' konvertuoti iš Celsijaus")<br />
print(" 'f' konvertuoti iš Farenheitų")<br />
print(" 'q' išjungti programą")<br />
<br />
def celsijus_į_farenheitus(c_temp):<br />
return 9.0 / 5.0 * c_temp + 32<br />
<br />
def farenheitai_į_celsijų(f_temp):<br />
return (f_temp - 32.0) * 5.0 / 9.0<br />
<br />
pasirinkimas = "p"<br />
while pasirinkimas != "q":<br />
if pasirinkimas == "c":<br />
c_temp = float(input("Celsijaus temperatūra: "))<br />
print("Farenheitai:", celsijus_į_farenheitus(c_temp))<br />
pasirinkimas = input("pasirinkimas: ")<br />
elif pasirinkimas == "f":<br />
f_temp = float(input("farenheitai_į_celsijų: "))<br />
print("Celsijus:", farenheitai_į_celsijų(f_temp))<br />
pasirinkimas= input("pasirinkimas: ")<br />
else:<br />
pasirinkimas= "p" #Arba pasirinkimas! = "q": kad spausdintų<br />
#kai įrašoma, kas nors netikėto<br />
spausdinti_pasirinkimus()<br />
pasirinkimas = input("pasirinkimas: ")<br />
</syntaxhighlight><br />
<br />
Kaip tai veikia?:<br />
<br />
Pasirinkimai:<br />
'p' spausdinti pasirinkimus<br />
'c' konvertuoti iš Celsijaus<br />
'f' konvertuoti iš Farenheitų<br />
'q' išjungti programą<br />
pasirinkimas: '''c'''<br />
Celsijaus temperatūra: '''30''' <br />
Farenheitai: 86.0<br />
pasirinkimas: '''f'''<br />
Farenheitų temperatūra: '''60'''<br />
Celsijus: 15.5555555556<br />
pasirinkimas: '''q'''<br />
<br />
'''plotas2.py'''<br />
<syntaxhighlight lang="python"><br />
#! /usr/bin/python<br />
#-*-coding: utf-8 -*-<br />
# apskaičiuoja duotą stačiakampio plotą<br />
<br />
def pasisveikinimas():<br />
print('Labas!')<br />
<br />
def plotas(plotis, aukštis):<br />
return plotis * aukštis<br />
<br />
def mano_vardas(vardas):<br />
print('Mano vardas yra,', vardas)<br />
<br />
def teigiama_įvestis(sugalvotas_skaičius):<br />
skaičius = float(input(sugalvotas_skaičius))<br />
while skaičius<= 0:<br />
print('Privalo būti teigiamas skaičius')<br />
skaičius = float(input(sugalvotas_skaičius))<br />
return skaičius<br />
<br />
vardas = input('Tavo vardas: ')<br />
pasisveikinimas()<br />
mano_vardas(name)<br />
print()<br />
print('Kad rastum stačiakampio plotą,')<br />
print('įrašyk plotį ir aukštį')<br />
print()<br />
w = teigiama_įvestis('Plotis: ')<br />
h = teigiama_įvestis('Aukštis: ')<br />
<br />
print('Plotis =', w, ' Aukštis =', h, ' Plotas =', area(w, h))<br />
</syntaxhighlight><br />
<br />
Kaip veikia ši programa?<br />
<br />
Tavo vardas: '''Jonas'''<br />
Labas!<br />
Mano vardas yra Jonas<br />
<br />
Kad rastum stačiakampio plotą,<br />
įrašyk plotį ir aukštį.<br />
<br />
Plotis: '''-4'''<br />
Privalo būti teigiamas skaičius<br />
Plotis: '''4'''<br />
Aukštis: '''3'''<br />
Plotis = 4 Aukštis = 3 Plotas = 12<br />
<br />
=== Užduotis ===<br />
Perrašyk programą plotas2.py, kuri yra aukščiau pateiktame pavyzdyje, taip, kad būtų parašytos atskiros kvadrato, stačiakampio ir apskritimo ploto funkcijos ((<code>3.14 * spindulys**2</code>). Taip pat šioje programoje turėtų būti sukurtas toks pasirinkimų meniu:<br />
<br />
Pasirinkimai:<br />
s = skaičiuoti kvadrato plotą.<br />
c = skaičiuoti apskritimo plotą.<br />
r = skaičiuoti stačiakampio plotą.<br />
q = išeiti.<br />
<br />
{| class="mw-collapsible mw-collapsed wikitable"<br />
! colspan=2 | Sprendimas &nbsp;<br />
|-<br />
|<br />
<syntaxhighlight lang="python"><br />
def kvadratas(L):<br />
return L * L<br />
<br />
def stačiakampis(aukštis, plotis):<br />
return aukštis * plotis<br />
<br />
def apskritimas(spindulys):<br />
return 3.14159 * spindulys** 2<br />
<br />
def opcijos():<br />
print()<br />
print("Pasirinkimai:")<br />
print("s = skaičiuoti kvadrato plotą.")<br />
print("c = skaičiuoti apskritimo plotą.")<br />
print("r = skaičiuoti stačiakampio plotą.")<br />
print("q = išeiti")<br />
print()<br />
<br />
print("Ši programa apskaičiuos kvadrato, apskritimo ar stačiakampio plotą.")<br />
pasirinkimas = "x"<br />
opcijos()<br />
while pasirinkimas != "q":<br />
choice = input("Įrašyk savo pasirinkimą: ")<br />
if pasirinkimas== "s":<br />
L = float(input("Kvadrato kraštinės ilgis: "))<br />
print("Šio kvadrato plotas", kvadratas(L))<br />
opcijos()<br />
elif pasirinkimas == "c":<br />
spindulys = float(input("Apskritimo spindulys yra: "))<br />
print("Apskritimo plotas yra", apskritimas(spindulys))<br />
opcijos()<br />
elif pasirinkimas == "r":<br />
plotis = float(input("Stačiakampio plotis: "))<br />
aukštis = float(input("Stačiakampio aukštis: "))<br />
print("Stačiakampio plotas yra", kvadratas(plotis, aukštis))<br />
opcijos()<br />
elif pasirinkimas == "q":<br />
print(" ",end="")<br />
else:<br />
print("Neatpažintas pasirinkimas.")<br />
opcijos()<br />
</syntaxhighlight><br />
|-<br />
|}<br />
<br />
{{navigation |previous=Derinimas |next=Pažangių funkcijų pavyzdys}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Labas,_Pasauli&diff=3874Python Vadovėlis/Labas, Pasauli2022-02-24T13:59:37Z<p>Modesta: </p>
<hr />
<div><!-- Now for our first lesson, what is a computer program? A computer program is a set of very detailed instructions that tell a computer what to do. --><br />
=== Ką sužinosi? ===<br />
Perskaitęs šį skyrių, turėtum suprasti kaip teksto redaktoriumi rašyti programas, kaip parašytas programas išsaugoti kompiuterio atmintyje ir kaip jas paleisti.<br />
<br />
=== Spausdinimas ===<br />
Istoriškai taip jau susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programėlės pavadinimu „Hello, World!“ arba lietuviškai [[„Labas, Pasauli!“]].<br />
<br />
Python'o programavimo kalboje programa atrodytų taip: <br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
==== Programavimas kodo redaktoriumi ====<br />
<br />
Programavimui rekomenduojame naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Non-Programmer's Tutorial for Python 3/Intro#Creating_and_Running_Programs|Programų kūrimas ir paleidimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File arba Failas -> Naujas failas), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save arba Failas -> Išsaugoti) pavadinimu <code>hello.py</code>.<br />
<br />
Sveikiname! Sukūrei savo pirmą Python programą.<br />
<br />
(Jeigu tokios programavimo aplinkos įsidiegti savo kompiuteryje negali, žr. kitą žingsnį).<br />
<br />
Dabar parašytą programą paleisk vykdyti: tiesiog paspausk žalią mygtuką dešinėje viršuje.<br />
<br />
Kai paleisi šią programą, ji suveiks ir terminale atsiras užrašas:<br />
<br />
Labas, Pasauli!<br />
<br />
==== Alternatyvus būdas: Programavimas paprastu teksto redaktoriumi ====<br />
<br />
Jeigu kodo redaktoriaus negali įsidiegti savo kompiuteryje dėl kokių nors priežasčių, programuoti galima ir tiesiog paprasčiausiu teksto redaktoriumi, pvz., Notepad. <br />
<br />
Tiesiog sukurk naują paprastą tekstinį failą (.txt), jame įrašyk programinį kodą <code>print("Labas, Pasauli!")</code>, failą išsaugok pavadinimu <code>hello.py</code>. <br />
<br />
Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 hello.py</code><br />
<br />
Tavo programa parašys: <br />
<br />
Labas, Pasauli!<br />
<br />
=== Eime toliau ===<br />
<br />
Labai rekomenduojame kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. Mūsų praktikoje toks mokymosi procesas yra pats efektyviausias ir veiksmingiausias.<br />
<br />
Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Benas ir Liepa lipo į kalną")<br />
print("Parsinešti puodą vandens.")<br />
print("Benas nukrito ir susidaužė karūną,")<br />
print("Ir Liepa suklupo taip pat.")<br />
</syntaxhighlight><br />
<br />
Kai paleidi šią programą, ji parašo trumpą istoriją:<br />
<br />
Benas ir Liepa lipo į kalną<br />
Parsinešti puodą vandens.<br />
Benas nukrito ir susidaužė karūną, <br />
Ir Liepa suklupo taip pat.<br />
<br />
Kai kompiuteris paleidžia programą, pirmiausia jis mato:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Benas ir Liepa lipo į kalną")<br />
</syntaxhighlight><br />
<br />
Todėl kompiuteris užrašo:<br />
<br />
Benas ir Liepa lipo į kalną<br />
<br />
Tada kompiuteris skaito kitą eilutę ir mato:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Parsinešti puodą vandens.")<br />
</syntaxhighlight><br />
<br />
Todėl ir ją užrašo kompiuterio ekrane:<br />
<br />
Parsinešti puodą vandens.<br />
<br />
Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs ir eina toliau: skaito kitą eilutę, ją įvykdo ir t.t. Taip kompiuteris vykdo visas surašytas komandas, kol pasiekia programos pabaigą.<br />
<br />
==== Terminologija ====<br />
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.<br />
<br />
Prieš tai rašydami kodą, mes naudojame „funkciją“ pavadinimu <code>print</code>. Po funkcijos pavadinimo <code>print</code> rašomi skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
funkcijai duodamas vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Programuotojai tai vadina „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme). Kitas tekstinės reikšmės pavyzdys yra <code>"Benas ir Liepa lipo į kalną"</code>. <br />
<br />
Užrašyta funkcija su argumentais yra komanda, kurią supranta Python'as. Sakinio pavyzdys:<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
Paprasčiau tariant, komandą gali įsivaizduoti kaip vieną programos eilutę. <br />
<br />
Kol kas terminologijos pakaks, keliaujam į kitą poskyrį ir mokomės toliau.<br />
<br />
====\n rašyme====<br />
<code>\n</code> (escape character), arba nauja eilutė. Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Pabandyk suprasti šią programą:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!\nKą turėčiau daryti?")<br />
</syntaxhighlight><br />
<br />
Kurios rezultatas yra toks:<br />
<br />
Labas, Pasauli! <br />
Ką turėčiau daryti?<br />
<br />
<code>\n</code> naudojamas, kai norime tekstą perkelti į kitą eilutę, bet nenorime naudoti kelių <code>print()</code> komandų.<br />
<br />
Spausdinimo komanda automatiškai naudoja <code>\n</code>, t. y. kiekviena komanda tekstą spausdina vis naujoje eilutėje, net jeigu pats <code>\n</code> ir neužrašai. Paprasčiau suprasti bus pamačius pavyzdį:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
iš tikrųjų yra:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!\n")<br />
</syntaxhighlight><br />
<br />
=== Aritmetinės operacijos ===<br />
Programos pavyzdys:<br />
<br />
<syntaxhighlight lang="python"><br />
print("2 + 2 yra", 2 + 2)<br />
print("3 * 4 yra", 3 * 4)<br />
print("100 - 1 yra", 100 - 1)<br />
print("((33 + 2) / 5 + 11.5 yra", (33 + 2) / 5 + 11.5)<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
2 + 2 yra 4<br />
3 * 4 yra 12<br />
100 - 1 yra 99<br />
(33 + 2) / 5 + 11.5 yra 18.5<br />
<br />
==== Aritmetinės išraiškos ====<br />
<br />
Šiame pavyzdyje, rašymo funkcija <code>print()</code> yra su dvejais argumentais, kurie atskirti kableliu. Panagrinėkime pirmoje eilutėje užrašytą komandą:<br />
<br />
<syntaxhighlight lang="python"><br />
print("2 + 2 yra", 2 + 2)<br />
</syntaxhighlight><br />
<br />
Pirmas argumentas yra teksto eilutė <code>"2 + 2 yra"</code> ir antras argumentas yra aritmetinė išraiška <code>2 + 2</code>, tiksliau tariant viena iš aritmetinių operacijų.<br />
<br />
Atkreipk dėmesį, kad eilutė, kuri yra užrašyta kabutėse yra atspausdinama kaip tekstas, o išraiška užrašyta be kabučių yra apskaičiuojama ir užrašomas atsakymas.<br />
<br />
Python'o programavimo kalba turi septynias pagrindines skaičių operacijas.<br />
<br />
{| class="wikitable"<br />
! Operacija <br />
! Simbolis <br />
! Pavyzdys<br />
|-<br />
|Kėlimas laipsniu <br />
| <code>**</code> <br />
| <code>5 ** 2 == 25</code><br />
|-<br />
|Daugyba <br />
| <code>*</code> <br />
|<code>2 * 3 == 6</code><br />
|-<br />
|Dalyba <br />
| <code>/</code> <br />
| <code>14 / 3 == 4.666666666666667</code> <br />
|-<br />
|Sveikųjų skaičių dalyba<br />
| <code>//</code><br />
| <code>14 // 3 == 4</code><br />
|-<br />
|Liekana<br />
| <code>%</code> <br />
| <code>14 % 3 == 2</code> <br />
|-<br />
|Sudėtis<br />
| <code>+</code> <br />
| <code>1 + 2 == 3</code> <br />
|-<br />
|Atimtis <br />
| <code>-</code> <br />
| <code>4 - 3 == 1</code><br />
|}<br />
<br />
Atkreipk dėmesį, kad yra trys dalybos būdai: vienas grąžina dešimtainį skaičių, antras – tik dalybos sveikąją dalį, o trečias – liekaną.<br />
Operacijų tvarka tokia pati kaip matematikoje:<br />
* pirmiausiai atliekami veiksmai skliausteliuose <code>()</code><br />
* kėlimas laipsniu <code>**</code><br />
* iš kairės į dešinę: daugyba <code>*</code>, dalyba<code>/</code>, sveikoji dalyba <code>//</code>, dalybos liekana <code>%</code> <br />
* iš kairės į dešinę: sudėtis <code>+</code> ir atimtis <code>-</code><br />
<br />
Taigi, užrašydamas formules, nepamiršk skliaustelių.<br />
<br />
=== Komentarai ===<br />
<br />
Rašant daug kodo, ateityje tikrai ne viską atsiminsi. Todėl programoje gali naudoti komentarus, kurie yra tiesiog pastabos/paaiškinimai sau pačiam arba kitiems programuotojams. Pavyzdžiui:<br />
<br />
<syntaxhighlight lang="python"><br />
# Skaičiaus PI išraiška kompiuterio ekrane<br />
print(22 / 7)<br />
</syntaxhighlight><br />
<br />
Rezultatas: <br />
<br />
3.14285714286<br />
<br />
Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra skirti žmonėms, pagerinti programos skaitomumą. <br />
<br />
Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris visą šį tekstą ignoruos iki pat eilutės galo.<br />
<br />
<syntaxhighlight lang = "python"><br />
# Skaičiaus PI išraiška kompiuterio ekrane<br />
print(22/7) # tokiu būdu gauname tik apytikslę PI reikšmę<br />
</syntaxhighlight><br />
<br />
=== Pavyzdžiai ===<br />
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python kodo redaktorių ir pažiūrėti kaip viekia. Jeigu suprasi, keliauk toliau, jeigu ne, bandyk dar kartą perskaityti skyriaus medžiagą ir suprasti pavyzdžių logiką.<br />
<br />
'''Danija.py'''<br />
<br />
<syntaxhighlight lang="python"><br />
print("Būti ar nebūti, štai kur klausimas.")<br />
print(" -- Šekspyras")<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Būti ar nebūti, štai kur klausimas.<br />
-- Šekspyras<br />
<br />
'''Mokykla.py'''<br />
<br />
<syntaxhighlight lang="python"><br />
print("Pirmoji klasė")<br />
print("1 + 1 =", 1 + 1)<br />
print("2 + 4 =", 2 + 4)<br />
print("5 - 2 =", 5 - 2)<br />
print()<br />
print("Trečioji klasė")<br />
print("243 - 23 =", 243 - 23)<br />
print("12 * 4 =", 12 * 4)<br />
print("12 / 3 =", 12 / 3)<br />
print("13 / 3 =", 13 // 3, "R", 13 % 3)<br />
print()<br />
print("Vidurinė")<br />
print("123.56 - 62.12 =", 123.56 - 62.12)<br />
print("(4 + 3) * 2 =", (4 + 3) * 2)<br />
print("4 + 3 * 2 =", 4 + 3 * 2)<br />
print("3 ** 2 =", 3 ** 2)<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Pirma klasė<br />
1 + 1 = 2<br />
2 + 4 = 6<br />
5 - 2 = 3<br />
<br />
Trečia klasė<br />
243 - 23 = 220<br />
12 * 4 = 48<br />
12 / 3 = 4<br />
13 / 3 = 4 R 1<br />
<br />
Vidurinė<br />
123.56 - 62.12 = 61.44<br />
(4 + 3) * 2 = 14<br />
4 + 3 * 2 = 10<br />
3 ** 2 = 9<br />
<br />
=== Pratimai ===<br />
<br />
# Parašyk programą, kuri atspausdintų tavo vardą ir gimimo datą atskirose eilutėse<br />
# Parašyk programą, kuri parodytų visų 7 [[#Aritmetinės_išraiškos|artimetinių operacijų]] panaudojimą.<br />
<br />
{| class="mw-collapsible mw-collapsed wikitable"<br />
! colspan=2 | Sprendimas #1 &nbsp;<br />
|-<br />
|<br />
1. Parašyk programą, kuri atspausdintų tavo vardą ir gimimo datą atskirose eilutėse<br />
<syntaxhighlight lang="python"><br />
print("Ada Lovelace", "gimusi", "lapkričio 27, 1852")<br />
</syntaxhighlight> <br />
<br />
<syntaxhighlight lang="python"><br />
print("Albertas Einšteinas", "gimęs", "14 kovo 1879")<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="python"><br />
print(("Jonas Smitas"), ("gimęs"), ("14 kovo 1879"))<br />
</syntaxhighlight><br />
|-<br />
|}<br />
<br />
{| class="mw-collapsible mw-collapsed wikitable"<br />
! colspan=2 | Sprendimas #2 &nbsp;<br />
|-<br />
|<br />
2. Parašyk programą, kuri parodytų visų 7 [[#Aritmetinės_išraiškos|artimetinių operacijų]] panaudojimą.<br />
<syntaxhighlight lang="python"><br />
print("5**5 = ", 5**5)<br />
print("6*7 = ", 6*7)<br />
print("56/8 = ", 56/8)<br />
print("14//6 = ", 14//6)<br />
print("14%6 = ", 14%6)<br />
print("5+6 = ", 5+6)<br />
print("9-0 = ", 9-0)<br />
</syntaxhighlight><br />
|-<br />
|}<br />
<br />
----<br />
==== Išnašos====<br />
<br />
<br />
{{navigation |previous=Įvadas |next=Kas čia eina?}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Rekursin%C4%97s_funkcijos&diff=3853Python Vadovėlis/Rekursinės funkcijos2022-02-11T13:44:54Z<p>Modesta: </p>
<hr />
<div>Vieniems šis skyrius gali pasirodyti naudingas, o kitiems - painus. Jeigu tau informacija pasirodys paini, tai nesuk galvos ir praleisk, prie šio skyriaus galėsi grįžti šiek tiek vėliau. O dabar pabandom pasižiūrėti į mūsų parašytą programą:<br />
<syntaxhighlight lang="python"><br />
def daug(a, b): # daug reiškia daugybą<br />
if b == 0:<br />
return 0<br />
lik = daug(a, b - 1) #lik reiškia likutį<br />
reikšmė = a + lik<br />
return reikšmė<br />
rezultatas = daug(3, 2)<br />
print("3 * 2 = ", rezultatas)<br />
</syntaxhighlight><br />
<br />
Iš esmės ši programa, tai teigiama sveikųjų skaičių daugybos funkcija (reikia atkreipti dėmesį į tai, kad Python'o programavimo kalboje jau yra integruota funkcija dauginimui, čia mes patys parašėme lengvai suprantamą pavyzdį (jeigu kurtume tokią funkciją patys), kuris parodo kaip atrodo daugybos veiksmas. Šioje programoje gali pamatyti rekursijos naudojimą, tai yra iteracijos (kartojimo) forma, kai funkcija yra pakartotinai iškviečiama, kol bus įvykdyta sukurta išvesties sąlyga. Programa naudoja pakartotinius papildymus, kad gautų tą patį rezultatą kaip ir daugyba: pavyzdžiui 3 + 3 (sudėtis) duoda tą patį rezultatą kaip ir 3 * 2 (daugyba).<br />
<br />
; ''Klausimas:'' Ką pirmiausia daro programa?<br />
: ''Atsakymas:'' Pirmiausia yra aprašyta daugybos funkcija:<br />
<syntaxhighlight lang="python"><br />
def daug(a, b):<br />
if b == 0:<br />
return 0<br />
lik = daug(a, b - 1)<br />
reikšmė = a + lik <br />
return reikšmė<br />
</syntaxhighlight><br />
: Ši funkcija paima du parametrus ir grąžina reikšmę. Vėliau šią funkciją galima bus iškviesti.<br />
; Kas nutinka toliau? <br />
: Vykdoma kita eilutė einanti po funkcijos <code>rezultatas = daug(3, 2)</code><br />
; Ką daro ši eilutė?<br />
: Ši eilutė priskiria funkcijos <code>daug(3, 2)</code> grąžinamą reikšmę kintamajam <code>rezultatas</code>.<br />
; Ką grąžina <code>daug(3, 2)</code>?<br />
: Norėdami tai išsiaiškinti, turime peržiūrėti funkciją <code>daug()</code>.<br />
; Kas vyksta su kodu?<br />
: Kintamasis <code>a</code> gauna jam priskirtą reikšmę 3, o kintamasis <code>b</code> - jam priskirtą reikšmę 2.<br />
; Kas nutinka tada?<br />
: Vykdoma eilutė <code>if b == 0:</code>. Kadangi <code>b</code> reikšmė yra 2, todėl eilutė <code>return 0</code> praleidžiama.<br />
; Kas vyksta toliau?<br />
: Vykdoma eilutė <code>lik = daug(a, b - 1)</code>. Ši eilutė nustato lokalaus kintamojo <code>lik</code> reikšmę į <code>daug(a, b - 1)</code> reikšmę. <code>a</code> reikšmė yra 3, o <code>b</code> - 2, todėl funkcija kviečia funkciją <code>daug(3, 1)</code><br />
; Taigi kokia yra <code>daug(3, 1)</code> reikšmė?<br />
: Turime paleisti funkciją <code>daug()</code> su parametrais, kurie yra 3 ir 1.<br />
; Kas nutinka toliau?<br />
: Lokalūs kintamieji vėl pasileidus kodui jau yra nustatyti, todėl <code>a</code> reikšmė būtų 3, o <code>b</code> reikšmė – 1. Kadangi jie yra lokalūs kintamieji, todėl jie neturi įtakos ankstesnėms <code>a</code> ir <code>b</code> reikšmėms.<br />
; Kas įvyksta toliau?<br />
: Kadangi <code>b</code> turi reikšmę 1, if sąlygos rezultatas yra neigiamas, todėl vykdoma kita eilutė <code>lik = daug(a, b - 1)</code>.<br />
; Ką daro ši eilutė?<br />
: Dabar kintamajam <code>lik</code> priskiriam funkcijos <code>daug(3, 0)</code> reikšmė.<br />
; Kokia ši reikšmė?<br />
: Norėdami tai išsiaiškinti, turime dar kartą paleisti funkciją. Šį kartą <code>a</code> reikšmė yra 3, o <code>b</code> – 0.<br />
; Kas vyksta toliau?<br />
: Pirmoji vykdytinos funkcijos eilutė yra <code>if b == 0:</code>. <code>b</code> reikšmė 0, todėl kita vykdoma eilutė yra <code>return 0</code><br />
; Ką daro <code>return 0</code> eilutė?<br />
: Ši eilutė grąžina funkcijos reikšmę lygią 0 į tą vietą, kur ji buvo iškviesta.<br />
; Kas iš to?<br />
: Dabar mes žinome, kad <code>daug(3, 0)</code> grąžina reikšmę 0. Dar žinome, ką daro eilutė <code>lik = daug(a, b - 1)</code>, nes paleidžiame funkciją <code>daug()</code> su parametrais 3 ir 0. Baigiame vykdyti <code>daug(3, 0)</code> ir dabar vėl pradedame vykdyti <code>daug(3, 1)</code>. Kintamajam <code>lik</code> priskiriama reikšmė yra 0.<br />
; Kurią eilutę kompiuteris skaito po to?<br />
: Toliau vykdoma eilutė <code>reikšmė = a + lik</code>. Žinome, kad <code>a = 3</code> ir <code>lik = 0</code> todėl dabar <code>reikšmė = 3</code>. <br />
; Kas nutinka toliau?<br />
: Vykdoma eilutė <code>return reikšmė</code>, kuri grąžina reikšmę 3. Šis skaičius atsiranda iš funkcijos <code>daug (3, 1)</code> vykdymo. Iškvietus <code>return</code>, grįžtame prie <code>daug(3, 2)</code>.<br />
; Kur yra <code>daug(3, 2)</code>?<br />
: Mes turėjome kintamuosius <code>a = 3</code> ir <code>b = 2</code> ir nagrinėjome eilutę <code>lik = daug(a, b - 1)</code>.<br />
; Kas įvyksta?<br />
: Kintamajam <code>lik</code> priskiriama reikšmė 3. Kita eilutė <code>reikšmė = a + lik</code> priskiria kintamajam <code>reikšmė</code> reikšmę <code>3 + 3</code> arba 6. <br />
; Kas įvyksta toliau?<br />
: Pradedama vykdyti kita eilutė, kuri grąžina 6 iš funkcijos. Tuomet grįžtame prie eilutės <code>rezultatas = daug(3, 2)</code>, kur kintamajam <code>rezultatas</code> dabar priskiriama reikšmė 6 <br />
; Kas nutinka toliau? <br />
: Paleidžiama kita eilutė po funkcijos <code>print ("3 * 2 =", rezultatas)</code>.<br />
; Ką ji daro?<br />
: Ji spausdina <code>3 * 2 =</code> ir <code>rezultatas</code> reikšmę, kuri yra 6. Visa išspausdinta eilutė yra <code>3 * 2 = 6</code>.<br />
; Taigi, kas čia įvyko apskritai? <br />
: Iš esmės panaudojome du skirtingus faktus, kad apskaičiuotume dviejų skaičių kartotinį. Pirmas, kad bet koks skaičius padauginus iš nulio yra nulis <code>(x * 0 = 0)</code>. Antras, kad skaičius padaugintas iš kito skaičiaus yra lygus pirmo skaičiaus ir pirmo bei vienetu mažesnio už antrąjį sandaugos sumai <code>(x * y = x + x * (y - 1))</code>. Taigi ir čia <code>3 * 2</code> pirmiausiai paverčiamas į <code>3 + 3 * 1</code>. Tada <code>3 * 1</code> paverčiamas į <code>3 + 3 * 0</code>. Tuomet mes žinome, kad bet kuris skaičius padaugintas iš nulio yra nulis, todėl <code>3 * 0</code> yra 0. Kai viskas surašoma vienoje eilutėje, gauname <code>3 + 3 + 0 </code> <br />
<br />
Štai kaip viskas veikia:<br />
<br />
daug(3, 2)<br />
3 + daug(3, 1)<br />
3 + 3 + daug(3, 0)<br />
3 + 3 + 0<br />
3 + 3<br />
6<br />
<br />
==== Rekursija ====<br />
Funkcijos, kurios kreipiasi pačios į save yra vadinamos rekursinėmis funkcijomis. Šio skyriaus pavyzdžiuose panagrinėsime tokias funkcijas. Tai palengvina programavimo užduočių spendimų įgyvendinimą, nes kartais pakanka apsvarstyti tik vieną problemos žingsnį, o ne visą problemą iš karto. Be to tai leidžia išreikšti kai kurias matematines sąvokas paprastu, lengvai skaitomu kodu.<br />
<br />
Bet kokią problemą, kurią galime išspręsti naudojant rekursiją, gali būti išspręsta naudojant ciklus. Jie veikia greičiau, bet kartais ciklus sunku atlikti teisingai.<br />
<br />
Turbūt intuityviausias „rekursijos“ apibrėžimas yra toks:<br />
REKURSIJA<br />
Jei vis dar nesupranti, tai skaityk: REKURSIJA.<br />
Pabandyk perskaityti dar kelis pavyzdžius.<br />
<br />
=== Pavyzdžiai ===<br />
'''faktorialas.py'''<br />
<syntaxhighlight lang="python"><br />
#apibrėžia funkciją, kuri apskaičiuoja koeficientą<br />
<br />
def faktorialas(n):<br />
if n == 0:<br />
return 1<br />
if n<0:<br />
return "Klaida, neigiami skaičiai neturi faktorialo reikšmių!!"<br />
return n * faktorialas(n - 1)<br />
<br />
print("2! =", faktorialas(2))<br />
print("3! =", faktorialas(3))<br />
print("4! =", faktorialas(4))<br />
print("5! =", faktorialas(5))<br />
print("-3! =", faktorialas(-3))<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
2! = 2<br />
3! = 6<br />
4! = 24<br />
5! = 120<br />
-3! = Klaida, neigiami skaičiai neturi faktorialo reikšmių!!<br />
<br />
'''atgalinis_skaičiavimas.py'''<br />
<syntaxhighlight lang="python"><br />
def atgalinis_skaičiavimas(n):<br />
print(n)<br />
if n > 0:<br />
return atgalinis_skaičiavimas(n-1)<br />
<br />
atgalinis_skaičiavimas(5)<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
5<br />
4<br />
3<br />
2<br />
1<br />
0<br />
<br />
<!-- Dabar pabandyk žodį <code>if</code>(lietuviškai jei) pakeisti žodžiu <code>while</code> (lietuviškai kol). Pamatysi, kad kompiuteris pavirto skaičiuotuvu, kuris negali suskaičiuoti iki keturių. Iš esmės <code>while</code>(kol) veikia kaip <code>if</code> (jei) ir <code>repeat</code>(angl. pakartok) kartu sudėjus.--><br />
<br />
{{navigation |previous=Funkcijų apibrėžimas |next=Sąrašai}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Derinimas&diff=3852Python Vadovėlis/Derinimas2022-02-11T13:38:56Z<p>Modesta: </p>
<hr />
<div>=== Kas yra derinimas? ===<br />
:„Pradėjus programuoti supratau, kad nėra taip lengva kurti teisingai veikiančias programas. Atsimenu akimirką, kai supratau, kad didedė dalis mano gyvenimo, bus skirta klaidų ieškojimui mano paties kurtose programose. Taip atsidaro derinimas.“ &mdash; ''Maurice Wilkes atranda derinimą'', 1949<br />
<br />
Jei jau bandei parašyti kelias programas, turbūt pastebėjai, kad kartais programa daro ką nors, ko neturėtų daryti. Tai yra tikrai dažna situacija. Derinimas tai yra procesas, kuomet bandoma suprasti, ką kompiuteris daro ir kaip jį priversti daryti tai, ką norėtum, kad jis darytų. Tai gali būti sudėtinga. Vieną kartą aš praleidau beveik savaitę ieškodamas ir taisydamas klaidą, kurią sukėlė kitas žmogus, kode parašęs <code>x</code> vietoje <code>y</code>.<br />
<br />
Ši dalis bus abstraktesnė, nei prieš tai buvusios dalys.<br />
<br />
=== Ką turėtų daryti programa? ===<br />
<br />
Pirmas dalykas, ką reikia padaryti (kad ir kaip akivaizdžiai tai skamba), tai suprasti, ką turėtų daryti teisingai veikianti programa. Sugalvok kelis tikrinimo scenarijus ir pažiūrėk, kas nutiks. Tarkime, kad aš noriu sukurti programą, kuri suskaičiuoja stačiakampio perimetrą (visų kraštinių sumą). Turiu tokius tikrinimo scenarijus:<br />
<br />
<br />
{| class="wikitable"<br />
|-<br />
!aukštis !! plotis !!perimetras<br />
|-<br />
|3 ||4 ||14<br />
|--<br />
|2 ||3 ||10<br />
|-<br />
|4 ||4 ||16<br />
|-<br />
|2 ||2 ||8<br />
|-<br />
|5 ||1 ||12<br />
|-<br />
|}<br />
<br />
Dabar galiu vykdyti savo programą su visais tikrinimo scenarijais ir pamatyti, ar programa daro tai, ko tikiuosi. Jei ne, turiu suprasti, ką iš tiesų daro kompiuteris.<br />
<br />
Dažniausiai, dalis tikrinimo scenarijų veikia, dalis - ne. Jei toks yra ir tavo atvejis, turėtum bandyti suprasti, ką veikiantys scenarijai turi bendro. <br />
Pavyzdžiui, apačioje yra perimetro programos išvestis (kodas bus pateiktas kiek vėliau):<br />
<br />
Aukštis: '''3'''<br />
Plotis: '''4'''<br />
Perimetras = 15<br />
<br />
Aukštis: '''2'''<br />
Plotis: '''3'''<br />
Perimetras = 11<br />
<br />
Aukštis: '''4'''<br />
Plotis: '''4'''<br />
Perimetras = 16<br />
<br />
Aukštis: '''2'''<br />
Plotis: '''2'''<br />
Perimetras = 8<br />
<br />
Aukštis: '''5'''<br />
Plotis: '''1'''<br />
Perimetras = 8<br />
<br />
Gali pastebėti, kad programa neveikė su pirmomis dvejomis įvestimis, veikė su sekančiomis dvejomis ir vėl neveikė su paskutine. Pabandyk sugalvoti, kas yra bendro tarp veikiančių scenarijų. Kai supranti, kokia yra programos problema, atrasti jos priežastį yra daug lengviau. Jei reikia, savo programoms gali sugalvoti ir daugiau tikrinimo scenarijų.<br />
<br />
=== Ką daro programa? ===<br />
<br />
Kitas dalykas, ką reikia padaryti, tai peržiūrėti pirminį programos tekstą. Tai vienas iš svarbiausių dalykų programavime. Pagrindinis būdas, kaip tai daroma - tai kodo peržiūros.<br />
<br />
Kodo peržiūra prasideda pirma eilute ir tęsiasi iki programos galo. <code>while</code> ciklai ir <code>if</code> sakiniai reiškia, kad kai kurios eilutės gali būti nekviečiamos niekada, o kai kurios - vykdomos keletą kartų. Kiekvienoje eilutėje turi suprasti, ką daro Python'as.<br />
<br />
Pradėkime su paprasta parametro programa. Šios programos nerašyk. Tau reikės ją tik skaityti, ne vykdyti. Programos pirminis tekstas:<br />
<br />
<syntaxhighlight lang="python"><br />
aukstis = int(input("Aukštis: "))<br />
plotis = int(input("Plotis: "))<br />
print("perimetras =", plotis + aukstis + plotis + plotis)<br />
</syntaxhighlight><br />
<br />
; ''Klausimas:'' Kuri eilutė vykdoma pirma?<br />
: ''Atsakymas:'' Pirmoji kodo eilutė visada yra vykdoma pirma. Šiuo atveju tai: <code>aukstis = int(input("Aukštis: "))</code><br />
; Ką daro ši eilutė?<br />
: Spausdina <code>Aukštis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>aukstis</code>.<br />
; Kuri eilutė vykdoma po to?<br />
: Bendrai, tai yra kita eilutė, kuri yra <code>plotis = int(input("Plotis: "))</code><br />
; Ką daro ši eilutė?<br />
: Spausdina <code>Plotis: </code>, laukia, kol naudotojas įves teksto eilutę ir ją konvertuoja į sveikąjį kintamąjį <code>plotis</code>.<br />
; Kuri eilutė vykdoma po to?<br />
: Kai kita eilutė nėra daugiau ar mažiau įtraukta, nei esama eilutė, ji ir yra vykdoma. Šiuo atveju tai: <code>print("perimetras =", plotis + aukstis + plotis + plotis)</code> (Taip pat gali būti kviečiama funkcija esamoje eilutėje, bet tai bus paaiškinta tolimesniame skyriuje) <br />
; Ką daro ši eilutė?<br />
: Visų pirma, ji spausdina <code>perimetras = </code>, o tada - sumą, sudarytą iš kintamųjų <code>plotis</code> ir <code>aukstis</code>, kuri užrašoma taip: <code>plotis + aukstis + plotis + plotis</code>.<br />
; Ar kodas <code>plotis + aukstis + plotis + plotis</code> skaičiuoja perimetrą teisingai?<br />
: Pažiūrėk: stačiakampio perimetras yra apatinė kraštinė (plotis), plius kairė (aukstis), plius viršutinė (plotis), plius dešinė kraštinė (a?). Paskutinis kintamasis turėtų būti dešinės kraštinės ilgis, arba kitaip - aukštis.<br />
; Ar supranti, kodėl, kai kuriais atvejais, skaičiuojant perimetrą buvo gaunamas teisingas atsakymas? <br />
: Teisingas atsakymas buvo gaunamas kai aukštis ir plotis buvo lygūs.<br />
<br />
Kita programa, kurios kodo peržiūrą darysime, tai programa, kuri turėtų ekrane išvesti 5 taškus. Tačiau, programos išvestis yra:<br />
<br />
. . . . <br />
<br />
Programa:<br />
<syntaxhighlight lang="python"><br />
skaicius = 5<br />
while skaicius > 1:<br />
print(".", end = " ")<br />
skaicius = skaicius - 1<br />
print()<br />
</syntaxhighlight><br />
<br />
Šios programos peržiūra bus kiek sudėtingesnė, nes joje yra įtrauktų kodo dalių. Pradėk.<br />
; Kuri eilutė vykdoma pirma?<br />
: Pirmoji kodo eilutė: <code>skaicius = 5</code><br />
; Ką ji daro?<br />
: Priskiria skaičių 5 kintamajam <code>skaicius</code>.<br />
; Kuri eilutė vykdoma po to?<br />
: Kita eilutė yra: <code>while skaicius > 1:</code><br />
; Ką ji daro?<br />
: Na, <code>while</code> sakiniai žiūri į juose esančius reiškinius. Jei jie yra tesingi, vykdomas kitas įtrauktas blokas. Jei klaidingi – įtrauktas blokas yra praleidžiamas.<br />
; Tai ką ji daro šiuo atveju?<br />
: Jei <code>skaicius > 1</code> yra ''teisinga'', bus vykdomos kitos dvi eilutės.<br />
; Taigi, ar <code>skaicius > 1</code>?<br />
: Paskutinė vertė, kuri buvo priskirta <code>skaicius</code> buvo <code>5</code> ir <code>5 > 1</code>, taigi – taip.<br />
; O kuri eilutė vykdoma po to?<br />
: Kadangi <code>while</code> buvo teisinga, tai kita eilutė yra: <code>print(".", end = " ")</code><br />
; Ką daro ši eilutė?<br />
: Spausdina vieną tašką. Kadangi funkcija turi papildomą argumentą <code>end = " "</code>, toliau spausdinamas tekstas nebus pradedamas naujoje eilutėje.<br />
; Kuri eilutė vykdoma po to?<br />
: <code>skaicius = skaicius - 1</code>, nes tai yra kita eilutė ir nėra jokių įtraukos pasikeitimų.<br />
; Ką ji daro?<br />
: Eilutė skaičiuoja <code>skaicius - 1</code>: iš esamos <code>skaicius</code> vertės (5) atimamas 1, ir tai tampa nauja kintamojo <code>skaicius</code> reikšmė. Sutrumpintai, <code>skaicius</code> vertė yra pakeičiama iš 5 į 4.<br />
; Kuri eilutė vykdoma po to?<br />
: Įtraukos lygis keičiasi, todėl turi žiūrėti į tai, kokią valdymo struktūrą turime. Peržiūrėk <code>while</code> ciklą, taigi turi grįžti į <code>while</code> sąlygą, kuri yra <code>while skaicius > 1:</code><br />
; Ką ji daro?<br />
: Eilutė žiūri į <code>skaicius</code> reikšmę, kuri yra 4, ir lygina ją su 1. Kadangi <code>4 > 1</code>, ciklas tęsiasi.<br />
; Kuri eilutė vykdoma po to?<br />
: Kadangi ciklo sąlyga buvo teisinga, kita eilutė yra: <code>print(".", end = " ")</code><br />
; Ką ji daro?<br />
: Ekrane išspausdina dar vieną tašką, po jo padėdama tarpą.<br />
; Kuri eilutė vykdoma po to?<br />
: Nėra įtraukos pokyčio, todėl: <code>skaicius = skaicius - 1</code><br />
; Ir ką ji daro?<br />
: Ima dabartinę <code>skaicius</code> reikšmę (4), atima 1, kas yra lygu 3 ir priskiria 3 kaip naują <code>skaicius</code> reikšmę.<br />
; Kuri eilutė vykdoma po to?<br />
: Kadangi turime įtraukos pokytį dėl ciklo, kita eilutė yra: <code>while skaicius > 1:</code><br />
; Ką ji daro?<br />
: Palygina dabartinę <code>skaicius</code> reikšmę (3) su 1. <code>3 > 1</code>, todėl ciklas tęsiasi.<br />
; Kuri eilutė vykdoma po to?<br />
: Kadangi ciklo sąlyga yra teisinga, kita eilutė: <code>print(".", end = " ")</code><br />
; O ji daro?<br />
: Trečias taškas yra spausdinamas eilutėje.<br />
; Kuri eilutė vykdoma po to?<br />
: Tai: <code>skaicius = skaicius - 1</code><br />
; Ką ji daro?<br />
: Ima dabartinę <code>skaicius</code> reikšmę (3), atima 1, kas yra lygu 2 ir priskiria 2 kaip naują <code>skaicius</code> reikšmę.<br />
; Kuri eilutė vykdoma po to?<br />
: Vėl grįžtame į ciklo pradžią: <code>while skaicius > 1:</code><br />
; Ką ji daro?<br />
: Palygina dabartinę <code>skaicius</code> reikšmę (2) su 1. <code>2 > 1</code>, todėl ciklas tęsiasi.<br />
; Kuri eilutė vykdoma po to?<br />
: Kadangi ciklas tęsiasi: <code>print(".", end = " ")</code><br />
; Ką ji daro?<br />
: Atranda atsakymą gyvenimui, Visatai, ir viskam. Juokauju (turėjau patikrinti, kad dar neužmigai). Eilutė spausdina ketvirtą tašką ekrane.<br />
; Kuri eilutė vykdoma po to?<br />
: Tai: <code>skaicius = skaicius - 1</code><br />
; Ką ji daro?<br />
: Ima dabartinę <code>skaicius</code> reikšmę (2), atima 1, kas yra lygu 1 ir priskiria 1 kaip naują <code>skaicius</code> reikšmę.<br />
; Kuri eilutė vykdoma po to?<br />
: Atgal į ciklo pradžią: <code>while skaicius > 1:</code><br />
; Ką daro ši eilutė?<br />
: Ji palygina <code>skaicius</code> reikšmę (1) to 1. Kadangi <code>1 > 1</code> yra ''klaidinga'' (vienas nėra daugiau nei vienas), ciklas baigiasi.<br />
; Kuri eilutė vykdoma po to?<br />
: Kadangi ciklo sąlyga buvo klaidinga, vykdoma kita eilutė esanti už ciklo. Tai yra: <code>print()</code><br />
; Ką daro ši eilutė?<br />
: Priverčia teksto žymeklį ekrane peršokti į kitą eilutę.<br />
; Kodėl programa nespausdina 5 taškų?<br />
: Ciklas baigiasi vienu tašku per anksti.<br />
; Kaip tai sutvarkyti?<br />
: Priversti ciklą baigtis vienu tašku vėliau.<br />
; Ir kaip tai padaryti?<br />
: Yra keli būdai. Vienas iš jų yra pakeisti ciklo sąlygą į: <code>while skaicius > 0:</code>. Kitas būdas pakeisti sąlygą į: <code>skaicius >= 1</code>. Yra ir daugiau būdų.<br />
<br />
=== Kaip turėčiau taisyti savo programą? ===<br />
<br />
Tau reikia suprasti, ką programa daro. Tau reikia suprasti, ką programa turėtų daryti. Suprasti, koks skirtumas tarp šių dviejų dalykų. Derinimas - tai įgūdis, kurį norint išmokti, reikia daug praktikos. Jei po valandos nepavyksta išspręsti problemos, pailsėk, pakalbėk su kuo nors apie tai. Po kurio laiko sugrįžk prie problemos ir greičiausiai turėsi naujų minčių, kaip ją įveikti. Sėkmės.<br />
<br />
{{navigation |previous=Pasirinkimai |next=Funkcijų apibrėžimas}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Labas,_Pasauli&diff=3851Python Vadovėlis/Labas, Pasauli2022-02-11T10:16:06Z<p>Modesta: </p>
<hr />
<div><!-- Now for our first lesson, what is a computer program? A computer program is a set of very detailed instructions that tell a computer what to do. --><br />
=== Ką sužinosi? ===<br />
Perskaitęs šį skyrių, turėtum suprasti kaip teksto redaktoriumi rašyti programas, kaip parašytas programas išsaugoti kompiuterio atmintyje ir kaip jas paleisti.<br />
<br />
=== Spausdinimas ===<br />
Istoriškai taip jau susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programėlės pavadinimu „Hello, World!“ arba lietuviškai [[„Labas, Pasauli!“]].<br />
<br />
Python'o programavimo kalboje programa atrodytų taip: <br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
==== Programavimas kodo redaktoriumi ====<br />
<br />
Programavimui rekomenduojame naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Non-Programmer's Tutorial for Python 3/Intro#Creating_and_Running_Programs|Programų kūrimas ir paleidimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File arba Failas -> Naujas failas), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save arba Failas -> Išsaugoti) pavadinimu <code>hello.py</code>.<br />
<br />
Sveikiname! Sukūrei savo pirmą Python programą.<br />
<br />
(Jeigu tokios programavimo aplinkos įsidiegti savo kompiuteryje negali, žr. kitą žingsnį).<br />
<br />
Dabar parašytą programą paleisk vykdyti: tiesiog paspausk žalią mygtuką dešinėje viršuje.<br />
<br />
Kai paleisi šią programą, ji suveiks ir terminale atsiras užrašas:<br />
<br />
Labas, Pasauli!<br />
<br />
==== Alternatyvus būdas: Programavimas paprastu teksto redaktoriumi ====<br />
<br />
Jeigu kodo redaktoriaus negali įsidiegti savo kompiuteryje dėl kokių nors priežasčių, programuoti galima ir tiesiog paprasčiausiu teksto redaktoriumi, pvz., Notepad. <br />
<br />
Tiesiog sukurk naują paprastą tekstinį failą (.txt), jame įrašyk programinį kodą <code>print("Labas, Pasauli!")</code>, failą išsaugok pavadinimu <code>hello.py</code>. <br />
<br />
Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 hello.py</code><br />
<br />
Tavo programa parašys: <br />
<br />
Labas, Pasauli!<br />
<br />
=== Eime toliau ===<br />
<br />
Labai rekomenduojame kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. Mūsų praktikoje toks mokymosi procesas yra pats efektyviausias ir veiksmingiausias.<br />
<br />
Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Benas ir Liepa lipo į kalną")<br />
print("Parsinešti puodą vandens.")<br />
print("Benas nukrito ir susidaužė karūną,")<br />
print("Ir Liepa suklupo taip pat.")<br />
</syntaxhighlight><br />
<br />
Kai paleidi šią programą, ji parašo trumpą istoriją:<br />
<br />
Benas ir Liepa lipo į kalną<br />
Parsinešti puodą vandens.<br />
Benas nukrito ir susidaužė karūną, <br />
Ir Liepa suklupo taip pat.<br />
<br />
Kai kompiuteris paleidžia programą, pirmiausia jis mato:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Benas ir Liepa lipo į kalną")<br />
</syntaxhighlight><br />
<br />
Todėl kompiuteris užrašo:<br />
<br />
Benas ir Liepa lipo į kalną<br />
<br />
Tada kompiuteris skaito kitą eilutę ir mato:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Parsinešti puodą vandens.")<br />
</syntaxhighlight><br />
<br />
Todėl ir ją užrašo kompiuterio ekrane:<br />
<br />
Parsinešti puodą vandens.<br />
<br />
Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs ir eina toliau: skaito kitą eilutę, ją įvykdo ir t.t. Taip kompiuteris vykdo visas surašytas komandas, kol pasiekia programos pabaigą.<br />
<br />
==== Terminologija ====<br />
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.<br />
<br />
Prieš tai rašydami kodą, mes naudojame „funkciją“ pavadinimu <code>print</code>. Po funkcijos pavadinimo <code>print</code> rašomi skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
funkcijai duodamas vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Programuotojai tai vadina „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme). Kitas tekstinės reikšmės pavyzdys yra <code>"Benas ir Liepa lipo į kalną"</code>. <br />
<br />
Užrašyta funkcija su argumentais yra komanda, kurią supranta Python'as. Sakinio pavyzdys:<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
Paprasčiau tariant, komandą gali įsivaizduoti kaip vieną programos eilutę. <br />
<br />
Kol kas terminologijos pakaks, keliaujam į kitą poskyrį ir mokomės toliau.<br />
<br />
====\n rašyme====<br />
<code>\n</code> (escape character), arba nauja eilutė. Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Pabandyk suprasti šią programą:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!\nKą turėčiau daryti?")<br />
</syntaxhighlight><br />
<br />
Kurios rezultatas yra toks:<br />
<br />
Labas, Pasauli! <br />
Ką turėčiau daryti?<br />
<br />
<code>\n</code> naudojamas, kai norime tekstą perkelti į kitą eilutę, bet nenorime naudoti kelių <code>print()</code> komandų.<br />
<br />
Spausdinimo komanda automatiškai naudoja <code>\n</code>, t. y. kiekviena komanda tekstą spausdina vis naujoje eilutėje, net jeigu pats <code>\n</code> ir neužrašai. Paprasčiau suprasti bus pamačius pavyzdį:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
iš tikrųjų yra:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!\n")<br />
</syntaxhighlight><br />
<br />
=== Aritmetinės operacijos ===<br />
Programos pavyzdys:<br />
<br />
<syntaxhighlight lang="python"><br />
print("2 + 2 yra", 2 + 2)<br />
print("3 * 4 yra", 3 * 4)<br />
print("100 - 1 yra", 100 - 1)<br />
print("((33 + 2) / 5 + 11.5 yra", (33 + 2) / 5 + 11.5)<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
2 + 2 yra 4<br />
3 * 4 yra 12<br />
100 - 1 yra 99<br />
(33 + 2) / 5 + 11.5 yra 18.5<br />
<br />
==== Aritmetinės išraiškos ====<br />
<br />
Šiame pavyzdyje, rašymo funkcija <code>print()</code> yra su dvejais argumentais, kurie atskirti kableliu. Panagrinėkime pirmoje eilutėje užrašytą komandą:<br />
<br />
<syntaxhighlight lang="python"><br />
print("2 + 2 yra", 2 + 2)<br />
</syntaxhighlight><br />
<br />
Pirmas argumentas yra teksto eilutė <code>"2 + 2 yra"</code> ir antras argumentas yra aritmetinė išraiška <code>2 + 2</code>, tiksliau tariant viena iš aritmetinių operacijų.<br />
<br />
Atkreipk dėmesį, kad eilutė, kuri yra užrašyta kabutėse yra atspausdinama kaip tekstas, o išraiška užrašyta be kabučių yra apskaičiuojama ir užrašomas atsakymas.<br />
<br />
Python'o programavimo kalba turi septynias pagrindines skaičių operacijas.<br />
<br />
{| class="wikitable"<br />
! Operacija <br />
! Simbolis <br />
! Pavyzdys<br />
|-<br />
|Kėlimas laipsniu <br />
| <code>**</code> <br />
| <code>5 ** 2 == 25</code><br />
|-<br />
|Daugyba <br />
| <code>*</code> <br />
|<code>2 * 3 == 6</code><br />
|-<br />
|Dalyba <br />
| <code>/</code> <br />
| <code>14 / 3 == 4.666666666666667</code> <br />
|-<br />
|Sveikųjų skaičių dalyba<br />
| <code>//</code><br />
| <code>14 // 3 == 4</code><br />
|-<br />
|Liekana<br />
| <code>%</code> <br />
| <code>14 % 3 == 2</code> <br />
|-<br />
|Sudėtis<br />
| <code>+</code> <br />
| <code>1 + 2 == 3</code> <br />
|-<br />
|Atimtis <br />
| <code>-</code> <br />
| <code>4 - 3 == 1</code><br />
|}<br />
<br />
Atkreipk dėmesį, kad yra trys dalybos būdai: vienas grąžina dešimtainį skaičių, antras – tik dalybos sveikąją dalį, o trečias – liekaną.<br />
Operacijų tvarka tokia pati kaip matematikoje:<br />
* pirmiausiai atliekami veiksmai skliausteliuose <code>()</code><br />
* kėlimas laipsniu <code>**</code><br />
* iš karės į dešinę: daugyba <code>*</code>, dalyba<code>/</code>, sveikoji dalyba <code>//</code>, dalybos liekana <code>%</code> <br />
* iš kairės į dešinę: sudėtis <code>+</code> ir atimtis <code>-</code><br />
<br />
Taigi, užrašydamas formules, nepamiršk skliaustelių.<br />
<br />
=== Komentarai ===<br />
<br />
Rašant daug kodo, ateityje tikrai ne viską atsiminsi. Todėl programoje gali naudoti komentarus, kurie yra tiesiog pastabos/paaiškinimai sau pačiam arba kitiems programuotojams. Pavyzdžiui:<br />
<br />
<syntaxhighlight lang="python"><br />
# Skaičiaus PI išraiška kompiuterio ekrane<br />
print(22 / 7)<br />
</syntaxhighlight><br />
<br />
Rezultatas: <br />
<br />
3.14285714286<br />
<br />
Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra skirti žmonėms, pagerinti programos skaitomumą. <br />
<br />
Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris visą šį tekstą ignoruos iki pat eilutės galo.<br />
<br />
<syntaxhighlight lang = "python"><br />
# Skaičiaus PI išraiška kompiuterio ekrane<br />
print(22/7) # tokiu būdu gauname tik apytikslę PI reikšmę<br />
</syntaxhighlight><br />
<br />
=== Pavyzdžiai ===<br />
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python kodo redaktorių ir pažiūrėti kaip viekia. Jeigu suprasi, keliauk toliau, jeigu ne, bandyk dar kartą perskaityti skyriaus medžiagą ir suprasti pavyzdžių logiką.<br />
<br />
'''Danija.py'''<br />
<br />
<syntaxhighlight lang="python"><br />
print("Būti ar nebūti, štai kur klausimas.")<br />
print(" -- Šekspyras")<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Būti ar nebūti, štai kur klausimas.<br />
-- Šekspyras<br />
<br />
'''Mokykla.py'''<br />
<br />
<syntaxhighlight lang="python"><br />
print("Pirmoji klasė")<br />
print("1 + 1 =", 1 + 1)<br />
print("2 + 4 =", 2 + 4)<br />
print("5 - 2 =", 5 - 2)<br />
print()<br />
print("Trečioji klasė")<br />
print("243 - 23 =", 243 - 23)<br />
print("12 * 4 =", 12 * 4)<br />
print("12 / 3 =", 12 / 3)<br />
print("13 / 3 =", 13 // 3, "R", 13 % 3)<br />
print()<br />
print("Vidurinė")<br />
print("123.56 - 62.12 =", 123.56 - 62.12)<br />
print("(4 + 3) * 2 =", (4 + 3) * 2)<br />
print("4 + 3 * 2 =", 4 + 3 * 2)<br />
print("3 ** 2 =", 3 ** 2)<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Pirma klasė<br />
1 + 1 = 2<br />
2 + 4 = 6<br />
5 - 2 = 3<br />
<br />
Trečia klasė<br />
243 - 23 = 220<br />
12 * 4 = 48<br />
12 / 3 = 4<br />
13 / 3 = 4 R 1<br />
<br />
Vidurinė<br />
123.56 - 62.12 = 61.44<br />
(4 + 3) * 2 = 14<br />
4 + 3 * 2 = 10<br />
3 ** 2 = 9<br />
<br />
=== Pratimai ===<br />
<br />
# Parašyk programą, kuri atspausdintų tavo vardą ir gimimo datą atskirose eilutėse<br />
# Parašyk programą, kuri parodytų visų 7 [[#Aritmetinės_išraiškos|artimetinių operacijų]] panaudojimą.<br />
<br />
{| class="mw-collapsible mw-collapsed wikitable"<br />
! colspan=2 | Sprendimas #1 &nbsp;<br />
|-<br />
|<br />
1. Parašyk programą, kuri atspausdintų tavo vardą ir gimimo datą atskirose eilutėse<br />
<syntaxhighlight lang="python"><br />
print("Ada Lovelace", "gimusi", "lapkričio 27, 1852")<br />
</syntaxhighlight> <br />
<br />
<syntaxhighlight lang="python"><br />
print("Albertas Einšteinas", "gimęs", "14 kovo 1879")<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="python"><br />
print(("Jonas Smitas"), ("gimęs"), ("14 kovo 1879"))<br />
</syntaxhighlight><br />
|-<br />
|}<br />
<br />
{| class="mw-collapsible mw-collapsed wikitable"<br />
! colspan=2 | Sprendimas #2 &nbsp;<br />
|-<br />
|<br />
2. Parašyk programą, kuri parodytų visų 7 [[#Aritmetinės_išraiškos|artimetinių operacijų]] panaudojimą.<br />
<syntaxhighlight lang="python"><br />
print("5**5 = ", 5**5)<br />
print("6*7 = ", 6*7)<br />
print("56/8 = ", 56/8)<br />
print("14//6 = ", 14//6)<br />
print("14%6 = ", 14%6)<br />
print("5+6 = ", 5+6)<br />
print("9-0 = ", 9-0)<br />
</syntaxhighlight><br />
|-<br />
|}<br />
<br />
----<br />
==== Išnašos====<br />
<br />
<br />
{{navigation |previous=Įvadas |next=Kas čia eina?}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/%C4%AEvadas&diff=3850Python Vadovėlis/Įvadas2022-02-11T10:13:10Z<p>Modesta: </p>
<hr />
<div>{{navigation |previous=Įžanga |next=Labas, Pasauli}}<br />
<br />
=== Įvadas ===<br />
Šis vadovėlis skirtas visiems norintiems išmokti Python: tiek pirmą kartą bandantiems programuoti, tiek bandžiusiems programuoti kitomis programavimo kalbomis ir norintiems išmokti Python, tiek jau pramokusiems Python, bei norintiems praplėsti žinias.<br />
<br />
Tėra vienintelis būdas išmokti programuoti. '''Tu''' turi skaityti ''kodą'' ir rašyti ''kodą''.<br />
Vadovėlyje parodysiu tau daug kodo. Bandyk vykdyti šį kodą kompiuteriu ir išbandyti pats kaip jis veikia. Ekperimentuok ir bandyk daryti pakeitimus. Nebijok kažką sugandinti, blogiausiu atveju tavo kodas tiesiog neveiks. Kai aš pats rašysiu kodą knygoje, jį suformatuosiu šitaip:<br />
<br />
<syntaxhighlight lang="python"><br />
# Python kalbą lengva išmokti<br />
print("Sveikas, pasauli!")<br />
</syntaxhighlight><br />
<br />
Prieš komentarą – paparastą tekstą – dėsiu groteles. Šitaip lengvai atskirsi kodo pavyzdžius nuo teksto. Jei skaitai internetinį knygos variantą, atkreipk dėmesį į kodo spalvą – ji kitokia, tam kad tam tikros kodo dalys išsiskirtų. Tau vedant kodą kompiuteriu redagavimo programa jį gali nuspalvinti kitokiomis spalvomis arba iš viso nenuspalvinti. Kodo nuspalvinimas gali skirtis, bet jei įvesi kodą, taip kaip nurodyta pavyzdžiuose jis veiks taip kaip ir aprašyta vadovėlyje.<br />
<br />
Pavyzdžiui, vykdant anksčiau parašytą kodo pavyzdį kompiuteris ekrane išves tokį tekstą:<br />
<br />
Sveikas, pasauli!<br />
<br />
<br />
Šis vadovėlis skirtas Python 3 versijai. Bandant kodo pavyzdžius vykdyti su Python 2.7 ir ankstesnėmis versijomis jis gali neveikti. Skirtumai tarp Python 2 ir 3 versijos nėra itin dideli, tad išmokęs Python 3 galėsi be didelių pastangų skaityti ir ankstenėms versijoms skirtą kodą.<br />
<br />
Pavyzdžiuose dažnai parodysiu programos vykdymo metu tavo įvedamą tekstą (jis bus '''paryškintas''') ir programos į ekraną išvedamą tekstą. Pavyzdžiui:<br />
<br />
Stok!<br />
Kas eina? '''Benas'''<br />
Benai, gali eiti toliau<br />
<br />
Vadovėlyje tave supažindinsiu ir su programavimo terminologiją. Tai ne tik tau padės suprasti apie ką kalba programuotojai, bet ir padės mokytis.<br />
<br />
Kad galėtum pradėti kurti Python programas tau reikės Python 3 programinės įrangos, bei kodo redaktoriaus. Rekomenduojame naudoti "LR NŠA Python" programą, kurią gali parsisiųsti iš https://www.visma.lt/python-diegimas/. Ši diegimo programa įdiegs Python interpretatorių, Visual Studio Code kodo redaktorių, bei sukonfiguruos tavo kompiuterį, kad galėtum iš karto rašyti ir vykdyti kodą.<br />
<br />
=== Python ir Visual Studio Code diegimas ===<br />
==== Diegimas Windows operacinėse sistemose ====<br />
LR NŠA Python diegimo programa yra skirta Windows operacinės sistemos naudotojams.<br />
<br />
1. Parsisiųsk diegimo programą iš https://www.visma.lt/python-diegimas/. Rekomeduojama rinktis 64 bitų versiją, nebent naudoji 32 bitų operacinės sistemą.<br />
<br />
2. Paleisk parsisiųstą programą<br />
<br />
3. Atsivers diegimo programos langas. Kad pradėtum diegimą spausk mygtuką '''Next'''.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 1.jpg|frame|center]]<br />
<br />
4. Atsivers naujas langas, kuriame galima pasirinkti kokias dalis norima įdiegti. Rekomenduojama nieko nekeisti ir spausti mygtuką '''Install'''.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 2.jpg|frame|center]]<br />
<br />
5. Palauk kol baigsis diegimas<br />
<br />
6. Baigus diegimą pamtysi langą su pirmo paleidimo instrukcijomis. Šiame lange paspausk mygtuką '''OK'''.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 3.jpg|frame|center]]<br />
<br />
7. Paspausk mygtuką '''Finish''', kad užbaigtum diegimą.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 4.jpg|frame|center]]<br />
<br />
==== Linux, BSD, bei Unix operacinėse sistemose ====<br />
Jei naudoji ne Windows operacinę sistemą Python ir kodo redaktorių reikės įsidiegti atskirai.<br />
Linux, BSD, bei Unix operacinėse sistemose Python dažnai bus įdiegtas kartu su operacine sistema. Patikrinti ar Python įdiegtas ir kuri versija įdiegta galima įvykdžius komandą:<br />
<br />
python3 --version<br />
<br />
Jei Python nėra įdiegtas, tai jį įsidiegti galima naudojantis instrukcija anglų kalba: https://docs.python-guide.org/starting/install3/linux/<br />
<br />
Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download<br />
<br />
==== Mac operacinėse sistemose ====<br />
Nuo Mac OS X Tiger (10.4) versijos, Python 2 yra instaliuojama kartu su operacine sistema. Tad Python 3 reikia įdiegti atskirai (Nebent vėlesnėse versijose pasikeis su operacine sistema diegiamo Python versija). Parsisiųsti Python 3 MAC operacinėms sistemoms galima iš https://www.python.org/downloads/macos/.<br />
<br />
Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download<br />
<br />
=== Pirmas paleidimas ===<br />
Windows operacinėse sistemose Visual Studio Code kodo redaktorių gali paleisti paspaudžiant ant darbalaukio atsiradusios ikonėlės.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 5.jpg|miniatiūra]]<br />
<br />
Pirmo paleidimo metu programa atliks reikiamus konfigūravimo veiksmus, kad būtų galima pilnai naudotis reikiamais įskiepiais. Todėl pirmo paleidimo metu reikia palaukti kelias minutes kol konfigūravimas bus baigtas.<br />
<br />
==== Pirmosios programos sukūrimas ====<br />
Sukurti pirmąją programą gali vykdydamas šiuos žingsnius Visual Studio Code redaktoriuje:<br />
<br />
1. Meniu pasirink Failas >> Atverti aplanką<br />
<br />
2. Pasirink ar susikurk aplanką kuriame laikysi Python programų kodo failus.<br />
<br />
3. Skyriuje '''NARŠYKLĖ''' prie aplanko paspausk ant naujo failo ikonėlės.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 6.jpg|frame|center]]<br />
<br />
4. Pavadink failą "Sveikas.py"<br />
<br />
5. Automatiškai atsivers failo redagavimo langas. Jame įrašyk<br />
<br />
<syntaxhighlight lang="python"><br />
print("Sveikas, pasauli!")<br />
</syntaxhighlight><br />
<br />
6. Paspausk klavišus ctrl + F5, kad paleistum programą<br />
<br />
7. Apatinėje skiltyje išvysi programos vykdymo langą, kur matysi ir savo programos vykdymo rezultatą:<br />
<br />
[[Vaizdas:Vadovelis 1Sk 7.jpg|frame|kairėje]]<br />
<br />
Tokiu pat principu galėsi kurti ir kitas programas.<br />
<br />
==== Programų failų pavadinimai ====<br />
Kuriant naujus Python kodo failus labai naudinga laikytis taisyklių, pavadinant savo programas. Nesilaikant šių taisyklių gali atsitkti taip kad programa "netikėtai" neveiks.<br />
# Visada naudok failo plėtinį <tt>.py</tt>.<br />
# Naudok vieintelį tašką - plėtinio atskyrimui<br />
# Naudok tik: raides, skaičius, brūkšnį (<tt>-</tt>) ir pabraukimo simbolį (<tt>_</tt>)<br />
# Nenaudok tarpų (zodziams atskirti galima naudoti pabraukimo simbolį (<tt>_</tt>).<br />
# Failo pavadinimas turi prasidėti raide<br />
# Nenaudok standartinių Python komandų pavadinimų (pvz. <tt>print.py</tt>, <tt>math.py</tt>, <tt>list.py</tt>)<br />
<br />
=== Python paleidimas per komandinę eilutę ===<br />
Python programinį kodą galima vykdyti ir naudojant komandinę eilutę. Sukūrus failą su programos kodu ją įvykdyti galima komandinėj eilutėj vykdant komandą: <code>python ''failo_pavadinimas''</code><br />
<br />
[[Vaizdas:Vadovelis 1Sk 8.jpg|frame|kairėje]]</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Labas,_Pasauli&diff=3849Python Vadovėlis/Labas, Pasauli2022-02-11T10:12:08Z<p>Modesta: </p>
<hr />
<div><!-- Now for our first lesson, what is a computer program? A computer program is a set of very detailed instructions that tell a computer what to do. --><br />
=== Ką sužinosi? ===<br />
Perskaitęs šį skyrių, turėtum suprasti kaip teksto redaktoriumi rašyti programas, kaip parašytas programas išsaugoti kompiuterio atmintyje ir kaip jas paleisti.<br />
<br />
=== Spausdinimas ===<br />
Istoriškai taip jau susiklostė, kad programavimo pamokos dažniausiai prasideda nuo mažos ir paprastos programėlės pavadinimu „Hello, World!“ arba lietuviškai [[„Labas, Pasauli!“]].<br />
<br />
Python'o programavimo kalboje programa atrodytų taip: <br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
==== Programavimas kodo redaktoriumi ====<br />
<br />
Programavimui rekomenduojame naudoti kodo redaktorių <code>LR NŠA Python</code>, kaip aprašytą skyriuje [[Non-Programmer's Tutorial for Python 3/Intro#Creating_and_Running_Programs|Programų kūrimas ir paleidimas]]. Savo kompiuteryje atsidaryk šią programavimo aplinką, sukurk naują failą (File -> New File arba Failas -> Naujas failas), įkopijuok šį kodą ir tuomet failą išsaugok (File -> Save arba Failas -> Išsaugoti) pavadinimu <code>hello.py</code>.<br />
<br />
Sveikiname! Sukūrei savo pirmą Python programą.<br />
<br />
(Jeigu tokios programavimo aplinkos įsidiegti savo kompiuteryje negali, žr. kitą žingsnį).<br />
<br />
Dabar parašytą programą paleisk vykdyti: tiesiog paspausk žalią mygtuką dešinėje viršuje.<br />
<br />
Kai paleisi šią programą, ji suveiks ir terminale atsiras užrašas:<br />
<br />
Labas, Pasauli!<br />
<br />
==== Alternatyvus būdas: Programavimas paprastu teksto redaktoriumi ====<br />
<br />
Jeigu kodo redaktoriaus negali įsidiegti savo kompiuteryje dėl kokių nors priežasčių, programuoti galima ir tiesiog paprasčiausiu teksto redaktoriumi, pvz., Notepad. <br />
<br />
Tiesiog sukurk naują paprastą tekstinį failą (.txt), jame įrašyk programinį kodą <code>print("Labas, Pasauli!")</code>, failą išsaugok pavadinimu <code>hello.py</code>. <br />
<br />
Dabar parašytą programą paleisk vykdyti, tiesiog konsolėje parašęs <code>python3 hello.py</code><br />
<br />
Tavo programa parašys: <br />
<br />
Labas, Pasauli!<br />
<br />
=== Eime toliau ===<br />
<br />
Labai rekomenduojame kiekvieną programos pavyzdį pasibandyti pačiam - parašyk ir tada pasileisk programą. Mūsų praktikoje toks mokymosi procesas yra pats efektyviausias ir veiksmingiausias.<br />
<br />
Na, o dabar keliaukime prie kiek sudėtingesnės programos pavyzdžio:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Benas ir Liepa lipo į kalną")<br />
print("Parsinešti puodą vandens.")<br />
print("Benas nukrito ir susidaužė karūną,")<br />
print("Ir Liepa suklupo taip pat.")<br />
</syntaxhighlight><br />
<br />
Kai paleidi šią programą, ji parašo trumpą istoriją:<br />
<br />
Benas ir Liepa lipo į kalną<br />
Parsinešti puodą vandens.<br />
Benas nukrito ir susidaužė karūną, <br />
Ir Liepa suklupo taip pat.<br />
<br />
Kai kompiuteris paleidžia programą, pirmiausia jis mato:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Benas ir Liepa lipo į kalną")<br />
</syntaxhighlight><br />
<br />
Todėl kompiuteris užrašo:<br />
<br />
Benas ir Liepa lipo į kalną<br />
<br />
Tada kompiuteris skaito kitą eilutę ir mato:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Parsinešti puodą vandens.")<br />
</syntaxhighlight><br />
<br />
Todėl ir ją užrašo kompiuterio ekrane:<br />
<br />
Parsinešti puodą vandens.<br />
<br />
Taip kompiuteris žiūri į kiekvieną eilutę *iš eilės*, ir ją įvykdęs ir eina toliau: skaito kitą eilutę, ją įvykdo ir t.t. Taip kompiuteris vykdo visas surašytas komandas, kol pasiekia programos pabaigą.<br />
<br />
==== Terminologija ====<br />
Taigi pats laikas truputį paaiškinti, kas vyksta ir trumpai supažindinti su terminologija.<br />
<br />
Prieš tai rašydami kodą, mes naudojame „funkciją“ pavadinimu <code>print</code>. Po funkcijos pavadinimo <code>print</code> rašomi skliausteliai <code>()</code>, kuriuose nurodome tos funkcijos parametrus/argumentus. Pažiūrėk į pavyzdį:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
funkcijai duodamas vienas parametras, kuris yra <code>"Labas, Pasauli!"</code>. Ar pastebėjai, kad šis parametras, sudarytas iš simbolių grupės, kuri įrašyta tarp dviejų kabučių ("")? Programuotojai tai vadina „rašytinių simbolių seka“ ar trumpiau tariant „eilute“ (tekstine reikšme). Kitas tekstinės reikšmės pavyzdys yra <code>"Benas ir Liepa lipo į kalną"</code>. <br />
<br />
Užrašyta funkcija su argumentais yra „teiginys“, kurį supranta Python'as. Sakinio pavyzdys:<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
Paprasčiau tariant, teiginį gali įsivaizduoti kaip vieną programos eilutę. <br />
<br />
Kol kas terminologijos pakaks, keliaujam į kitą poskyrį ir mokomės toliau.<br />
<br />
====\n rašyme====<br />
<code>\n</code> (escape character), arba nauja eilutė. Rašant tekstą, visas tekstas po \n yra užrašomas naujoje eilutėje. Pabandyk suprasti šią programą:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!\nKą turėčiau daryti?")<br />
</syntaxhighlight><br />
<br />
Kurios rezultatas yra toks:<br />
<br />
Labas, Pasauli! <br />
Ką turėčiau daryti?<br />
<br />
<code>\n</code> naudojamas, kai norime tekstą perkelti į kitą eilutę, bet nenorime naudoti kelių <code>print()</code> komandų.<br />
<br />
Spausdinimo komanda automatiškai naudoja <code>\n</code>, t. y. kiekviena komanda tekstą spausdina vis naujoje eilutėje, net jeigu pats <code>\n</code> ir neužrašai. Paprasčiau suprasti bus pamačius pavyzdį:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!")<br />
</syntaxhighlight><br />
<br />
iš tikrųjų yra:<br />
<br />
<syntaxhighlight lang="python"><br />
print("Labas, Pasauli!\n")<br />
</syntaxhighlight><br />
<br />
=== Aritmetinės operacijos ===<br />
Programos pavyzdys:<br />
<br />
<syntaxhighlight lang="python"><br />
print("2 + 2 yra", 2 + 2)<br />
print("3 * 4 yra", 3 * 4)<br />
print("100 - 1 yra", 100 - 1)<br />
print("((33 + 2) / 5 + 11.5 yra", (33 + 2) / 5 + 11.5)<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
2 + 2 yra 4<br />
3 * 4 yra 12<br />
100 - 1 yra 99<br />
(33 + 2) / 5 + 11.5 yra 18.5<br />
<br />
==== Aritmetinės išraiškos ====<br />
<br />
Šiame pavyzdyje, rašymo funkcija <code>print()</code> yra su dvejais argumentais, kurie atskirti kableliu. Panagrinėkime pirmoje eilutėje užrašytą komandą:<br />
<br />
<syntaxhighlight lang="python"><br />
print("2 + 2 yra", 2 + 2)<br />
</syntaxhighlight><br />
<br />
Pirmas argumentas yra teksto eilutė <code>"2 + 2 yra"</code> ir antras argumentas yra aritmetinė išraiška <code>2 + 2</code>, tiksliau tariant viena iš aritmetinių operacijų.<br />
<br />
Atkreipk dėmesį, kad eilutė, kuri yra užrašyta kabutėse yra atspausdinama kaip tekstas, o išraiška užrašyta be kabučių yra apskaičiuojama ir užrašomas atsakymas.<br />
<br />
Python'o programavimo kalba turi septynias pagrindines skaičių operacijas.<br />
<br />
{| class="wikitable"<br />
! Operacija <br />
! Simbolis <br />
! Pavyzdys<br />
|-<br />
|Kėlimas laipsniu <br />
| <code>**</code> <br />
| <code>5 ** 2 == 25</code><br />
|-<br />
|Daugyba <br />
| <code>*</code> <br />
|<code>2 * 3 == 6</code><br />
|-<br />
|Dalyba <br />
| <code>/</code> <br />
| <code>14 / 3 == 4.666666666666667</code> <br />
|-<br />
|Sveikųjų skaičių dalyba<br />
| <code>//</code><br />
| <code>14 // 3 == 4</code><br />
|-<br />
|Liekana<br />
| <code>%</code> <br />
| <code>14 % 3 == 2</code> <br />
|-<br />
|Sudėtis<br />
| <code>+</code> <br />
| <code>1 + 2 == 3</code> <br />
|-<br />
|Atimtis <br />
| <code>-</code> <br />
| <code>4 - 3 == 1</code><br />
|}<br />
<br />
Atkreipk dėmesį, kad yra trys dalybos būdai: vienas grąžina dešimtainį skaičių, antras – tik dalybos sveikąją dalį, o trečias – liekaną.<br />
Operacijų tvarka tokia pati kaip matematikoje:<br />
* pirmiausiai atliekami veiksmai skliausteliuose <code>()</code><br />
* kėlimas laipsniu <code>**</code><br />
* iš karės į dešinę: daugyba <code>*</code>, dalyba<code>/</code>, sveikoji dalyba <code>//</code>, dalybos liekana <code>%</code> <br />
* iš kairės į dešinę: sudėtis <code>+</code> ir atimtis <code>-</code><br />
<br />
Taigi, užrašydamas formules, nepamiršk skliaustelių.<br />
<br />
=== Komentarai ===<br />
<br />
Rašant daug kodo, ateityje tikrai ne viską atsiminsi. Todėl programoje gali naudoti komentarus, kurie yra tiesiog pastabos/paaiškinimai sau pačiam arba kitiems programuotojams. Pavyzdžiui:<br />
<br />
<syntaxhighlight lang="python"><br />
# Skaičiaus PI išraiška kompiuterio ekrane<br />
print(22 / 7)<br />
</syntaxhighlight><br />
<br />
Rezultatas: <br />
<br />
3.14285714286<br />
<br />
Atkreipk dėmesį, kad komentaras prasideda grotelių ženklu: <code>#</code>. Komentarai yra skirti žmonėms, pagerinti programos skaitomumą. <br />
<br />
Taip pat svarbu suprasti, kad po <code>#</code> galima naudoti bet kokius ženklus ir kompiuteris visą šį tekstą ignoruos iki pat eilutės galo.<br />
<br />
<syntaxhighlight lang = "python"><br />
# Skaičiaus PI išraiška kompiuterio ekrane<br />
print(22/7) # tokiu būdu gauname tik apytikslę PI reikšmę<br />
</syntaxhighlight><br />
<br />
=== Pavyzdžiai ===<br />
Kiekvieno skyriaus gale bus pateikiami su skyriaus tema susiję pavyzdžiai. Turėtum juos peržvelgti ir išsiaiškinti ar supratai. Taip pat juos gali įsikelti į python kodo redaktorių ir pažiūrėti kaip viekia. Jeigu suprasi, keliauk toliau, jeigu ne, bandyk dar kartą perskaityti skyriaus medžiagą ir suprasti pavyzdžių logiką.<br />
<br />
'''Danija.py'''<br />
<br />
<syntaxhighlight lang="python"><br />
print("Būti ar nebūti, štai kur klausimas.")<br />
print(" -- Šekspyras")<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Būti ar nebūti, štai kur klausimas.<br />
-- Šekspyras<br />
<br />
'''Mokykla.py'''<br />
<br />
<syntaxhighlight lang="python"><br />
print("Pirmoji klasė")<br />
print("1 + 1 =", 1 + 1)<br />
print("2 + 4 =", 2 + 4)<br />
print("5 - 2 =", 5 - 2)<br />
print()<br />
print("Trečioji klasė")<br />
print("243 - 23 =", 243 - 23)<br />
print("12 * 4 =", 12 * 4)<br />
print("12 / 3 =", 12 / 3)<br />
print("13 / 3 =", 13 // 3, "R", 13 % 3)<br />
print()<br />
print("Vidurinė")<br />
print("123.56 - 62.12 =", 123.56 - 62.12)<br />
print("(4 + 3) * 2 =", (4 + 3) * 2)<br />
print("4 + 3 * 2 =", 4 + 3 * 2)<br />
print("3 ** 2 =", 3 ** 2)<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Pirma klasė<br />
1 + 1 = 2<br />
2 + 4 = 6<br />
5 - 2 = 3<br />
<br />
Trečia klasė<br />
243 - 23 = 220<br />
12 * 4 = 48<br />
12 / 3 = 4<br />
13 / 3 = 4 R 1<br />
<br />
Vidurinė<br />
123.56 - 62.12 = 61.44<br />
(4 + 3) * 2 = 14<br />
4 + 3 * 2 = 10<br />
3 ** 2 = 9<br />
<br />
=== Pratimai ===<br />
<br />
# Parašyk programą, kuri atspausdintų tavo vardą ir gimimo datą atskirose eilutėse<br />
# Parašyk programą, kuri parodytų visų 7 [[#Aritmetinės_išraiškos|artimetinių operacijų]] panaudojimą.<br />
<br />
{| class="mw-collapsible mw-collapsed wikitable"<br />
! colspan=2 | Sprendimas #1 &nbsp;<br />
|-<br />
|<br />
1. Parašyk programą, kuri atspausdintų tavo vardą ir gimimo datą atskirose eilutėse<br />
<syntaxhighlight lang="python"><br />
print("Ada Lovelace", "gimusi", "lapkričio 27, 1852")<br />
</syntaxhighlight> <br />
<br />
<syntaxhighlight lang="python"><br />
print("Albertas Einšteinas", "gimęs", "14 kovo 1879")<br />
</syntaxhighlight><br />
<br />
<syntaxhighlight lang="python"><br />
print(("Jonas Smitas"), ("gimęs"), ("14 kovo 1879"))<br />
</syntaxhighlight><br />
|-<br />
|}<br />
<br />
{| class="mw-collapsible mw-collapsed wikitable"<br />
! colspan=2 | Sprendimas #2 &nbsp;<br />
|-<br />
|<br />
2. Parašyk programą, kuri parodytų visų 7 [[#Aritmetinės_išraiškos|artimetinių operacijų]] panaudojimą.<br />
<syntaxhighlight lang="python"><br />
print("5**5 = ", 5**5)<br />
print("6*7 = ", 6*7)<br />
print("56/8 = ", 56/8)<br />
print("14//6 = ", 14//6)<br />
print("14%6 = ", 14%6)<br />
print("5+6 = ", 5+6)<br />
print("9-0 = ", 9-0)<br />
</syntaxhighlight><br />
|-<br />
|}<br />
<br />
----<br />
==== Išnašos====<br />
<br />
<br />
{{navigation |previous=Įvadas |next=Kas čia eina?}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/%C4%AEvadas&diff=3848Python Vadovėlis/Įvadas2022-02-11T10:01:00Z<p>Modesta: </p>
<hr />
<div>{{navigation |previous=Įžanga |next=Labas, Pasauli}}<br />
<br />
=== Įvadas ===<br />
Šis vadovėlis skirtas visiems norintiems išmokti Python: tiek pirmą kartą bandantiems programuoti, tiek bandžiusiems programuoti kitomis programavimo kalbomis ir norintiems išmokti Python, tiek jau pramokusiems Python, bei norintiems praplėsti žinias.<br />
<br />
Tėra vienintelis būdas išmokti programuoti. '''Tu''' turi skaityti ''kodą'' ir rašyti ''kodą''.<br />
Vadovėlyje parodysiu tau daug kodo. Bandyk vykdyti šį kodą kompiuteriu ir išbandyti pats kaip jis veikia. Ekperimentuok ir bandyk daryti pakeitimus. Nebijok kažką sugandinti, blogiausiu atveju tavo kodas tiesiog neveiks. Kai aš pats rašysiu kodą knygoje, jį suformatuosiu šitaip:<br />
<br />
<syntaxhighlight lang="python"><br />
# Python kalbą lengva išmokti<br />
print("Sveikas, pasauli!")<br />
</syntaxhighlight><br />
<br />
Prieš komentarą – paparastą tekatą – dėsiu groteles. Šitaip lengvai atskirsi kodo pavyzdžius nuo teksto. Jei skaitai internetinį knygos variantą, atkreipk dėmesį į kodo spalvą – ji kitokia, tam kad tam tikros kodo dalys išsiskirtų. Tau vedant kodą kompiuteriu redagavimo programa jį gali nuspalvinti kitokiomis spalvomis arba iš viso nenuspalvinti. Kodo nuspalvinimas gali skirtis, bet jei įvesi kodą, taip kaip nurodyta pavyzdžiuose jis veiks taip kaip ir aprašyta vadovėlyje.<br />
<br />
Pavyzdžiui, vykdant anksčiau parašytą kodo pavyzdį kompiuteris ekrane išves tokį tekstą:<br />
<br />
Sveikas, pasauli!<br />
<br />
<br />
Šis vadovėlis skirtas Python 3 versijai. Bandant kodo pavyzdžius vykdyti su Python 2.7 ir ankstesnėmis versijomis jis gali neveikti. Skirtumai tarp Python 2 ir 3 versijos nėra itin dideli, tad išmokęs Python 3 galėsi be didelių pastangų skaityti ir ankstenėms versijoms skirtą kodą.<br />
<br />
Pavyzdžiuose dažnai parodysiu programos vykdymo metu tavo įvedamą tekstą (jis bus '''paryškintas''') ir programos į ekraną išvedamą tekstą. Pavyzdžiui:<br />
<br />
Stok!<br />
Kas eina? '''Benas'''<br />
Benai, gali eiti toliau<br />
<br />
Vadovėlyje tave supažindinsiu ir su programavimo terminologiją. Tai ne tik tau padės suprasti apie ką kalba programuotojai, bet ir padės mokytis.<br />
<br />
Kad galėtum pradėti kurti Python programas tau reikės Python 3 programinės įrangos, bei kodo redaktoriaus. Rekomenduojame naudoti "LR NŠA Python" programą, kurią gali parsisiųsti iš https://www.visma.lt/python-diegimas/. Ši diegimo programa įdiegs Python interpretatorių, Visual Studio Code kodo redaktorių, bei sukonfiguruos tavo kompiuterį, kad galėtum iš karto rašyti ir vykdyti kodą.<br />
<br />
=== Python ir Visual Studio Code diegimas ===<br />
==== Diegimas Windows operacinėse sistemose ====<br />
LR NŠA Python diegimo programa yra skirta Windows operacinės sistemos naudotojams.<br />
<br />
1. Parsisiųsk diegimo programą iš https://www.visma.lt/python-diegimas/. Rekomeduojama rinktis 64 bitų versiją, nebent naudoji 32 bitų operacinės sistemą.<br />
<br />
2. Paleisk parsisiųstą programą<br />
<br />
3. Atsivers diegimo programos langas. Kad pradėtum diegimą spausk mygtuką '''Next'''.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 1.jpg|frame|center]]<br />
<br />
4. Atsivers naujas langas, kuriame galima pasirinkti kokias dalis norima įdiegti. Rekomenduojama nieko nekeisti ir spausti mygtuką '''Install'''.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 2.jpg|frame|center]]<br />
<br />
5. Palauk kol baigsis diegimas<br />
<br />
6. Baigus diegimą pamtysi langą su pirmo paleidimo instrukcijomis. Šiame lange paspausk mygtuką '''OK'''.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 3.jpg|frame|center]]<br />
<br />
7. Paspausk mygtuką '''Finish''', kad užbaigtum diegimą.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 4.jpg|frame|center]]<br />
<br />
==== Linux, BSD, bei Unix operacinėse sistemose ====<br />
Jei naudoji ne Windows operacinę sistemą Python ir kodo redaktorių reikės įsidiegti atskirai.<br />
Linux, BSD, bei Unix operacinėse sistemose Python dažnai bus įdiegtas kartu su operacine sistema. Patikrinti ar Python įdiegtas ir kuri versija įdiegta galima įvykdžius komandą:<br />
<br />
python3 --version<br />
<br />
Jei Python nėra įdiegtas, tai jį įsidiegti galima naudojantis instrukcija anglų kalba: https://docs.python-guide.org/starting/install3/linux/<br />
<br />
Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download<br />
<br />
==== Mac operacinėse sistemose ====<br />
Nuo Mac OS X Tiger (10.4) versijos, Python 2 yra instaliuojama kartu su operacine sistema. Tad Python 3 reikia įdiegti atskirai (Nebent vėlesnėse versijose pasikeis su operacine sistema diegiamo Python versija). Parsisiųsti Python 3 MAC operacinėms sistemoms galima iš https://www.python.org/downloads/macos/.<br />
<br />
Parsiųsti ir įdiegti Visual Studio Code kodo redaktorių galima iš https://code.visualstudio.com/Download<br />
<br />
=== Pirmas paleidimas ===<br />
Windows operacinėse sistemose Visual Studio Code kodo redaktorių gali paleisti paspaudžiant ant darbalaukio atsiradusios ikonėlės.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 5.jpg|miniatiūra]]<br />
<br />
Pirmo paleidimo metu programa atliks reikiamus konfigūravimo veiksmus, kad būtų galima pilnai naudotis reikiamais įskiepiais. Todėl pirmo paleidimo metu reikia palaukti kelias minutes kol konfigūravimas bus baigtas.<br />
<br />
==== Pirmosios programos sukūrimas ====<br />
Sukurti pirmąją programą gali vykdydamas šiuos žingsnius Visual Studio Code redaktoriuje:<br />
<br />
1. Meniu pasirink Failas >> Atverti aplanką<br />
<br />
2. Pasirink ar susikurk aplanką kuriame laikysi Python programų kodo failus.<br />
<br />
3. Skyriuje '''NARŠYKLĖ''' prie aplanko paspausk ant naujo failo ikonėlės.<br />
<br />
[[Vaizdas:Vadovelis 1Sk 6.jpg|frame|center]]<br />
<br />
4. Pavadink failą "Sveikas.py"<br />
<br />
5. Automatiškai atsivers failo redagavimo langas. Jame įrašyk<br />
<br />
<syntaxhighlight lang="python"><br />
print("Sveikas, pasauli!")<br />
</syntaxhighlight><br />
<br />
6. Paspausk klavišus ctrl + F5, kad paleistum programą<br />
<br />
7. Apatinėje skiltyje išvysi programos vykdymo langą, kur matysi ir savo programos vykdymo rezultatą:<br />
<br />
[[Vaizdas:Vadovelis 1Sk 7.jpg|frame|kairėje]]<br />
<br />
Tokiu pat principu galėsi kurti ir kitas programas.<br />
<br />
==== Programų failų pavadinimai ====<br />
Kuriant naujus Python kodo failus labai naudinga laikytis taisyklių, pavadinant savo programas. Nesilaikant šių taisyklių gali atsitkti taip kad programa "netikėtai" neveiks.<br />
# Visada naudok failo plėtinį <tt>.py</tt>.<br />
# Naudok vieintelį tašką - plėtinio atskyrimui<br />
# Naudok tik: raides, skaičius, brūkšnį (<tt>-</tt>) ir pabraukimo simbolį (<tt>_</tt>)<br />
# Nenaudok tarpų (zodziams atskirti galima naudoti pabraukimo simbolį (<tt>_</tt>).<br />
# Failo pavadinimas turi prasidėti raide<br />
# Nenaudok standartinių Python komandų pavadinimų (pvz. <tt>print.py</tt>, <tt>math.py</tt>, <tt>list.py</tt>)<br />
<br />
=== Python paleidimas per komandinę eilutę ===<br />
Python programinį kodą galima vykdyti ir naudojant komandinę eilutę. Sukūrus failą su programos kodu ją įvykdyti galima komandinėj eilutėj vykdant komandą: <code>python ''failo_pavadinimas''</code><br />
<br />
[[Vaizdas:Vadovelis 1Sk 8.jpg|frame|kairėje]]</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Autoriai&diff=3580Python Vadovėlis/Autoriai2021-11-24T13:38:05Z<p>Modesta: /* Lietuviškas vertimas ir modifikacija */</p>
<hr />
<div>Originalaus (angliško) vadovėlio autoriai<br />
<br />
; Josh Cogliati<br />
: Jrincayc, jjcogliati-jan2007 AT yahoo.com<br />
<br />
=== Angliškos versijos bendraautoriai ===<br />
* Mitchell Aikens, LGIT, WSIT, AAS <br />
* Kiah Morante <br />
*Elizabeth Cogliati<br />
*James A. Brown<br />
*Joe Oppegaard<br />
*Benjamin Hell <br />
<br />
=== Lietuviškas vertimas ir modifikacija ===<br />
* Mantas Urbonas, Visma Lietuva<br />
* Povilas Jeremičius, Visma Lietuva<br />
* Martynas Teleiša, Visma lietuva<br />
* Artūras Nikončukas, Visma Lietuva<br />
* Laura Kutovaja, Visma Lietuva<br />
* Monika Bijeikytė, Visma Lietuva<br />
* Rokas Cvirka, Visma Lietuva<br />
* Modesta Jeremičienė, Visma Lietuva<br />
TODO<br />
<br />
<br />
{{navigation |previous=BEGINNING |next=Front matter}}<br />
{{BookCat}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Kas_%C4%8Dia_eina%3F&diff=3579Python Vadovėlis/Kas čia eina?2021-11-24T13:34:36Z<p>Modesta: </p>
<hr />
<div>=== Įvestis ir kintamieji ===<br />
Aš jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:<br />
<syntaxhighlight lang="python"><br />
print("Stop!")<br />
vartotojo_įvestis = input(" Kas čia eina? ")<br />
print("Gali praeiti,", vartotojo_įvestis )<br />
</syntaxhighlight><br />
<br />
Kai '''Aš''' paleidau programą, štai ką '''mano''' ekranas parodė:<br />
<br />
Stop!<br />
Kas čia eina? '''Jonas'''<br />
Gali praeiti, Jonas<br />
<br />
''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''<br />
<br />
Stop!<br />
Kas čia eina?<br />
<br />
''Tu turi įvesti savo vardą į python shell ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''<br />
<br />
Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.<br />
Kai paleidai programą (juk paleidai, tiesa?), tu turėjai surinkti savo vardą ir tada paspausti Enter.<br />
Programa atspausdino dalį teksto ir tavo vardą. Taip atrodo ''įvesties' pavyzdys.<br />
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojo įvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.<br />
<br />
Žinoma, gauti informaciją iš vartotojo pasaulio yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.<br />
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos. <br />
Šai programa, parodanti kintamųjų pavyzdžius:<br />
<br />
<syntaxhighlight lang="python"><br />
a = 123.4<br />
b23 = 'Šlamštas'<br />
vardas = "Jonas"<br />
b = 432<br />
c = a + b<br />
print("a + b yra ",c)<br />
print("vardas yra ",vardas)<br />
print("Rūšiuotos dalys, Po vidurnakčio ar",b23)<br />
</syntaxhighlight><br />
<br />
Štai kokia išvestis:<br />
<br />
a + b yra 555.4<br />
vardas yra Jonas<br />
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas<br />
<br />
<br />
Kintamieji talpina 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>Jonas</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>.<br />
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.<br />
<br />
<syntaxhighlight lang="python"><br />
reikšmė1 == Op!<br />
reikšmė2 == "Op!"<br />
</syntaxhighlight><br />
<br />
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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų apie tekstą ir <code>==</code>).<br />
<br />
<br />
=== Priskyrimai ===<br />
<br />
Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kuri gali būti kintamajame. Komputeris pamatys tokią eilutę <code>vardas = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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.<br />
<br />
<br />
O štai ir kitas kintamųjų naudojimo pavyzdys:<br />
<syntaxhighlight lang="python"><br />
a = 1<br />
print(a)<br />
a = a + 1<br />
print(a)<br />
a = a * 2<br />
print(a)<br />
</syntaxhighlight><br />
<br />
Ir žinoma štai tokį rezultatą gausime:<br />
<br />
1<br />
2<br />
4<br />
<br />
Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), komputeris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"<br />
<br />
Dar viena programa prieš man pabangiant šį skyrių:<br />
<syntaxhighlight lang="python"><br />
skaičius = float(input("Įvesk skaičių: "))<br />
sveikasSkaičius= int(input("Įvesk sveiką skaičių: "))<br />
tekstas = input("Įvesk tekstą: ")<br />
print("skaičius =", skaičius)<br />
print("skaičius yra", type(skaičius ))<br />
print("skaičius * 2 =", skaičius * 2)<br />
print("sveikas skaičius =", sveikasSkaičius)<br />
print("sveikas skaičius yra", type(sveikasSkaičius))<br />
print("sveikasSkaičius* 2 =", sveikasSkaičius* 2)<br />
print("tekstas=", tekstas)<br />
print("tekstas yra ", type(tekstas))<br />
print("tekstas* 2 =", tekstas* 2)<br />
<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk skaičių: '''12.34'''<br />
Įvesk sveiką skaičių: '''-3'''<br />
Įvesk tekstą: '''Labas'''<br />
skaičius = 12.34<br />
skaičius yra <class 'float'><br />
skaičius * 2 = 24.68<br />
sveikas skaičius = -3<br />
sveikas skaičius yra <class 'int'><br />
sveikasSkaičius * 2 = -6<br />
tekstas = Labas<br />
tekstas yra <class 'str'><br />
tekstas * 2 = LabasLabas<br />
<br />
<br />
Atkreipk dėmesę, kad <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir gražino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> graž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>, bet jei nori teksto - naudok <code>input()</code>.<br />
<br />
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'' (virvelė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas - ne. Atkreipk dėmesį, kai python 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>)<br />
<br />
Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus ir duos klaidą, jei bus bandoma panaudoti tesktą. Štai keleta interaktyvių pavyzdžių:<br />
<br />
<pre><br />
>>> print("Čia" + " " + "yra" + " junginys.")<br />
Čia yra junginys.<br />
>>> print("Ha, " * 5)<br />
Ha, Ha, Ha, Ha, Ha, <br />
>>> print("Ha, " * 5 + "ha!")<br />
Ha, Ha, Ha, Ha, Ha, ha!<br />
>>> print(3 - 1)<br />
2<br />
>>> print("3" - "1")<br />
Traceback (paskutinis veiksmas):<br />
File "<stdin>", line 1, in <module><br />
TypeError: unsupported operand type(s) for -: 'str' and 'str'<br />
>>> <br />
</pre><br />
<br />
Štai sąrašas kelių operacijų su tekstu:<br />
<br />
{| class="wikitable"<br />
!Operation <br />
!Symbol <br />
!Example<br />
|-<br />
|Pakartojimas<br />
|<code>*</code> <br />
|<code>"i" * 5 == "iiiii"</code><br />
|-<br />
|Sujungimas<br />
|<code>+</code> <br />
|<code>"Hello, " + "World!" == "Hello, World!"</code><br />
|}<br />
<br />
=== Pavyzdžiai ===<br />
<br />
'''Laikas.py'''<br />
<syntaxhighlight lang="python"><br />
# ši programa apskaičiuoja laiko priklausomybę nuo greičio ir atstumo<br />
print("Įvesk greitį ir atstumą")<br />
greitis = float(input("Greitis: "))<br />
atstumas = float(input("Atstumas: "))<br />
laikas=(atstumas / greitis )<br />
print("Laikas:", laikas)<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''5'''<br />
Atstumas: '''10'''<br />
Laikas: 2.0<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''3.52'''<br />
Atstumas: '''45.6'''<br />
Laikas: 12.9545454545<br />
<br />
'''Plotas.py'''<br />
<syntaxhighlight lang="python"><br />
# Ši programa apskaičiuoja stačiakampio perimetrą ir plotą <br />
print("Įvestike stačiakampio informaciją")<br />
ilgis = float(input("Ilgis: "))<br />
plotis = float(input("Plotis: "))<br />
Perimetras=(2 * ilgis+ 2 * plotis) <br />
print("Plotas:", ilgis * plotis)<br />
print("Perimetras:", Perimetras)<br />
</syntaxhighlight><br />
<br />
Pavyzdžio rezultatas:<br />
<br />
Įvestike stačiakampio informaciją<br />
Ilgis: '''4'''<br />
Plotis: '''3'''<br />
Plotas: 12.0<br />
Perimetras: 14.0<br />
<br />
Įvestike stačiakampio informaciją<br />
Ilgis: '''2.53'''<br />
Plotis: '''5.2'''<br />
Plotas: 13.156<br />
Perimetras: 15.46<br />
<br />
'''Temperatura.py'''<br />
<syntaxhighlight lang="python"><br />
# Ši programa koncertuoja temperatūra iš Farenheitų į Celsijų<br />
far_temp = float(input("Temperatura Farenheitais: "))<br />
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)<br />
print("Temperatura Celsijaus laipsniais:", cels_temp )<br />
</syntaxhighlight><br />
<br />
Pavyzdžio rezultatas:<br />
<br />
Temperatura Farenheitais: '''32'''<br />
Temperatura Celsijaus laipsniais: 0.0<br />
<br />
Temperatura Farenheitais: '''-40'''<br />
Temperatura Celsijaus laipsniais: -40.0<br />
<br />
Temperatura Farenheitais: '''212'''<br />
Temperatura Celsijaus laipsniais: 100.0<br />
<br />
Temperatura Farenheitais: '''98.6'''<br />
Temperatura Celsijaus laipsniais: 37.0<br />
<br />
=== Užduotis ===<br />
Parašyti programa, kuri priima 2 tekstines reikšmes, 2 skaičius ir vartotojo įvestį, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.<br />
<br />
<br />
=== Sprendimas ===<br />
<br />
<syntaxhighlight lang="python"> <br />
tekstas1 = input('Tekstas 1: ')<br />
tekstas2 = input('Tekstas 2: ')<br />
skaičius1 = float(input('Skaičius 1: '))<br />
skaičius2 = float(input('Skaičius 2: '))<br />
print(tekstas1 + tekstas2 )<br />
print(skaičius1 * skaičius2 )<br />
</syntaxhighlight><br />
}}<br />
<br />
{{navigation |previous=Hello, World |next=Count to 10}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Kas_%C4%8Dia_eina%3F&diff=3578Python Vadovėlis/Kas čia eina?2021-11-24T13:31:23Z<p>Modesta: </p>
<hr />
<div>=== Įvestis ir kintamieji ===<br />
Aš jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:<br />
<syntaxhighlight lang="python"><br />
print("Stop!")<br />
vartotojo_įvestis = input(" Kas čia eina? ")<br />
print("Gali praeiti,", vartotojo_įvestis )<br />
</syntaxhighlight><br />
<br />
Kai '''Aš''' paleidau programą, štai ką '''mano''' ekranas parodė:<br />
<br />
Stop!<br />
Kas čia eina? '''Jonas'''<br />
Gali praeiti, Jonas<br />
<br />
''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''<br />
<br />
Stop!<br />
Kas čia eina?<br />
<br />
''Tu turi įvesti savo vardą į python shell ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''<br />
<br />
Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.<br />
Kai paleidai programą (juk paleidai, tiesa?), tu turėjai surinkti savo vardą ir tada paspausti Enter.<br />
Programa atspausdino dalį teksto ir tavo vardą. Taip atrodo ''įvesties' pavyzdys.<br />
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojo įvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.<br />
<br />
Žinoma, gauti informaciją iš vartotojo pasaulio yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.<br />
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos. <br />
Šai programa, parodanti kintamųjų pavyzdžius:<br />
<br />
<syntaxhighlight lang="python"><br />
a = 123.4<br />
b23 = 'Šlamštas'<br />
vardas = "Jonas"<br />
b = 432<br />
c = a + b<br />
print("a + b yra ",c)<br />
print("vardas yra ",vardas)<br />
print("Rūšiuotos dalys, Po vidurnakčio ar",b23)<br />
</syntaxhighlight><br />
<br />
Štai kokia išvestis:<br />
<br />
a + b yra 555.4<br />
vardas yra Jonas<br />
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas<br />
<br />
<br />
Kintamieji talpina 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>Jonas</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>.<br />
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.<br />
<br />
<syntaxhighlight lang="python"><br />
reikšmė1 == Op!<br />
reikšmė2 == "Op!"<br />
</syntaxhighlight><br />
<br />
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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>O</code>,<code>o</code> ir<code>!</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų apie tekstą ir <code>==</code>).<br />
<br />
<br />
=== Priskyrimai ===<br />
<br />
Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kuri gali būti kintamajame. Komputeris pamatys tokią eilutę <code>vardas = "Jonas"</code> ir perskaitys ją kaip "Padėk tekstą <code>Jonas</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.<br />
<br />
<br />
O štai ir kitas kintamųjų naudojimo pavyzdys:<br />
<syntaxhighlight lang="python"><br />
a = 1<br />
print(a)<br />
a = a + 1<br />
print(a)<br />
a = a * 2<br />
print(a)<br />
</syntaxhighlight><br />
<br />
Ir žinoma štai tokį rezultatą gausime:<br />
<br />
1<br />
2<br />
4<br />
<br />
Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), komputeris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"<br />
<br />
Dar viena programa prieš man pabangiant šį skyrių:<br />
<syntaxhighlight lang="python"><br />
skaičius = float(input("Įvesk skaičių: "))<br />
sveikasSkaičius= int(input("Įvesk sveiką skaičių: "))<br />
tekstas = input("Įvesk tekstą: ")<br />
print("skaičius =", skaičius)<br />
print("skaičius yra", type(skaičius ))<br />
print("skaičius * 2 =", skaičius * 2)<br />
print("sveikas skaičius =", sveikasSkaičius)<br />
print("sveikas skaičius yra", type(sveikasSkaičius))<br />
print("sveikasSkaičius* 2 =", sveikasSkaičius* 2)<br />
print("tekstas=", tekstas)<br />
print("tekstas yra ", type(tekstas))<br />
print("tekstas* 2 =", tekstas* 2)<br />
<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk skaičių: '''12.34'''<br />
Įvesk sveiką skaičių: '''-3'''<br />
Įvesk tekstą: '''Labas'''<br />
skaičius = 12.34<br />
skaičius yra <class 'float'><br />
skaičius * 2 = 24.68<br />
sveikas skaičius = -3<br />
sveikas skaičius yra <class 'int'><br />
sveikasSkaičius * 2 = -6<br />
tekstas = Labas<br />
tekstas yra <class 'str'><br />
tekstas * 2 = LabasLabas<br />
<br />
<br />
Atkreipk dėmesę, kad <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir gražino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> graž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>, bet jei nori teksto - naudok <code>input()</code>.<br />
<br />
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'' (virvelė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinėms funkcijoms, tekstas - ne. Atkreipk dėmesį, kai python 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>)<br />
<br />
Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus ir duos klaidą, jei bus bandoma panaudoti tesktą. Štai keleta interaktyvių pavyzdžių:<br />
<br />
<pre><br />
>>> print("Čia" + " " + "yra" + " junginys.")<br />
Čia yra junginys.<br />
>>> print("Ha, " * 5)<br />
Ha, Ha, Ha, Ha, Ha, <br />
>>> print("Ha, " * 5 + "ha!")<br />
Ha, Ha, Ha, Ha, Ha, ha!<br />
>>> print(3 - 1)<br />
2<br />
>>> print("3" - "1")<br />
Traceback (paskutinis veiksmas):<br />
File "<stdin>", line 1, in <module><br />
TypeError: unsupported operand type(s) for -: 'str' and 'str'<br />
>>> <br />
</pre><br />
<br />
Štai sąrašas kelių operacijų su tekstu:<br />
<br />
{| class="wikitable"<br />
!Operation <br />
!Symbol <br />
!Example<br />
|-<br />
|Pakartojimas<br />
|<code>*</code> <br />
|<code>"i" * 5 == "iiiii"</code><br />
|-<br />
|Sujungimas<br />
|<code>+</code> <br />
|<code>"Hello, " + "World!" == "Hello, World!"</code><br />
|}<br />
<br />
=== Pavyzdžiai ===<br />
<br />
'''Laikas.py'''<br />
<syntaxhighlight lang="python"><br />
# ši programa apskaičiuoja laiką priklausomai nuo greičio ir atstumo<br />
print("Įvesk greitį ir atstumą")<br />
greitis = float(input("Greitis: "))<br />
atstumas = float(input("Atstumas: "))<br />
laikas=(atstumas / greitis )<br />
print("Laikas:", laikas)<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''5'''<br />
Atstumas: '''10'''<br />
Laikas: 2.0<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''3.52'''<br />
Atstumas: '''45.6'''<br />
Laikas: 12.9545454545<br />
<br />
'''Plotas.py'''<br />
<syntaxhighlight lang="python"><br />
# Ši programa apskaičiuoja stačiakampio perimetrą ir plotą <br />
print("Investike stačiakampio informaciją")<br />
ilgis = float(input("Ilgis: "))<br />
plotis = float(input("Plotis: "))<br />
Perimetras=(2 * ilgis+ 2 * plotis) <br />
print("Plotas:", ilgis * plotis)<br />
print("Perimetras:", Perimetras)<br />
</syntaxhighlight><br />
<br />
Pavyzdžio rezultatas:<br />
<br />
Investike stačiakampio informaciją<br />
Ilgis: '''4'''<br />
Plotis: '''3'''<br />
Plotas: 12.0<br />
Perimetras: 14.0<br />
<br />
Investike stačiakampio informaciją<br />
Ilgis: '''2.53'''<br />
Plotis: '''5.2'''<br />
Plotas: 13.156<br />
Perimetras: 15.46<br />
<br />
'''Temperatura.py'''<br />
<syntaxhighlight lang="python"><br />
# Ši programa koncertuoja temperatūra Farenheitais į Celsijų<br />
far_temp = float(input("Temperatura Farenheitas: "))<br />
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)<br />
print("Temperature Celsijaus laipsniais:", cels_temp )<br />
</syntaxhighlight><br />
<br />
Pavyzdžio rezultatas:<br />
<br />
Temperatura Farenheitas: '''32'''<br />
Temperature Celsijaus laipsniais: 0.0<br />
<br />
Temperatura Farenheitas: '''-40'''<br />
Temperature Celsijaus laipsniais: -40.0<br />
<br />
Temperatura Farenheitas: '''212'''<br />
Temperature Celsijaus laipsniais: 100.0<br />
<br />
Temperatura Farenheitas: '''98.6'''<br />
Temperature Celsijaus laipsniais: 37.0<br />
<br />
=== Užduotis ===<br />
Parašyti programa, kuri priima 2 tekstines reikšmes ir 2 skaičius ir naudotojo, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.<br />
<br />
<br />
=== Sprendimas ===<br />
<br />
<syntaxhighlight lang="python"> <br />
tekstas1 = input('Tekstas 1: ')<br />
tekstas2 = input('Tekstas 2: ')<br />
skaičius1 = float(input('Skaičius 1: '))<br />
skaičius2 = float(input('Skaičius 2: '))<br />
print(tekstas1 + tekstas2 )<br />
print(skaičius1 * skaičius2 )<br />
</syntaxhighlight><br />
}}<br />
<br />
{{navigation |previous=Hello, World |next=Count to 10}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Kas_%C4%8Dia_eina%3F&diff=3518Python Vadovėlis/Kas čia eina?2021-11-11T14:37:51Z<p>Modesta: </p>
<hr />
<div>=== Įvestis ir kintamieji ===<br />
Aš jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:<br />
<syntaxhighlight lang="python"><br />
print("Stop!")<br />
user_input = input(" Kas čia eina? ")<br />
print("Gali praeiti,", user_input)<br />
</syntaxhighlight><br />
<br />
Kai '''Aš''' paleidžiu programą, tai ką '''mano''' ekranas parodė:<br />
<br />
Stop!<br />
Kas čia eina? '''Josh'''<br />
Gali praeiti, Josh<br />
<br />
''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''<br />
<br />
Stop!<br />
Kas čia eina?<br />
<br />
''Tu turi įvesti savo vardą į python shell ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''<br />
<br />
Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.<br />
Kai paleidai programą (juk paleidai, tiesa?), kad tu turėjai surinkti savo vardą ir tada paspausti Enter.<br />
Programa atspausdino dalį teksto ir tavo vardą. Čia yra pavyzdys ''įvesties'.<br />
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojoįvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.<br />
<br />
Žinoma, gauti informaciją iš vartotojo pasaulio yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.<br />
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos. <br />
Šai programa, parodanti kintamųjų pavyzdžius:<br />
<br />
<syntaxhighlight lang="python"><br />
a = 123.4<br />
b23 = 'Šlamštas'<br />
vardas = "Jonas"<br />
b = 432<br />
c = a + b<br />
print("a + b is",c)<br />
print("vardas yra ",vardas)<br />
print("Rūšiuotos dalys, Po vidurnakčio ar",b23)<br />
</syntaxhighlight><br />
<br />
Štai kokia išvestis:<br />
<br />
a + b is 555.4<br />
vardas yra Jonas<br />
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas<br />
<br />
<br />
Kintamieji talpina duomenis. Viršuje aprašytoje programoje kintamieji yra <code>a</code>, <code>b23</code>, <code>vardas</code>, <code>b</code>, and <code>c</code>. Pagrindiniai du kintamųjų tipai yra ''tekstas'' ir ''skaičius''. Tekstas yra seka raidžių, skaičių ir kitų simbolių. Šiame pavyzdyje <code>b23</code> ir <code>vardas</code> yra kintamieji, kurie talpina tekstą. <code>Spam</code>, <code>Bill</code>, <code>a + b is</code>, <code>vardas yra</code>, ir <code>Rūšiuotos dalys, Po vidurnakčio ar</code> yra tiesiog tekstinės reikšmės šioje programoje. Tekstas yra apsuptas kabučių <code>"</code> arba <code>'</code>. <br />
Kitas kintamojo tipas yra skaičiai. Prisiminkite, kad kintamieji, kurie naudojami saugoti reikšmes, nenaudoja kabučių (" ir '). Jei norite naudoti realias ''reikšmes'', privalote naudoti kabutes.<br />
<br />
<syntaxhighlight lang="python"><br />
reikšmė1 == Pim<br />
reikšmė2 == "Pim"<br />
</syntaxhighlight><br />
<br />
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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>P</code>,<code>i</code> ir<code>m</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų apie tekstą ir <code>==</code>).<br />
<br />
<br />
=== Priskyrimai ===<br />
<br />
Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kurie gali būti kintamajame. Komputeris pamatys tokią eilutę <code>vardas = "Bill"</code> ir perskaitys ją kaip "Padėk tekstą <code>Bill</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> ar <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.<br />
<br />
<br />
O štai ir kitas kintamųjų naudojimo pavyzdys:<br />
<syntaxhighlight lang="python"><br />
a = 1<br />
print(a)<br />
a = a + 1<br />
print(a)<br />
a = a * 2<br />
print(a)<br />
</syntaxhighlight><br />
<br />
Ir žinoma štai tokį rezultatą gausime:<br />
<br />
1<br />
2<br />
4<br />
<br />
Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), komputeris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"<br />
<br />
Dar viena programa prieš man pabangiant šį skyrių:<br />
<syntaxhighlight lang="python"><br />
skaičius = float(input("Įvesk skaičių: "))<br />
sveikasSkaičius= int(input("Įvesk sveiką skaičių: "))<br />
tekstas = input("Įvesk tekstą: ")<br />
print("skaičius =", nuskaičius mber)<br />
print("skaičius yra", type(skaičius ))<br />
print("skaičius * 2 =", skaičius * 2)<br />
print("sveikas skaičius =", sveikasSkaičius)<br />
print("sveikas skaičius yra", type(sveikasSkaičius))<br />
print("sveikasSkaičius* 2 =", sveikasSkaičius* 2)<br />
print("tekstas=", tekstas)<br />
print("tekstas yra ", type(tekstas))<br />
print("tekstas* 2 =", tekstas* 2)<br />
<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk skaičių: '''12.34'''<br />
Įvesk sveiką skaičių: '''-3'''<br />
Įvesk sveiką tekstą: '''Labas'''<br />
skaičius = 12.34<br />
skaičius yra <class 'float'><br />
skaičius * 2 = 24.68<br />
sveikas skaičius = -3<br />
sveikas skaičius yra <class 'int'><br />
sveikasSkaičius * 2 = -6<br />
tekstas = Labas<br />
tekstas yra <class 'str'><br />
tekstas * 2 = LabasLabas<br />
<br />
<br />
Atkreipk dėmesę, kad <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir gražino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> graž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> tipą. Jei nori, kad vartotojas įvestų sveiką skaičių, naudok <code>int(input())</code>, bet jei nori teksto - naudok <code>input()</code>.<br />
<br />
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 kambleliu) trumpiniai. Tekstinė eilutė yra <code>str</code>, trumpinys ''string'' (virvelė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinės funkcijoms, tekstas - ne. Atkreipk dėmesį, kai python daugina skaičių iš sveiko skaičiaus gaunamas tikėtas rezultatas, tačiau jei tekstas padauginamas iš sveiko skaičiaus - sukuriamos kelios teksto kopijos (pavyzdžiui, <code>tekstas * 2 = LabasLabas</code>)<br />
<br />
Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus ir duos klaidą, jei bus bandoma panaudoti tesktą. Štai keleta interaktyvių pavyzdžių:<br />
<br />
<pre><br />
>>> print("Čia" + " " + "yra" + " junginys.")<br />
Čia yra junginys.<br />
>>> print("Ha, " * 5)<br />
Ha, Ha, Ha, Ha, Ha, <br />
>>> print("Ha, " * 5 + "ha!")<br />
Ha, Ha, Ha, Ha, Ha, ha!<br />
>>> print(3 - 1)<br />
2<br />
>>> print("3" - "1")<br />
Traceback (paskutinis veiksmas):<br />
File "<stdin>", line 1, in <module><br />
TypeError: unsupported operand type(s) for -: 'str' and 'str'<br />
>>> <br />
</pre><br />
<br />
Štai sąrašas kelių operacijų su tekstu:<br />
<br />
{| class="wikitable"<br />
!Operation <br />
!Symbol <br />
!Example<br />
|-<br />
|Pakartojimas<br />
|<code>*</code> <br />
|<code>"i" * 5 == "iiiii"</code><br />
|-<br />
|Sujungimas<br />
|<code>+</code> <br />
|<code>"Hello, " + "World!" == "Hello, World!"</code><br />
|}<br />
<br />
=== Pavyzdžiai ===<br />
<br />
'''Laikas.py'''<br />
<syntaxhighlight lang="python"><br />
# ši programa apskaičiuoja laiką priklausomai nuo greičio ir atstumo<br />
print("Įvesk greitį ir atstumą")<br />
greitis = float(input("Greitis: "))<br />
atstumas = float(input("Atstumas: "))<br />
laikas=(atstumas / greitis )<br />
print("Laikas:", laikas)<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''5'''<br />
Atstumas: '''10'''<br />
Laikas: 2.0<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''3.52'''<br />
Atstumas: '''45.6'''<br />
Laikas: 12.9545454545<br />
<br />
'''Plotas.py'''<br />
<syntaxhighlight lang="python"><br />
# Ši programa apskaičiuoja stačiakampio perimetrą ir plotą <br />
print("Investike stačiakampio informaciją")<br />
ilgis = float(input("Ilgis: "))<br />
plotis = float(input("Plotis: "))<br />
Perimetras=(2 * ilgis+ 2 * plotis) <br />
print("Plotas:", ilgis * plotis)<br />
print("Perimetras:", Perimetras)<br />
</syntaxhighlight><br />
<br />
Pavyzdžio rezultatas:<br />
<br />
Investike stačiakampio informaciją<br />
Ilgis: '''4'''<br />
Plotis: '''3'''<br />
Plotas: 12.0<br />
Perimetras: 14.0<br />
<br />
Investike stačiakampio informaciją<br />
Ilgis: '''2.53'''<br />
Plotis: '''5.2'''<br />
Plotas: 13.156<br />
Perimetras: 15.46<br />
<br />
'''Temperatura.py'''<br />
<syntaxhighlight lang="python"><br />
# Ši programa koncertuoja temperatūra Farenheitais į Celsijų<br />
far_temp = float(input("Temperatura Farenheitas: "))<br />
cels_temp = (far_temp - 32.0) *( 5.0 / 9.0)<br />
print("Temperature Celsijaus laipsniais:", cels_temp )<br />
</syntaxhighlight><br />
<br />
Pavyzdžio rezultatas:<br />
<br />
Temperatura Farenheitas: '''32'''<br />
Temperature Celsijaus laipsniais: 0.0<br />
<br />
Temperatura Farenheitas: '''-40'''<br />
Temperature Celsijaus laipsniais: -40.0<br />
<br />
Temperatura Farenheitas: '''212'''<br />
Temperature Celsijaus laipsniais: 100.0<br />
<br />
Temperatura Farenheitas: '''98.6'''<br />
Temperature Celsijaus laipsniais: 37.0<br />
<br />
=== Užduotis ===<br />
Parašyti programa, kuri priima 2 tekstines reikšmes ir 2 skaičius ir naudotojo, sujungia juos be tarpų ir atvaizduoja tekstus, o tada sudaugina du skaičius ir atvaizduoja naujoje eilutėje.<br />
<br />
<br />
=== Sprendimas ===<br />
<br />
<syntaxhighlight lang="python"> <br />
tekstas1 = input('Tekstas 1: ')<br />
tekstas2 = input('Tekstas 2: ')<br />
skaičius1 = float(input('Skaičius 1: '))<br />
skaičius2 = float(input('Skaičius 2: '))<br />
print(tekstas1 + tekstas2 )<br />
print(skaičius1 * skaičius2 )<br />
</syntaxhighlight><br />
}}<br />
<br />
{{navigation |previous=Hello, World |next=Count to 10}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Kas_%C4%8Dia_eina%3F&diff=3504Python Vadovėlis/Kas čia eina?2021-11-09T09:33:48Z<p>Modesta: </p>
<hr />
<div>=== Įvestis ir kintamieji ===<br />
Aš jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:<br />
<syntaxhighlight lang="python"><br />
print("Stop!")<br />
user_input = input(" Kas čia eina? ")<br />
print("Gali praeiti,", user_input)<br />
</syntaxhighlight><br />
<br />
Kai '''Aš''' paleidžiu programą, tai ką '''mano''' ekranas parodė:<br />
<br />
Stop!<br />
Kas čia eina? '''Josh'''<br />
Gali praeiti, Josh<br />
<br />
''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''<br />
<br />
Stop!<br />
Kas čia eina?<br />
<br />
''Tu turi įvesti savo vardą į python shell ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''<br />
<br />
Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.<br />
Kai paleidai programą (juk paleidai, tiesa?), kad tu turėjai surinkti savo vardą ir tada paspausti Enter.<br />
Programa atspausdino dalį teksto ir tavo vardą. Čia yra pavyzdys ''įvesties'.<br />
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojoįvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.<br />
<br />
Žinoma, gauti informaciją iš vartotojo pasaulio yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.<br />
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos. <br />
Šai programa, parodanti kintamųjų pavyzdžius:<br />
<br />
<syntaxhighlight lang="python"><br />
a = 123.4<br />
b23 = 'Šlamštas'<br />
vardas = "Jonas"<br />
b = 432<br />
c = a + b<br />
print("a + b is",c)<br />
print("vardas yra ",vardas)<br />
print("Rūšiuotos dalys, Po vidurnakčio ar",b23)<br />
</syntaxhighlight><br />
<br />
Štai kokia išvestis:<br />
<br />
a + b is 555.4<br />
vardas yra Jonas<br />
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas<br />
<br />
<br />
Kintamieji talpina duomenis. Viršuje aprašytoje programoje kintamieji yra <code>a</code>, <code>b23</code>, <code>vardas</code>, <code>b</code>, and <code>c</code>. Pagrindiniai du kintamųjų tipai yra ''tekstas'' ir ''skaičius''. Tekstas yra seka raidžių, skaičių ir kitų simbolių. Šiame pavyzdyje <code>b23</code> ir <code>vardas</code> yra kintamieji, kurie talpina tekstą. <code>Spam</code>, <code>Bill</code>, <code>a + b is</code>, <code>vardas yra</code>, ir <code>Rūšiuotos dalys, Po vidurnakčio ar</code> yra tiesiog tekstinės reikšmės šioje programoje. Tekstas yra apsuptas kabučių <code>"</code> arba <code>'</code>. <br />
Kitas kintamojo tipas yra skaičiai. Prisiminkite, kad kintamieji, kurie naudojami saugoti reikšmes, nenaudoja kabučių (" ir '). Jei norite naudoti realias ''reikšmes'', privalote naudoti kabutes.<br />
<br />
<syntaxhighlight lang="python"><br />
reikšmė1 == Pim<br />
reikšmė2 == "Pim"<br />
</syntaxhighlight><br />
<br />
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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>P</code>,<code>i</code> ir<code>m</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų apie tekstą ir <code>==</code>).<br />
<br />
<br />
=== Priskyrimai ===<br />
<br />
Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kurie gali būti kintamajame. Komputeris pamatys tokią eilutę <code>vardas = "Bill"</code> ir perskaitys ją kaip "Padėk tekstą <code>Bill</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> ar <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.<br />
<br />
<br />
O štai ir kitas kintamųjų naudojimo pavyzdys:<br />
<syntaxhighlight lang="python"><br />
a = 1<br />
print(a)<br />
a = a + 1<br />
print(a)<br />
a = a * 2<br />
print(a)<br />
</syntaxhighlight><br />
<br />
Ir žinoma štai tokį rezultatą gausime:<br />
<br />
1<br />
2<br />
4<br />
<br />
Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), komputeris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"<br />
<br />
Dar viena programa prieš man pabangiant šį skyrių:<br />
<syntaxhighlight lang="python"><br />
skaičius = float(input("Įvesk skaičių: "))<br />
sveikasSkaičius= int(input("Įvesk sveiką skaičių: "))<br />
tekstas = input("Įvesk tekstą: ")<br />
print("skaičius =", nuskaičius mber)<br />
print("skaičius yra", type(skaičius ))<br />
print("skaičius * 2 =", skaičius * 2)<br />
print("sveikas skaičius =", sveikasSkaičius)<br />
print("sveikas skaičius yra", type(sveikasSkaičius))<br />
print("sveikasSkaičius* 2 =", sveikasSkaičius* 2)<br />
print("tekstas=", tekstas)<br />
print("tekstas yra ", type(tekstas))<br />
print("tekstas* 2 =", tekstas* 2)<br />
<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk skaičių: '''12.34'''<br />
Įvesk sveiką skaičių: '''-3'''<br />
Įvesk sveiką tekstą: '''Labas'''<br />
skaičius = 12.34<br />
skaičius yra <class 'float'><br />
skaičius * 2 = 24.68<br />
sveikas skaičius = -3<br />
sveikas skaičius yra <class 'int'><br />
sveikasSkaičius * 2 = -6<br />
tekstas = Labas<br />
tekstas yra <class 'str'><br />
tekstas * 2 = LabasLabas<br />
<br />
<br />
Atkreipk dėmesę, kad <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir gražino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> graž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> tipą. Jei nori, kad vartotojas įvestų sveiką skaičių, naudok <code>int(input())</code>, bet jei nori teksto - naudok <code>input()</code>.<br />
<br />
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 kambleliu) trumpiniai. Tekstinė eilutė yra <code>str</code>, trumpinys ''string'' (virvelė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinės funkcijoms, tekstas - ne. Atkreipk dėmesį, kai python daugina skaičių iš sveiko skaičiaus gaunamas tikėtas rezultatas, tačiau jei tekstas padauginamas iš sveiko skaičiaus - sukuriamos kelios teksto kopijos (pavyzdžiui, <code>tekstas * 2 = LabasLabas</code>)<br />
<br />
Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus ir duos klaidą, jei bus bandoma panaudoti tesktą. Štai keleta interaktyvių pavyzdžių:<br />
<br />
<pre><br />
>>> print("Čia" + " " + "yra" + " junginys.")<br />
Čia yra junginys.<br />
>>> print("Ha, " * 5)<br />
Ha, Ha, Ha, Ha, Ha, <br />
>>> print("Ha, " * 5 + "ha!")<br />
Ha, Ha, Ha, Ha, Ha, ha!<br />
>>> print(3 - 1)<br />
2<br />
>>> print("3" - "1")<br />
Traceback (paskutinis veiksmas):<br />
File "<stdin>", line 1, in <module><br />
TypeError: unsupported operand type(s) for -: 'str' and 'str'<br />
>>> <br />
</pre><br />
<br />
Štai sąrašas kelių operacijų su tekstu:<br />
<br />
{| class="wikitable"<br />
!Operation <br />
!Symbol <br />
!Example<br />
|-<br />
|Pakartojimas<br />
|<code>*</code> <br />
|<code>"i" * 5 == "iiiii"</code><br />
|-<br />
|Sujungimas<br />
|<code>+</code> <br />
|<code>"Hello, " + "World!" == "Hello, World!"</code><br />
|}<br />
<br />
=== Pavyzdžiai ===<br />
<br />
'''Laikas.py'''<br />
<syntaxhighlight lang="python"><br />
# ši programa apskaičiuoja laiką priklausomai nuo greičio ir atstumo<br />
print("Įvesk greitį ir atstumą")<br />
greitis = float(input("Greitis: "))<br />
atstumas = float(input("Atstumas: "))<br />
laikas=(atstumas / greitis )<br />
print("Laikas:", laikas)<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''5'''<br />
Atstumas: '''10'''<br />
Laikas: 2.0<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''3.52'''<br />
Atstumas: '''45.6'''<br />
Laikas: 12.9545454545<br />
<br />
'''Area.py'''<br />
<syntaxhighlight lang="python"><br />
# This program calculates the perimeter and area of a rectangle<br />
print("Calculate information about a rectangle")<br />
length = float(input("Length: "))<br />
width = float(input("Width: "))<br />
Perimeter=(2 * length + 2 * width) <br />
print("Area:", length * width)<br />
print("Perimeter:",Perimeter)<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Calculate information about a rectangle<br />
Length: '''4'''<br />
Width: '''3'''<br />
Area: 12.0<br />
Perimeter: 14.0<br />
<br />
Calculate information about a rectangle<br />
Length: '''2.53'''<br />
Width: '''5.2'''<br />
Area: 13.156<br />
Perimeter: 15.46<br />
<br />
'''Temperature.py'''<br />
<syntaxhighlight lang="python"><br />
# This program converts Fahrenheit to Celsius<br />
fahr_temp = float(input("Fahrenheit temperature: "))<br />
celc_temp = (fahr_temp - 32.0) *( 5.0 / 9.0)<br />
print("Celsius temperature:", celc_temp)<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Fahrenheit temperature: '''32'''<br />
Celsius temperature: 0.0<br />
<br />
Fahrenheit temperature: '''-40'''<br />
Celsius temperature: -40.0<br />
<br />
Fahrenheit temperature: '''212'''<br />
Celsius temperature: 100.0<br />
<br />
Fahrenheit temperature: '''98.6'''<br />
Celsius temperature: 37.0<br />
<br />
=== Exercises ===<br />
Write a program that gets 2 string variables and 2 number variables<br />
from the user, concatenates (joins them together with no spaces) and<br />
displays the strings, then multiplies the two numbers on a new line.<br />
<br />
{{Solution|title=Solution|text=<br />
<br />
Write a program that gets 2 string variables and 2 number variables<br />
from the user, concatenates (joins them together with no spaces) and<br />
displays the strings, then multiplies the two numbers on a new line.<br />
<br />
<syntaxhighlight lang="python"> <br />
string1 = input('String 1: ')<br />
string2 = input('String 2: ')<br />
float1 = float(input('Number 1: '))<br />
float2 = float(input('Number 2: '))<br />
print(string1 + string2)<br />
print(float1 * float2)<br />
</syntaxhighlight><br />
}}<br />
<br />
{{navigation |previous=Hello, World |next=Count to 10}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Kas_%C4%8Dia_eina%3F&diff=3503Python Vadovėlis/Kas čia eina?2021-11-09T09:23:16Z<p>Modesta: </p>
<hr />
<div>=== Įvestis ir kintamieji ===<br />
Aš jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:<br />
<syntaxhighlight lang="python"><br />
print("Stop!")<br />
user_input = input(" Kas čia eina? ")<br />
print("Gali praeiti,", user_input)<br />
</syntaxhighlight><br />
<br />
Kai '''Aš''' paleidžiu programą, tai ką '''mano''' ekranas parodė:<br />
<br />
Stop!<br />
Kas čia eina? '''Josh'''<br />
Gali praeiti, Josh<br />
<br />
''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''<br />
<br />
Stop!<br />
Kas čia eina?<br />
<br />
''Tu turi įvesti savo vardą į python shell ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''<br />
<br />
Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.<br />
Kai paleidai programą (juk paleidai, tiesa?), kad tu turėjai surinkti savo vardą ir tada paspausti Enter.<br />
Programa atspausdino dalį teksto ir tavo vardą. Čia yra pavyzdys ''įvesties'.<br />
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojoįvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.<br />
<br />
Žinoma, gauti informaciją iš vartotojo pasaulio yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.<br />
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos. <br />
Šai programa, parodanti kintamųjų pavyzdžius:<br />
<br />
<syntaxhighlight lang="python"><br />
a = 123.4<br />
b23 = 'Šlamštas'<br />
vardas = "Jonas"<br />
b = 432<br />
c = a + b<br />
print("a + b is",c)<br />
print("vardas yra ",vardas)<br />
print("Rūšiuotos dalys, Po vidurnakčio ar",b23)<br />
</syntaxhighlight><br />
<br />
Štai kokia išvestis:<br />
<br />
a + b is 555.4<br />
vardas yra Jonas<br />
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas<br />
<br />
<br />
Kintamieji talpina duomenis. Viršuje aprašytoje programoje kintamieji yra <code>a</code>, <code>b23</code>, <code>vardas</code>, <code>b</code>, and <code>c</code>. Pagrindiniai du kintamųjų tipai yra ''tekstas'' ir ''skaičius''. Tekstas yra seka raidžių, skaičių ir kitų simbolių. Šiame pavyzdyje <code>b23</code> ir <code>vardas</code> yra kintamieji, kurie talpina tekstą. <code>Spam</code>, <code>Bill</code>, <code>a + b is</code>, <code>vardas yra</code>, ir <code>Rūšiuotos dalys, Po vidurnakčio ar</code> yra tiesiog tekstinės reikšmės šioje programoje. Tekstas yra apsuptas kabučių <code>"</code> arba <code>'</code>. <br />
Kitas kintamojo tipas yra skaičiai. Prisiminkite, kad kintamieji, kurie naudojami saugoti reikšmes, nenaudoja kabučių (" ir '). Jei norite naudoti realias ''reikšmes'', privalote naudoti kabutes.<br />
<br />
<syntaxhighlight lang="python"><br />
reikšmė1 == Pim<br />
reikšmė2 == "Pim"<br />
</syntaxhighlight><br />
<br />
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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>P</code>,<code>i</code> ir<code>m</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų apie tekstą ir <code>==</code>).<br />
<br />
<br />
=== Priskyrimai ===<br />
<br />
Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kurie gali būti kintamajame. Komputeris pamatys tokią eilutę <code>vardas = "Bill"</code> ir perskaitys ją kaip "Padėk tekstą <code>Bill</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> ar <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.<br />
<br />
<br />
O štai ir kitas kintamųjų naudojimo pavyzdys:<br />
<syntaxhighlight lang="python"><br />
a = 1<br />
print(a)<br />
a = a + 1<br />
print(a)<br />
a = a * 2<br />
print(a)<br />
</syntaxhighlight><br />
<br />
Ir žinoma štai tokį rezultatą gausime:<br />
<br />
1<br />
2<br />
4<br />
<br />
Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), komputeris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"<br />
<br />
Dar viena programa prieš man pabangiant šį skyrių:<br />
<syntaxhighlight lang="python"><br />
skaičius = float(input("Įvesk skaičių: "))<br />
sveikasSkaičius= int(input("Įvesk sveiką skaičių: "))<br />
tekstas = input("Įvesk tekstą: ")<br />
print("skaičius =", nuskaičius mber)<br />
print("skaičius yra", type(skaičius ))<br />
print("skaičius * 2 =", skaičius * 2)<br />
print("sveikas skaičius =", sveikasSkaičius)<br />
print("sveikas skaičius yra", type(sveikasSkaičius))<br />
print("sveikasSkaičius* 2 =", sveikasSkaičius* 2)<br />
print("tekstas=", tekstas)<br />
print("tekstas yra ", type(tekstas))<br />
print("tekstas* 2 =", tekstas* 2)<br />
<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk skaičių: '''12.34'''<br />
Įvesk sveiką skaičių: '''-3'''<br />
Įvesk sveiką tekstą: '''Labas'''<br />
skaičius = 12.34<br />
skaičius yra <class 'float'><br />
skaičius * 2 = 24.68<br />
sveikas skaičius = -3<br />
sveikas skaičius yra <class 'int'><br />
sveikasSkaičius * 2 = -6<br />
tekstas = Labas<br />
tekstas yra <class 'str'><br />
tekstas * 2 = LabasLabas<br />
<br />
<br />
Pastebėk, kad <code>skaičius</code> buvo sukurtas su <code>float(input())</code> ,<code>int(input())</code> ir gražino sveiką skaičių - reikšmę be kablelio, kai tuo tarpu <code>tekstas</code> buvo sukurtas su <code>input()</code> <br />
graž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> tipą. Jei nori, kad vartotojas įvestų sveiką skaičių, naudok <code>int(input())</code>, bet jei nori teksto - naudok <code>input()</code>.<br />
<br />
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 kambleliu) trumpiniai. Tekstinė eilutė yra <code>str</code>, trumpinys ''string'' (virvelė). Sveiki skaičiai ir slankusis kablelis gali būti naudojami matematinės funkcijoms, tekstas - ne. Atkreipk dėmesį, kai python daugina skaičių iš sveiko skaičiaus gaunamas tikėtas rezultatas, tačiau jei tekstas padauginamas iš sveiko skaičiaus - sukuriamos kelios teksto kopijos (pavyzdžiui, <code>tekstas * 2 = LabasLabas</code>)<br />
<br />
Operacijos su tekstu daro kitokius dalykus nei operacijos su skaičiaus. Taip pat, kai kurios operacijos veikia tik su skaičiaus ir duos klaidą, jei bus bandoma panaudoti tesktą. Štai keleta interaktyvių pavyzdžių:<br />
<br />
<pre><br />
>>> print("Čia" + " " + "yra" + " junginys.")<br />
Čia yra junginys.<br />
>>> print("Ha, " * 5)<br />
Ha, Ha, Ha, Ha, Ha, <br />
>>> print("Ha, " * 5 + "ha!")<br />
Ha, Ha, Ha, Ha, Ha, ha!<br />
>>> print(3 - 1)<br />
2<br />
>>> print("3" - "1")<br />
Traceback (paskutinis veiksmas):<br />
File "<stdin>", line 1, in <module><br />
TypeError: unsupported operand type(s) for -: 'str' and 'str'<br />
>>> <br />
</pre><br />
<br />
Štai sąrašas kelių operacijų su tekstu:<br />
<br />
{| class="wikitable"<br />
!Operation <br />
!Symbol <br />
!Example<br />
|-<br />
|Pakartojimas<br />
|<code>*</code> <br />
|<code>"i" * 5 == "iiiii"</code><br />
|-<br />
|Sujungimas<br />
|<code>+</code> <br />
|<code>"Hello, " + "World!" == "Hello, World!"</code><br />
|}<br />
<br />
=== Pavyzdžiai ===<br />
<br />
'''Laikas.py'''<br />
<syntaxhighlight lang="python"><br />
# ši programa apskaičiuoja laiką priklausomai nuo greičio ir atstumo<br />
print("Įvesk greitį ir atstumą")<br />
greitis = float(input("Greitis: "))<br />
atstumas = float(input("Atstumas: "))<br />
laikas=(atstumas / greitis )<br />
print("Laikas:", laikas)<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''5'''<br />
Atstumas: '''10'''<br />
Laikas: 2.0<br />
<br />
Įvesk greitį ir atstumą<br />
Greitis: '''3.52'''<br />
Atstumas: '''45.6'''<br />
Laikas: 12.9545454545<br />
<br />
'''Area.py'''<br />
<syntaxhighlight lang="python"><br />
# This program calculates the perimeter and area of a rectangle<br />
print("Calculate information about a rectangle")<br />
length = float(input("Length: "))<br />
width = float(input("Width: "))<br />
Perimeter=(2 * length + 2 * width) <br />
print("Area:", length * width)<br />
print("Perimeter:",Perimeter)<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Calculate information about a rectangle<br />
Length: '''4'''<br />
Width: '''3'''<br />
Area: 12.0<br />
Perimeter: 14.0<br />
<br />
Calculate information about a rectangle<br />
Length: '''2.53'''<br />
Width: '''5.2'''<br />
Area: 13.156<br />
Perimeter: 15.46<br />
<br />
'''Temperature.py'''<br />
<syntaxhighlight lang="python"><br />
# This program converts Fahrenheit to Celsius<br />
fahr_temp = float(input("Fahrenheit temperature: "))<br />
celc_temp = (fahr_temp - 32.0) *( 5.0 / 9.0)<br />
print("Celsius temperature:", celc_temp)<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Fahrenheit temperature: '''32'''<br />
Celsius temperature: 0.0<br />
<br />
Fahrenheit temperature: '''-40'''<br />
Celsius temperature: -40.0<br />
<br />
Fahrenheit temperature: '''212'''<br />
Celsius temperature: 100.0<br />
<br />
Fahrenheit temperature: '''98.6'''<br />
Celsius temperature: 37.0<br />
<br />
=== Exercises ===<br />
Write a program that gets 2 string variables and 2 number variables<br />
from the user, concatenates (joins them together with no spaces) and<br />
displays the strings, then multiplies the two numbers on a new line.<br />
<br />
{{Solution|title=Solution|text=<br />
<br />
Write a program that gets 2 string variables and 2 number variables<br />
from the user, concatenates (joins them together with no spaces) and<br />
displays the strings, then multiplies the two numbers on a new line.<br />
<br />
<syntaxhighlight lang="python"> <br />
string1 = input('String 1: ')<br />
string2 = input('String 2: ')<br />
float1 = float(input('Number 1: '))<br />
float2 = float(input('Number 2: '))<br />
print(string1 + string2)<br />
print(float1 * float2)<br />
</syntaxhighlight><br />
}}<br />
<br />
{{navigation |previous=Hello, World |next=Count to 10}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Kas_%C4%8Dia_eina%3F&diff=3436Python Vadovėlis/Kas čia eina?2021-10-18T14:02:31Z<p>Modesta: </p>
<hr />
<div>=== Įvestis ir kintamieji ===<br />
Aš jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:<br />
<syntaxhighlight lang="python"><br />
print("Stop!")<br />
user_input = input(" Kas čia eina? ")<br />
print("Gali praeiti,", user_input)<br />
</syntaxhighlight><br />
<br />
Kai '''Aš''' paleidžiu programą, tai ką '''mano''' ekranas parodė:<br />
<br />
Stop!<br />
Kas čia eina? '''Josh'''<br />
Gali praeiti, Josh<br />
<br />
''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''<br />
<br />
Stop!<br />
Kas čia eina?<br />
<br />
''Tu turi įvesti savo vardą į python shell ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''<br />
<br />
Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.<br />
Kai paleidai programą (juk paleidai, tiesa?), kad tu turėjai surinkti savo vardą ir tada paspausti Enter.<br />
Programa atspausdino dalį teksto ir tavo vardą. Čia yra pavyzdys ''įvesties'.<br />
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojoįvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.<br />
<br />
Žinoma, gauti informaciją iš vartotojo pasaulio yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.<br />
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos. <br />
Šai programa, parodanti kintamųjų pavyzdžius:<br />
<br />
<syntaxhighlight lang="python"><br />
a = 123.4<br />
b23 = 'Šlamštas'<br />
vardas = "Jonas"<br />
b = 432<br />
c = a + b<br />
print("a + b is",c)<br />
print("vardas yra ",vardas)<br />
print("Rūšiuotos dalys, Po vidurnakčio ar",b23)<br />
</syntaxhighlight><br />
<br />
Štai kokia išvestis:<br />
<br />
a + b is 555.4<br />
vardas yra Jonas<br />
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas<br />
<br />
<br />
Kintamieji talpina duomenis. Viršuje aprašytoje programoje kintamieji yra <code>a</code>, <code>b23</code>, <code>vardas</code>, <code>b</code>, and <code>c</code>. Pagrindiniai du kintamųjų tipai yra ''tekstas'' ir ''skaičius''. Tekstas yra seka raidžių, skaičių ir kitų simbolių. Šiame pavyzdyje <code>b23</code> ir <code>vardas</code> yra kintamieji, kurie talpina tekstą. <code>Spam</code>, <code>Bill</code>, <code>a + b is</code>, <code>vardas yra</code>, ir <code>Rūšiuotos dalys, Po vidurnakčio ar</code> yra tiesiog tekstinės reikšmės šioje programoje. Tekstas yra apsuptas kabučių <code>"</code> arba <code>'</code>. <br />
Kitas kintamojo tipas yra skaičiai. Prisiminkite, kad kintamieji, kurie naudojami saugoti reikšmes, nenaudoja kabučių (" ir '). Jei norite naudoti realias ''reikšmes'', privalote naudoti kabutes.<br />
<br />
<syntaxhighlight lang="python"><br />
reikšmė1 == Pim<br />
reikšmė2 == "Pim"<br />
</syntaxhighlight><br />
<br />
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>Pim</code>. Antrame pavyzdyje Python tikrins ar tekstas (konkrečios raidės <code>P</code>,<code>i</code> ir<code>m</code>) yra tokios pat kaip ir <code>reikšmė2</code> (skaitant toliau bus daugiau paaiškinimų apie tekstą ir <code>==</code>).<br />
<br />
<br />
=== Priskyrimai ===<br />
<br />
Gerai, dabar mes turime dėžutes, pavadintas kintamaisiais, taip pat informaciją, kurie gali būti kintamajame. Komputeris pamatys tokią eilutę <code>vardas = "Bill"</code> ir perskaitys ją kaip "Padėk tekstą <code>Bill</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> ar <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.<br />
<br />
<br />
O štai ir kitas kintamųjų naudojimo pavyzdys:<br />
<syntaxhighlight lang="python"><br />
a = 1<br />
print(a)<br />
a = a + 1<br />
print(a)<br />
a = a * 2<br />
print(a)<br />
</syntaxhighlight><br />
<br />
Ir žinoma štai tokį rezultatą gausime:<br />
<br />
1<br />
2<br />
4<br />
<br />
Net jei kintamieji yra abiejose lygybės pusėse (pavyzdžiui šlamštas = šlamštas), komputeris vis tiek perskaitys taip: "Pirmiausia surask informaciją, kuri patalpinta ir tada surask, kur ją padėti"<br />
<br />
Dar viena programa prieš man pabangiant šį skyrių:<br />
<syntaxhighlight lang="python"><br />
skaičius = float(input("Įvesk skaičių: "))<br />
sveikasSkaičius= int(input("Įvesk sveiką skaičių: "))<br />
tekstas = input("Įvesk tekstą: ")<br />
print("skaičius =", nuskaičius mber)<br />
print("skaičius yra", type(skaičius ))<br />
print("skaičius * 2 =", skaičius * 2)<br />
print("sveikas skaičius =", sveikasSkaičius)<br />
print("sveikas skaičius yra", type(sveikasSkaičius))<br />
print("sveikasSkaičius* 2 =", sveikasSkaičius* 2)<br />
print("tekstas=", tekstas)<br />
print("tekstas yra ", type(tekstas))<br />
print("tekstas* 2 =", tekstas* 2)<br />
<br />
<br />
</syntaxhighlight><br />
<br />
Rezultatas:<br />
<br />
Įvesk skaičių: '''12.34'''<br />
Įvesk sveiką skaičių: '''-3'''<br />
Įvesk sveiką tekstą: '''Labas'''<br />
skaičius = 12.34<br />
skaičius yra <class 'float'><br />
skaičius * 2 = 24.68<br />
sveikas skaičius = -3<br />
sveikas skaičius yra <class 'int'><br />
sveikasSkaičius * 2 = -6<br />
tekstas = Labas<br />
tekstas yra <class 'str'><br />
tekstas * 2 = LabasLabas<br />
<br />
Notice that <code>number</code> was created with <code>float(input())</code> ,<code>int(input())</code> returns an integer, a number with no decimal point, <br />
while <code>text</code> created with <code>input()</code> returns a string(can be writen as <code>str(input())</code>, too). When you want the user to type in a decimal use <code>float(input())</code>, if you want the user to type in an integer use <code>int(input())</code>, but if you want the user to type in a string use <code>input()</code>.<br />
<br />
The second half of the program uses the <code>type()</code> function which tells what kind a<br />
variable is. Numbers are of type <code>int</code> or <code>float</code>, which are<br />
short for ''integer'' and ''floating point'' (mostly used for decimal numbers), respectively. Text strings are of type <code>str</code>, short for ''string''. Integers and floats can be worked on by mathematical functions, strings cannot. Notice how when python<br />
multiplies a number by an integer the expected thing happens. However<br />
when a string is multiplied by an integer the result is that multiple<br />
copies of the string are produced (i.e., <code>text * 2 = HelloHello</code>).<br />
<br />
Operations with strings do different things than <br />
operations with numbers. As well, some operations only work with numbers (both integers and floating point numbers) and will give an error if a string is used. Here are some interactive mode examples<br />
to show that some more.<br />
<br />
<pre><br />
>>> print("This" + " " + "is" + " joined.")<br />
This is joined.<br />
>>> print("Ha, " * 5)<br />
Ha, Ha, Ha, Ha, Ha, <br />
>>> print("Ha, " * 5 + "ha!")<br />
Ha, Ha, Ha, Ha, Ha, ha!<br />
>>> print(3 - 1)<br />
2<br />
>>> print("3" - "1")<br />
Traceback (most recent call last):<br />
File "<stdin>", line 1, in <module><br />
TypeError: unsupported operand type(s) for -: 'str' and 'str'<br />
>>> <br />
</pre><br />
<br />
Here is the list of some string operations:<br />
<br />
{| class="wikitable"<br />
!Operation <br />
!Symbol <br />
!Example<br />
|-<br />
|Repetition <br />
|<code>*</code> <br />
|<code>"i" * 5 == "iiiii"</code><br />
|-<br />
|Concatenation <br />
|<code>+</code> <br />
|<code>"Hello, " + "World!" == "Hello, World!"</code><br />
|}<br />
<br />
=== Examples ===<br />
<br />
'''Rate_times.py'''<br />
<syntaxhighlight lang="python"><br />
# This program calculates rate and distance problems<br />
print("Input a rate and a distance")<br />
rate = float(input("Rate: "))<br />
distance = float(input("Distance: "))<br />
time=(distance/ rate)<br />
print("Time:", time)<br />
<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Input a rate and a distance<br />
Rate: '''5'''<br />
Distance: '''10'''<br />
Time: 2.0<br />
<br />
Input a rate and a distance<br />
Rate: '''3.52'''<br />
Distance: '''45.6'''<br />
Time: 12.9545454545<br />
<br />
'''Area.py'''<br />
<syntaxhighlight lang="python"><br />
# This program calculates the perimeter and area of a rectangle<br />
print("Calculate information about a rectangle")<br />
length = float(input("Length: "))<br />
width = float(input("Width: "))<br />
Perimeter=(2 * length + 2 * width) <br />
print("Area:", length * width)<br />
print("Perimeter:",Perimeter)<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Calculate information about a rectangle<br />
Length: '''4'''<br />
Width: '''3'''<br />
Area: 12.0<br />
Perimeter: 14.0<br />
<br />
Calculate information about a rectangle<br />
Length: '''2.53'''<br />
Width: '''5.2'''<br />
Area: 13.156<br />
Perimeter: 15.46<br />
<br />
'''Temperature.py'''<br />
<syntaxhighlight lang="python"><br />
# This program converts Fahrenheit to Celsius<br />
fahr_temp = float(input("Fahrenheit temperature: "))<br />
celc_temp = (fahr_temp - 32.0) *( 5.0 / 9.0)<br />
print("Celsius temperature:", celc_temp)<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Fahrenheit temperature: '''32'''<br />
Celsius temperature: 0.0<br />
<br />
Fahrenheit temperature: '''-40'''<br />
Celsius temperature: -40.0<br />
<br />
Fahrenheit temperature: '''212'''<br />
Celsius temperature: 100.0<br />
<br />
Fahrenheit temperature: '''98.6'''<br />
Celsius temperature: 37.0<br />
<br />
=== Exercises ===<br />
Write a program that gets 2 string variables and 2 number variables<br />
from the user, concatenates (joins them together with no spaces) and<br />
displays the strings, then multiplies the two numbers on a new line.<br />
<br />
{{Solution|title=Solution|text=<br />
<br />
Write a program that gets 2 string variables and 2 number variables<br />
from the user, concatenates (joins them together with no spaces) and<br />
displays the strings, then multiplies the two numbers on a new line.<br />
<br />
<syntaxhighlight lang="python"> <br />
string1 = input('String 1: ')<br />
string2 = input('String 2: ')<br />
float1 = float(input('Number 1: '))<br />
float2 = float(input('Number 2: '))<br />
print(string1 + string2)<br />
print(float1 * float2)<br />
</syntaxhighlight><br />
}}<br />
<br />
{{navigation |previous=Hello, World |next=Count to 10}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis/Kas_%C4%8Dia_eina%3F&diff=3420Python Vadovėlis/Kas čia eina?2021-10-15T10:31:14Z<p>Modesta: vertimo pradžia</p>
<hr />
<div>=== Įvestis ir kintamieji ===<br />
Aš jaučiu, kad atėjo laikas tikrai sudėtingai programai. Štai ji:<br />
<syntaxhighlight lang="python"><br />
print("Stop!")<br />
user_input = input(Kas čia eina? ")<br />
print("Gali praeiti,", user_input)<br />
</syntaxhighlight><br />
<br />
Kai '''Aš''' paleidžiu programą, tai ką '''mano''' ekranas parodė:<br />
<br />
Stop!<br />
Kas čia eina? '''Josh'''<br />
Gali praeiti, Josh<br />
<br />
''Pastaba: Jei paleisi kodą spausdamas "F5", python shell išves tik tiek:''<br />
<br />
Stop!<br />
Kas čia eina?<br />
<br />
''Tu turi įvesti savo vardą į python shell ir tada paspausti enter norėdama/s pamatyt likusį tekstą.''<br />
<br />
Žinoma, kai tu paleisi programą, tavo ekranas atrodys kitaip dėl <code>input()</code> užklausos.<br />
Kai paleidai programą (juk paleidai, tiesa?), kad tu turėjai surinkti savo vardą ir tada paspausti Enter.<br />
Programa atspausdino dalį teksto ir tavo vardą. Čia yra pavyzdys ''įvesties'.<br />
Programa pasiekia tam tikrą kodo tašką ir laukia vartotojoįvesties, kad duomenis galėtų panaudoti tolimesniuose procesuose.<br />
<br />
Žinoma, gauti informaciją iš vartotojo pasaulio yra nieko verta, jei tos informacijos nėra kur patalpinti. Ir šioje vietoje atsiranda kintamieji.<br />
Paskutinėje programojo <code>user_input</code> yra ''kintamasis''. Kintamieji yra kaip dėžes į kurias galima patalpinti tam tikras dalis informacijos. <br />
Šai programa, parodanti kintamųjų pavyzdžius:<br />
<br />
<syntaxhighlight lang="python"><br />
a = 123.4<br />
b23 = 'Šlamštas'<br />
vardas = "Jonas"<br />
b = 432<br />
c = a + b<br />
print("a + b is",c)<br />
print("vardas yra ",vardas)<br />
print("Rūšiuotos dalys, Po vidurnakčio ar",b23)<br />
</syntaxhighlight><br />
<br />
Štai kokia išvestis:<br />
<br />
a + b is 555.4<br />
vardas yra Jonas<br />
Rūšiuotos dalys, Po vidurnakčio ar Šlamštas<br />
<br />
<br />
Variables store data. The variables in the above program are <code>a</code>, <code>b23</code>, <code>first_name</code>, <code>b</code>, and <code>c</code>. The two basic types are ''strings'' and ''numbers''. Strings are a sequence of letters, numbers and other characters. In this example <code>b23</code> and <code>first_name</code> are variables that are storing strings. <code>Spam</code>, <code>Bill</code>, <code>a + b is</code>, <code>first_name is</code>, and <code>Sorted Parts, After Midnight or</code> are the strings in this program. The characters are surrounded by <code>"</code> or <code>'</code>. The other type of variables are numbers. Remember that variables are used to store a value, they do not use quotation marks (" and '). If you want to use an actual ''value'', you ''must'' use quotation marks.<br />
<br />
<syntaxhighlight lang="python"><br />
value1 == Pim<br />
value2 == "Pim"<br />
</syntaxhighlight><br />
<br />
Both look the same, but in the first one Python checks if the value stored in the variable <code>value1</code> is the same as the value stored in the ''variable'' <code>Pim</code>. In the second one, Python checks if the string (the actual letters <code>P</code>,<code>i</code>, and <code>m</code>) are the same as in <code>value2</code> (continue this tutorial for more explanation about strings and about the <code>==</code>).<br />
<br />
=== Assignment ===<br />
<br />
Okay, so we have these boxes called variables and also data that can go into the variable. The computer will see a line like <code>first_name = "Bill"</code> and it reads it as "Put the string <code>Bill</code> into the box (or variable) <code>first_name</code>". Later on it sees the statement <code>c = a + b</code> and it reads it as "put the sum of <code>a + b</code> or <code>123.4 + 432</code> which equals <code>555.4</code> into <code>c</code>". The right hand side of the statement (<code>a + b</code>) is ''evaluated'' and the result is stored in the variable on the left hand side (<code>c</code>). This is called ''assignment'', and you should not confuse the assignment equal sign (<code>=</code>) with "equality" in a mathematical sense here (that's what <code>==</code> will be used for later).<br />
<br />
Here is another example of variable usage:<br />
<syntaxhighlight lang="python"><br />
a = 1<br />
print(a)<br />
a = a + 1<br />
print(a)<br />
a = a * 2<br />
print(a)<br />
</syntaxhighlight><br />
<br />
And of course here is the output:<br />
<br />
1<br />
2<br />
4<br />
<br />
Even if the same variable appears on both sides of the equals sign (e.g., spam = spam), the computer still reads it as, "First find out the data to store and then find out where the data goes."<br />
<br />
One more program before I end this chapter:<br />
<syntaxhighlight lang="python"><br />
number = float(input("Type in a number: "))<br />
integer = int(input("Type in an integer: "))<br />
text = input("Type in a string: ")<br />
print("number =", number)<br />
print("number is a", type(number))<br />
print("number * 2 =", number * 2)<br />
print("integer =", integer)<br />
print("integer is a", type(integer))<br />
print("integer * 2 =", integer * 2)<br />
print("text =", text)<br />
print("text is a", type(text))<br />
print("text * 2 =", text * 2)<br />
<br />
<br />
<br />
<br />
</syntaxhighlight><br />
<br />
The output I got was:<br />
<br />
Type in a number: '''12.34'''<br />
Type in an integer: '''-3'''<br />
Type in a string: '''Hello'''<br />
number = 12.34<br />
number is a <class 'float'><br />
number * 2 = 24.68<br />
integer = -3<br />
integer is a <class 'int'><br />
integer * 2 = -6<br />
text = Hello<br />
text is a <class 'str'><br />
text * 2 = HelloHello<br />
<br />
Notice that <code>number</code> was created with <code>float(input())</code> ,<code>int(input())</code> returns an integer, a number with no decimal point, <br />
while <code>text</code> created with <code>input()</code> returns a string(can be writen as <code>str(input())</code>, too). When you want the user to type in a decimal use <code>float(input())</code>, if you want the user to type in an integer use <code>int(input())</code>, but if you want the user to type in a string use <code>input()</code>.<br />
<br />
The second half of the program uses the <code>type()</code> function which tells what kind a<br />
variable is. Numbers are of type <code>int</code> or <code>float</code>, which are<br />
short for ''integer'' and ''floating point'' (mostly used for decimal numbers), respectively. Text strings are of type <code>str</code>, short for ''string''. Integers and floats can be worked on by mathematical functions, strings cannot. Notice how when python<br />
multiplies a number by an integer the expected thing happens. However<br />
when a string is multiplied by an integer the result is that multiple<br />
copies of the string are produced (i.e., <code>text * 2 = HelloHello</code>).<br />
<br />
Operations with strings do different things than <br />
operations with numbers. As well, some operations only work with numbers (both integers and floating point numbers) and will give an error if a string is used. Here are some interactive mode examples<br />
to show that some more.<br />
<br />
<pre><br />
>>> print("This" + " " + "is" + " joined.")<br />
This is joined.<br />
>>> print("Ha, " * 5)<br />
Ha, Ha, Ha, Ha, Ha, <br />
>>> print("Ha, " * 5 + "ha!")<br />
Ha, Ha, Ha, Ha, Ha, ha!<br />
>>> print(3 - 1)<br />
2<br />
>>> print("3" - "1")<br />
Traceback (most recent call last):<br />
File "<stdin>", line 1, in <module><br />
TypeError: unsupported operand type(s) for -: 'str' and 'str'<br />
>>> <br />
</pre><br />
<br />
Here is the list of some string operations:<br />
<br />
{| class="wikitable"<br />
!Operation <br />
!Symbol <br />
!Example<br />
|-<br />
|Repetition <br />
|<code>*</code> <br />
|<code>"i" * 5 == "iiiii"</code><br />
|-<br />
|Concatenation <br />
|<code>+</code> <br />
|<code>"Hello, " + "World!" == "Hello, World!"</code><br />
|}<br />
<br />
=== Examples ===<br />
<br />
'''Rate_times.py'''<br />
<syntaxhighlight lang="python"><br />
# This program calculates rate and distance problems<br />
print("Input a rate and a distance")<br />
rate = float(input("Rate: "))<br />
distance = float(input("Distance: "))<br />
time=(distance/ rate)<br />
print("Time:", time)<br />
<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Input a rate and a distance<br />
Rate: '''5'''<br />
Distance: '''10'''<br />
Time: 2.0<br />
<br />
Input a rate and a distance<br />
Rate: '''3.52'''<br />
Distance: '''45.6'''<br />
Time: 12.9545454545<br />
<br />
'''Area.py'''<br />
<syntaxhighlight lang="python"><br />
# This program calculates the perimeter and area of a rectangle<br />
print("Calculate information about a rectangle")<br />
length = float(input("Length: "))<br />
width = float(input("Width: "))<br />
Perimeter=(2 * length + 2 * width) <br />
print("Area:", length * width)<br />
print("Perimeter:",Perimeter)<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Calculate information about a rectangle<br />
Length: '''4'''<br />
Width: '''3'''<br />
Area: 12.0<br />
Perimeter: 14.0<br />
<br />
Calculate information about a rectangle<br />
Length: '''2.53'''<br />
Width: '''5.2'''<br />
Area: 13.156<br />
Perimeter: 15.46<br />
<br />
'''Temperature.py'''<br />
<syntaxhighlight lang="python"><br />
# This program converts Fahrenheit to Celsius<br />
fahr_temp = float(input("Fahrenheit temperature: "))<br />
celc_temp = (fahr_temp - 32.0) *( 5.0 / 9.0)<br />
print("Celsius temperature:", celc_temp)<br />
</syntaxhighlight><br />
<br />
Sample runs:<br />
<br />
Fahrenheit temperature: '''32'''<br />
Celsius temperature: 0.0<br />
<br />
Fahrenheit temperature: '''-40'''<br />
Celsius temperature: -40.0<br />
<br />
Fahrenheit temperature: '''212'''<br />
Celsius temperature: 100.0<br />
<br />
Fahrenheit temperature: '''98.6'''<br />
Celsius temperature: 37.0<br />
<br />
=== Exercises ===<br />
Write a program that gets 2 string variables and 2 number variables<br />
from the user, concatenates (joins them together with no spaces) and<br />
displays the strings, then multiplies the two numbers on a new line.<br />
<br />
{{Solution|title=Solution|text=<br />
<br />
Write a program that gets 2 string variables and 2 number variables<br />
from the user, concatenates (joins them together with no spaces) and<br />
displays the strings, then multiplies the two numbers on a new line.<br />
<br />
<syntaxhighlight lang="python"> <br />
string1 = input('String 1: ')<br />
string2 = input('String 2: ')<br />
float1 = float(input('Number 1: '))<br />
float2 = float(input('Number 2: '))<br />
print(string1 + string2)<br />
print(float1 * float2)<br />
</syntaxhighlight><br />
}}<br />
<br />
{{navigation |previous=Hello, World |next=Count to 10}}</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis&diff=3419Python Vadovėlis2021-10-15T10:13:50Z<p>Modesta: </p>
<hr />
<div>Tai - standartinės Python programavimo kalbos vadovėlis, išverstas iš [https://en.wikibooks.org/wiki/Non-Programmer%27s_Tutorial_for_Python_3 Non programmer's Tutorial for Python 3].<br />
<br />
Šis vadovėlis yra atvirojo kodo, [https://www.gnu.org/licenses/gpl-3.0.html GPL v3] licencija.<br />
<br />
==Contents==<br />
{{print version}}<br />
{{PDF version}}<br />
;[[Vadovėlis/Authors]] <br />
: Contributors to this book<br />
;[[Vadovėlis/Front matter]]<br />
: Initial remarks<br />
;[[Vadovėlis/Intro]]<br />
: Installing and using Python&nbsp;&ndash; where to get help<br />
;[[Vadovėlis/Hello, World]] [Rokas]<br />
: The famous first program&nbsp;&ndash; screen output&nbsp;&ndash; variables&nbsp;&ndash; numbers and calculations<br />
;[[Vadovėlis/Who Goes There?|Vadovėlis/Who Goes There? [Modesta]]]<br />
: Interactive input&nbsp;&ndash; strings<br />
;[[Vadovėlis/Count to 10]] [Rokas]<br />
: <tt>while</tt> loops<br />
;[[Vadovėlis/Decisions|Vadovėlis/Decisions [Monika]]]<br />
:<tt>if</tt> statements<br />
;[[Vadovėlis/Debugging|Vadovėlis/Debugging [Monika]]]<br />
:Finding out what goes wrong<br />
;[[Vadovėlis/Defining Functions]] [Rokas]<br />
: Structuring programs with the use of functions<br />
;[[Vadovėlis/Advanced Functions Example]]<br />
: (Almost) mind-blowing example of how programmers can think<br />
;[[Vadovėlis/Lists|Vadovėlis/Lists [Artūras]]]<br />
:Variables containing more than one value<br />
;[[Vadovėlis/For Loops|Vadovėlis/For Loops [Artūras]]]<br />
:A second kind of loop<br />
;[[Vadovėlis/Boolean Expressions|Vadovėlis/Boolean Expressions [Laura]]]<br />
:Computer logic&nbsp;&ndash; <tt>True</tt> and <tt>False</tt>&nbsp;&ndash; <tt>and</tt> and <tt>or</tt>&nbsp;&ndash; <tt>not</tt><br />
;[[Vadovėlis/Dictionaries|Vadovėlis/Dictionaries [zivile]]]<br />
:Variables containing key/value pairs<br />
;[[Vadovėlis/Using Modules |Vadovėlis/Using Modules [zivile]]]<br />
:Extensions to the standard set of functionality<br />
;[[Vadovėlis/More on Lists|Vadovėlis/More on Lists [Laura]]]<br />
:Using elements or parts of lists<br />
;[[Vadovėlis/Revenge of the Strings]]<br />
:More advanced text manipulations<br />
;[[Vadovėlis/File IO]]<br />
:Reading from files and writing to files<br />
;[[Vadovėlis/Dealing with the imperfect]]<br />
:How to handle errors<br />
;[[Vadovėlis/Recursion]]<br />
:Recursive Functions<br />
;[[Vadovėlis/Intro to Object Oriented Programming in Python 3]]<br />
:Basics of OOP (Object Oriented Programming)<br />
;[[Vadovėlis/Intro to Imported Libraries and other Functions]]<br />
:Basic functions from various libraries.<br />
;[[Vadovėlis/The End]]<br />
:How to go further<br />
;[[Vadovėlis/FAQ]]<br />
:Some frequently asked questions<br />
;[[Vadovėlis/Terminai]]<br />
:Terminų žodynas<br />
<br />
{{Alphabetical|N}}<br />
{{status|100%}}<br />
__NOTOC__ __NOEDITSECTION__</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis&diff=3222Python Vadovėlis2021-10-06T08:03:45Z<p>Modesta: </p>
<hr />
<div>Tai - standartinės Python programavimo kalbos vadovėlis, išverstas iš [https://en.wikibooks.org/wiki/Non-Programmer%27s_Tutorial_for_Python_3 Non programmer's Tutorial for Python 3].<br />
<br />
Šis vadovėlis yra atvirojo kodo, [https://www.gnu.org/licenses/gpl-3.0.html GPL v3] licencija.<br />
<br />
==Contents==<br />
{{print version}}<br />
{{PDF version}}<br />
;[[Vadovėlis/Authors]] <br />
: Contributors to this book<br />
;[[Vadovėlis/Front matter]]<br />
: Initial remarks<br />
;[[Vadovėlis/Intro]]<br />
: Installing and using Python&nbsp;&ndash; where to get help<br />
;[[Vadovėlis/Hello, World]]<br />
: The famous first program&nbsp;&ndash; screen output&nbsp;&ndash; variables&nbsp;&ndash; numbers and calculations<br />
;[[Vadovėlis/Who Goes There?]]<br />
: Interactive input&nbsp;&ndash; strings<br />
;[[Vadovėlis/Count to 10 ]]<br />
: <tt>while</tt> loops<br />
;[[Vadovėlis/Decisions|Vadovėlis/Decisions [Monika]]]<br />
:<tt>if</tt> statements<br />
;[[Vadovėlis/Debugging|Vadovėlis/Debugging [Monika]]]<br />
:Finding out what goes wrong<br />
;[[Vadovėlis/Defining Functions]]<br />
: Structuring programs with the use of functions<br />
;[[Vadovėlis/Advanced Functions Example]]<br />
: (Almost) mind-blowing example of how programmers can think<br />
;[[Vadovėlis/Lists|Vadovėlis/Lists [Artūras]]]<br />
:Variables containing more than one value<br />
;[[Vadovėlis/For Loops|Vadovėlis/For Loops [Artūras]]]<br />
:A second kind of loop<br />
;[[Vadovėlis/Boolean Expressions|Vadovėlis/Boolean Expressions [Laura]]]<br />
:Computer logic&nbsp;&ndash; <tt>True</tt> and <tt>False</tt>&nbsp;&ndash; <tt>and</tt> and <tt>or</tt>&nbsp;&ndash; <tt>not</tt><br />
;[[Vadovėlis/Dictionaries|Vadovėlis/Dictionaries [zivile]]]<br />
:Variables containing key/value pairs<br />
;[[Vadovėlis/Using Modules |Vadovėlis/Using Modules [zivile]]]<br />
:Extensions to the standard set of functionality<br />
;[[Vadovėlis/More on Lists|Vadovėlis/More on Lists [Laura]]]<br />
:Using elements or parts of lists<br />
;[[Vadovėlis/Revenge of the Strings]]<br />
:More advanced text manipulations<br />
;[[Vadovėlis/File IO]]<br />
:Reading from files and writing to files<br />
;[[Vadovėlis/Dealing with the imperfect]]<br />
:How to handle errors<br />
;[[Vadovėlis/Recursion]]<br />
:Recursive Functions<br />
;[[Vadovėlis/Intro to Object Oriented Programming in Python 3]]<br />
:Basics of OOP (Object Oriented Programming)<br />
;[[Vadovėlis/Intro to Imported Libraries and other Functions]]<br />
:Basic functions from various libraries.<br />
;[[Vadovėlis/The End]]<br />
:How to go further<br />
;[[Vadovėlis/FAQ]]<br />
:Some frequently asked questions<br />
;[[Vadovėlis/Terminai]]<br />
:Terminų žodynas<br />
<br />
{{Alphabetical|N}}<br />
{{status|100%}}<br />
__NOTOC__ __NOEDITSECTION__</div>Modestahttps://wiki.angis.net/index.php?title=Python_Vadov%C4%97lis&diff=3221Python Vadovėlis2021-10-06T08:02:43Z<p>Modesta: </p>
<hr />
<div>Tai - standartinės Python programavimo kalbos vadovėlis, išverstas iš [https://en.wikibooks.org/wiki/Non-Programmer%27s_Tutorial_for_Python_3 Non programmer's Tutorial for Python 3].<br />
<br />
Šis vadovėlis yra atvirojo kodo, [https://www.gnu.org/licenses/gpl-3.0.html GPL v3] licencija.<br />
<br />
==Contents==<br />
{{print version}}<br />
{{PDF version}}<br />
;[[Vadovėlis/Authors]] <br />
: Contributors to this book<br />
;[[Vadovėlis/Front matter]]<br />
: Initial remarks<br />
;[[Vadovėlis/Intro]]<br />
: Installing and using Python&nbsp;&ndash; where to get help<br />
;[[Vadovėlis/Hello, World]]<br />
: The famous first program&nbsp;&ndash; screen output&nbsp;&ndash; variables&nbsp;&ndash; numbers and calculations<br />
;[[Vadovėlis/Who Goes There?]]<br />
: Interactive input&nbsp;&ndash; strings<br />
;[[Vadovėlis/Count to 10 [Modesta]]]<br />
: <tt>while</tt> loops<br />
;[[Vadovėlis/Decisions|Vadovėlis/Decisions [Monika]]]<br />
:<tt>if</tt> statements<br />
;[[Vadovėlis/Debugging|Vadovėlis/Debugging [Monika]]]<br />
:Finding out what goes wrong<br />
;[[Vadovėlis/Defining Functions]]<br />
: Structuring programs with the use of functions<br />
;[[Vadovėlis/Advanced Functions Example]]<br />
: (Almost) mind-blowing example of how programmers can think<br />
;[[Vadovėlis/Lists|Vadovėlis/Lists [Artūras]]]<br />
:Variables containing more than one value<br />
;[[Vadovėlis/For Loops|Vadovėlis/For Loops [Artūras]]]<br />
:A second kind of loop<br />
;[[Vadovėlis/Boolean Expressions|Vadovėlis/Boolean Expressions [Laura]]]<br />
:Computer logic&nbsp;&ndash; <tt>True</tt> and <tt>False</tt>&nbsp;&ndash; <tt>and</tt> and <tt>or</tt>&nbsp;&ndash; <tt>not</tt><br />
;[[Vadovėlis/Dictionaries|Vadovėlis/Dictionaries [zivile]]]<br />
:Variables containing key/value pairs<br />
;[[Vadovėlis/Using Modules |Vadovėlis/Using Modules [zivile]]]<br />
:Extensions to the standard set of functionality<br />
;[[Vadovėlis/More on Lists|Vadovėlis/More on Lists [Laura]]]<br />
:Using elements or parts of lists<br />
;[[Vadovėlis/Revenge of the Strings]]<br />
:More advanced text manipulations<br />
;[[Vadovėlis/File IO]]<br />
:Reading from files and writing to files<br />
;[[Vadovėlis/Dealing with the imperfect]]<br />
:How to handle errors<br />
;[[Vadovėlis/Recursion]]<br />
:Recursive Functions<br />
;[[Vadovėlis/Intro to Object Oriented Programming in Python 3]]<br />
:Basics of OOP (Object Oriented Programming)<br />
;[[Vadovėlis/Intro to Imported Libraries and other Functions]]<br />
:Basic functions from various libraries.<br />
;[[Vadovėlis/The End]]<br />
:How to go further<br />
;[[Vadovėlis/FAQ]]<br />
:Some frequently asked questions<br />
;[[Vadovėlis/Terminai]]<br />
:Terminų žodynas<br />
<br />
{{Alphabetical|N}}<br />
{{status|100%}}<br />
__NOTOC__ __NOEDITSECTION__</div>Modesta