https://wiki.angis.net/api.php?action=feedcontributions&feedformat=atom&user=Eimutiswiki.angis.net - Naudotojo indėlis [lt]2026-05-03T09:13:04ZNaudotojo indėlisMediaWiki 1.35.0https://wiki.angis.net/index.php?title=Ap/Py/VBE_su_Python&diff=4463Ap/Py/VBE su Python2023-04-24T05:59:29Z<p>Eimutis: </p>
<hr />
<div>Pasibaigus '''VBE2022 IT''' egzaminui, aptarkime ar pavyko panaudoti konsultacijų metu gautas žinias. Šių metų užduotys pasižymėjo, jog nebuvo reikalaujama rašyti rikiavimo funkcijos, todėl laimėjo tie mokiniai, kurie lankė mūsų FB grupę '''IT VBE konsultacijos''' (LInMA) 🙂 kadangi rikiuoti reikėjo abiejose užduotyse. Taip pat užduočių autoriai mėgsta grupavimą pagal vardus antroje užduotyje, kas buvo detaliai išnagrinėta konsultacijose (garantuotas indekso radimas su reikšme pabaigoje).<br />
<br />
Užduotis U1 buvo gana paprasta, buvo duotas konkretus konkurso dalyvių skaičius, todėl masyvo dydis buvo fiksuotas. Spausdinant rezultatus reikėjo atkreipti dėmesį, jog pateikiami ne visi dalyviai, o tik tie, kurie surinko daugiausiai taškų. Galima netgi naudoti supaprastintą ciklo variantą for, kuris vadinamas '''foreach'''.<br />
Teko pasikrapštyti, kad išpildyti visus U2 užduoties niuansus 🙂 Užduotis buvo kaip ir nesudėtinga - sukuriamas pratimų masyvas, kurio raktas yra pratimo vardas. Kabliukas buvo tame, kad kai kuriomis dienomis buvo kartojamas tas pats pratimas. Todėl pratimų elemento reikšmę sudarė: skaitliukai dienos dalims ir minutėms bei dienų masyvas, kurio elementas yra '''true''', kai i-ąją dieną atliekamas pratimas. Tada skirtingų dienų skaičius bus paprasta požymių suma.<br />
<br />
U1 Python sprendimas https://onlinegdb.com/VmRv0FrFH<br><br />
U2 Python sprendimas https://onlinegdb.com/TredllMTV<br><br />
<br />
Visos eilės ankstesnių metų VBE sprendimai pateikiami [https://ktuedu-my.sharepoint.com/:b:/g/personal/eimkarc_ktu_lt/EXwwBLx-mtFMsHx4JB41pMoBpQ2HtdggNq8HexrgcrTJfg?e=Hy9MQu čia].<br />
<br />
Palyginimui galite pasižiūrėti '''sprendimus su C++''' [https://wiki.angis.net/w/Ap/Cpp/VBE_treniruot%C4%97s]<br><br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/VBE_su_Python&diff=4462Ap/Py/VBE su Python2023-04-24T05:58:58Z<p>Eimutis: </p>
<hr />
<div>Pasibaigus '''VBE2022 IT''' egzaminui, aptarkime ar pavyko panaudoti konsultacijų metu gautas žinias. Šių metų užduotys pasižymėjo, jog nebuvo reikalaujama rašyti rikiavimo funkcijos, todėl laimėjo tie mokiniai, kurie lankė mūsų FB grupę '''IT VBE konsultacijos''' (LInMA) 🙂 kadangi rikiuoti reikėjo abiejose užduotyse. Taip pat užduočių autoriai mėgsta grupavimą pagal vardus antroje užduotyje, kas buvo detaliai išnagrinėta konsultacijose (garantuotas indekso radimas su reikšme pabaigoje).<br />
<br />
Užduotis U1 buvo gana paprasta, buvo duotas konkretus konkurso dalyvių skaičius, todėl masyvo dydis buvo fiksuotas. Spausdinant rezultatus reikėjo atkreipti dėmesį, jog pateikiami ne visi dalyviai, o tik tie, kurie surinko daugiausiai taškų. Galima netgi naudoti supaprastintą ciklo variantą for, kuris vadinamas '''foreach'''.<br />
Teko pasikrapštyti, kad išpildyti visus U2 užduoties niuansus 🙂 Užduotis buvo kaip ir nesudėtinga - sukuriamas pratimų masyvas, kurio raktas yra pratimo vardas. Kabliukas buvo tame, kad kai kuriomis dienomis buvo kartojamas tas pats pratimas. Todėl pratimų elemento reikšmę sudarė: skaitliukai dienos dalims ir minutėms bei dienų masyvas, kurio elementas yra '''true''', kai i-ąją dieną atliekamas pratimas. Tada skirtingų dienų skaičius bus paprasta požymių suma.<br />
<br />
U1 Python sprendimas https://onlinegdb.com/VmRv0FrFH<br><br />
U2 Python sprendimas https://onlinegdb.com/TredllMTV<br><br />
<br />
Visos eilės ankstesnių metų VBE sprendimai pateikiami [https://ktuedu-my.sharepoint.com/:b:/g/personal/eimkarc_ktu_lt/EXwwBLx-mtFMsHx4JB41pMoBpQ2HtdggNq8HexrgcrTJfg?e=Hy9MQu čia].<br />
<br />
Palyginimui galite pasižiūrėti sprendimus su C++ [https://wiki.angis.net/w/Ap/Cpp/VBE_treniruot%C4%97s]<br><br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Cpp/VBE_treniruot%C4%97s&diff=4461Ap/Cpp/VBE treniruotės2023-04-24T05:46:18Z<p>Eimutis: </p>
<hr />
<div>Aptariamos treniruotės, skirtos IT VBE egzamino programavimo dalies pasiruošimui. Naudojamos tik įprastinės C++ konstrukcijos, aprašytos vadovėlyje ''„Šiuolaikiškas žvilgsnis į programavimą C++, kursas 11–12 klasėms“'', nenaudojama STL biblioteka. Tačiau medžiagoje atsisakoma kai kurių perteklinių elementų bei pateikiami patogesni algoritmai, kas leidžia gauti racionalius sprendimus per trumpesnį laiką.<br />
<br />
=== Įžanga ===<br />
Programavimo mokymąsi galima palyginti su treniruotėmis, kai pradedama nuo paprastų uždavinukų ir einama link sudėtingesnių. Egzamino užduotys nėra labai sudėtingos, bet turi tam tikrą specifiką, kuriai reikia geriau pasiruošti. Siekiant geresnių rezultatų, peržvelgsime jau įvykusių egazaminų užduotis ir susidėliosime savo sprendimo schemą. Analizuojant užduotis galima pastebėti, kad šiemet jau dešimtas sezonas, kai programavimo uždaviniai pateikiami tuo pačiu šablonu 🙂. Dar 2012 metais formatas buvo kitas, o nuo 2013 metų – programavimo užduočių šablonas nesikeičia. Todėl tikslinga taikyti galimai aiškesnę sprendimo schemą, kurią toliau aptarsime ir išbandysime spręsdami konkrečias VBE užduotis. Pateiktų programų tekstų rinkti klaviatūra iš naujo nereikia, jums pateikiami visi C++ tekstai aplinkoje '''https://onlineGDB.com''', kurie paruošti vykdymui, pakanka paspausti mygtuką '''Run'''. Norėdami eksperimentuoti ir keisti programą, spauskite mygtuką '''Fork this''' arba persikelkite duomenis į savo naudojamą programavimo aplinką. VBE atveju bus galima naudoti tik '''Code::Blocks''', todėl pasitreniruokite su šia aplinka, kad įgautumėte reikalingų įgūdžių. <br />
<br />
=== Rekomenduojama sprendimo schema ===<br />
Apžvelgus visas VBE užduotis C++ naudojimo laikotarpiu, aiškiai matyti tokia sprendimo schema:<br />
* aprašyti duomenų struktūras ir jų saugyklas, <br />
* skaityti duomenis, <br />
* pagal juos skaičiuoti ir spausdinti rezultatus. <br />
<br />
Duomenys visada pateikiami viename faile, paprastai yra perteklinių duomenų (skaitikliai), nurodančių toliau pateikiamų atskirų elementų (duomenų) kiekį. Todėl ruošiantis egzaminui tikslinga laikytis šablono, sutrumpintai vadinamo VBE_DRCP (Data_Read_Calculate_Print), kurį paaiškinsime paprastos užduoties pavyzdžiu. <br />
<br />
DUOTAS konkurse dalyvaujančių mokinių sąrašas, kuriame nurodytas vardas, klasės kodas ir surinktų taškų kiekis (0–100), mokinių skaičius n<=90. <br />
<syntaxhighlight lang="C++"><br />
6 <br />
Simonas 12a 66 <br />
Martina 10b 100 <br />
Jonas 11c 75 <br />
Marius 11c 68 <br />
Stepas 12a 77 <br />
Darius 12c 68 <br />
</syntaxhighlight><br />
RASKITE: kiek klasių dalyvavo konkurse, kiek buvo klasės mokinių bei kiek jie surinko taškų, klases surikiuokite taškų mažėjimo tvarka bei pagal klasės kodą. <br />
<syntaxhighlight lang="C++"><br />
klasiu_sk= 4 <br />
11c 2 143 <br />
12a 2 143 <br />
10b 1 100 <br />
12c 1 68 <br />
</syntaxhighlight><br />
<br />
=== Pradinai žingsniai: duomenų struktūros ir skaitymo funkcija === <br />
1. Perkelkite pradinių duomenų pavyzdžius į programos komentarų dalį, o po to į failą. Duomenys, esantys prieš akis programos tekste, padeda rašyti skaitymo funkciją! <br />
<br />
2. Parašykite main() funkciją, kurioje nurodykite srautų stdin ir stdout priskyrimą failams. <br />
freopen ("U1.txt","r",stdin); <br />
freopen ("U1rez.txt","w",stdout); // pradžioje paslėpkite <br />
3. Apibrėžkite struktūrą Mokinys ir rezervuokite vietą mokinių sąrašui. Naudokite vienaskaitą struktūrai ir daugiskaitą sąrašui. Rezervuokite tokio dydžio masyvą kaip nurodyta užduotyje. Masyvas ir mokinių skaitliukas rašomas globalių kintamųjų srityje. <br />
<syntaxhighlight lang="C++"><br />
struct Mokinys { <br />
string vardas; <br />
string klase; // klasės kodas <br />
int taskai; <br />
}; <br />
Mokinys mokiniai[90]; // numatytosios reikšmės yra nuliai <br />
int msk = 0; // mokinių skaičius sąraše <br />
</syntaxhighlight><br />
4. Parašykite skaitymo funkciją, kurioje įrašykite įvestų duomenų spausdinimą (nors to užduotis nereikalauja, bet tai pravers programos derinimo metu). <br />
<br />
5. Išbandykite skaitymo funkcijos veikimą: pažymėkite funkciją freopen() kaip komentarą (dėl stdout – tada lieka konsolės režimas), o rezultatus stebėkite terminalo lange. <br />
<br />
6. Jei duomenys perskaityti teisingai (sutampa su tais, kurie buvo pradinių duomenų faile) – tai esate teisingame kelyje, jau tam tikrą balų skaičių gausite 😊. <br />
<br />
Naujausias pradinės programos variantas pateikiamas čia - [https://onlinegdb.com/g9oUvwQXU] <br />
<br />
=== Tolimesnė eiga: skaičiavimai ir rezultatai ===<br />
Toliau tęsiame programos kūrimą – aprašysime rezultatų struktūrą ir masyvą pradinių duomenų globalioje srityje ir sukursime skaičiavimo funkciją. Tai yra esminė dalis, bet ir čia galima įžvelgti bendrų visoms užduotims požymių. Dažnai reikalaujama pradinius duomenis sugrupuoti pagal tam tikrą požymį. Nors C++ tam yra skirtos specialios priemonės (map struktūros), bet tai į mokyklos programą neįeina ir egzaminui, deja, tai nenaudotina. Todėl siūloma rašyti indekso paieškos funkciją, kuri rastų reikiamą vietą. Pradžioje ieškoma reikšmė įrašoma sąrašo pabaigoje – todėl '''ji visada bus randama'''. Jei ieškodami pasiekėme pabaigą, tai reiškia kad sąrašą reikia papildyti. Kadangi ieškoma reikšmė jau įrašyta, o struktūrų masyvo pradinės reikšmės yra nulinės, tai pakanka tik padidinti faktinių elementų skaitiklio reikšmę. <br />
<syntaxhighlight lang="C++"><br />
struct Klase {<br />
string vardas; // klasės kodas<br />
int mok_sk; // klasės mokinių skaičius<br />
int taskai; // klasės mokinių taškų suma<br />
};<br />
Klase klases[30]; // pagal nutylėjimą reikšmės nulinės<br />
int ksk = 0; // klasių sąraše kiekis<br />
<br />
//==================================================<br />
// taikysime paiešką su apsaugine reikšme pabaigoje !<br />
// randa klasės indeksą pagal paieškos kodą<br />
// o jei nėra, tai papildo klasių masyvą<br />
int rastiKlase(string paieska) {<br />
klases[ksk].vardas = paieska; // visada rasime :)<br />
int i = 0;<br />
while (klases[i].vardas != paieska) i++;<br />
if(i == ksk) ksk++; // jei nebuvo - padidiname<br />
return i;<br />
}<br />
//------------------------------------------------<br />
void skaiciuoti(){ // grupuojame pagal klases<br />
for (int i = 0; i < msk; i++){<br />
Mokinys m = mokiniai[i];<br />
int ki = rastiKlase(m.klase);<br />
klases[ki].mok_sk++;<br />
klases[ki].taskai += m.taskai;<br />
}<br />
}<br />
</syntaxhighlight><br />
Spausdinimo funkcijoje tikslinga suformuoti tarpinį vienos raidės kintamąjį, kad atskirų struktūros elementų užrašai taptų lakoniškesni nei su indeksu. <br />
<br />
Toliau deriname parašytas skaičiavimo funkcijas, stebime gaunamus rezultatus. <br />
<br />
=== Baigiamoji dalis ===<br />
Atskirai parašome rikiavimo kriterijui reikalingą funkciją '''arTvarka()'''. Tada ją galime išbandyti su standartine funkcija sort(). Tokiu būdu užduotis jau įvykdyta. Bet jei už rikiavimo funkciją skiriami balai, tai turėdami laiko galite ją parašyti, panaudodami tą pačią funkciją '''arTvarka()'''. <br />
<br />
NEPAMIRŠKITE: pašalinkite komentarą ties funkcija freopen(..., stdout), kad rezultatai pakliūtų į failą. Panaikinkite tarpinių rezultatų išvedimą skaitymo funkcijoje. <br />
<br />
Aktyvus pilnos programos variantas yra pateikiamas [https://onlinegdb.com/dLBHyBIa- čia]<br />
<br />
Kad programa būtų labiau individuali, parašykite savo nuožiūra komentarų, kuriuose nereikia tuščiažodžiauti. Galite iš anksto pasiruošti sinonimų funkcijų vardams: <br />
<br />
* skaityti() => formuoti(), skaityti_duomenis(), read(), ... <br />
* skaiciuoti() => formuoti(), grupuoti(), calculate(), ... <br />
* spausdinti() => isvesti(), rezultatai(), print(), write(), ... <br />
<br />
Aišku, kad kiekvienais metais VBE metu būna tam tikrų „kabliukų“, todėl reikia atidžiai perskaityti užduočių sąlygas. Pradžioje pasirašykite vadinamuosius griaučius: duomenų struktūras, masyvus, main() ir kitas funkcijas, o tada spręskite ir tikrinkite savo sprendimus.<br />
<br />
=== Siūlomų sprendimų apibendrinimas === <br />
A1. Darbą su failais geriausia organizuoti panaudojant funkciją '''reopen()'''. Tuomet '''cin''' visada bus įvedimo srautas, o '''cout''' – išvedimo. Pradžioje '''cout''' priskyrimą išjungiame naudodami //, nes žiūrėti rezultatus yra patogiau konsolės lange. Kadangi standartiniai srautai uždaromi automatiškai, todėl nereikia '''close()'''. Taip pat nereikia #include <fstream>. Kadangi '''main()''' funkcijos pradžia su freopen() tampa visada vienoda, tai į tą vietą ir keliame failų vardus, jų atskirai su raktažodiu const neaprašome.<br />
<br />
A2. Programos pradinius duomenis ir rezultatus '''tikslinga formuoti kaip globalius''', tai leidžia nekartoti jų funkcijų antraštėse. Tokiu būdu programa tampa aiškesnė! Struktūrų masyvai aprašomi kartu su elementų skaitikliais, kurie imituoja vector<T> tipą. <br />
<br />
A3. '''Funkcijų antraščių rašyti nereikia''', pakanka metodą '''main()''' nukelti į programos pabaigą. Kadangi duomenys ir rezultatai yra globalūs, daugelis funkcijų lieka be parametrų. Jos skirtos algoritmui suskaidyti į aiškiai apibėžtas dalis. Su parametrais rašomos rikiavimo ir paieškos funkcijos, kadangi tai yra universalios, nepriklausančios nuo konteksto funkcijos. <br />
<br />
A4. '''Rikiavimo kriterijų''' visada tikslinga aprašyti kaip atskirą loginę funkciją. Tada jūsų rašomas rikiavimo algoritmas bus aiškesnis, be to galėsite patikrinimui naudoti standartinę funkciją '''sort()'''. <br />
<br />
A5. Užduotyje minima sąvoka „Prasmingai pavadinti kintamieji“ nereiškia kad reikia rašyti ilgus sudurtinius vardus – tai gali apsunkinti programos teksto skaitymą.<br />
<br />
=== Konkrečių VBE 2022-2013 užduočių sprendimai ===<br />
<br />
Jums pateikiami ketverių pastarųjų, 2016 bei 2013 metų užduočių sprendimai. Treniruotės metu patartina susipažinti su oficialiomis užduotimis, kadangi jų formuluotės pateikiamos naudojant tą patį šabloną. Visada būna dvi užduotys, viena lengvesnė, kita sudėtingesnė. Suprantama kad egzamino metu veikia stresas, nepavyksta iš karto rasti gero kelio, todėl ir siūloma mūsų VBE pritaikyta schema, leidžianti lengviau išspręsti užduotis. O mokytis geriau ne pagal egzamino metu gautus sprendimus, o pagal ramiai apibendrintus. <br />
<br />
Visose programose duomenys yra pateikti programos priekyje, kas leidžia juos pastoviai stebėti ir geriau suprasti sąlygą. Perkėlimas į failą kopijavimo būdu yra greitas. Dar siūlome prasmingas skaičių grupes išryškinti skirtingų tarpų skaičiumi, kadangi skaičių įvedimui tas netrukdo, o uždavinys tampa aiškesnis. <br />
<br />
'''2022 metų''' užduotys yra [https://www.nsa.smm.lt/wp-content/uploads/2022/06/IT_2022_pagr.pdf čia]. U1 sprendimas yra [https://onlinegdb.com/gA8kKvUUz čia]. U2 sprendimas yra [https://onlinegdb.com/SiZ9AFiZb čia].<br><br />
2022 metų užduotys pasižymėjo, jog nebuvo reikalaujama rašyti rikiavimo funkcijos, todėl laimėjo tie mokiniai, kurie lankė mūsų FB grupę IT VBE konsultacijos 🙂 kadangi rikiuoti reikėjo abiejose užduotyse ir buvo galima naudoti standartinę '''sort()''' funkciją. Taip pat užduočių autoriai mėgsta grupavimą pagal vardus antroje užduotyje, kas buvo detaliai išnagrinėta konsultacijose (garantuotas indekso radimas su reikšme pabaigoje).<br><br />
U1 – ''Konkursas''. Tai gana paprasta užduotis, buvo duotas konkretus konkurso dalyvių skaičius, todėl eilučių skaičius (masyvo dydis) buvo fiksuotas. Gal neįprasta buvo tai, jog pradinis skaičius rodė skaičiukų kiekį kitose eilutėse. Spausdinant rezultatus reikėjo atkreipti dėmesį, jog pateikiami ne visi dalyviai, o tik tie, kurie surinko daugiausiai taškų. Galima netgi naudoti supaprastintą ciklo variantą for, kuris vadinamas '''foreach'''.<br><br />
U2 – ''Sportas''. Teko pasikrapštyti, kad išpildyti visus U2 užduoties niuansus (palyginkite su '''2016 metų U2''') 🙂 Užduotis buvo kaip ir nesudėtinga - sukuriamas pratimų masyvas, kurio raktas yra pratimo vardas. Kabliukas buvo tame, kad kai kuriomis dienomis buvo kartojamas tas pats pratimas. Todėl pratimų elemento reikšmę sudarė: skaitliukai dienos dalims ir minutėms bei dienų masyvas, kurio elementas yra true, kai i-ąją dieną atliekamas pratimas. Tada skirtingų dienų skaičius bus paprasta požymių suma.<br />
<br />
'''2021 metų''' užduotys yra [https://www.nsa.smm.lt/wp-content/uploads/2021/06/IT_2021_pagr.pdf čia]. U1 sprendimas yra [https://www.onlinegdb.com/dcCmz0d2Z čia]. U2 sprendimas yra [https://www.onlinegdb.com/Ap6LRGgDc čia].<br><br />
U1 – ''Bėgimas''. Šioje užduotyje duomenis sudaro tik skaičiukai. Todėl funkcija trukmė() atlieka laiko skaičiavimą, naudodama 4 nuoseklius skaičius iš srauto cin. Mažiausią laiką randame tiesiog įvedimo metu.<br><br />
U2 – ''Apklausa''. Gana normali sąlyga, nėra pozicinio vardų įvedimo. Algoritmo pagrindą sudaro grupavimo pagal pamokos vardą metodas, kuriame taikome paiešką su ieškomo elemento įrašymu į pamokų sąrašo pabaigą. <br />
<br />
'''2020 metų''' užduotys yra [https://www.nsa.smm.lt/wp-content/uploads/2021/02/8563_IT_2020_pagr_www.pdf čia]. U1 sprendimas yra [https://www.onlinegdb.com/n-YGS8_xB čia]. U2 sprendimas yra [https://www.onlinegdb.com/yKCTu5fvZ čia].<br><br />
U1 – ''Gėlės''. Sprendžiant reikia transformuoti mėnesį ir dieną į vasaros dienų masyvo indeksą ir tam naudojamas mėnesio pradžios indeksų masyvas const int mi[] = {0, 30, 61};<br><br />
U2 – ''Žvejų varžybos''. Tai gana paini sąlyga. Kad su ta pačia funkcija būtų galima rikiuoti žvejų ir žuvų masyvus, yra naudojama struct Duomuo - universali struktūra - tinka žvejui ir žuvims. <br />
<br />
'''2019 metų''' užduotys yra [https://www.nsa.smm.lt/wp-content/uploads/2021/02/8018_IT-VBE-1_2019.pdf čia]. U1 sprendimas yra [https://www.onlinegdb.com/-x4MpZMj7 čia]. U2 sprendimas yra [https://www.onlinegdb.com/UJ-lZowKD čia].<br><br />
U1 – ''Aliejus''. Gana keista užduotis – daug pradinių duomenų (atskirų kintamųjų), o sprendžiant nereikalingi nei sąlygos, nei ciklo sakiniai😊. Gali išmokyti šabloninio vardų sudarymo.<br><br />
U2 – ''Biatlonas''. Vidutinio sunkumo užduotis, reikia suformuoti laiką iš atskirų dalių. <br />
<br />
'''2016 metų''' užduotys yra [https://www.nsa.smm.lt/wp-content/uploads/2021/03/6287_IT-VBE-1_2016-GALUTINIS.pdf čia]. U1 sprendimas yra [https://onlinegdb.com/kkU272ZjR čia]. U2 sprendimas yra [https://onlinegdb.com/sd-t4JNr5 čia].<br> <br />
U1 – ''Kuprinės'' ir U2 – ''Makšta'' yra pačios lengviausios šios serijos užduotys 😊 U1 reikalavimas nenaudoti masyvų, o pakartotinai skaityti failą, priminė 50 metų senumo faktus, kai dėl atminties trūkumo buvo naudojamas tarpinių duomenų kaupimas 🙁 Tuo tarpu U2 įdomi dėl to, kad ji tapo prototipu 2022 metų užduočiai.<br />
<br />
'''2013 metų''' užduotys yra [https://www.nsa.smm.lt/wp-content/uploads/2021/03/3679_2013-IT-1-uzd-intern.pdf čia]. U1 sprendimas yra [https://www.onlinegdb.com/znJHu66bk čia]. U2 sprendimas yra [https://www.onlinegdb.com/OXcnIZnId čia].<br> <br />
U1 – ''Siuntos'' ir U2 – ''Apskritys'' yra nesudėtingos užduotys 😊<br><br />
<br />
Aptartą programavimą pagal šabloną galima palyginti su krepšinio deriniais - juos žinantys pasiekia geresnių rezultatų nei besiblaškantys. Kadangi visos VBE užduotys yra panašaus pobūdžio, tai siūlomas būdas leidžia pasiekti geresnį rezultatą aiškesnėmis priemonėmis. 😊 <br />
<br />
Apskritai kodo peržiūra ir pertvarkymas yra gera mokymosi priemonė! Ją naudoja ir profesionalai, tai vadinamasis refaktoringas https://en.wikipedia.org/wiki/Code_refactoring. Tikimės kad pavyks rasti ir daugiau racionalių sprendimų. <br />
<br />
Savo pastebėjimus apie galimus pagerinimus, netikslumus bei neaiškumus rašykite tiesiog autoriui el. paštu arba komentuokite FB grupės https://www.facebook.com/groups/itvbekonsultacijos/ diskusijose. Radusieji programose klaidų bus apdovanojami: mokytojai – skanėstais, o mokiniai – papildomais balais KTU duomenų struktūrų kurse 😊.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Cpp/Metodika&diff=4460Ap/Cpp/Metodika2023-02-13T15:22:11Z<p>Eimutis: </p>
<hr />
<div>Pasiūlymai IT VBE susitarimams 2021/22 mokslo metams<br />
Susitarimai turi skatinti mokinių algoritminį mąstymą, kadangi pasiruošimas VBE yra svarbi mokymo dalis. Šiuo metu de facto yra nusistovėję susitarimai ankstesnių VBE pagrindu, dalis jų yra pagrįsti mokymo efektyvumo prasme, pvz. duomenyse nenaudojami lietuviški simboliai su nosinėmis ir varnelėmis ir tai gali toliau likti mokymo ir VBE metu. Kiti jau tampa neaktualūs ir nėra efektyvūs mokymo eigoje.<br />
<br />
Aptariant VBE užduotis yra remiamasi NŠA pateikiama informacija https://www.nsa.smm.lt/stebesenos-ir-vertinimo-departamentas/pasiekimu-patikrinimai/brandos-egzaminai/egzaminu-uzduotys/ (opens new window).<br />
<br />
==Programavimo vardų susitarimai (Naming conventions)==<br />
<br />
Siūlymo argumentai: lig šiol mokyklose nebuvo aiškaus vieningo stiliaus kaip konstruoti įvairių tipų kintamųjų, masyvų, struktūrų funkcijų vardus, todėl kai kurie vertinimo kriterijai yra abstraktūs, kaip "Prasmingai pavadinti kintamieji. Komentuojamos programos dalys, laikomasi rašybos taisyklių". Susitarimas palengvins mokytojų darbą aiškinant apie programavimo rašymo stilių.<br />
<br />
Reikia tiesiog pasirinkti tarp [https://en.wikipedia.org/wiki/Snake_case gyvatėlės_stiliaus] ir [https://en.wikipedia.org/wiki/Camel_case KupraNugarioStiliaus] ir laikytis vardų suteikimo [https://en.wikipedia.org/wiki/Naming_convention_(programming) taisyklių]<br />
<br />
==Tekstinius duomenis VBE užduotyse rekomenduojama pateikti skyriklių pagalba==<br />
<br />
Reikia atsisakyti vyravusio pozicinio pateikimo. Siūlymo argumentai: naudotas pozicinis teksto pateikimas yra neaktualus duomenų pasikeitimo sistemose, jo programavimui mokiniai turi naudoti senosios C kalbos stiliumi tarpinį char masyvą. Mokymo eigoje veltui gaištamas laikas specifinio šablono įsiminimui. Dar papildomai reikėtų nukirpti baigiamuosius tarpus.<br />
<br />
Metodiniai sprendimai: paieškos uždaviniuose reikia naudoti vieną žodį, tuo atveju skyriklis bus tarpas cin >> vardas;. Norint sujungti kelis vardus naudojami taškai, brūkšneliai. Uždaviniuose, kur naudojamos frazės, (pvz. knygos pavadinimas) naudojama getline(cin, pavadinimas, ';') tiesiogiai nurodant skyriklį.<br />
<br />
==Sąrašo tipo duomenis rekomenduojama pateikti be perteklinio sąrašo elementų skaičiaus==<br />
<br />
Siūlymo argumentai: sąrašo pateikimas be pertekliaus yra natūralus, lengviau suprantama užduoties sąlyga. Elementų skaičiaus pateikimas prieš elementus prieštarauja sprendimo logikai, todėl mokiniams turi kilti klausimas kodėl tą daryti ruošiant duomenis.<br />
<br />
Metodiniai sprendimai: kai duomenys pateikiami eilutėmis, naudojamas ciklas while(!cin.eof()) { … }. Kai sąrašo elementai pateikiami vienoje eilutėje, naudojamas while() ciklas, įvertinantis konkrečius skyriklius, tame tarpe ir eilutės pabaigos simbolį '\n'.. Apibendrinti atvejai yra pateikiami plačiau.<br />
<br />
==VBE užduotyse reikalavimuose rekomenduojama vector traktuoti kaip masyvo sinonimą==<br />
<br />
Siūlymo argumentai: C++ vector tipas faktiškai atitinka dabartinėse programavimo kalbose naudojamą sąrašo sąvoką. Lig šiol mokyklose praktikuojamas masyvas poroje su elementų skaičiumi yra senosios C kalbos palikimas ir metodiškai nenaudotinas, kadangi reikia iš anksto rezervuoti atmintį. Jau daug metų pažangesni mokiniai kelia šį klausimą, neformaliai lyg tai leidžiama vector naudoti, bet gali būti mažinami balai dėl VBE reikalavimų. Naudojant masyvus mokiniai praranda galimybę naudoti foreach tipo ciklus. Pats uždavinių su sąrašais mokymas masyvų pagalba yra nerekomenduojamas programavimo edukologijos specialistų. C++ standartizavimo komitetas rekomenduoja naudoti vektorius vietoj masyvų. Taip pat, rekomenduojama vietoj vektoriaus operator[] naudoti at() metodą, nes jis tikrina ar argumentas yra tinkamame rėžyje. Žiūr.: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1231r0.pdf (opens new window).<br />
<br />
Metodiniai sprendimai: perėjimo metodika nuo masyvų prie vector jau buvo pristata FB mokytojų grupėje pavyzdžių pagalba ir dar bus pateikiama atskirai.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Cpp/Metodika&diff=4459Ap/Cpp/Metodika2023-02-13T11:10:00Z<p>Eimutis: /* VBE užduotyse reikalavimuose rekomenduojama vector traktuoti kaip masyvo sinonimą */</p>
<hr />
<div><br />
[https://informatikosvbe.lt/pasiulymai/]<br />
[http://itpamoka.lt/]<br />
<br />
Pasiūlymai IT VBE susitarimams 2021/22 mokslo metams<br />
Susitarimai turi skatinti mokinių algoritminį mąstymą, kadangi pasiruošimas VBE yra svarbi mokymo dalis. Šiuo metu de facto yra nusistovėję susitarimai ankstesnių VBE pagrindu, dalis jų yra pagrįsti mokymo efektyvumo prasme, pvz. duomenyse nenaudojami lietuviški simboliai su nosinėmis ir varnelėmis ir tai gali toliau likti mokymo ir VBE metu. Kiti jau tampa neaktualūs ir nėra efektyvūs mokymo eigoje.<br />
<br />
Aptariant VBE užduotis yra remiamasi NŠA pateikiama informacija https://www.nsa.smm.lt/stebesenos-ir-vertinimo-departamentas/pasiekimu-patikrinimai/brandos-egzaminai/egzaminu-uzduotys/ (opens new window).<br />
<br />
==Programavimo vardų susitarimai (Naming conventions)==<br />
<br />
Siūlymo argumentai: lig šiol mokyklose nebuvo aiškaus vieningo stiliaus kaip konstruoti įvairių tipų kintamųjų, masyvų, struktūrų funkcijų vardus, todėl kai kurie vertinimo kriterijai yra abstraktūs, kaip "Prasmingai pavadinti kintamieji. Komentuojamos programos dalys, laikomasi rašybos taisyklių". Susitarimas palengvins mokytojų darbą aiškinant apie programavimo rašymo stilių.<br />
<br />
Reikia tiesiog pasirinkti tarp [https://en.wikipedia.org/wiki/Snake_case gyvatėlės_stiliaus] ir [https://en.wikipedia.org/wiki/Camel_case KupraNugarioStiliaus] ir laikytis vardų suteikimo [https://en.wikipedia.org/wiki/Naming_convention_(programming) taisyklių]<br />
<br />
==Tekstinius duomenis VBE užduotyse rekomenduojama pateikti skyriklių pagalba==<br />
<br />
Reikia atsisakyti vyravusio pozicinio pateikimo. Siūlymo argumentai: naudotas pozicinis teksto pateikimas yra neaktualus duomenų pasikeitimo sistemose, jo programavimui mokiniai turi naudoti senosios C kalbos stiliumi tarpinį char masyvą. Mokymo eigoje veltui gaištamas laikas specifinio šablono įsiminimui. Dar papildomai reikėtų nukirpti baigiamuosius tarpus.<br />
<br />
Metodiniai sprendimai: paieškos uždaviniuose reikia naudoti vieną žodį, tuo atveju skyriklis bus tarpas cin >> vardas;. Norint sujungti kelis vardus naudojami taškai, brūkšneliai. Uždaviniuose, kur naudojamos frazės, (pvz. knygos pavadinimas) naudojama getline(cin, pavadinimas, ';') tiesiogiai nurodant skyriklį.<br />
<br />
==Sąrašo tipo duomenis rekomenduojama pateikti be perteklinio sąrašo elementų skaičiaus==<br />
<br />
Siūlymo argumentai: sąrašo pateikimas be pertekliaus yra natūralus, lengviau suprantama užduoties sąlyga. Elementų skaičiaus pateikimas prieš elementus prieštarauja sprendimo logikai, todėl mokiniams turi kilti klausimas kodėl tą daryti ruošiant duomenis.<br />
<br />
Metodiniai sprendimai: kai duomenys pateikiami eilutėmis, naudojamas ciklas while(!cin.eof()) { … }. Kai sąrašo elementai pateikiami vienoje eilutėje, naudojamas while() ciklas, įvertinantis konkrečius skyriklius, tame tarpe ir eilutės pabaigos simbolį '\n'.. Apibendrinti atvejai yra pateikiami plačiau.<br />
<br />
==VBE užduotyse reikalavimuose rekomenduojama vector traktuoti kaip masyvo sinonimą==<br />
<br />
Siūlymo argumentai: C++ vector tipas faktiškai atitinka dabartinėse programavimo kalbose naudojamą sąrašo sąvoką. Lig šiol mokyklose praktikuojamas masyvas poroje su elementų skaičiumi yra senosios C kalbos palikimas ir metodiškai nenaudotinas, kadangi reikia iš anksto rezervuoti atmintį. Jau daug metų pažangesni mokiniai kelia šį klausimą, neformaliai lyg tai leidžiama vector naudoti, bet gali būti mažinami balai dėl VBE reikalavimų. Naudojant masyvus mokiniai praranda galimybę naudoti foreach tipo ciklus. Pats uždavinių su sąrašais mokymas masyvų pagalba yra nerekomenduojamas programavimo edukologijos specialistų. C++ standartizavimo komitetas rekomenduoja naudoti vektorius vietoj masyvų. Taip pat, rekomenduojama vietoj vektoriaus operator[] naudoti at() metodą, nes jis tikrina ar argumentas yra tinkamame rėžyje. Žiūr.: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1231r0.pdf (opens new window).<br />
<br />
Metodiniai sprendimai: perėjimo metodika nuo masyvų prie vector jau buvo pristata FB mokytojų grupėje pavyzdžių pagalba ir dar bus pateikiama atskirai.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Cpp/Metodika&diff=4458Ap/Cpp/Metodika2023-02-13T11:09:42Z<p>Eimutis: /* Sąrašo tipo duomenis rekomenduojama pateikti be perteklinio sąrašo elementų skaičiaus */</p>
<hr />
<div><br />
[https://informatikosvbe.lt/pasiulymai/]<br />
[http://itpamoka.lt/]<br />
<br />
Pasiūlymai IT VBE susitarimams 2021/22 mokslo metams<br />
Susitarimai turi skatinti mokinių algoritminį mąstymą, kadangi pasiruošimas VBE yra svarbi mokymo dalis. Šiuo metu de facto yra nusistovėję susitarimai ankstesnių VBE pagrindu, dalis jų yra pagrįsti mokymo efektyvumo prasme, pvz. duomenyse nenaudojami lietuviški simboliai su nosinėmis ir varnelėmis ir tai gali toliau likti mokymo ir VBE metu. Kiti jau tampa neaktualūs ir nėra efektyvūs mokymo eigoje.<br />
<br />
Aptariant VBE užduotis yra remiamasi NŠA pateikiama informacija https://www.nsa.smm.lt/stebesenos-ir-vertinimo-departamentas/pasiekimu-patikrinimai/brandos-egzaminai/egzaminu-uzduotys/ (opens new window).<br />
<br />
==Programavimo vardų susitarimai (Naming conventions)==<br />
<br />
Siūlymo argumentai: lig šiol mokyklose nebuvo aiškaus vieningo stiliaus kaip konstruoti įvairių tipų kintamųjų, masyvų, struktūrų funkcijų vardus, todėl kai kurie vertinimo kriterijai yra abstraktūs, kaip "Prasmingai pavadinti kintamieji. Komentuojamos programos dalys, laikomasi rašybos taisyklių". Susitarimas palengvins mokytojų darbą aiškinant apie programavimo rašymo stilių.<br />
<br />
Reikia tiesiog pasirinkti tarp [https://en.wikipedia.org/wiki/Snake_case gyvatėlės_stiliaus] ir [https://en.wikipedia.org/wiki/Camel_case KupraNugarioStiliaus] ir laikytis vardų suteikimo [https://en.wikipedia.org/wiki/Naming_convention_(programming) taisyklių]<br />
<br />
==Tekstinius duomenis VBE užduotyse rekomenduojama pateikti skyriklių pagalba==<br />
<br />
Reikia atsisakyti vyravusio pozicinio pateikimo. Siūlymo argumentai: naudotas pozicinis teksto pateikimas yra neaktualus duomenų pasikeitimo sistemose, jo programavimui mokiniai turi naudoti senosios C kalbos stiliumi tarpinį char masyvą. Mokymo eigoje veltui gaištamas laikas specifinio šablono įsiminimui. Dar papildomai reikėtų nukirpti baigiamuosius tarpus.<br />
<br />
Metodiniai sprendimai: paieškos uždaviniuose reikia naudoti vieną žodį, tuo atveju skyriklis bus tarpas cin >> vardas;. Norint sujungti kelis vardus naudojami taškai, brūkšneliai. Uždaviniuose, kur naudojamos frazės, (pvz. knygos pavadinimas) naudojama getline(cin, pavadinimas, ';') tiesiogiai nurodant skyriklį.<br />
<br />
==Sąrašo tipo duomenis rekomenduojama pateikti be perteklinio sąrašo elementų skaičiaus==<br />
<br />
Siūlymo argumentai: sąrašo pateikimas be pertekliaus yra natūralus, lengviau suprantama užduoties sąlyga. Elementų skaičiaus pateikimas prieš elementus prieštarauja sprendimo logikai, todėl mokiniams turi kilti klausimas kodėl tą daryti ruošiant duomenis.<br />
<br />
Metodiniai sprendimai: kai duomenys pateikiami eilutėmis, naudojamas ciklas while(!cin.eof()) { … }. Kai sąrašo elementai pateikiami vienoje eilutėje, naudojamas while() ciklas, įvertinantis konkrečius skyriklius, tame tarpe ir eilutės pabaigos simbolį '\n'.. Apibendrinti atvejai yra pateikiami plačiau.<br />
<br />
==VBE užduotyse reikalavimuose rekomenduojama vector traktuoti kaip masyvo sinonimą==<br />
<br />
Siūlymo argumentai: C++ vector tipas faktiškai atitinka dabartinėse programavimo kalbose naudojamą sąrašo sąvoką. Lig šiol mokyklose praktikuojamas masyvas poroje su elementų skaičiumi yra senosios C kalbos palikimas ir metodiškai nenaudotinas, kadangi reikia iš anksto rezervuoti atmintį. Jau daug metų pažangesni mokiniai kelia šį klausimą, neformaliai lyg tai leidžiama vector naudoti, bet gali būti mažinami balai dėl VBE reikalavimų. Naudojant masyvus mokiniai praranda galimybę naudoti foreach tipo ciklus. Pats uždavinių su sąrašais mokymas masyvų pagalba yra nerekomenduojamas programavimo edukologijos specialistų. C++ standartizavimo komitetas rekomenduoja naudoti vektorius vietoj masyvų. Taip pat, rekomenduojama vietoj vektoriaus operator[] naudoti at() metodą, nes jis tikrina ar argumentas yra tinkamame rėžyje. Žiūr.: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1231r0.pdf (opens new window).<br />
<br />
Metodiniai sprendimai: perėjimo metodika nuo masyvų prie vector jau buvo pristata FB mokytojų grupėje pavyzdžių pagalba ir dar bus pateikiama atskirai.<br />
<br />
Argumentai prieš: vector nenaudojamas oficialiuose LT vadovėliuose.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Cpp/Metodika&diff=4457Ap/Cpp/Metodika2023-02-13T11:09:20Z<p>Eimutis: /* Tekstinius duomenis VBE užduotyse rekomenduojama pateikti skyriklių pagalba */</p>
<hr />
<div><br />
[https://informatikosvbe.lt/pasiulymai/]<br />
[http://itpamoka.lt/]<br />
<br />
Pasiūlymai IT VBE susitarimams 2021/22 mokslo metams<br />
Susitarimai turi skatinti mokinių algoritminį mąstymą, kadangi pasiruošimas VBE yra svarbi mokymo dalis. Šiuo metu de facto yra nusistovėję susitarimai ankstesnių VBE pagrindu, dalis jų yra pagrįsti mokymo efektyvumo prasme, pvz. duomenyse nenaudojami lietuviški simboliai su nosinėmis ir varnelėmis ir tai gali toliau likti mokymo ir VBE metu. Kiti jau tampa neaktualūs ir nėra efektyvūs mokymo eigoje.<br />
<br />
Aptariant VBE užduotis yra remiamasi NŠA pateikiama informacija https://www.nsa.smm.lt/stebesenos-ir-vertinimo-departamentas/pasiekimu-patikrinimai/brandos-egzaminai/egzaminu-uzduotys/ (opens new window).<br />
<br />
==Programavimo vardų susitarimai (Naming conventions)==<br />
<br />
Siūlymo argumentai: lig šiol mokyklose nebuvo aiškaus vieningo stiliaus kaip konstruoti įvairių tipų kintamųjų, masyvų, struktūrų funkcijų vardus, todėl kai kurie vertinimo kriterijai yra abstraktūs, kaip "Prasmingai pavadinti kintamieji. Komentuojamos programos dalys, laikomasi rašybos taisyklių". Susitarimas palengvins mokytojų darbą aiškinant apie programavimo rašymo stilių.<br />
<br />
Reikia tiesiog pasirinkti tarp [https://en.wikipedia.org/wiki/Snake_case gyvatėlės_stiliaus] ir [https://en.wikipedia.org/wiki/Camel_case KupraNugarioStiliaus] ir laikytis vardų suteikimo [https://en.wikipedia.org/wiki/Naming_convention_(programming) taisyklių]<br />
<br />
==Tekstinius duomenis VBE užduotyse rekomenduojama pateikti skyriklių pagalba==<br />
<br />
Reikia atsisakyti vyravusio pozicinio pateikimo. Siūlymo argumentai: naudotas pozicinis teksto pateikimas yra neaktualus duomenų pasikeitimo sistemose, jo programavimui mokiniai turi naudoti senosios C kalbos stiliumi tarpinį char masyvą. Mokymo eigoje veltui gaištamas laikas specifinio šablono įsiminimui. Dar papildomai reikėtų nukirpti baigiamuosius tarpus.<br />
<br />
Metodiniai sprendimai: paieškos uždaviniuose reikia naudoti vieną žodį, tuo atveju skyriklis bus tarpas cin >> vardas;. Norint sujungti kelis vardus naudojami taškai, brūkšneliai. Uždaviniuose, kur naudojamos frazės, (pvz. knygos pavadinimas) naudojama getline(cin, pavadinimas, ';') tiesiogiai nurodant skyriklį.<br />
<br />
==Sąrašo tipo duomenis rekomenduojama pateikti be perteklinio sąrašo elementų skaičiaus==<br />
<br />
Siūlymo argumentai: sąrašo pateikimas be pertekliaus yra natūralus, lengviau suprantama užduoties sąlyga. Elementų skaičiaus pateikimas prieš elementus prieštarauja sprendimo logikai, todėl mokiniams turi kilti klausimas kodėl tą daryti ruošiant duomenis.<br />
<br />
Metodiniai sprendimai: kai duomenys pateikiami eilutėmis, naudojamas ciklas while(!cin.eof()) { … }. Kai sąrašo elementai pateikiami vienoje eilutėje, naudojamas while() ciklas, įvertinantis konkrečius skyriklius, tame tarpe ir eilutės pabaigos simbolį '\n'.. Apibendrinti atvejai yra pateikiami plačiau.<br />
<br />
Argumentai prieš: ...<br />
<br />
==VBE užduotyse reikalavimuose rekomenduojama vector traktuoti kaip masyvo sinonimą==<br />
<br />
Siūlymo argumentai: C++ vector tipas faktiškai atitinka dabartinėse programavimo kalbose naudojamą sąrašo sąvoką. Lig šiol mokyklose praktikuojamas masyvas poroje su elementų skaičiumi yra senosios C kalbos palikimas ir metodiškai nenaudotinas, kadangi reikia iš anksto rezervuoti atmintį. Jau daug metų pažangesni mokiniai kelia šį klausimą, neformaliai lyg tai leidžiama vector naudoti, bet gali būti mažinami balai dėl VBE reikalavimų. Naudojant masyvus mokiniai praranda galimybę naudoti foreach tipo ciklus. Pats uždavinių su sąrašais mokymas masyvų pagalba yra nerekomenduojamas programavimo edukologijos specialistų. C++ standartizavimo komitetas rekomenduoja naudoti vektorius vietoj masyvų. Taip pat, rekomenduojama vietoj vektoriaus operator[] naudoti at() metodą, nes jis tikrina ar argumentas yra tinkamame rėžyje. Žiūr.: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1231r0.pdf (opens new window).<br />
<br />
Metodiniai sprendimai: perėjimo metodika nuo masyvų prie vector jau buvo pristata FB mokytojų grupėje pavyzdžių pagalba ir dar bus pateikiama atskirai.<br />
<br />
Argumentai prieš: vector nenaudojamas oficialiuose LT vadovėliuose.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Cpp/Metodika&diff=4456Ap/Cpp/Metodika2023-02-13T11:08:36Z<p>Eimutis: </p>
<hr />
<div><br />
[https://informatikosvbe.lt/pasiulymai/]<br />
[http://itpamoka.lt/]<br />
<br />
Pasiūlymai IT VBE susitarimams 2021/22 mokslo metams<br />
Susitarimai turi skatinti mokinių algoritminį mąstymą, kadangi pasiruošimas VBE yra svarbi mokymo dalis. Šiuo metu de facto yra nusistovėję susitarimai ankstesnių VBE pagrindu, dalis jų yra pagrįsti mokymo efektyvumo prasme, pvz. duomenyse nenaudojami lietuviški simboliai su nosinėmis ir varnelėmis ir tai gali toliau likti mokymo ir VBE metu. Kiti jau tampa neaktualūs ir nėra efektyvūs mokymo eigoje.<br />
<br />
Aptariant VBE užduotis yra remiamasi NŠA pateikiama informacija https://www.nsa.smm.lt/stebesenos-ir-vertinimo-departamentas/pasiekimu-patikrinimai/brandos-egzaminai/egzaminu-uzduotys/ (opens new window).<br />
<br />
==Programavimo vardų susitarimai (Naming conventions)==<br />
<br />
Siūlymo argumentai: lig šiol mokyklose nebuvo aiškaus vieningo stiliaus kaip konstruoti įvairių tipų kintamųjų, masyvų, struktūrų funkcijų vardus, todėl kai kurie vertinimo kriterijai yra abstraktūs, kaip "Prasmingai pavadinti kintamieji. Komentuojamos programos dalys, laikomasi rašybos taisyklių". Susitarimas palengvins mokytojų darbą aiškinant apie programavimo rašymo stilių.<br />
<br />
Reikia tiesiog pasirinkti tarp [https://en.wikipedia.org/wiki/Snake_case gyvatėlės_stiliaus] ir [https://en.wikipedia.org/wiki/Camel_case KupraNugarioStiliaus] ir laikytis vardų suteikimo [https://en.wikipedia.org/wiki/Naming_convention_(programming) taisyklių]<br />
<br />
==Tekstinius duomenis VBE užduotyse rekomenduojama pateikti skyriklių pagalba==<br />
<br />
Reikia atsisakyti vyravusio pozicinio pateikimo. Siūlymo argumentai: naudotas pozicinis teksto pateikimas yra neaktualus duomenų pasikeitimo sistemose, jo programavimui mokiniai turi naudoti senosios C kalbos stiliumi tarpinį char masyvą. Mokymo eigoje veltui gaištamas laikas specifinio šablono įsiminimui. Dar papildomai reikėtų nukirpti baigiamuosius tarpus.<br />
<br />
Metodiniai sprendimai: paieškos uždaviniuose reikia naudoti vieną žodį, tuo atveju skyriklis bus tarpas cin >> vardas;. Norint sujungti kelis vardus naudojami taškai, brūkšneliai. Uždaviniuose, kur naudojamos frazės, (pvz. knygos pavadinimas) naudojama getline(cin, pavadinimas, ';') tiesiogiai nurodant skyriklį.<br />
<br />
Argumentai prieš: ...<br />
<br />
==Sąrašo tipo duomenis rekomenduojama pateikti be perteklinio sąrašo elementų skaičiaus==<br />
<br />
Siūlymo argumentai: sąrašo pateikimas be pertekliaus yra natūralus, lengviau suprantama užduoties sąlyga. Elementų skaičiaus pateikimas prieš elementus prieštarauja sprendimo logikai, todėl mokiniams turi kilti klausimas kodėl tą daryti ruošiant duomenis.<br />
<br />
Metodiniai sprendimai: kai duomenys pateikiami eilutėmis, naudojamas ciklas while(!cin.eof()) { … }. Kai sąrašo elementai pateikiami vienoje eilutėje, naudojamas while() ciklas, įvertinantis konkrečius skyriklius, tame tarpe ir eilutės pabaigos simbolį '\n'.. Apibendrinti atvejai yra pateikiami plačiau.<br />
<br />
Argumentai prieš: ...<br />
<br />
==VBE užduotyse reikalavimuose rekomenduojama vector traktuoti kaip masyvo sinonimą==<br />
<br />
Siūlymo argumentai: C++ vector tipas faktiškai atitinka dabartinėse programavimo kalbose naudojamą sąrašo sąvoką. Lig šiol mokyklose praktikuojamas masyvas poroje su elementų skaičiumi yra senosios C kalbos palikimas ir metodiškai nenaudotinas, kadangi reikia iš anksto rezervuoti atmintį. Jau daug metų pažangesni mokiniai kelia šį klausimą, neformaliai lyg tai leidžiama vector naudoti, bet gali būti mažinami balai dėl VBE reikalavimų. Naudojant masyvus mokiniai praranda galimybę naudoti foreach tipo ciklus. Pats uždavinių su sąrašais mokymas masyvų pagalba yra nerekomenduojamas programavimo edukologijos specialistų. C++ standartizavimo komitetas rekomenduoja naudoti vektorius vietoj masyvų. Taip pat, rekomenduojama vietoj vektoriaus operator[] naudoti at() metodą, nes jis tikrina ar argumentas yra tinkamame rėžyje. Žiūr.: http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p1231r0.pdf (opens new window).<br />
<br />
Metodiniai sprendimai: perėjimo metodika nuo masyvų prie vector jau buvo pristata FB mokytojų grupėje pavyzdžių pagalba ir dar bus pateikiama atskirai.<br />
<br />
Argumentai prieš: vector nenaudojamas oficialiuose LT vadovėliuose.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Formul%C4%97s_tapatyb%C4%97s&diff=4455Ap/Py/Formulės tapatybės2023-01-24T12:46:37Z<p>Eimutis: /* Taikomieji uždaviniai */</p>
<hr />
<div>'''Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpC čia]'''<br />
==Nuo matematikos prie programos==<br />
Ši tema yra skirta matematinių išraiškų užrašymo Python kalba treniruotėms. Reikia atkreipti dėmesį, kad visose programavimo kalbose išraiškų užrašai skiriasi nuo matematinio teksto: negalima praleisti daugybos veiksmo, nėra šaknies ženklo, negalima rašyti kėlimo laipsniu su ženklais ² ir ³. Atliekant bandymus, mokiniams pateikiamos įvairios matematinės išraiškos, tačiau dažnai lieka neaišku ar gerai skaičiuojama. Todėl mokiniams siūloma nagrinėti pasirinktas tapatybes, kur reikia paskaičiuoti kairę ir dešinę tapatybės puses ir jas sulyginti. Galima naudotis įvairiais šaltiniais, pvz. matematikos VBE užduotimis:<br />
[[Vaizdas:Matematika1.png|500px|center]]<br />
[[Vaizdas:Matematika2.png|500px|center]]<br />
Pradėti geriausia nuo veiksmų su sveikaisiais skaičiais, nuo trumpųjų daugybos [https://www.mat.lt/matematikos-formules/daugybos-formules.html formulių]. Neteisingai atlikus veiksmus gausime pranešimą "blogai". Būtent toks pranešimas pasirodo pradiniame variante, kadangi kėlimui laipsniu mokiniai dažnai pasirenka ženklą ^ kaip įprasta Excel skaičiuoklėse. Tuo tarpu Python kalboje naudojamas derinys **. Čia mokiniams galima suteikti savarankiškumo, pasirenkant su kokiomis tapatybėmis nori pasitreniruoti. <br />
<br />
Reikia atkreipti dėmesį, kad tai '''nėra tapatybių įrodymas''', o tik išraiškų rašymo treniruotė su pranešimais gerai ar blogai. Panaši metodika yra taikoma ir sudėtingų sistemų testavime, kai naujai sukurtos programos rezultatai yra lyginami su išbandytos programos rezultatais.<br />
==Realūs skaičiai gali būti apytiksliai==<br />
Jei atliekant veiksmus su sveikais skaičiais '''gauname tikslius atsakymus ir galime naudoti == operaciją''', tai atlikdami veiksmus su '''realiais (float) skaičiais''' (trigonometrijos [https://www.mat.lt/matematikos-formules/trigonometrijos-formules.html tapatybės]) prie kai kurių pradinių reikšmių gauname netikslumus. Jie yra labai nedideli, konkrečiai užrašas '''1.1e-16''' reiškia, kad kablelį reikia perkelti 16 pozicijų į kairę, t.y. gausime skaičių, kur po kablelio bus 15 nulių! Tai yra labai mažas skaičius ir tokia paklaida realiems skaičiavimams visai netrukdo. Išbandykite trigonometrinių funkcijų skaičiavimus su matematikoje dažnai sutinkamomis reikšmėmis 30°, 45°, 60°, 90° ir patikrinkite ar teisingi atsakymai!<br />
<br />
Demonstruojant paklaidų eliminavimą realių skaičių atveju naudojama funkcija '''abs()''', kuri reiškia absoliutinį dydį, kadangi nėra žinoma ar gauta reikšmė bus didesnė ar mažesnė už etaloną. Formuojant sąlyginį pranešimą '''"gerai – blogai"''' vietoje sąlyginio if sakinio yra naudojamas ternarinis (trinaris) operatorius, kuris užtikrina paprastesnį užrašymą vienoje eilutėje.<br />
==Kvadratinė ir kubinė šaknys==<br />
Dažnai matematiniuose skaičiavimuose tenka traukti kvadratines ar kubines šaknis, todėl siūloma eksperimentuoti su įvairiais užrašymo būdais, tikslu suprasti apie teisingus ar klaidingus variantus.<br />
<syntaxhighlight lang="python"><br />
# bandome skaičiuoti kvadratinę ir kubinę šaknį<br />
print(9**1/2, 9**0.5) # kodėl nesutampa ??<br />
print(27**(1/3), 27**0.3) # didinkite trejetukų skaičių<br />
print(sqrt(1234 * 1234)) # turime gauti tą patį skaičių<br />
</syntaxhighlight><br />
==Taikomieji uždaviniai==<br />
Kai mokame teisingai užrašyti matematine išraiškas, atsiveria plačios galimybės įvairių uždavinių sprendimui, tiek iš matematikos vadovėlių, tiek praktinėse situacijose. Vieną kartą teisingai užrašius matematinę išraišką, ją nesunkiai galima panaudoti, skaičiuojant funkcijos reikšmes prie įvairių argumento reikšmių. Tai yra žymiai prasmingiau nei spaudyti kalkuliatoriaus klavišus, kai tą pačią rutininę procedūrą reikia kartoti kelis kartus. Lyginant su Excel tipo skaičiuoklėmis, išraiškų užrašymas Python kalba yra žymiai paprastesnis ir vaizdingesnis.<br />
<br />
Išspręsime 31 uždavinį iš '''Matematika 12, Uždavinynas, Išplėstinis kursas, 2004 (9 psl.)'''<br />
[[Vaizdas:Matematika12.png|500px|center]]<br />
[[Vaizdas:Vanduo_verda.png|500px|center]]<br />
Sprendimas yra paprastas - rašome funkciją, kuri skaičiuoja vandens temperatūros kitimą iki nurodyto pabaigos. Kai teisingai užbaigsite išraišką ir vykdysite programą, pamatysite jog temperatūra kildama pasiekia 100 laipsnių po 20 min. Kadangi pabaigą galima nurodyti pasirinktinai, matome kad vėliau temperatūra pradeda mažėti. Pagal reikšmių lentelę nesunkiai galima atsakyti į užduotyje keliamus klausimus.<br />
<syntaxhighlight lang="python"><br />
def vandens_temp(pabaiga):<br />
buvo = 10<br />
for t in range(pabaiga):<br />
T = -9/40*t # užbaikite šią išraišką pagal vadovėlio užduotį<br />
print(f"{t:2} {T:6.2f} {T-buvo:6.2f}")<br />
buvo = T<br />
</syntaxhighlight><br />
Reziumuojant, šią temą galima traktuoti kaip informatikos mokymo medžiagos integravimo su matematika pavyzdį. Reikia pastebėti, kad gana dažnai matematika nėra mėgstama jaunuolių, pasinėrusių į kompiuterines studijas. Todėl šios temos savarankiškumas gal suteiks postūmį atidžiau panagrinėti matematines išraiškas.<br />
[[Vaizdas:dalyba.jpg|300px|center]]<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Formul%C4%97s_tapatyb%C4%97s&diff=4454Ap/Py/Formulės tapatybės2023-01-24T12:42:37Z<p>Eimutis: /* Taikomieji uždaviniai */</p>
<hr />
<div>'''Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpC čia]'''<br />
==Nuo matematikos prie programos==<br />
Ši tema yra skirta matematinių išraiškų užrašymo Python kalba treniruotėms. Reikia atkreipti dėmesį, kad visose programavimo kalbose išraiškų užrašai skiriasi nuo matematinio teksto: negalima praleisti daugybos veiksmo, nėra šaknies ženklo, negalima rašyti kėlimo laipsniu su ženklais ² ir ³. Atliekant bandymus, mokiniams pateikiamos įvairios matematinės išraiškos, tačiau dažnai lieka neaišku ar gerai skaičiuojama. Todėl mokiniams siūloma nagrinėti pasirinktas tapatybes, kur reikia paskaičiuoti kairę ir dešinę tapatybės puses ir jas sulyginti. Galima naudotis įvairiais šaltiniais, pvz. matematikos VBE užduotimis:<br />
[[Vaizdas:Matematika1.png|500px|center]]<br />
[[Vaizdas:Matematika2.png|500px|center]]<br />
Pradėti geriausia nuo veiksmų su sveikaisiais skaičiais, nuo trumpųjų daugybos [https://www.mat.lt/matematikos-formules/daugybos-formules.html formulių]. Neteisingai atlikus veiksmus gausime pranešimą "blogai". Būtent toks pranešimas pasirodo pradiniame variante, kadangi kėlimui laipsniu mokiniai dažnai pasirenka ženklą ^ kaip įprasta Excel skaičiuoklėse. Tuo tarpu Python kalboje naudojamas derinys **. Čia mokiniams galima suteikti savarankiškumo, pasirenkant su kokiomis tapatybėmis nori pasitreniruoti. <br />
<br />
Reikia atkreipti dėmesį, kad tai '''nėra tapatybių įrodymas''', o tik išraiškų rašymo treniruotė su pranešimais gerai ar blogai. Panaši metodika yra taikoma ir sudėtingų sistemų testavime, kai naujai sukurtos programos rezultatai yra lyginami su išbandytos programos rezultatais.<br />
==Realūs skaičiai gali būti apytiksliai==<br />
Jei atliekant veiksmus su sveikais skaičiais '''gauname tikslius atsakymus ir galime naudoti == operaciją''', tai atlikdami veiksmus su '''realiais (float) skaičiais''' (trigonometrijos [https://www.mat.lt/matematikos-formules/trigonometrijos-formules.html tapatybės]) prie kai kurių pradinių reikšmių gauname netikslumus. Jie yra labai nedideli, konkrečiai užrašas '''1.1e-16''' reiškia, kad kablelį reikia perkelti 16 pozicijų į kairę, t.y. gausime skaičių, kur po kablelio bus 15 nulių! Tai yra labai mažas skaičius ir tokia paklaida realiems skaičiavimams visai netrukdo. Išbandykite trigonometrinių funkcijų skaičiavimus su matematikoje dažnai sutinkamomis reikšmėmis 30°, 45°, 60°, 90° ir patikrinkite ar teisingi atsakymai!<br />
<br />
Demonstruojant paklaidų eliminavimą realių skaičių atveju naudojama funkcija '''abs()''', kuri reiškia absoliutinį dydį, kadangi nėra žinoma ar gauta reikšmė bus didesnė ar mažesnė už etaloną. Formuojant sąlyginį pranešimą '''"gerai – blogai"''' vietoje sąlyginio if sakinio yra naudojamas ternarinis (trinaris) operatorius, kuris užtikrina paprastesnį užrašymą vienoje eilutėje.<br />
==Kvadratinė ir kubinė šaknys==<br />
Dažnai matematiniuose skaičiavimuose tenka traukti kvadratines ar kubines šaknis, todėl siūloma eksperimentuoti su įvairiais užrašymo būdais, tikslu suprasti apie teisingus ar klaidingus variantus.<br />
<syntaxhighlight lang="python"><br />
# bandome skaičiuoti kvadratinę ir kubinę šaknį<br />
print(9**1/2, 9**0.5) # kodėl nesutampa ??<br />
print(27**(1/3), 27**0.3) # didinkite trejetukų skaičių<br />
print(sqrt(1234 * 1234)) # turime gauti tą patį skaičių<br />
</syntaxhighlight><br />
==Taikomieji uždaviniai==<br />
Kai mokame teisingai užrašyti matematine išraiškas, atsiveria plačios galimybės įvairių uždavinių sprendimui, tiek iš matematikos vadovėlių, tiek praktinėse situacijose. Vieną kartą teisingai užrašius matematinę išraišką, ją nesunkiai galima panaudoti, skaičiuojant funkcijos reikšmes prie įvairių argumento reikšmių. Tai yra žymiai prasmingiau nei spaudyti kalkuliatoriaus klavišus, kai tą pačią rutininę procedūrą reikia kartoti kelis kartus. Lyginant su Excel tipo skaičiuoklėmis, išraiškų užrašymas Python kalba yra žymiai paprastesnis ir vaizdingesnis.<br />
<br />
Išspręsime 31 uždavinį iš '''Matematika 12, Uždavinynas, Išplėstinis kursas, 2004 (9 psl.)'''<br />
[[Vaizdas:Matematika12.png|500px|center]]<br />
[[Vaizdas:Vanduo_verda.png|500px|center]]<br />
Sprendimas yra paprastas - rašome funkciją, kuri skaičiuoja vandens temperatūros kitimą iki nurodyto pabaigos. Kai teisingai užbaigsite išraišką ir vykdysite programą, pamatysite jog temperatūra kildama pasiekia 100 laipsnių po 20 min. Kadangi pabaigą galima nurodyti pasirinktinai, matome kad vėliau temperatūra pradeda mažėti. Pagal reikšmių lentelę nesunkiai galima atsakyti į užduotyje keliamus klausimus.<br />
<syntaxhighlight lang="python"><br />
def vandens_temp(pabaiga):<br />
buvo = 10<br />
for t in range(pabaiga):<br />
T = -9/40*t # užbaikite šią išraišką pagal vadovėlio užduotį<br />
print(f"{t:2} {T:6.2f} {T-buvo:6.2f}")<br />
buvo = T<br />
</syntaxhighlight><br />
Reziumuojant šią temą galima traktuoti kaip informatikos mokymo medžiagos integravimo su matematika pavyzdį. Reikia pastebėti, kad gana dažnai matematika nėra mėgstama jaunuolių, pasinėrusių į kompiuterines studijas. Todėl šios temos savarankiškumas gal suteiks postūmį atidžiau panagrinėti matematines išraiškas.<br />
[[Vaizdas:dalyba.jpg|300px|center]]<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Vaizdas:Dalyba.jpg&diff=4453Vaizdas:Dalyba.jpg2023-01-24T12:40:45Z<p>Eimutis: </p>
<hr />
<div></div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Pamoka_A0&diff=4452Ap/Py/Pamoka A02022-09-29T13:33:10Z<p>Eimutis: /* Spausdinimas su paaiškinimais */</p>
<hr />
<div><big>'''<big>Neformali smagi pradžia su Pyjthon</big>'''</big><br><br />
''Pilnas šios treniruotės Python kodas [https://www.jdoodle.com/a/4YX9 yra čia]''<br />
<br />
== Skaičiuojame ir spausdiname ==<br />
Šis nedidelis įvadas yra skirtas parodyti, kad skaičiavimai Python kalba yra užrašomi paprastai ir natūraliai, galima iškart pradėti ir džiaugtis rezultatais 🙂.<br><br />
Pradedame nuo vienos raidės kintamųjų, kuriems priskiriame skaitines reikšmes. Norint parodyti kintamųjų reikšmes, naudojame spausdinimo komandą <code>print()</code> ir pamatysime pagrindinių keturių operacijų rezultatus, atskirtus tarpais. Keiskite pradines reikšmes - gausite kitus rezultatus.<br><br />
<syntaxhighlight lang="python"><br />
a = 11<br />
b = 4<br />
print(a, b)<br />
print (a+b, a-b, a*b, a/b)<br />
</syntaxhighlight><br />
PATOGU: Eilutės pabaigoje nereikia jokių papildomų kabliataškių, t.y. jie gali būti, bet Python programose (skirtingai nei C++) įprasta jų nerašyti 🙂 juk ir be jų yra aišku.<br />
<br />
== Spausdinimas su paaiškinimais ==<br />
Kai pateikiami skaičiukai, tai dažnai reikia paaiškinti, ką jie reiškia. Tai galima atlikti dviem būdais:<br />
<br />
1 - prieš kiekvieną reikšmę pateikiant paaiškinantį tekstą, žiūrėkite pavyzdį:<br />
<syntaxhighlight lang="python"><br />
a=11; b=4<br />
print("a:", a, "b:", b)<br />
print ("a+b:", a+b, a-b, a*b, a/b)<br />
# užbaikite paaiškinimus kitoms trims reikšmėms !!<br />
</syntaxhighlight><br />
2 - naudodami formatinę eilutę - tai palyginus naujas programavimo kalbų išradimas 🙂:<br />
<syntaxhighlight lang="python"><br />
a=11; b=4<br />
print(f"{a=}, {b=}")<br />
print (f"Py aritmetika: {a+b=}, {a-b=}, {a*b=}, {a/b=}")<br />
# Atsakymas<br />
a=11, b=4<br />
Py aritmetika: a+b=15, a-b=7, a*b=44, a/b=2.75<br />
</syntaxhighlight><br />
Taigi formatinėje eilutėje, kuri pradedama f raide, rašomas tekstas, o tarp riestinių skliaustų rašomas kintamasis arba išraiška. Jei dar įrašome lygybės ženklą, tai suformuojamas ir paaiškinantis tekstas. Tarp riestinių skliaustų rašant dvitaškį, galime nurodyti reišmei skirto lauko plotį. Argi ne puiku, trumpai ir aiškiai formuojame atsakymą 🙂. Kadangi formatinė eilutė yra santykinai nauja savybė, tai vykdant programą reikia nustatyti '''Python versiją 3.9.9'''.<br />
<br />
Išbandykite dar dvi dalybos operacijas // - sveikoji dalybos dalis, % - dalybos liekana, naudodami tokią Python išraišką <code> print(a//b, a%b) </code>.<br />
<br />
== Su sąrašais - paprastai ir aiškiai ==<br />
<br />
Parodome kaip reikia formuoti ie analizuoti krepšinio žaidėjų pelnytų taškų sąrašą. Tam sąrašui naudosime prasmingesnį pavadinimą nei viena raidė <code>taškai</code>. o pačius taškus rašysime tarp laužtinių skliaustų. Tada funkcija <code>sum()</code> skaičiuos taškų sumą. Tada funkcija <code>len()</code> skaičiuos sąrašo elementų kiekį ''(len - nuo pilno žodžio length)''.<br />
<br />
<syntaxhighlight lang="python"><br />
taškai = [4, 0, 12, 23, 9, 0, 17]<br />
viso_taškų = sum(taškai)<br />
kiek_žaidėjų = len(taškai)<br />
print(taškai, viso_taškų, kiek_žaidėjų)<br />
</syntaxhighlight><br />
<br />
== Sąrašo peržiūros ciklas ==<br />
O dabar atliksime truputį sudėtingesnę analizę: skaičiuosime kiek žaidėjų taškų nepelnė ir kiek žaidėjų pelnė dviženklį taškų skaičių, t.y. >= 10. Tuo tikslu panaudosime sąrašo peržiūros ciklą <br />
<code>for t in taškai:</code> '''kur taškai''' žymi sąrašą, '''t''' atskirą elementą. Kintamųjų k0 ir k2ž pagalba bus skaičiuojami taškų nepelnusių ir dviženklį pelniusių žaidėjų kiekiai.<br />
<syntaxhighlight lang="python"><br />
k0, k2ž = 0, 0<br />
for t in taškai:<br />
if t == 0:<br />
k0 += 1<br />
if t >= 10:<br />
k2ž += 1<br />
print("Taškų nepelnė:", k0)<br />
print("Dviženklį pelnė:", k2ž)<br />
</syntaxhighlight><br />
Cikle yra du sąlygos tikrinimo sakiniai ir jei sąlyga yra teisinga, skaitikliai yra didinami vienetu.<br />
<br />
Pilnas šios treniruotės Python kodas [https://www.jdoodle.com/a/4YX9 yra čia]<br />
<br />
Su šiuo kodu galima laisvai eksperimentuoti, pagal šį pavyzdį pabandykite atlikti ir kitus skaičiavimus, pvz. meteo duomenų sąrašo analizę, kiek kartų temperatūra buvo neigiama ar teigiama.<br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Pamoka_A0&diff=4451Ap/Py/Pamoka A02022-09-29T13:31:36Z<p>Eimutis: /* Spausdinimas su paaiškinimais */</p>
<hr />
<div><big>'''<big>Neformali smagi pradžia su Pyjthon</big>'''</big><br><br />
''Pilnas šios treniruotės Python kodas [https://www.jdoodle.com/a/4YX9 yra čia]''<br />
<br />
== Skaičiuojame ir spausdiname ==<br />
Šis nedidelis įvadas yra skirtas parodyti, kad skaičiavimai Python kalba yra užrašomi paprastai ir natūraliai, galima iškart pradėti ir džiaugtis rezultatais 🙂.<br><br />
Pradedame nuo vienos raidės kintamųjų, kuriems priskiriame skaitines reikšmes. Norint parodyti kintamųjų reikšmes, naudojame spausdinimo komandą <code>print()</code> ir pamatysime pagrindinių keturių operacijų rezultatus, atskirtus tarpais. Keiskite pradines reikšmes - gausite kitus rezultatus.<br><br />
<syntaxhighlight lang="python"><br />
a = 11<br />
b = 4<br />
print(a, b)<br />
print (a+b, a-b, a*b, a/b)<br />
</syntaxhighlight><br />
PATOGU: Eilutės pabaigoje nereikia jokių papildomų kabliataškių, t.y. jie gali būti, bet Python programose (skirtingai nei C++) įprasta jų nerašyti 🙂 juk ir be jų yra aišku.<br />
<br />
== Spausdinimas su paaiškinimais ==<br />
Kai pateikiami skaičiukai, tai dažnai reikia paaiškinti, ką jie reiškia. Tai galima atlikti dviem būdais:<br />
<br />
1 - prieš kiekvieną reikšmę pateikiant paaiškinantį tekstą, žiūrėkite pavyzdį:<br />
<syntaxhighlight lang="python"><br />
a=11; b=4<br />
print("a:", a, "b:", b)<br />
print ("a+b:", a+b, a-b, a*b, a/b)<br />
# užbaikite paaiškinimus kitoms trims reikšmėms !!<br />
</syntaxhighlight><br />
2 - naudodami formatinę eilutę - tai palyginus naujas programavimo kalbų išradimas 🙂:<br />
<syntaxhighlight lang="python"><br />
a=11; b=4<br />
print(f"{a=}, {b=}")<br />
print (f"Py aritmetika: {a+b=}, {a+b=}, {a-b=}, {a*b=}, {a/b=}")<br />
# Atsakymas<br />
a=11, b=4<br />
Py aritmetika: a+b=15, a+b=15, a-b=7, a*b=44, a/b=2.75<br />
</syntaxhighlight><br />
Taigi formatinėje eilutėje, kuri pradedama f raide, rašomas tekstas, o tarp riestinių skliaustų rašomas kintamasis arba išraiška. Jei dar įrašome lygybės ženklą, tai suformuojamas ir paaiškinantis tekstas. Tarp riestinių skliaustų rašant dvitaškį, galime nurodyti reišmei skirto lauko plotį. Argi ne puiku, trumpai ir aiškiai formuojame atsakymą 🙂. Kadangi formatinė eilutė yra santykinai nauja savybė, tai vykdant programą reikia nustatyti '''Python versiją 3.9.9'''.<br />
<br />
Išbandykite dar dvi dalybos operacijas // - sveikoji dalybos dalis, % - dalybos liekana, naudodami tokią Python išraišką <code> print(a//b, a%b) </code>.<br />
<br />
== Su sąrašais - paprastai ir aiškiai ==<br />
<br />
Parodome kaip reikia formuoti ie analizuoti krepšinio žaidėjų pelnytų taškų sąrašą. Tam sąrašui naudosime prasmingesnį pavadinimą nei viena raidė <code>taškai</code>. o pačius taškus rašysime tarp laužtinių skliaustų. Tada funkcija <code>sum()</code> skaičiuos taškų sumą. Tada funkcija <code>len()</code> skaičiuos sąrašo elementų kiekį ''(len - nuo pilno žodžio length)''.<br />
<br />
<syntaxhighlight lang="python"><br />
taškai = [4, 0, 12, 23, 9, 0, 17]<br />
viso_taškų = sum(taškai)<br />
kiek_žaidėjų = len(taškai)<br />
print(taškai, viso_taškų, kiek_žaidėjų)<br />
</syntaxhighlight><br />
<br />
== Sąrašo peržiūros ciklas ==<br />
O dabar atliksime truputį sudėtingesnę analizę: skaičiuosime kiek žaidėjų taškų nepelnė ir kiek žaidėjų pelnė dviženklį taškų skaičių, t.y. >= 10. Tuo tikslu panaudosime sąrašo peržiūros ciklą <br />
<code>for t in taškai:</code> '''kur taškai''' žymi sąrašą, '''t''' atskirą elementą. Kintamųjų k0 ir k2ž pagalba bus skaičiuojami taškų nepelnusių ir dviženklį pelniusių žaidėjų kiekiai.<br />
<syntaxhighlight lang="python"><br />
k0, k2ž = 0, 0<br />
for t in taškai:<br />
if t == 0:<br />
k0 += 1<br />
if t >= 10:<br />
k2ž += 1<br />
print("Taškų nepelnė:", k0)<br />
print("Dviženklį pelnė:", k2ž)<br />
</syntaxhighlight><br />
Cikle yra du sąlygos tikrinimo sakiniai ir jei sąlyga yra teisinga, skaitikliai yra didinami vienetu.<br />
<br />
Pilnas šios treniruotės Python kodas [https://www.jdoodle.com/a/4YX9 yra čia]<br />
<br />
Su šiuo kodu galima laisvai eksperimentuoti, pagal šį pavyzdį pabandykite atlikti ir kitus skaičiavimus, pvz. meteo duomenų sąrašo analizę, kiek kartų temperatūra buvo neigiama ar teigiama.<br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4450Ap/Py/Sąrašų demonstracija2022-09-29T10:58:39Z<p>Eimutis: </p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Analizuojant sąrašus galima naudoti klasikinius ciklus su indeksais, panašiai kaip senosios C kalbos atveju. <br>Naudojant '''for i in range(len(sąr)):''' gausime iteraciją per visus galimus sąrašo indeksus.<br />
<syntaxhighlight lang="python"><br />
def su_indeksais_suma(sąr):<br />
print("Pradinis:", sąr)<br />
suma = 0 # kaupiama suma<br />
for i in range(len(sąr)):<br />
suma += sąr[i] # pridedame eilinį narį<br />
print("sąr["+str(i)+"]=", sąr[i], "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
su_indeksais_suma(skaičiai)<br />
skaičiai.append(7)<br />
su_indeksais_suma(skaičiai)<br />
""" Gaunami rezultatai:<br />
Pradinis: [11, 8, 10, 6]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
Galutinė suma= 35<br />
Pradinis: [11, 8, 10, 6, 7]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
sąr[4]= 7 ∑= 42<br />
Galutinė suma= 42<br />
"""<br />
</syntaxhighlight><br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo pokyčių skaičiavimo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<syntaxhighlight lang="python"><br />
def be_indeksų_suma(sąr):<br />
suma = 0<br />
for sk in sąr:<br />
suma += sk<br />
print(sk, "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
be_indeksų_suma(skaičiai)<br />
skaičiai.append(7)<br />
be_indeksų_suma(skaičiai)<br />
""" Rezultatai tokie patys kaip ir su indeksais """<br />
</syntaxhighlight><br />
===Savarankiškas darbas===<br />
Žinių apie sąrašus įtvirtinimui pateikiama paprasta užduotis:<br><br />
DUOTA: krepšinio komandos žaidėjų pelnytų taškų sąrašas<br><br />
taškai = [8, 2, 11, 15, 5, 0, 21, 12, 1]<br><br />
* parašykite funkciją, kuri pagal surinktus krepšinio rungtynių taškus rastų <br />
* kiek yra silpnų, vidutinių ir gerų žaidėjų: <br />
* silpni < 5 tšk, vidutiniai < 12, geri >= 12<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4449Ap/Py/Sąrašų demonstracija2022-09-29T10:44:28Z<p>Eimutis: /* Sąrašo analizė su indeksais */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Analizuojant sąrašus galima naudoti klasikinius ciklus su indeksais, panašiai kaip senosios C kalbos atveju. <br>Naudojant '''for i in range(len(sąr)):''' gausime iteraciją per visus galimus sąrašo indeksus.<br />
<syntaxhighlight lang="python"><br />
def su_indeksais_suma(sąr):<br />
print("Pradinis:", sąr)<br />
suma = 0 # kaupiama suma<br />
for i in range(len(sąr)):<br />
suma += sąr[i] # pridedame eilinį narį<br />
print("sąr["+str(i)+"]=", sąr[i], "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
su_indeksais_suma(skaičiai)<br />
skaičiai.append(7)<br />
su_indeksais_suma(skaičiai)<br />
""" Gaunami rezultatai:<br />
Pradinis: [11, 8, 10, 6]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
Galutinė suma= 35<br />
Pradinis: [11, 8, 10, 6, 7]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
sąr[4]= 7 ∑= 42<br />
Galutinė suma= 42<br />
"""<br />
</syntaxhighlight><br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo pokyčių skaičiavimo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<syntaxhighlight lang="python"><br />
def be_indeksų_suma(sąr):<br />
suma = 0<br />
for sk in sąr:<br />
suma += sk<br />
print(sk, "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
be_indeksų_suma(skaičiai)<br />
skaičiai.append(7)<br />
be_indeksų_suma(skaičiai)<br />
""" Rezultatai tokie patys kaip ir su indeksais """<br />
</syntaxhighlight><br />
===Savarankiškas darbas===<br />
Žinių apie sąrašus įtvirtinimui pateikiama paprasta užduotis:<br><br />
DUOTA: krepšinio komandos žaidėjų pelnytų taškų sąrašas<br><br />
taškai = [8, 2, 11, 15, 5, 0, 21, 12, 1]<br><br />
* parašykite funkciją, kuri pagal surinktus krepšinio rungtynių taškus rastų <br />
* kiek yra silpnų, vidutinių ir gerų žaidėjų: <br />
* silpni < 5 tšk, vidutiniai < 12, geri >= 12<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4448Ap/Py/Sąrašų demonstracija2022-09-29T10:43:15Z<p>Eimutis: /* Sąrašo analizė be indeksų */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Analizuojant sąrašus galima naudoti klasikinius ciklus su indeksais, panašiai kaip senosios C kalbos atveju. <br>Naudojant '''for i in range(len(sąr)):''' gausime iteraciją per visus galimus sąrašo indeksus.<br />
<syntaxhighlight lang="python"><br />
def su_indeksais_suma(sąr):<br />
print("Pradinis:", sąr)<br />
suma = 0 # kaupiama suma<br />
for i in range(len(sąr)):<br />
suma += sąr[i] # pridedame eilinį narį<br />
print("sąr["+str(i)+"]=", sąr[i], "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
su_indeksais_suma(skaičiai)<br />
skaičiai.append(7)<br />
su_indeksais_suma(skaičiai)<br />
""" Gaunami rezultatai:<br />
Pradinis: [11, 8, 10, 6]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
Galutinė suma= 35<br />
Pradinis: [11, 8, 10, 6, 7]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
sąr[4]= 7 ∑= 42<br />
Galutinė suma= 42<br />
"""<br />
</syntaxhighlight><br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<syntaxhighlight lang="python"><br />
def be_indeksų_suma(sąr):<br />
suma = 0<br />
for sk in sąr:<br />
suma += sk<br />
print(sk, "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
be_indeksų_suma(skaičiai)<br />
skaičiai.append(7)<br />
be_indeksų_suma(skaičiai)<br />
""" Rezultatai tokie patys kaip ir su indeksais """<br />
</syntaxhighlight><br />
===Savarankiškas darbas===<br />
Žinių apie sąrašus įtvirtinimui pateikiama paprasta užduotis:<br><br />
DUOTA: krepšinio komandos žaidėjų pelnytų taškų sąrašas<br><br />
taškai = [8, 2, 11, 15, 5, 0, 21, 12, 1]<br><br />
* parašykite funkciją, kuri pagal surinktus krepšinio rungtynių taškus rastų <br />
* kiek yra silpnų, vidutinių ir gerų žaidėjų: <br />
* silpni < 5 tšk, vidutiniai < 12, geri >= 12<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4447Ap/Py/Sąrašų demonstracija2022-09-29T10:42:32Z<p>Eimutis: /* Sąrašo analizė be indeksų */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Analizuojant sąrašus galima naudoti klasikinius ciklus su indeksais, panašiai kaip senosios C kalbos atveju. <br>Naudojant '''for i in range(len(sąr)):''' gausime iteraciją per visus galimus sąrašo indeksus.<br />
<syntaxhighlight lang="python"><br />
def su_indeksais_suma(sąr):<br />
print("Pradinis:", sąr)<br />
suma = 0 # kaupiama suma<br />
for i in range(len(sąr)):<br />
suma += sąr[i] # pridedame eilinį narį<br />
print("sąr["+str(i)+"]=", sąr[i], "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
su_indeksais_suma(skaičiai)<br />
skaičiai.append(7)<br />
su_indeksais_suma(skaičiai)<br />
""" Gaunami rezultatai:<br />
Pradinis: [11, 8, 10, 6]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
Galutinė suma= 35<br />
Pradinis: [11, 8, 10, 6, 7]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
sąr[4]= 7 ∑= 42<br />
Galutinė suma= 42<br />
"""<br />
</syntaxhighlight><br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<syntaxhighlight lang="python"><br />
def be_indeksų_suma(sąr):<br />
suma = 0<br />
for sk in sąr:<br />
suma += sk<br />
print(sk, "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
be_indeksų_suma(skaičiai)<br />
skaičiai.append(7)<br />
be_indeksų_suma(skaičiai)<br />
""" Rezultatai tokie patys kaip ir su indeksais """<br />
</syntaxhighlight><br />
Žinių apie sąrašus įtvirtinimui pateikiama paprasta užduotis:<br><br />
DUOTA: krepšinio komandos žaidėjų pelnytų taškų sąrašas<br><br />
taškai = [8, 2, 11, 15, 5, 0, 21, 12, 1]<br><br />
* parašykite funkciją, kuri pagal surinktus krepšinio rungtynių taškus rastų <br />
* kiek yra silpnų, vidutinių ir gerų žaidėjų: <br />
* silpni < 5 tšk, vidutiniai < 12, geri >= 12<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4446Ap/Py/Sąrašų demonstracija2022-09-29T09:43:34Z<p>Eimutis: /* Sąrašo analizė be indeksų */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Analizuojant sąrašus galima naudoti klasikinius ciklus su indeksais, panašiai kaip senosios C kalbos atveju. <br>Naudojant '''for i in range(len(sąr)):''' gausime iteraciją per visus galimus sąrašo indeksus.<br />
<syntaxhighlight lang="python"><br />
def su_indeksais_suma(sąr):<br />
print("Pradinis:", sąr)<br />
suma = 0 # kaupiama suma<br />
for i in range(len(sąr)):<br />
suma += sąr[i] # pridedame eilinį narį<br />
print("sąr["+str(i)+"]=", sąr[i], "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
su_indeksais_suma(skaičiai)<br />
skaičiai.append(7)<br />
su_indeksais_suma(skaičiai)<br />
""" Gaunami rezultatai:<br />
Pradinis: [11, 8, 10, 6]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
Galutinė suma= 35<br />
Pradinis: [11, 8, 10, 6, 7]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
sąr[4]= 7 ∑= 42<br />
Galutinė suma= 42<br />
"""<br />
</syntaxhighlight><br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<syntaxhighlight lang="python"><br />
def be_indeksų_suma(sąr):<br />
suma = 0<br />
for sk in sąr:<br />
suma += sk<br />
print(sk, "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
be_indeksų_suma(skaičiai)<br />
skaičiai.append(7)<br />
be_indeksų_suma(skaičiai)<br />
""" Rezultatai tokie patys kaip ir su indeksais<br />
</syntaxhighlight><br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4445Ap/Py/Sąrašų demonstracija2022-09-29T09:25:54Z<p>Eimutis: /* Sąrašo analizė su indeksais */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Analizuojant sąrašus galima naudoti klasikinius ciklus su indeksais, panašiai kaip senosios C kalbos atveju. <br>Naudojant '''for i in range(len(sąr)):''' gausime iteraciją per visus galimus sąrašo indeksus.<br />
<syntaxhighlight lang="python"><br />
def su_indeksais_suma(sąr):<br />
print("Pradinis:", sąr)<br />
suma = 0 # kaupiama suma<br />
for i in range(len(sąr)):<br />
suma += sąr[i] # pridedame eilinį narį<br />
print("sąr["+str(i)+"]=", sąr[i], "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
su_indeksais_suma(skaičiai)<br />
skaičiai.append(7)<br />
su_indeksais_suma(skaičiai)<br />
""" Gaunami rezultatai:<br />
Pradinis: [11, 8, 10, 6]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
Galutinė suma= 35<br />
Pradinis: [11, 8, 10, 6, 7]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
sąr[4]= 7 ∑= 42<br />
Galutinė suma= 42<br />
"""<br />
</syntaxhighlight><br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4444Ap/Py/Sąrašų demonstracija2022-09-29T09:25:04Z<p>Eimutis: /* Sąrašo analizė su indeksais */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Analizuojant sąrašus galima naudoti klasikinius ciklus su indeksais, panašiai kaip senosios C kalbos atveju. Naudojant '''for i in range(len(sąr)):''' gausime iteraciją per visus galimus sąrašo indeksus.<br />
<syntaxhighlight lang="python"><br />
def su_indeksais_suma(sąr):<br />
print("Pradinis:", sąr)<br />
suma = 0 # kaupiama suma<br />
for i in range(len(sąr)):<br />
suma += sąr[i] # pridedame eilinį narį<br />
print("sąr["+str(i)+"]=", sąr[i], "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
su_indeksais_suma(skaičiai)<br />
skaičiai.append(7)<br />
su_indeksais_suma(skaičiai)<br />
"""<br />
Pradinis: [11, 8, 10, 6]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
Galutinė suma= 35<br />
Pradinis: [11, 8, 10, 6, 7]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
sąr[4]= 7 ∑= 42<br />
Galutinė suma= 42<br />
"""<br />
</syntaxhighlight><br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4443Ap/Py/Sąrašų demonstracija2022-09-29T09:07:15Z<p>Eimutis: /* Sąrašams skirtos funkcijos */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
<br />
<syntaxhighlight lang="python"><br />
def su_indeksais_suma(sąr):<br />
print("Pradinis:", sąr)<br />
suma = 0 # kaupiama suma<br />
for i in range(len(sąr)):<br />
suma += sąr[i] # pridedame eilinį narį<br />
print("sąr["+str(i)+"]=", sąr[i], "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
su_indeksais_suma(skaičiai)<br />
skaičiai.append(7)<br />
su_indeksais_suma(skaičiai)<br />
"""<br />
Pradinis: [11, 8, 10, 6]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
Galutinė suma= 35<br />
Pradinis: [11, 8, 10, 6, 7]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
sąr[4]= 7 ∑= 42<br />
Galutinė suma= 42<br />
"""<br />
</syntaxhighlight><br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4442Ap/Py/Sąrašų demonstracija2022-09-29T09:05:13Z<p>Eimutis: /* Sąrašo analizė su indeksais */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai yra prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
<br />
<syntaxhighlight lang="python"><br />
def su_indeksais_suma(sąr):<br />
print("Pradinis:", sąr)<br />
suma = 0 # kaupiama suma<br />
for i in range(len(sąr)):<br />
suma += sąr[i] # pridedame eilinį narį<br />
print("sąr["+str(i)+"]=", sąr[i], "\t∑=", suma)<br />
print("Galutinė suma=", suma)<br />
su_indeksais_suma(skaičiai)<br />
skaičiai.append(7)<br />
su_indeksais_suma(skaičiai)<br />
"""<br />
Pradinis: [11, 8, 10, 6]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
Galutinė suma= 35<br />
Pradinis: [11, 8, 10, 6, 7]<br />
sąr[0]= 11 ∑= 11<br />
sąr[1]= 8 ∑= 19<br />
sąr[2]= 10 ∑= 29<br />
sąr[3]= 6 ∑= 35<br />
sąr[4]= 7 ∑= 42<br />
Galutinė suma= 42<br />
"""<br />
</syntaxhighlight><br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4441Ap/Py/Sąrašų demonstracija2022-09-29T08:47:09Z<p>Eimutis: /* Sąrašo analizė be indeksų */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai yra prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas '''for sk in sąr:''' dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba '''for each'''). Panagrinėjus šiuos du atvejus detaliau matyti, kad ''atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti'', todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4440Ap/Py/Sąrašų demonstracija2022-09-29T08:46:03Z<p>Eimutis: /* Sąrašo analizė su indeksais */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai yra prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją '''sąr.append(sk)''', kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4439Ap/Py/Sąrašų demonstracija2022-09-29T08:44:16Z<p>Eimutis: /* Sąrašams skirtos funkcijos */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos '''len(sąr)''' pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija '''sum(sąr)''' grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą. Todėl jei sąrašo elementai yra prieš sumavimą yra nežinomo tipo, reikia patikrinti ar jie yra '''int''' tipo. Matome ir kitas naudingas funkcijas, skirtas mažiausių ir didžiausių reikšmių radimui, rikiavimui.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4438Ap/Py/Sąrašų demonstracija2022-09-29T08:39:04Z<p>Eimutis: /* Sąrašams skirtos funkcijos */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos len(sąr) pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija sum(sąr) grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą.<br />
<syntaxhighlight lang="python"><br />
def demo_funkcijos(sąr):<br />
print("visas sąrašas:", sąr)<br />
print("sąrašo ilgis: ", len(sąr))<br />
if isinstance(sąr[0], int): # sumuoti galima tik skaičius<br />
print("sąrašo suma: ", sum(sąr))<br />
print("sąrašo min: ", min(sąr))<br />
print("sąrašo max: ", max(sąr))<br />
print("Rikiuotas sąr:", sorted(sąr))<br />
print("Galutinis sąr:", sąr, "\n---------")<br />
demo_funkcijos(skaičiai)<br />
demo_funkcijos(komandos)<br />
""" Gaunami rezultatai:<br />
visas sąrašas: [11, 8, 10, 6]<br />
sąrašo ilgis: 4<br />
sąrašo suma: 35<br />
sąrašo min: 6<br />
sąrašo max: 11<br />
Rikiuotas sąr: [6, 8, 10, 11]<br />
Galutinis sąr: [11, 8, 10, 6] <br />
---------<br />
visas sąrašas: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas']<br />
sąrašo ilgis: 5<br />
sąrašo min: Atletas<br />
sąrašo max: Žalgiris<br />
Rikiuotas sąr: ['Atletas', 'Galiūnas', 'Neptūnas', 'Vilkai', 'Žalgiris']<br />
Galutinis sąr: ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] <br />
"""<br />
</syntaxhighlight><br />
<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4437Ap/Py/Sąrašų demonstracija2022-09-29T08:19:05Z<p>Eimutis: /* Sąrašai yra indeksuojami */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias savybes:<br />
* sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
* parodo kaip pasiekiami pirmieji trys elementai.<br />
* parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos len(sąr) pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija sum(sąr) grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą.<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4436Ap/Py/Sąrašų demonstracija2022-09-29T08:17:45Z<p>Eimutis: /* Sąrašai yra indeksuojami */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Sąrašas gali būti užrašomas tiesiogiai programoje, elementus išvardijant tarp laužtinių skliaustų. Pažvelkite į šį pavyzdį:<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
Demonstracinė funkcija rodo šias pagrindines savybes:<br />
1 sąrašą galima spausdinti tiesiogiai kaip vientisą objektą;<br />
2 parodo kaip pasiekiami pirmieji trys elementai.<br />
3 parodo kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą, tai yra naujovė, lyginant su C++ šeimos kalbomis.<br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos len(sąr) pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija sum(sąr) grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą.<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4435Ap/Py/Sąrašų demonstracija2022-09-29T08:02:01Z<p>Eimutis: /* Sąrašai yra indeksuojami */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Naujovė, lyginant su C++ šeimos kalbomis, yra tai, kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą.<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Gaunami rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos len(sąr) pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija sum(sąr) grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą.<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4434Ap/Py/Sąrašų demonstracija2022-09-29T08:00:57Z<p>Eimutis: /* Sąrašai yra indeksuojami */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Naujovė, lyginant su C++ šeimos kalbomis, yra tai, kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą.<br />
<syntaxhighlight lang="python"><br />
skaičiai = [11, 8, 10, 6]<br />
# indeksai 0 1 2 3 -> len=4<br />
komandos = ["Žalgiris", "Galiūnas", "Atletas", "Vilkai", "Neptūnas"]<br />
# indeksai 0 1 2 3 4 -> len=5<br />
<br />
def demo_indeksai(sąr):<br />
print("Duota->", sąr, "ilgis=", len(sąr))<br />
print(sąr[0], sąr[1], sąr[2]) # pradžia<br />
print(sąr[-1], sąr[-2], sąr[-3]) # pabaiga - atvirkščiai<br />
#=== def end <br />
demo_indeksai(skaičiai)<br />
demo_indeksai(komandos)<br />
demo_indeksai([10, 11, 12, 13, 14, 15, 16])<br />
""" Rezultatai<br />
Duota-> [11, 8, 10, 6] ilgis= 4<br />
11 8 10<br />
6 10 8<br />
Duota-> ['Žalgiris', 'Galiūnas', 'Atletas', 'Vilkai', 'Neptūnas'] ilgis= 5<br />
Žalgiris Galiūnas Atletas<br />
Neptūnas Vilkai Atletas<br />
Duota-> [10, 11, 12, 13, 14, 15, 16] ilgis= 7<br />
10 11 12<br />
16 15 14<br />
"""<br />
</syntaxhighlight><br />
<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos len(sąr) pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija sum(sąr) grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą.<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Pvz&diff=4433Ap/Pvz2022-09-29T06:19:07Z<p>Eimutis: </p>
<hr />
<div>==Ciklai kol==<br />
Šiame skyriuje susipažinsi su ciklu <code>while</code>(liet. kol). <br />
<syntaxhighlight lang="python"><br />
a = 0<br />
</syntaxhighlight><br />
Expression - reiškinys False - Melas Feature - ypatybė<br />
<br />
== Begaliniai ciklai ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis.<br />
<br />
== Fibonačio skaičių seka ==<br />
Fibonačio skaičių seka – sveikųjų skaičių seka. Seka prasideda šiais skaičiais: 0, 1, 1, 2.<br />
Expression - reiškinys<br />
False - Melas<br />
<br />
== Begaliniai ciklai2 ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis. Expression - reiškinys<br />
<br />
Edukologijos tyrimai rodo, kad mokymasis yra efektyvesnis, kai<br />
studentai aktyviai dalyvauja [3,8]. Perdavimas į vieną pusę<br />
žinios paskaitose lemia prastą mokymąsi. Van der Vleuten<br />
[13] cituoja JAV mokslininką Balesą, vaizduojantį santykius<br />
tarp aktyvaus studentų įsitraukimo ir išlaikymo<br />
atitinkamos žinios piramidės pavidalu (žr. 1 pav.)<br />
Akivaizdu, kad efektyvi mokymosi aplinka turėtų skatinti<br />
mokiniai patys ieško informacijos, o ne turi<br />
jie gauna pasyviai iš anksto apdorotą informaciją. Apie<br />
Žinoma, tai priklauso nuo konkrečios situacijos, kaip geriausia užsiimti<br />
studentai. Nepaisant to, tokios edukacinės sąvokos kaip „atradimas“.<br />
mokymasis“, „mokymasis darant“. „mokymasis patirtimi“ ir „studentas“.<br />
sutelktas mokymasis“ siūlo išnaudoti tokias žmogaus savybes kaip smalsumas,<br />
iššūkis ir apsisprendimas [9].<br />
<br />
The Same But Different<br />
Students’ Understandings of Primitive and Object Variables<br />
Juha Sorva<br />
Department of Computer Science and Engineering<br />
Helsinki University of Technology<br />
Espoo, Finland<br />
jsorva@cs.hut.fi<br />
<br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Pvz&diff=4432Ap/Pvz2022-09-27T06:00:56Z<p>Eimutis: /* Begaliniai ciklai2 */</p>
<hr />
<div>==Ciklai kol==<br />
Šiame skyriuje susipažinsi su ciklu <code>while</code>(liet. kol). <br />
<syntaxhighlight lang="python"><br />
a = 0<br />
# Python program for implementation of MergeSort<br />
# https://www.geeksforgeeks.org/merge-sort/<br />
def mergeSort(arr):<br />
⎧ if len(arr) < 2: return<br />
⎪ mid = len(arr)//2 # Finding the mid of the array<br />
⎪ L = arr[:mid] # Dividing the array elements<br />
⎪ R = arr[mid:] # into 2 halves<br />
⎪ <br />
⎪ mergeSort(L) # Sorting the first half <br />
⎪ mergeSort(R) # Sorting the second half<br />
⎪ <br />
⎪ i = j = k = 0<br />
⎪ # Copy data to temp arrays L[] and R[]<br />
⎪ while i < len(L) and j < len(R):<br />
⎪ ⎧ if L[i] <= R[j]:<br />
⎪ ⎪ ⎧ arr[k] = L[i]<br />
⎪ ⎪ ⎩ i += 1<br />
⎪ ⎪ else:<br />
⎪ ⎪ ⎧ arr[k] = R[j]<br />
⎪ ⎪ ⎪ j += 1<br />
⎪ ⎩ ⎩ k += 1<br />
⎪ <br />
⎪ # Checking if any element was left<br />
⎪ while i < len(L):<br />
⎪ ⎧ arr[k] = L[i]<br />
⎪ ⎪ i += 1<br />
⎪ ⎩ k += 1<br />
⎪ while j < len(R):<br />
⎪ ⎧ arr[k] = R[j]<br />
⎪ ⎪ j += 1<br />
⎩ ⎩ k += 1<br />
<br />
# Code to print the list<br />
def printList(arr):<br />
⎧ for i in range(len(arr)):<br />
⎪ ⎩ print(arr[i], end=" ")<br />
⎩ print()<br />
<br />
# Driver Code<br />
if __name__ == '__main__':<br />
⎧ arr = [12, 11, 13, 5, 6, 7, 15, 14, 2, 17]<br />
⎪ print("Given array is", end="\n")<br />
⎪ printList(arr)<br />
⎪ mergeSort(arr)<br />
⎪ print("Sorted array is: ", end="\n")<br />
⎩ printList(arr)<br />
<br />
</syntaxhighlight><br />
Expression - reiškinys False - Melas Feature - ypatybė<br />
<br />
== Begaliniai ciklai ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis.<br />
<br />
== Fibonačio skaičių seka ==<br />
Fibonačio skaičių seka – sveikųjų skaičių seka. Seka prasideda šiais skaičiais: 0, 1, 1, 2.<br />
Expression - reiškinys<br />
False - Melas<br />
<br />
== Begaliniai ciklai2 ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis. Expression - reiškinys<br />
<br />
Edukologijos tyrimai rodo, kad mokymasis yra efektyvesnis, kai<br />
studentai aktyviai dalyvauja [3,8]. Perdavimas į vieną pusę<br />
žinios paskaitose lemia prastą mokymąsi. Van der Vleuten<br />
[13] cituoja JAV mokslininką Balesą, vaizduojantį santykius<br />
tarp aktyvaus studentų įsitraukimo ir išlaikymo<br />
atitinkamos žinios piramidės pavidalu (žr. 1 pav.)<br />
Akivaizdu, kad efektyvi mokymosi aplinka turėtų skatinti<br />
mokiniai patys ieško informacijos, o ne turi<br />
jie gauna pasyviai iš anksto apdorotą informaciją. Apie<br />
Žinoma, tai priklauso nuo konkrečios situacijos, kaip geriausia užsiimti<br />
studentai. Nepaisant to, tokios edukacinės sąvokos kaip „atradimas“.<br />
mokymasis“, „mokymasis darant“. „mokymasis patirtimi“ ir „studentas“.<br />
sutelktas mokymasis“ siūlo išnaudoti tokias žmogaus savybes kaip smalsumas,<br />
iššūkis ir apsisprendimas [9].<br />
<br />
The Same But Different<br />
Students’ Understandings of Primitive and Object Variables<br />
Juha Sorva<br />
Department of Computer Science and Engineering<br />
Helsinki University of Technology<br />
Espoo, Finland<br />
jsorva@cs.hut.fi<br />
<br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Pvz&diff=4431Ap/Pvz2022-09-26T20:23:05Z<p>Eimutis: /* Ciklai kol */</p>
<hr />
<div>==Ciklai kol==<br />
Šiame skyriuje susipažinsi su ciklu <code>while</code>(liet. kol). <br />
<syntaxhighlight lang="python"><br />
a = 0<br />
# Python program for implementation of MergeSort<br />
# https://www.geeksforgeeks.org/merge-sort/<br />
def mergeSort(arr):<br />
⎧ if len(arr) < 2: return<br />
⎪ mid = len(arr)//2 # Finding the mid of the array<br />
⎪ L = arr[:mid] # Dividing the array elements<br />
⎪ R = arr[mid:] # into 2 halves<br />
⎪ <br />
⎪ mergeSort(L) # Sorting the first half <br />
⎪ mergeSort(R) # Sorting the second half<br />
⎪ <br />
⎪ i = j = k = 0<br />
⎪ # Copy data to temp arrays L[] and R[]<br />
⎪ while i < len(L) and j < len(R):<br />
⎪ ⎧ if L[i] <= R[j]:<br />
⎪ ⎪ ⎧ arr[k] = L[i]<br />
⎪ ⎪ ⎩ i += 1<br />
⎪ ⎪ else:<br />
⎪ ⎪ ⎧ arr[k] = R[j]<br />
⎪ ⎪ ⎪ j += 1<br />
⎪ ⎩ ⎩ k += 1<br />
⎪ <br />
⎪ # Checking if any element was left<br />
⎪ while i < len(L):<br />
⎪ ⎧ arr[k] = L[i]<br />
⎪ ⎪ i += 1<br />
⎪ ⎩ k += 1<br />
⎪ while j < len(R):<br />
⎪ ⎧ arr[k] = R[j]<br />
⎪ ⎪ j += 1<br />
⎩ ⎩ k += 1<br />
<br />
# Code to print the list<br />
def printList(arr):<br />
⎧ for i in range(len(arr)):<br />
⎪ ⎩ print(arr[i], end=" ")<br />
⎩ print()<br />
<br />
# Driver Code<br />
if __name__ == '__main__':<br />
⎧ arr = [12, 11, 13, 5, 6, 7, 15, 14, 2, 17]<br />
⎪ print("Given array is", end="\n")<br />
⎪ printList(arr)<br />
⎪ mergeSort(arr)<br />
⎪ print("Sorted array is: ", end="\n")<br />
⎩ printList(arr)<br />
<br />
</syntaxhighlight><br />
Expression - reiškinys False - Melas Feature - ypatybė<br />
<br />
== Begaliniai ciklai ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis.<br />
<br />
== Fibonačio skaičių seka ==<br />
Fibonačio skaičių seka – sveikųjų skaičių seka. Seka prasideda šiais skaičiais: 0, 1, 1, 2.<br />
Expression - reiškinys<br />
False - Melas<br />
<br />
== Begaliniai ciklai2 ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis. Expression - reiškinys<br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Pvz&diff=4430Ap/Pvz2022-09-26T20:22:42Z<p>Eimutis: /* Ciklai kol */</p>
<hr />
<div>==Ciklai kol==<br />
Šiame skyriuje susipažinsi su ciklu <code>while</code>(liet. kol). <br />
<syntaxhighlight lang="python"><br />
a = 0<br />
# Python program for implementation of MergeSort<br />
# https://www.geeksforgeeks.org/merge-sort/<br />
def mergeSort(arr):<br />
⎧ if len(arr) < 2: return<br />
⎪ mid = len(arr)//2 # Finding the mid of the array<br />
⎪ L = arr[:mid] # Dividing the array elements<br />
⎪ R = arr[mid:] # into 2 halves<br />
⎪ <br />
⎪ mergeSort(L) # Sorting the first half <br />
⎪ mergeSort(R) # Sorting the second half<br />
⎪ <br />
⎪ i = j = k = 0<br />
⎪ # Copy data to temp arrays L[] and R[]<br />
⎪ while i < len(L) and j < len(R):<br />
⎪ ⎧ if L[i] <= R[j]:<br />
⎪ ⎪ ⎧ arr[k] = L[i]<br />
⎪ ⎪ ⎩ i += 1<br />
⎪ ⎪ else:<br />
⎪ ⎪ ⎧ arr[k] = R[j]<br />
⎪ ⎪ ⎪ j += 1<br />
⎪ ⎩ ⎩ k += 1<br />
⎪ <br />
⎪ # Checking if any element was left<br />
⎪ while i < len(L):<br />
⎪ ⎧ arr[k] = L[i]<br />
⎪ ⎪ i += 1<br />
⎪ ⎩ k += 1<br />
⎪ while j < len(R):<br />
⎪ ⎧ arr[k] = R[j]<br />
⎪ ⎪ j += 1<br />
⎩ ⎩ k += 1<br />
<br />
# Code to print the list<br />
def printList(arr):<br />
⎧ for i in range(len(arr)):<br />
⎪ ⎩ print(arr[i], end=" ")<br />
⎩ print()<br />
<br />
# Driver Code<br />
if __name__ == '__main__':<br />
⎧ arr = [12, 11, 13, 5, 6, 7, 15, 14, 2, 17]<br />
⎪ print("Given array is", end="\n")<br />
⎪ printList(arr)<br />
⎪ mergeSort(arr)<br />
⎪ print("Sorted array is: ", end="\n")<br />
⎩ printList(arr)<br />
<br />
</syntaxhighlight><br />
Expression - reiškinys False - Melas Feature - ypatybė<br />
<br />
== Begaliniai ciklai ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis.<br />
<br />
== Fibonačio skaičių seka ==<br />
Fibonačio skaičių seka – sveikųjų skaičių seka. Seka prasideda šiais skaičiais: 0, 1, 1, 2.<br />
Expression - reiškinys<br />
False - Melas<br />
<br />
== Begaliniai ciklai2 ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis. Expression - reiškinys<br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Pvz&diff=4429Ap/Pvz2022-09-26T09:53:09Z<p>Eimutis: </p>
<hr />
<div>==Ciklai kol==<br />
Šiame skyriuje susipažinsi su ciklu <code>while</code>(liet. kol). <br />
<syntaxhighlight lang="python"><br />
a = 0<br />
# Python program for implementation of MergeSort<br />
# https://www.geeksforgeeks.org/merge-sort/<br />
def mergeSort(arr):<br />
⎧if len(arr) < 2: return<br />
⎪ mid = len(arr)//2 # Finding the mid of the array<br />
⎪ L = arr[:mid] # Dividing the array elements<br />
⎪ R = arr[mid:] # into 2 halves<br />
⎪ <br />
⎪ mergeSort(L) # Sorting the first half <br />
⎪ mergeSort(R) # Sorting the second half<br />
⎪ <br />
⎪ i = j = k = 0<br />
⎪ # Copy data to temp arrays L[] and R[]<br />
⎪ while i < len(L) and j < len(R):<br />
⎪ ⎧ if L[i] <= R[j]:<br />
⎪ ⎪ ⎧ arr[k] = L[i]<br />
⎪ ⎪ ⎩ i += 1<br />
⎪ ⎪ else:<br />
⎪ ⎪ ⎧ arr[k] = R[j]<br />
⎪ ⎪ ⎪ j += 1<br />
⎪ ⎩ ⎩ k += 1<br />
⎪ <br />
⎪ # Checking if any element was left<br />
⎪ while i < len(L):<br />
⎪ ⎧ arr[k] = L[i]<br />
⎪ ⎪ i += 1<br />
⎪ ⎩ k += 1<br />
⎪ while j < len(R):<br />
⎪ ⎧ arr[k] = R[j]<br />
⎪ ⎪ j += 1<br />
⎩ ⎩ k += 1<br />
<br />
# Code to print the list<br />
def printList(arr):<br />
⎧ for i in range(len(arr)):<br />
⎪ ⎩ print(arr[i], end=" ")<br />
⎩ print()<br />
<br />
# Driver Code<br />
if __name__ == '__main__':<br />
⎧ arr = [12, 11, 13, 5, 6, 7, 15, 14, 2, 17]<br />
⎪ print("Given array is", end="\n")<br />
⎪ printList(arr)<br />
⎪ mergeSort(arr)<br />
⎪ print("Sorted array is: ", end="\n")<br />
⎩ printList(arr)<br />
<br />
</syntaxhighlight><br />
Expression - reiškinys False - Melas Feature - ypatybė<br />
<br />
== Begaliniai ciklai ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis.<br />
<br />
== Fibonačio skaičių seka ==<br />
Fibonačio skaičių seka – sveikųjų skaičių seka. Seka prasideda šiais skaičiais: 0, 1, 1, 2.<br />
Expression - reiškinys<br />
False - Melas<br />
<br />
== Begaliniai ciklai2 ==<br />
Dabar, kai jau išsiaiškinome, kas yra ciklas <code>while</code>, pasižiūrėkime kaip atrodo niekada nesibaigiantys ciklai, kaip kad ir šis. Expression - reiškinys<br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Tikslas&diff=4428Ap/Tikslas2022-09-22T17:26:24Z<p>Eimutis: </p>
<hr />
<div>Pastarieji 2021-22 metai buvo gana ženklių pokyčių Lietuvos vaikų programavimo mokyme metais. 2021 m. pavasarį startavo '''[https://angis.net/ projektas Angis]''', sukurtas ''Vismos'' įmonės entuziastų. Gegužės - birželio mėnesiais Švietimo ministerijos atstovams buvo aktyviai aiškinama, kad į brandos egzaminų programą reikia įtraukti Python programavimo kalbą. Argumentai paveikė ir 2021 metų rudenį Švietimo ministrės įsakymu Python tapo oficialiai pripažinta priemone egzamino laikymui. Iškart buvo pradėti pagreitinti kursai, skirti susipažinti su Python kalbos privalumais. 2022 metų pavasarį abiturientams buvo pateikti ankstesnių VBE programavimo užduočių sprendimai, kuriuos jie galėjo savarankiškai nagrinėti.<br />
<br />
Visi šie žingsniai buvo žengti todėl, kad Lietuvos mokyklose pernelyg ilgai dominavo ''"Šiuolaikiško žvilgsnio ..."'' stiliaus vadovėliai, kuriuose pateikiama gerokai senstelėjusi ir dabartiniams mokiniams neaktuali medžiaga. To pasėkoje daug Lietuvos mokytojų ir mokinių savarankiškai rinko mokymo medžiagą, užduotis ir sprendimo pavyzdžius, o kiti apsiribodavo oficialiai apibrėžta programa, kurioje nebuvo tokių patogių ir aiškių sąvokų kaip sąrašai, žodynai, dvimačiai masyvai. Tuo tarpu netgi VBE užduotyse pradėjo vyrauti tokios tematikos, kurių sprendimui reikia žinoti šias sąvokas.<br />
<br />
Šiuo projektu siekiama suteikti Lietuvos moksleiviams aktualių programavimo žinių, aktyviai dirbant su jiems pateiktais programiniais sprendimais.<br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Gra%C5%BEinamos_reik%C5%A1m%C4%97s&diff=4427Ap/Py/Gražinamos reikšmės2022-09-18T17:18:12Z<p>Eimutis: /* Matavimo vienetų keitimo funkcijos */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpM čia]<br />
==Kodėl reikia gražinti reikšmes==<br />
Lig šiol visos mūsų sukurtos funkcijos rezultatus išvedinėjo į ekraną. Šios funkcijos yra skirtos vienos užduoties vykdymui (skaičiavimams) ir rezultatų vaizdavimui. Tuo tarpu kuriant didesnes programas, yra tikslinga atskirti skaičiavimų dalį nuo rezultatų pateikimo. Tada vienos funkcijos atlieka smulkesnius skaičiavimus, kitos - stambesnius, apjungiančius, ir tik pačioj pabaigoje pateikiami galutiniai rezultatai.<br />
<br />
Mums dažnai reikia tokių funkcijų kaip '''sin(x)''' ar '''cos(x)''', kurios vykdo skaičiavimus ir nerodo jokių rezultatų, bet gautas reikšmes atiduoda jas kvietusiai programai (ar kitai funkcijai). Tokios funkcijos yra vadinamos grąžinančiomis reikšmes funkcijomis. Jų veikimui yra būtinas sakinys '''return''' su paskaičiuota reikšme. Pirmuose pavyzdžiuose tai bus tiesiog skaitinės reikšmės, t.y. konkrečių figūrų plotai. Gautas reikšmes jau galima naudoti sudėtingesnių figūrų, sudarytų iš trikampių, skaičiavimui.<br />
==Python funkcijų specifika==<br />
Tolimesniuose pavyzdžiuose demonstruojama Python savybė, kai galima skaičiuoti ir grąžinti kelias reikšmes, pvz. perimetrą ir plotą. Tokiu atveju grąžinamą reikšmę galima traktuoti kaip vieną, taikant rinkinio sąvoką. Jei kuri nors reikšmė iš grąžinamo rinkinio yra nereikalinga, priimant reikšmes rekomenduojam toje vietoje rašyti pabraukimo ženklą _.<br />
<br />
Tuo pačiu reikia atkreipti dėmesį, kad funkcijos parametrai tik perduoda reikšmes į funkcijos vidų, bet negali grąžinti reikšmės į išorę, kaip buvo C++ atveju, naudojant nuorodas, žymimas & ženklu. Reikšmės yra grąžinamos <br />
tik naudojant sakinį return. Vėliau pamatysite kad galima grąžinti ne tik skaičius, bet ir kitas struktūras, taip kuriant bibliotekas, kurios užtikrina sudėtingų programų kūrimą.<br />
==Savarankiško darbo užduotys su plotais==<br />
[[Vaizdas:MatematikaFig.png|500px|center]]<br />
Pateiktame variante užduotys yra susietos su figūrų perimetro ir ploto skaičiavimo funkcijomis.<br><br />
Taip pat tikslinga išplėsti nagrinėjamų funkcijų tematiką, pasinaudojant fizikos sąvokomis, pvz. nuoseklaus ir ir lygiagretaus jungimo varžų skaičiavimo funkcijos.<br />
<br />
==Matavimo vienetų keitimo funkcijos==<br />
Kaip žinoma iš fizikos, yra įvairių matavimo sistemų: temperatūra matuojama Celsijaus ir Farenheito laipsniais, ilgis matuojamas metrais, jardais, coliais; svoris - kilogramais ir pūdais ir panašiai.<br><br />
Siūloma savarankiškai užbaigti ir išbandyti šias konvertavimo funkcijas:<br />
<syntaxhighlight lang="python"><br />
def fa_to_ce(fa):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
def ce_to_fa(ce):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
<br />
def km2mi(km):<br />
return 0.0 # reikia kilometrus perskaičiuoti į mylias<br />
</syntaxhighlight><br />
Ši pamoka dar yra tvarkoma :)<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Gra%C5%BEinamos_reik%C5%A1m%C4%97s&diff=4426Ap/Py/Gražinamos reikšmės2022-09-18T17:10:43Z<p>Eimutis: /* Savarankiško darbo užduotys su plotais */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpM čia]<br />
==Kodėl reikia gražinti reikšmes==<br />
Lig šiol visos mūsų sukurtos funkcijos rezultatus išvedinėjo į ekraną. Šios funkcijos yra skirtos vienos užduoties vykdymui (skaičiavimams) ir rezultatų vaizdavimui. Tuo tarpu kuriant didesnes programas, yra tikslinga atskirti skaičiavimų dalį nuo rezultatų pateikimo. Tada vienos funkcijos atlieka smulkesnius skaičiavimus, kitos - stambesnius, apjungiančius, ir tik pačioj pabaigoje pateikiami galutiniai rezultatai.<br />
<br />
Mums dažnai reikia tokių funkcijų kaip '''sin(x)''' ar '''cos(x)''', kurios vykdo skaičiavimus ir nerodo jokių rezultatų, bet gautas reikšmes atiduoda jas kvietusiai programai (ar kitai funkcijai). Tokios funkcijos yra vadinamos grąžinančiomis reikšmes funkcijomis. Jų veikimui yra būtinas sakinys '''return''' su paskaičiuota reikšme. Pirmuose pavyzdžiuose tai bus tiesiog skaitinės reikšmės, t.y. konkrečių figūrų plotai. Gautas reikšmes jau galima naudoti sudėtingesnių figūrų, sudarytų iš trikampių, skaičiavimui.<br />
==Python funkcijų specifika==<br />
Tolimesniuose pavyzdžiuose demonstruojama Python savybė, kai galima skaičiuoti ir grąžinti kelias reikšmes, pvz. perimetrą ir plotą. Tokiu atveju grąžinamą reikšmę galima traktuoti kaip vieną, taikant rinkinio sąvoką. Jei kuri nors reikšmė iš grąžinamo rinkinio yra nereikalinga, priimant reikšmes rekomenduojam toje vietoje rašyti pabraukimo ženklą _.<br />
<br />
Tuo pačiu reikia atkreipti dėmesį, kad funkcijos parametrai tik perduoda reikšmes į funkcijos vidų, bet negali grąžinti reikšmės į išorę, kaip buvo C++ atveju, naudojant nuorodas, žymimas & ženklu. Reikšmės yra grąžinamos <br />
tik naudojant sakinį return. Vėliau pamatysite kad galima grąžinti ne tik skaičius, bet ir kitas struktūras, taip kuriant bibliotekas, kurios užtikrina sudėtingų programų kūrimą.<br />
==Savarankiško darbo užduotys su plotais==<br />
[[Vaizdas:MatematikaFig.png|500px|center]]<br />
Pateiktame variante užduotys yra susietos su figūrų perimetro ir ploto skaičiavimo funkcijomis.<br><br />
Taip pat tikslinga išplėsti nagrinėjamų funkcijų tematiką, pasinaudojant fizikos sąvokomis, pvz. nuoseklaus ir ir lygiagretaus jungimo varžų skaičiavimo funkcijos.<br />
<br />
==Matavimo vienetų keitimo funkcijos==<br />
Kaip žinoma iš fizikos, yra įvairių matavimo sistemų: temperatūra matuojama Celsijaus ir Farenheito laipsniais, ilgis matuojamas metrais, jardais, coliais; svoris - kilogramais ir pūdais ir panašiai.<br><br />
Siūloma savarankiškai užbaigti ir išbandyti šias konvertavimo funkcijas:<br />
<syntaxhighlight lang="python"><br />
def fa_to_ce(fa):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
def ce_to_fa(ce):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
<br />
def km2mi(km):<br />
return 0.0 # reikia kilometrus perskaičiuti į mylias<br />
</syntaxhighlight><br />
Ši pamoka dar yra tvarkoma :)<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4425Ap/Py/Sąrašų demonstracija2022-09-18T09:28:37Z<p>Eimutis: </p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Naujovė, lyginant su C++ šeimos kalbomis, yra tai, kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą.<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos len(sąr) pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija sum(sąr) grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą.<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4424Ap/Py/Sąrašų demonstracija2022-09-18T09:24:20Z<p>Eimutis: </p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ar yra bandę Vėžliuko grafiką ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Naujovė, lyginant su C++ šeimos kalbomis, yra tai, kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą.<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos len(sąr) pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija sum(sąr) grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4423Ap/Py/Sąrašų demonstracija2022-09-16T10:07:42Z<p>Eimutis: </p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]. Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Naujovė, lyginant su C++ šeimos kalbomis, yra tai, kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą.<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos len(sąr) pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija sum(sąr) grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/S%C4%85ra%C5%A1%C5%B3_demonstracija&diff=4422Ap/Py/Sąrašų demonstracija2022-09-16T10:07:04Z<p>Eimutis: </p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3Ppw čia]<br><br />
Tai yra trumpas įvadas, skirtas tiems kas jau žino Pascal ar C++ kalbų masyvus ir nori greitai įgauti supratimą apie darbą su Python sąrašais.<br />
===Sąrašai yra indeksuojami===<br />
Sąrašų sąvoka yra glaudžiai susijusi su masyvais, kur prieiga prie atskirų elementų atliekama indeksų pagalba, ką demonstruoja pirmoji šios temos funkcija. Naujovė, lyginant su C++ šeimos kalbomis, yra tai, kad panaudojant neigiamus indeksus patogu nagrinėti sąrašo pabaigą.<br />
=== Sąrašams skirtos funkcijos===<br />
Atliekant sąrašo kaip objekto analizę būtina žinoti, kad jo aktualus dydis nustatomas funkcijos len(sąr) pagalba, todėl parametruose nereikia papildomai nurodyti sąrašo dydžio.<br />
Funkcija sum(sąr) grąžina visų sąraše esančių skaičių sumą. Jei sąraše pasitaiko teksto eilučių, signalizuojama apie klaidą.<br />
===Sąrašo analizė be indeksų===<br />
Pilnai sąrašo analizei galimi ciklai panaudojant indeksus ir be jų. Ciklas for sk in sąr: dažnai yra skaitomas taip “kiekvienam sk iš sąr” (anglų kalba for each). Panagrinėjus šiuos du atvejus detaliau matyti, kad atvejis be indeksų yra paprastesnis, mažiau galimybių suklysti, todėl ir yra rekomenduojamas naudoti ten, kur indeksai nebūtini.<br />
===Sąrašo analizė su indeksais===<br />
Kita sąrašo ypatybė yra ta, kad sąrašą galima eigoje papildyti naudojant funkciją sąr.append(sk), kas yra svarbu dinamiškai formuojant sąrašus.<br />
Jei užduotyje yra nagrinėjami sąrašo elementų tarpusavio santykiai (pvz. važiuojama į kalną ar leidžiamasi), tai tokiu atveju geriau naudoti indeksus, kas ir parodyta demo funkcijoje.<br />
<br />
Žinių apie sąrašus įtvirtinimui pateikiamos kelios užduotys.<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py&diff=4421Ap/Py2022-09-15T10:24:21Z<p>Eimutis: </p>
<hr />
<div>== Aktyvių pamokų Python turinys ==<br />
<br />
;[[ap/Py/Pamoka_A0|Smagi pradžia - pasidžiaukime]]<br />
: Pamatysite kaip natūralu, lengva ir smagu su Python <br />
;[[ap/Py/Pamoka_A1|Labas pasauli - pradedame su funkcijomis]]<br />
: Pamatysite kaip veikia funkcijos ir ką reiškia parametrai<br />
;[[ap/Py/Pamoka_A2|Range intervalai - išbandome ciklų jėgą]]<br />
: Susipažinsite kaip efektyviai užrašyti kartojimus<br />
;[[ap/Py/Figūrų_konstravimas|Figūrų konstravimas - Simbolių dėlionės]]<br />
: Ciklų pagalba konstruosime figūras iš spausdinamų simbolių<br />
;[[ap/Py/Formulės_tapatybės|Matematinės formulės - tiriame tapatybes]]<br />
: Tikriname kaip mokame rašyti matematines formules<br />
;[[ap/Py/Gražinamos_reikšmės|Funkcijų galimybė gražinti reikšmes]]<br />
: Pagrindinė funkcijų savybė yra gražinti suformuotas reikšmes<br />
;[[ap/Py/Sąrašų_demonstracija|Įžanga į sąrašus - konkretūs pavyzdžiai]]<br />
: Pavyzdžių pagalba aptarsime kaip konstruoti ir analizuoti sąrašus<br />
;[[ap/Py/Iškarpų_demonstracija|Iškarpos (slice) - dalinių sąrašų atvejis]]<br />
: Išsiaiškinsime kaip iškarpų pagalba sudaryti dalinius sąrašų ar eilučių atvejus<br />
;[[ap/Py/Lyginame_Cpp_Py|Lyginame sprendimus su C++ ir Python]]<br />
: Tą patį uždavinį sprendžiame su C++ ir Python<br />
;[[ap/Py/VBE_su_Python|VBE sprendimai su Python]]<br />
: Pateikiami VBE sprendimai su Python<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Gra%C5%BEinamos_reik%C5%A1m%C4%97s&diff=4420Ap/Py/Gražinamos reikšmės2022-09-12T16:51:50Z<p>Eimutis: /* Matavimo vienetų keitimo funkcijos */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpM čia]<br />
==Kodėl reikia gražinti reikšmes==<br />
Lig šiol visos mūsų sukurtos funkcijos rezultatus išvedinėjo į ekraną. Šios funkcijos yra skirtos vienos užduoties vykdymui (skaičiavimams) ir rezultatų vaizdavimui. Tuo tarpu kuriant didesnes programas, yra tikslinga atskirti skaičiavimų dalį nuo rezultatų pateikimo. Tada vienos funkcijos atlieka smulkesnius skaičiavimus, kitos - stambesnius, apjungiančius, ir tik pačioj pabaigoje pateikiami galutiniai rezultatai.<br />
<br />
Mums dažnai reikia tokių funkcijų kaip '''sin(x)''' ar '''cos(x)''', kurios vykdo skaičiavimus ir nerodo jokių rezultatų, bet gautas reikšmes atiduoda jas kvietusiai programai (ar kitai funkcijai). Tokios funkcijos yra vadinamos grąžinančiomis reikšmes funkcijomis. Jų veikimui yra būtinas sakinys '''return''' su paskaičiuota reikšme. Pirmuose pavyzdžiuose tai bus tiesiog skaitinės reikšmės, t.y. konkrečių figūrų plotai. Gautas reikšmes jau galima naudoti sudėtingesnių figūrų, sudarytų iš trikampių, skaičiavimui.<br />
==Python funkcijų specifika==<br />
Tolimesniuose pavyzdžiuose demonstruojama Python savybė, kai galima skaičiuoti ir grąžinti kelias reikšmes, pvz. perimetrą ir plotą. Tokiu atveju grąžinamą reikšmę galima traktuoti kaip vieną, taikant rinkinio sąvoką. Jei kuri nors reikšmė iš grąžinamo rinkinio yra nereikalinga, priimant reikšmes rekomenduojam toje vietoje rašyti pabraukimo ženklą _.<br />
<br />
Tuo pačiu reikia atkreipti dėmesį, kad funkcijos parametrai tik perduoda reikšmes į funkcijos vidų, bet negali grąžinti reikšmės į išorę, kaip buvo C++ atveju, naudojant nuorodas, žymimas & ženklu. Reikšmės yra grąžinamos <br />
tik naudojant sakinį return. Vėliau pamatysite kad galima grąžinti ne tik skaičius, bet ir kitas struktūras, taip kuriant bibliotekas, kurios užtikrina sudėtingų programų kūrimą.<br />
==Savarankiško darbo užduotys su plotais==<br />
[[Vaizdas:MatematikaFig.png|500px|center]]<br />
Pateiktame variante užduotys yra susietos su figūrų perimetro ir ploto skaičiavimu. Tikslinga išplėsti nagrinėjamų funkcijų tematiką, pasinaudojant fizikos sąvokomis.<br />
==Matavimo vienetų keitimo funkcijos==<br />
Kaip žinoma iš fizikos, yra įvairių matavimo sistemų: temperatūra matuojama Celsijaus ir Farenheito laipsniais, ilgis matuojamas metrais, jardais, coliais; svoris - kilogramais ir pūdais ir panašiai.<br><br />
Siūloma savarankiškai užbaigti ir išbandyti šias konvertavimo funkcijas:<br />
<syntaxhighlight lang="python"><br />
def fa_to_ce(fa):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
def ce_to_fa(ce):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
<br />
def km2mi(km):<br />
return 0.0 # reikia kilometrus perskaičiuti į mylias<br />
</syntaxhighlight><br />
Ši pamoka dar yra tvarkoma :)<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Gra%C5%BEinamos_reik%C5%A1m%C4%97s&diff=4419Ap/Py/Gražinamos reikšmės2022-09-12T16:50:57Z<p>Eimutis: </p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpM čia]<br />
==Kodėl reikia gražinti reikšmes==<br />
Lig šiol visos mūsų sukurtos funkcijos rezultatus išvedinėjo į ekraną. Šios funkcijos yra skirtos vienos užduoties vykdymui (skaičiavimams) ir rezultatų vaizdavimui. Tuo tarpu kuriant didesnes programas, yra tikslinga atskirti skaičiavimų dalį nuo rezultatų pateikimo. Tada vienos funkcijos atlieka smulkesnius skaičiavimus, kitos - stambesnius, apjungiančius, ir tik pačioj pabaigoje pateikiami galutiniai rezultatai.<br />
<br />
Mums dažnai reikia tokių funkcijų kaip '''sin(x)''' ar '''cos(x)''', kurios vykdo skaičiavimus ir nerodo jokių rezultatų, bet gautas reikšmes atiduoda jas kvietusiai programai (ar kitai funkcijai). Tokios funkcijos yra vadinamos grąžinančiomis reikšmes funkcijomis. Jų veikimui yra būtinas sakinys '''return''' su paskaičiuota reikšme. Pirmuose pavyzdžiuose tai bus tiesiog skaitinės reikšmės, t.y. konkrečių figūrų plotai. Gautas reikšmes jau galima naudoti sudėtingesnių figūrų, sudarytų iš trikampių, skaičiavimui.<br />
==Python funkcijų specifika==<br />
Tolimesniuose pavyzdžiuose demonstruojama Python savybė, kai galima skaičiuoti ir grąžinti kelias reikšmes, pvz. perimetrą ir plotą. Tokiu atveju grąžinamą reikšmę galima traktuoti kaip vieną, taikant rinkinio sąvoką. Jei kuri nors reikšmė iš grąžinamo rinkinio yra nereikalinga, priimant reikšmes rekomenduojam toje vietoje rašyti pabraukimo ženklą _.<br />
<br />
Tuo pačiu reikia atkreipti dėmesį, kad funkcijos parametrai tik perduoda reikšmes į funkcijos vidų, bet negali grąžinti reikšmės į išorę, kaip buvo C++ atveju, naudojant nuorodas, žymimas & ženklu. Reikšmės yra grąžinamos <br />
tik naudojant sakinį return. Vėliau pamatysite kad galima grąžinti ne tik skaičius, bet ir kitas struktūras, taip kuriant bibliotekas, kurios užtikrina sudėtingų programų kūrimą.<br />
==Savarankiško darbo užduotys su plotais==<br />
[[Vaizdas:MatematikaFig.png|500px|center]]<br />
Pateiktame variante užduotys yra susietos su figūrų perimetro ir ploto skaičiavimu. Tikslinga išplėsti nagrinėjamų funkcijų tematiką, pasinaudojant fizikos sąvokomis.<br />
==Matavimo vienetų keitimo funkcijos==<br />
Kaip žinoma iš fizikos, yra įvairių matavimo sistemų: temperatūra matuojama Celsijaus ir Farenheito laipsniais, ilgis matuojamas metrais, jardais, coliais; svoris - kilogramais ir pūdais ir panašiai.<br><br />
Siūloma savarankiškai užbaigti ir išbandyti šias konvertavimo funkcijas:<br />
<syntaxhighlight lang="python"><br />
def fa_to_ce(fa):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
def ce_to_fa(ce):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
<br />
def km2mi(km):<br />
return 0.0 # reikia kilometrus perskaičiuti į mylias<br />
</syntaxhighlight><br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Gra%C5%BEinamos_reik%C5%A1m%C4%97s&diff=4418Ap/Py/Gražinamos reikšmės2022-09-12T14:30:46Z<p>Eimutis: /* Matavimo vienetų keitimo funkcijos */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpM čia]<br />
==Kodėl reikia gražinti reikšmes==<br />
Lig šiol visos mūsų sukurtos funkcijos rezultatus išvedinėjo į ekraną. Šios funkcijos yra skirtos vienos užduoties vykdymui (skaičiavimams) ir rezultatų vaizdavimui. Tuo tarpu kuriant didesnes programas, yra tikslinga atskirti skaičiavimų dalį nuo rezultatų pateikimo. Tada vienos funkcijos atlieka smulkesnius skaičiavimus, kitos - stambesnius, apjungiančius, ir tik pačioj pabaigoje pateikiami galutiniai rezultatai.<br />
<br />
Mums dažnai reikia tokių funkcijų kaip '''sin(x)''' ar '''cos(x)''', kurios vykdo skaičiavimus ir nerodo jokių rezultatų, bet gautas reikšmes atiduoda jas kvietusiai programai (ar kitai funkcijai). Tokios funkcijos yra vadinamos grąžinančiomis reikšmes funkcijomis. Jų veikimui yra būtinas sakinys '''return''' su paskaičiuota reikšme. Pirmuose pavyzdžiuose tai bus tiesiog skaitinės reikšmės, t.y. konkrečių figūrų plotai. Gautas reikšmes jau galima naudoti sudėtingesnių figūrų, sudarytų iš trikampių, skaičiavimui.<br />
<br />
Tolimesniuose pavyzdžiuose demonstruojama Python savybė, kai galima skaičiuoti ir grąžinti kelias reikšmes, pvz. perimetrą ir plotą. Tokiu atveju grąžinamą reikšmę galima traktuoti kaip vieną, taikant rinkinio sąvoką. Jei kuri nors reikšmė iš grąžinamo rinkinio yra nereikalinga, priimant reikšmes rekomenduojam toje vietoje rašyti pabraukimo ženklą _.<br />
==Python funkcijų specifika==<br />
Tuo pačiu reikia atkreipti dėmesį, kad funkcijos parametrai tik perduoda reikšmes į funkcijos vidų, bet negali grąžinti reikšmės į išorę, kaip buvo C++ atveju, naudojant nuorodas, žymimas & ženklu. Reikšmės yra grąžinamos <br />
tik naudojant sakinį return. Vėliau pamatysite kad galima grąžinti ne tik skaičius, bet ir kitas struktūras, taip kuriant bibliotekas, kurios užtikrina sudėtingų programų kūrimą.<br />
==Savarankiško darbo užduotys su plotais==<br />
[[Vaizdas:MatematikaFig.png|500px|center]]<br />
Pateiktame variante užduotys yra susietos su figūrų perimetro ir ploto skaičiavimu. Tikslinga išplėsti nagrinėjamų funkcijų tematiką, pasinaudojant fizikos sąvokomis.<br />
==Matavimo vienetų keitimo funkcijos==<br />
Kaip žinoma iš fizikos, yra įvairių matavimo sistemų: temperatūra matuojama Celsijaus ir Farenheito laipsniais, ilgis matuojamas metrais, jardais, coliais; svoris - kilogramais ir pūdais ir panašiai.<br><br />
Siūloma savarankiškai užbaigti ir išbandyti šias konvertavimo funkcijas:<br />
<syntaxhighlight lang="python"><br />
def fa_to_ce(fa):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
def ce_to_fa(ce):<br />
return 0.0 # reikia gražinti Farenkeito laipsnius<br />
<br />
def km2mi(km):<br />
return 0.0 # reikia kilometrus perskaičiuti į mylias<br />
</syntaxhighlight><br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Gra%C5%BEinamos_reik%C5%A1m%C4%97s&diff=4417Ap/Py/Gražinamos reikšmės2022-09-12T14:21:05Z<p>Eimutis: /* Matavimo vienetų keitimo funkcijos */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpM čia]<br />
==Kodėl reikia gražinti reikšmes==<br />
Lig šiol visos mūsų sukurtos funkcijos rezultatus išvedinėjo į ekraną. Šios funkcijos yra skirtos vienos užduoties vykdymui (skaičiavimams) ir rezultatų vaizdavimui. Tuo tarpu kuriant didesnes programas, yra tikslinga atskirti skaičiavimų dalį nuo rezultatų pateikimo. Tada vienos funkcijos atlieka smulkesnius skaičiavimus, kitos - stambesnius, apjungiančius, ir tik pačioj pabaigoje pateikiami galutiniai rezultatai.<br />
<br />
Mums dažnai reikia tokių funkcijų kaip '''sin(x)''' ar '''cos(x)''', kurios vykdo skaičiavimus ir nerodo jokių rezultatų, bet gautas reikšmes atiduoda jas kvietusiai programai (ar kitai funkcijai). Tokios funkcijos yra vadinamos grąžinančiomis reikšmes funkcijomis. Jų veikimui yra būtinas sakinys '''return''' su paskaičiuota reikšme. Pirmuose pavyzdžiuose tai bus tiesiog skaitinės reikšmės, t.y. konkrečių figūrų plotai. Gautas reikšmes jau galima naudoti sudėtingesnių figūrų, sudarytų iš trikampių, skaičiavimui.<br />
<br />
Tolimesniuose pavyzdžiuose demonstruojama Python savybė, kai galima skaičiuoti ir grąžinti kelias reikšmes, pvz. perimetrą ir plotą. Tokiu atveju grąžinamą reikšmę galima traktuoti kaip vieną, taikant rinkinio sąvoką. Jei kuri nors reikšmė iš grąžinamo rinkinio yra nereikalinga, priimant reikšmes rekomenduojam toje vietoje rašyti pabraukimo ženklą _.<br />
==Python funkcijų specifika==<br />
Tuo pačiu reikia atkreipti dėmesį, kad funkcijos parametrai tik perduoda reikšmes į funkcijos vidų, bet negali grąžinti reikšmės į išorę, kaip buvo C++ atveju, naudojant nuorodas, žymimas & ženklu. Reikšmės yra grąžinamos <br />
tik naudojant sakinį return. Vėliau pamatysite kad galima grąžinti ne tik skaičius, bet ir kitas struktūras, taip kuriant bibliotekas, kurios užtikrina sudėtingų programų kūrimą.<br />
==Savarankiško darbo užduotys su plotais==<br />
[[Vaizdas:MatematikaFig.png|500px|center]]<br />
Pateiktame variante užduotys yra susietos su figūrų perimetro ir ploto skaičiavimu. Tikslinga išplėsti nagrinėjamų funkcijų tematiką, pasinaudojant fizikos sąvokomis.<br />
==Matavimo vienetų keitimo funkcijos==<br />
Kaip žinoma iš fizikos, yra įvairių matavimo sistemų: temperatūra matuojama Celsijaus ir Farenheito laipsniais, ilgis matuojamas metrais, jardais, coliais; svoris - kilogramais ir pūdais ir panašiai.<br><br />
Siūloma savarankiškai užbaigti ir išbandyti šias konvertavimo funkcijas:<br />
<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Gra%C5%BEinamos_reik%C5%A1m%C4%97s&diff=4416Ap/Py/Gražinamos reikšmės2022-09-12T12:51:24Z<p>Eimutis: </p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpM čia]<br />
==Kodėl reikia gražinti reikšmes==<br />
Lig šiol visos mūsų sukurtos funkcijos rezultatus išvedinėjo į ekraną. Šios funkcijos yra skirtos vienos užduoties vykdymui (skaičiavimams) ir rezultatų vaizdavimui. Tuo tarpu kuriant didesnes programas, yra tikslinga atskirti skaičiavimų dalį nuo rezultatų pateikimo. Tada vienos funkcijos atlieka smulkesnius skaičiavimus, kitos - stambesnius, apjungiančius, ir tik pačioj pabaigoje pateikiami galutiniai rezultatai.<br />
<br />
Mums dažnai reikia tokių funkcijų kaip '''sin(x)''' ar '''cos(x)''', kurios vykdo skaičiavimus ir nerodo jokių rezultatų, bet gautas reikšmes atiduoda jas kvietusiai programai (ar kitai funkcijai). Tokios funkcijos yra vadinamos grąžinančiomis reikšmes funkcijomis. Jų veikimui yra būtinas sakinys '''return''' su paskaičiuota reikšme. Pirmuose pavyzdžiuose tai bus tiesiog skaitinės reikšmės, t.y. konkrečių figūrų plotai. Gautas reikšmes jau galima naudoti sudėtingesnių figūrų, sudarytų iš trikampių, skaičiavimui.<br />
<br />
Tolimesniuose pavyzdžiuose demonstruojama Python savybė, kai galima skaičiuoti ir grąžinti kelias reikšmes, pvz. perimetrą ir plotą. Tokiu atveju grąžinamą reikšmę galima traktuoti kaip vieną, taikant rinkinio sąvoką. Jei kuri nors reikšmė iš grąžinamo rinkinio yra nereikalinga, priimant reikšmes rekomenduojam toje vietoje rašyti pabraukimo ženklą _.<br />
==Python funkcijų specifika==<br />
Tuo pačiu reikia atkreipti dėmesį, kad funkcijos parametrai tik perduoda reikšmes į funkcijos vidų, bet negali grąžinti reikšmės į išorę, kaip buvo C++ atveju, naudojant nuorodas, žymimas & ženklu. Reikšmės yra grąžinamos <br />
tik naudojant sakinį return. Vėliau pamatysite kad galima grąžinti ne tik skaičius, bet ir kitas struktūras, taip kuriant bibliotekas, kurios užtikrina sudėtingų programų kūrimą.<br />
==Savarankiško darbo užduotys su plotais==<br />
[[Vaizdas:MatematikaFig.png|500px|center]]<br />
Pateiktame variante užduotys yra susietos su figūrų perimetro ir ploto skaičiavimu. Tikslinga išplėsti nagrinėjamų funkcijų tematiką, pasinaudojant fizikos sąvokomis.<br />
==Matavimo vienetų keitimo funkcijos==<br />
Celsijus -> Farenheitas<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Ap/Py/Gra%C5%BEinamos_reik%C5%A1m%C4%97s&diff=4415Ap/Py/Gražinamos reikšmės2022-09-12T12:50:00Z<p>Eimutis: /* Kodėl reikia gražinti reikšmes */</p>
<hr />
<div>Pilnas šios treniruotės Python kodas yra [https://www.jdoodle.com/a/3RpM čia]<br />
==Kodėl reikia gražinti reikšmes==<br />
Lig šiol visos mūsų sukurtos funkcijos rezultatus išvedinėjo į ekraną. Šios funkcijos yra skirtos vienos užduoties vykdymui (skaičiavimams) ir rezultatų vaizdavimui. Tuo tarpu kuriant didesnes programas, yra tikslinga atskirti skaičiavimų dalį nuo rezultatų pateikimo. Tada vienos funkcijos atlieka smulkesnius skaičiavimus, kitos - stambesnius, apjungiančius, ir tik pačioj pabaigoje pateikiami galutiniai rezultatai.<br />
<br />
Mums dažnai reikia tokių funkcijų kaip sin() ar cos(), kurios vykdo skaičiavimus ir nerodo jokių rezultatų, bet gautas reikšmes atiduoda jas kvietusiai programai (ar kitai funkcijai). Tokios funkcijos yra vadinamos grąžinančiomis reikšmes funkcijomis. Jų veikimui yra būtinas sakinys '''return''' su paskaičiuota reikšme. Pirmuose pavyzdžiuose tai bus tiesiog skaitinės reikšmės, t.y. konkrečių figūrų plotai. Gautas reikšmes jau galima naudoti sudėtingesnių figūrų, sudarytų iš trikampių, skaičiavimui.<br />
<br />
Tolimesniuose pavyzdžiuose demonstruojama Python savybė, kai galima skaičiuoti ir grąžinti kelias reikšmes, pvz. perimetrą ir plotą. Tokiu atveju grąžinamą reikšmę galima traktuoti kaip vieną, taikant rinkinio sąvoką. Jei kuri nors reikšmė iš grąžinamo rinkinio yra nereikalinga, priimant reikšmes rekomenduojam toje vietoje rašyti pabraukimo ženklą _.<br />
==Python funkcijų specifika==<br />
Tuo pačiu reikia atkreipti dėmesį, kad funkcijos parametrai tik perduoda reikšmes į funkcijos vidų, bet negali grąžinti reikšmės į išorę, kaip buvo C++ atveju, naudojant nuorodas, žymimas & ženklu. Reikšmės yra grąžinamos <br />
tik naudojant sakinį return. Vėliau pamatysite kad galima grąžinti ne tik skaičius, bet ir kitas struktūras, taip kuriant bibliotekas, kurios užtikrina sudėtingų programų kūrimą.<br />
==Savarankiško darbo užduotys su plotais==<br />
[[Vaizdas:MatematikaFig.png|500px|center]]<br />
Pateiktame variante užduotys yra susietos su figūrų perimetro ir ploto skaičiavimu. Tikslinga išplėsti nagrinėjamų funkcijų tematiką, pasinaudojant fizikos sąvokomis.<br />
==Matavimo vienetų keitimo funkcijos==<br />
Celsijus -> Farenheitas<br />
{{navigation |previous=BEGINNING |next=END}}</div>Eimutishttps://wiki.angis.net/index.php?title=Vaizdas:MatematikaFig.png&diff=4414Vaizdas:MatematikaFig.png2022-09-12T12:18:52Z<p>Eimutis: Eimutis įkėlė naują Vaizdas:MatematikaFig.png versiją</p>
<hr />
<div></div>Eimutis