Knyga/Sąrašai: Skirtumas tarp puslapio versijų

17:54, 16 gegužės 2025 versija

Sąrašai

Kintamieji, turintys daugiau nei vieną reikšmę

Tu jau žinai įprastus kintamuosius, kuriuose saugoma viena reikšmė. Tačiau kiti kintamųjų tipai gali turėti daugiau nei vieną reikšmę. Jie vadinami konteineriais (containers), nes juose gali būti daugiau nei vienas objektas. Paprasčiausias tipas vadinamas sąrašu (list). Sąrašo pavyzdys:

MĖNESIAI = ["Sausis", "Vasaris", "Kovas", "Balandis", "Gegužė", "Birželis", "Liepa",
          "Rugpjūtis", "Rugsėjis", "Spalis", "Lapkritis", "Gruodis"]
kuris = int(input("Kuris mėnuo (1-12)? "))

if 1 <= kuris <= 12:
    print("Mėnuo yra ", MĖNESIAI[kuris - 1])

pavyzdžio išvestis būtų:

Kuris mėnuo (1-12)? 3
Mėnuo yra Kovas

Šiame pavyzdyje mėnesiai yra sąrašas. Kintamasis mėnesiai yra apibrėžtas šia eilute mėnesiai = ["Sausis", "Vasaris", "Kovas", "Balandis", "Gegužė", "Birželis", "Liepa", ir "Rugpjūtis", "Rugsėjis", "Spalis", "Lapkritis", "Gruodis"] (atkreipk dėmesį, kad viena komanda parašyta per dvi eilutes; paprastai keliant eilutę yra naudojamas simbolis / tačiau šiuo atveju jis nėra būtinas, nes Python'as supranta, kad viskas, kas yra laužtiniuose skliaustuose yra kartu). [ ir ] pradeda ir užbaigia sąrašą, o kableliai (,) atskiria sąrašo elementus. Sąrašas naudojamas šioje dalyje: mėnesiai[kuris - 1]. Sąrašas susideda iš elementų, kurie sunumeruoti pradedant nuo 0. Kitaip tariant, norint sąraše pasiekti elementą "Sausis", turėtum rašyti mėnesiai[0]. Nurodant sąrašui skaičių, tu gauni reikšmę išsaugotą toje sąrašo pozicijoje.

Sąlyginis sakinys if 1 <= kuris <= 12: tikrina, ar skaičius kintamajame kuris yra tarp vieno ir dvylikos imtinai (tiek yra mėnesių ir taip jie numeruojami).

Viename sąraše gali būti saugomi ir skirtingų tipų duomenys. Kiekvienas elementas saugo vis kitą reikšmę. Pavyzdžiui, sąrašas sukurtas šiuo kodu: demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9] atrodytų taip:

elemento numeris	0	1	2	3	4	5
demoSąrašas	"gyvybė"	42	"visata"	6	"ir"	9

Kiekvienas elementas pasiekiamas per jo eilės numerį – indeksą, todėl komanda demoSąrašas[0] pateiktų reikšmę: "gyvybė", o komanda demoSąrašas[1] – reikšmę 42 ir taip toliau iki kol demoSąrašas[5] pateikia reikšmę 9.

Daugiau sąrašų funkcijų

Kitas pavyzdys yra skirtas parodyti daugybę kitų dalykų, kuriuos gali padaryti sąrašai (šį kartą nesitikiu, kad viską pats sugebėsi parašyti, bet tikriausiai turėtum šiek tiek pažaisti su sąrašais interaktyviame režime, kol apsiprasi su jais). Pavyzdys:

demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]
print("demoSąrašas = ", demoSąrašas)
demoSąrašas.append("oras")
print("po 'oras' pridėjimo, demoSąrašas atrodo taip:")
print(demoSąrašas)
print("len(demoSąrašas) =", len(demoSąrašas))
print("demoSąrašas.index(42) =", demoSąrašas.index(42))
print("demoSąrašas[1] =", demoSąrašas[1])

# o dabar mes pereisime per visą sąrašą "for" ciklu
for c in range(len(demoSąrašas)):
    print("demoSąrašas[", c, "] =", demoSąrašas[c])

del demoSąrašas[2]
print("Po 'visata' pašalinimo, demoSąrašas atrodo taip:")
print(demoSąrašas)
if "gyvybė" in demoSąrašas:
    print("'gyvybė' buvo rasta kintamajame demoSąrašas")
else:
    print("'gyvybė' nebuvo rasta kintamajame demoSąrašas")

if "ameba" in demoSąrašas:
    print("'ameba' buvo rasta kintamajame demoSąrašas")

if "ameba" not in demoSąrašas:
    print("'ameba' nebuvo rasta kintamajame demoSąrašas")

kitasSąrašas = [42, 7, 0, 123]
kitasSąrašas.sort()
print("Išrikiuotas kitasSąrašas atrodo taip", kitasSąrašas)

Kodo išvestis būtų tokia:

demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9]
po "oras" pridėjimo, demoSąrašas atrodo taip:
["gyvybė", 42, "visata", 6, "ir", 9, "oras"]
len(demoSąrašas) = 7
demoSąrašas.index(42) = 1
demoSąrašas[1] = 42
demoSąrašas[ 0 ] = gyvybė
demoSąrašas[ 1 ] = 42
demoSąrašas[ 2 ] = visata
demoSąrašas[ 3 ] = 6
demoSąrašas[ 4 ] = ir
demoSąrašas[ 5 ] = 9
demoSąrašas[ 6 ] = oras
Po 'visata' pašalinimo, demoSąrašas atrodo taip:
["gyvybė", 42, 6, "ir", 9, "oras"]
"gyvybė" buvo rasta kintamajame demoSąrašas
"ameba" nebuvo rasta kintamajame demoSąrašas
Išrikiuotas kitasSąrašas atrodo taip [0, 7, 42, 123]

Šiame pavyzdyje rasi daug naujų funkcijų. Atkreipk dėmesį, kad gali tiesiog atspausdinti (print) visą sąrašą. Toliau funkcija append naudojama tam, kad pridėtum naują elementą į sąrašo pabaigą. len grąžina kiek elementų yra sąraše. Tinkami sąrašo indeksai (skaičiai kuriuos naudojame viduje laužtinių skliaustų []) yra nuo 0 iki len - 1. Funkcija index nurodo, kur sąraše yra pirmoji elemento vieta. Atkreipk dėmesį, kaip demoSąrašas.index(42) pateikia 1, o paleidus demoSąrašas[1] grąžina 42. Norint gauti pagalbos dėl visų sąrašo funkcijų, įvykdyk komandą help(list) interaktyviajame Python'o interpretatoriuje.

Eilutė # o dabar mes pereisime per visą sąrašą for ciklu yra tik priminimas programuotojui (dar vadinamas kaip „komentaras“). Python'as ignoruoja viską, kas parašyta esamoje eilutėje po simbolio #. Toliau eilutės:

for c in range(len(demoSąrašas)):
    print("demoSąrašas[", c, "] =", demoSąrašas[c])

sukuria kintamajį c, kuris prasideda nuo 0 ir didinamas vienetu, kol pasiekia paskutinį sąrašo indeksą. Tuo tarpu print komanda išspausdina kiekvieną sąrašo elementą.

Daug geresnis būdas tai padaryti:

for c, x in enumerate(demoSąrašas):
    print("demoSąrašas[", c, "] =", x)

Komanda del gali būti naudojama tam tikram sąrašo elementui pašalinti. Kitos kelios eilutės naudoja in operatorių, kad patikrintų, ar elementas yra sąraše, ar ne. Funkcija sort rūšiuoja sąrašą. Tai naudinga, jei tau reikia sąrašo nuo mažiausio iki didžiausio arba abėcėlės tvarka. Atmink, kad tai pakeičia sąrašą. Apibendrinant, su sąrašu yra atliekami šie veiksmai:

pavyzdys	paaiškinimas
`demoSąrašas[2]`	grąžina 2 sąrašo demoSąrašas elementą
`demoSąrašas[2] = 3`	į sąrašo demoSąrašas 2 poziciją (numeruojama nuo 0) įrašo reikšmę 3
`del demoSąrašas[2]`	pašalina sąrašo demoSąrašas elementą, esantį 2 pozicijoje
`len(demoSąrašas)`	grąžina `demoSąrašas` sąrašo ilgį, t.y. elementų skaičių
`"reikšmė" in demoSąrašas`	yra True jeigu `"reikšmė"` yra elementas, priklausantis `demoSąrašas`
`"reikšmė" not in demoSąrašas`	yra True jeigu `"reikšmė"` nėra elementas, priklausantis `demoSąrašas`
`kitasSąrašas.sort()`	surūšiuoja `kitasSąrašas`. Atmink, kad rūšiavimas pavyktų, visi sąrašo elementai turi būti arba skaičiai, arba eilutės (string).
`demoSąrašas.index("reikšmė")`	grąžina pirmosios vietos, kurioje atsiranda `"reikšmė"`, indeksą
`demoSąrašas.append("reikšmė")`	sąrašo pabaigoje prideda elementą `"reikšmė"`
`demoSąrašas.remove("reikšmė")`	pašalina pirmą rastą elementą su nurodyta reikšme iš `demoSąrašas` (taip pat, kaip `del demoSąrašas[demoSąrašas.index("reikšmė")]`)

Pavyzdžiai, kur praktiškai naudojamos šios funkcijos:

meniuElementas = 0
vardųSarašas = []
while meniuElementas != 9:
    print("--------------------")
    print("1. Spausdinti sąrašą")
    print("2. Pridėti vardą prie sąrašo")
    print("3. Pašalinti vardą iš sąrašo")
    print("4. Pakeisti elementą sąraše")
    print("9. Išeiti")
    meniuElementas = int(input("Pasirinkite elementą iš meniu: "))
    if meniuElementas == 1:
        dabartinis = 0
        if len(vardųSarašas) > 0:
            while dabartinis < len(vardųSarašas):
                print(dabartinis, ".", vardųSarašas[dabartinis])
                dabartinis = dabartinis + 1
        else:
            print("Sąrašas tuščias")
    elif meniuElementas == 2:
        vardas = input("Įveskite vardą, kurį norite pridėti: ")
        vardųSarašas.append(vardas)
    elif meniuElementas == 3:
        šalinamasVardas = input("Kokį vardą norėtumėte pašalinti:")
        if šalinamasVardas in vardųSarašas:
            # vardųSarašas.remove(šalinamasVardas) veiktų taip pat gerai
            elementoIndeksas = vardųSarašas.index(šalinamasVardas)
            del vardųSarašas[elementoIndeksas]
            # Aukščiau pateiktas kodas pašalina tik pirmąjį surasta vardą.
            # Žemiau esantis kodas pašalina visus.
            # while šalinamasVardas in vardųSarašas:
            #       elementoIndeksas = vardųSarašas.index(šalinamasVardas)
            #       del vardųSarašas[elementoIndeksas]
        else:
            print(šalinamasVardas, "nerastas")
    elif meniuElementas == 4:
        senasVardas = input("Kokį vardą norėtumėte pakeisti:")
        if senasVardas in vardųSarašas:
            elementoIndeksas = vardųSarašas.index(senasVardas)
            naujasVardas = input("Koks yra naujas vardas: ")
            vardųSarašas[elementoIndeksas] = naujasVardas
        else:
            print(senasVardas, "nerastas")

print("Iki pasimatymo")

Ir čia yra išvesties dalis:

--------------------
1. Spausdinti sąrašą
2. Pridėti vardą prie sąrašo
3. Pašalinti vardą iš sąrašo
4. Pakeisti elementą sąraše
9. Išeiti

Pasirinkite elementą iš meniu: 2
Įveskite vardą, kurį norite pridėti: Benas

Pasirinkite elementą iš meniu: 2
Įveskite vardą, kurį norite pridėti: Liepa

Pasirinkite elementą iš meniu: 1
0. Benas
1. Liepa

Pasirinkite elementą iš meniu: 3
Kokį vardą norėtumėte pašalinti: Benas

Pasirinkite elementą iš meniu: 4
Kokį vardą norėtumėte pakeisti: Liepa
Koks yra naujas vardas: Liepa Petraitė

Pasirinkite elementą iš meniu: 1
0. Liepa Petraitė

Pasirinkite elementą iš meniu: 9
Iki pasimatymo

Tai buvo ilga programa. Panagrinėkime pirminį programos tekstą. Eilutė vardųSarašas = [] sukuria kintamajį vardųSarašas, tuščia sąrašą, be elementų. Kita svarbi eilutė yra while meniuElementas != 9:. Ši eilutė pradeda ciklą, leidžiantį šios programos meniu sistemai veikti. Kitos eilutės parodo meniu ir nusprendžia, kurią programos dalį paleisti.

Ši dalis:

dabartinis = 0
    if len(vardųSarašas) > 0:
        while dabartinis < len(vardųSarašas):
            print(dabartinis, ".", vardųSarašas[dabartinis])
            dabartinis = dabartinis + 1
    else:
        print("Sąrašas tuščias")

eina per sąrašą ir spausdina kiekvieną vardą. len(vardųSarašas) nurodo, kiek elementų yra sąraše. Jei len grąžina 0, tai reiškia sąrašas tuščias.

Toliau po kelių eilučių matysi sakinį vardųSarašas.append(vardas). Jis naudoja funkciją append, kad pridėtų elementą į sąrašo pabaigą. Peršokus dar dvi eilutes, pastebėsi šią kodo dalį:

elementoIndeksas = vardųSarašas.index(šalinamasVardas)
del vardųSarašas[elementoIndeksas]

Čia funkcija index yra naudojama norint rasti indekso reikšmę, kuri vėliau bus naudojama elementui pašalinti. del vardųSarašas[elementoIndeksas] naudojamas sąrašo elementui pašalinti.

Kitoje kodo dalyje

senasVardas = input("Kokį vardą norėtumėte pakeisti:")
if senasVardas in vardųSarašas:
    elementoIndeksas = vardųSarašas.index(senasVardas)
    naujasVardas = input("Koks yra naujas vardas: ")
    vardųSarašas[elementoIndeksas] = naujasVardas
else:
    print(senasVardas, "nerastas")

naudojamas index, kad surastų elementoIndeksas ir tada įdėtų naujasVardas ten, kur buvo senasVardas.

Sveikinu, perpratus sąrašus, dabar tu pakankamai žinai kalbą, kad galėtum atlikti bet kokius skaičiavimus, kuriuos gali atlikti kompiuteris (tai techniškai žinoma kaip Turing-Completeness). Žinoma, vis dar yra daug funkcijų, kurias naudojant tu pasilengvinsi sau gyvenimą.

Sąrašo generavimas naudojant Range funkciją

Range funkciją tau jau teko naudoti kartu su for ciklais. range funkcija grąžina iteraciją (proceso kartojimas skirtas rezultatų sekos generavimui). Range funkcijoje nurodytą intervalą galima paversti sąrašu naudojant funkciją list. Štai keli pavyzdžiai, parodantys, kas nutinka su komanda range:

>>> range(1, 10)
range(1, 10)
>>> list(range(1, 10))
[1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(-32, -20))
[-32, -31, -30, -29, -28, -27, -26, -25, -24, -23, -22, -21]
>>> list(range(5,21))
[5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
>>> list(range(5))
[0, 1, 2, 3, 4]
>>> list(range(21, 5))
[]

Sąrašo naudojimas for cikle

Iki šiol for ciklą naudojome perėjimui per tam tikrą skaičių intervalą, nurodytą range funkcijoje. Python leidžia for ciklui naudoti ne vien skaičių intervalus, bet ir sąrašus.

for struktūra atrodo taip: for elementas in sąrašas:. sąrašas pereinamas nuo pirmojo sąrašo elemento iki paskutinio. Kai for eina per kiekvieną sąrašo elementą, jis kiekvieną reikšmę priskiria elementas kintamajam. Tai leidžia naudoti elementas kiekvieną kartą, kai ciklas for pereinamas iš eilės. Štai dar vienas pavyzdys, kad būtų lengviau suprasti:

demoSąrašas = ["gyvybė", 42, "visata", 6, "ir", 9, "oras"]
for elementas in demoSąrašas:
    print("Dabartinis elementas yra:", elementas)

Rezultatas yra:

Dabartinis elementas yra: gyvybė
Dabartinis elementas yra: 42
Dabartinis elementas yra: visata
Dabartinis elementas yra: 6
Dabartinis elementas yra: ir
Dabartinis elementas yra: 9
Dabartinis elementas yra: oras

Atkreipk dėmesį, kaip ciklas for praeina ir nustato elemento reikšmę kiekvienam sąrašo elementui. Taigi, kam tinkamas for? Pirmasis naudojimas yra peržiūrėti visus sąrašo elementus ir ką nors padaryti su kiekvienu iš jų. Štai greitas būdas sudėti visus elementus:

sąrašas = [2, 4, 6, 8]
suma = 0
for skaičius in sąrašas:
    suma = suma + skaičius

print("Suma yra:", suma)

o išvestis yra tiesiog:

Suma yra: 20

Arba gali parašyti programą, kad sužinotum, ar sąraše yra dublikatų. Pavyzdžiui kaip ši programa:

sąrašas = [4, 5, 7, 8, 9, 1, 0, 7, 10]
sąrašas.sort()
praeitas = None
for elementas in sąrašas:
    if praeitas == elementas:
        print("Dublikatas", praeitas, "rastas.")
    praeitas = elementas

ir turime rezultatą:

Dublikatas 7 rastas.

Gerai, tai kaip gi tai veikia? Čia yra speciali derinimo versija, kuri turėtų tau padėti suprasti (tau to nereikia įvesti):

l = [4, 5, 7, 8, 9, 1, 0, 7, 10]
print("l = [4, 5, 7, 8, 9, 1, 0, 7, 10]", "\t\tl:", l)
l.sort()
print("l.sort()", "\t\tl:", l)
praeitas = l[0]
print("praeitas = l[0]", "\t\tpraeitas:", praeitas)
del l[0]
print("del l[0]", "\t\tl:", l)
for elementas in l:
    if praeitas == elementas:
        print("Dublikatas", praeitas, "rastas.")
    print("if praeitas == elementas:", "\t\tpraeitas:", praeitas, "\telementas:", elementas)
    praeitas = elementas
    print("praeitas = elementas", "\t\tpraeitas:", praeitas, "\telementas:", elementas)

ir kodo išvestis būtų:

l = [4, 5, 7, 8, 9, 1, 0, 7, 10]        l: [4, 5, 7, 8, 9, 1, 0, 7, 10]
l.sort()                l: [0, 1, 4, 5, 7, 7, 8, 9, 10]
praeitas = l[0]             praeitas: 0
del l[0]                l: [1, 4, 5, 7, 7, 8, 9, 10]
if praeitas == elementas:        praeitas: 0         elementas: 1
praeitas = elementas             praeitas: 1         elementas: 1
if praeitas == elementas:        praeitas: 1         elementas: 4
praeitas = elementas             praeitas: 4         elementas: 4
if praeitas == elementas:        praeitas: 4         elementas: 5
praeitas = elementas             praeitas: 5         elementas: 5
if praeitas == elementas:        praeitas: 5         elementas: 7
praeitas = elementas             praeitas: 7         elementas: 7
Dublikatas 7 rastas.
if praeitas == elementas:        praeitas: 7         elementas: 7
praeitas = elementas             praeitas: 7         elementas: 7
if praeitas == elementas:        praeitas: 7         elementas: 8
praeitas = elementas             praeitas: 8         elementas: 8
if praeitas == elementas:        praeitas: 8         elementas: 9
praeitas = elementas             praeitas: 9         elementas: 9
if praeitas == elementas:        praeitas: 9         elementas: 10
praeitas = elementas             praeitas: 10        elementas: 10

Priežastis, kodėl į kodą įdėjau tiek daug print komandų, buvo ta, kad galėtum matyti, kas vyksta kiekvienoje eilutėje (beje, jei kažkada negalėsi suprasti, kodėl programa neveikia, pabandyk įdėti spausdintų komandų tose vietose, kur nori sužinoti, kas vyksta). Pirmiausia programa prasideda nuobodžiu senu sąrašu. Toliau programa surūšiuoja sąrašą. Tai darome tam, kad visi dublikatai būtų dedami vienas šalia kito. Tada programa apibrėžia kintamąjį praeitas. Tada pirmasis sąrašo elementas ištrinamas, kad pirmasis elementas nebūtų klaidingai laikomas dublikatu. Toliau aprašomas for ciklas. Kiekvienas sąrašo elementas tikrinamas, ar jis sutampa su ankstesniu. Jeigu sutampa – dublikatas rastas. Tada kintamasis praeitas yra pakeičiamas taip, kad kitame for cikle kintamasis praeitas būtų ankstesnis dabartinis elementas. Be abejo, nustatome, kad 7 yra dublikatas. (Atkreipk dėmesį, kaip \t naudojamas spausdinant tabuliavimo žymę (tab'as).)

Sąrašų rūšiavimas

Ciklas for taip pat dažnai naudojamas sąrašų rūšiavimo užduotyse. Paprastų sąrašų, kurie yra sudaryti iš skaičių ar eilučių, rūšiavimui gali naudoti funkciją sort. Tačiau gali susidurti su situacijomis, kai ši funkcija yra nepakankama. Egzistuoja daug rūšiavimo algoritmų, tačiau čia išmoksi vieną paprasčiausių iš jų - burbuliuko algoritmą (angl. bubble sort).

Algoritmo idėja yra tokia, kad iš kairės į dešinę lyginame gretimų elementų poras ir sukeičiame elementus vietomis, jei pirmasis yra didesnis už antrąjį. Kiekvienos iteracijos metu, didžiausias nesurūšiuotas elementas juda link sąrašo galo. Toks judėjimas primena burbuliukų vandenyje judėjimą į paviršių, iš ko ir kilo algoritmo pavadinimas. Iteracijos kartojamos tol, kol visi elementai yra savo vietose.

Pavyzdžiui, surūšiuokime jau prieš tai naudotą sąrašą [42, 7, 0, 123].

Pirma iteracija:

Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
Lyginami antras ir trečias elementai. Trečiasis yra didesnis už antrąjį, todėl elementai pakeičiami vietomis.
Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

Antra iteracija:

Lyginami pirmi du elementai. Antrasis yra didesnis už pirmąjį, todėl elementai pakeičiami vietomis.
Lyginami antras ir trečias elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.
Lyginami paskutiniai du elementai. Jie yra išdėstyti tinkamai, todėl nėra pakeičiami vietomis.

Trečia iteracija:

Elementai išdėstyti tinkamai.
Elementai išdėstyti tinkamai.
Elementai išdėstyti tinkamai.

Trečios iteracijos metu algoritmas neatlieka jokių pakeitimų, tad nustatoma, kad sąrašas yra surūšiuotas, algoritmas baigtas.

Algoritmo kodą galima užrašyti taip:

def burbuliukoRūšiavimas(sąrašas):
    sąrašoIlgis = len(sąrašas)
    # Maksimalus iteracijų skaičius - sąrašo ilgis - 1 elementas
    for i in range(sąrašoIlgis  - 1): 
        arBuvoPakeitimų = 0
        # Kiekvienoje iteracijoje lyginami visi elementai
        for j in range(sąrašoIlgis - 1): 
            if sąrašas[j] > sąrašas[j + 1]:
                # Sukuriame laikiną elementą, kuris saugo pirmąjį lyginamą elementą
                laikinasElementas = sąrašas[j]
                # Pirmąjam elementui priskiriame antro elemento reikšmę
                sąrašas[j] = sąrašas[j + 1]
                # Antrajam elementui priskiriame laikino elemento reikšmę, kuri yra lygi buvusiam pirmąjam elementui
                sąrašas[j + 1] = laikinasElementas
                # Pasižymime, kad iteracijos metu buvo padaryti pakeitimai, taigi reikės papildomų iteracijų
                arBuvoPakeitimų = 1
        # Jei visos iteracijos metu nebuvo nei vieno pakeitimo, algoritmas baigiamas
        if arBuvoPakeitimų == 0:
            break
    return sąrašas

rezultatas = burbuliukoRūšiavimas([42, 7, 0, 123])

print (rezultatas)

Programos išvestis:

[0, 7, 42, 123]

Pavyzdžiai

testas.py

## Ši programa atlieka žinių patikrinimą

# Pirmiausia surenkame testo klausimus.
# Vėliau šią dalį pakeisime, kad būtų naudojama failinė sistema.
def gauti_klausimus():
    # atkreipk dėmesį, kad duomenys saugomi kaip sąrašų sąrašas
    return [["Kokios spalvos yra dangus giedrą dieną? ", "mėlynas"],
            ["Koks atsakymas į gyvenimą, visatą ir viską? ", "42"],
            ["Kas yra keturių raidžių žodis pelės gaudyklei? ", "katė"]]

# Ši dalis patikrins vieną klausimą
# pateikiamas vienas klausimas
# grąžinama teisinga (True), jei vartotojas įvedė teisingą atsakymą, kitu atveju - klaidinga (False)

def pateik_klausimą(klausimas_ir_atsakymas):
    # ištraukiame klausimą ir atsakymą iš sąrašo
    # Ši funkcija priima dviejų elementų sąrašą, klausimą ir atsakymą.  
    klausimas = klausimas_ir_atsakymas[0]   
    atsakymas = klausimas_ir_atsakymas[1]
    # užduodame klausimą vartotojui
    duotas_atsakymas = input(klausimas)
    # palyginame vartotojo atsakymą su teisingu atsakymu
    if atsakymas == duotas_atsakymas:
        print("Teisingai")
        return True
    else:
        print("Neteisingai. Teisingas atsakymas: ", atsakymas)
        return False

# Šis kodas apims visus klausimus
def atlikti_testus(klausimai):
    if len(klausimai) == 0:
        print("Nepateiktas nei vienas klausimas.")
        # `return` išeis iš funkcijos
        return
    indeksas = 0
    teisingai = 0
    while indeksas < len(klausimai):
        # patikriname klausimą
        # Atkreipk dėmesį, kad tai yra klausimų ir atsakymų sąrašo ištraukimas iš sąrašų sąrašo.
        if pateik_klausimą(klausimai[indeksas]): 
            teisingai = teisingai + 1
        # pareiname prie kito klausimo
        indeksas = indeksas + 1
    # atkreipk dėmesį į skaičiavimo tvarką: pirmiausia padaugini, tada padalini
    print("Atsakei teisingai į ", teisingai * 100 / len(klausimai),\
           "% klausimų iš ", len(klausimai))

# dabar paimkime klausimus iš funkcijos gauti_klausimus ir
# paduokime grąžintą sąrašų sąrašą kaip argumentą funkcijai atlikti_testus.

atlikti_testus(gauti_klausimus())

Reikšmės True ir False turi reikšmes atitinkamai 1 ir 0. Jie dažnai naudojami loginės sekos patikrinimui, ciklo sąlygoms ir pan. Daugiau apie tai sužinosi šiek tiek vėliau (skyrius Loginiai reiškiniai). Atkreipk dėmesį, kad gauti_klausimus() iš esmės yra sąrašas, nors tai techniškai yra funkcija - sąrašų grąžinimas yra vienintelis dalykas, kurį jis daro.

Pavyzdžio išvestis:

Kokios spalvos yra dangus giedrą dieną? žalias
Neteisingai. Teisingas atsakymas: mėlynas
Koks atsakymas į gyvenimą, visatą ir viską? 42
Teisingai
Kas yra keturių raidžių žodis pelės gaudyklei? katė
Teisingai
Atsakei teisingai į 66% klausimų iš 3

Pratimai

1. Išplėsk testas.py programą, kad ji turėtų meniu, kuriame būtų galima atlikti testą, peržiūrėti klausimų ir atsakymų sąrašą ir pasirinkti išeiti iš programos. Taip pat, pridėk naują klausimą: „Kokį triukšmą kelia tikrai pažangi mašina?“ su teisingu atsakymu „ping“.

Sprendimas

## Ši programa atlieka žinių patikrinimą

klausimai = [["Kokios spalvos yra dangus giedrą dieną? ", "mėlynas"],
             ["Koks atsakymas į gyvenimą, visatą ir viską? ", "42"],
             ["Kas yra keturių raidžių žodis pelės gaudyklei? ", "katė"],
             ["Kokį triukšmą kelia tikrai pažangi mašina?", "ping"]]

# Ši dalis patikrins vieną klausimą
# pateikiamas vienas klausimas
# grąžinama teisinga (True), jei vartotojas įvedė teisingą atsakymą, kitu atveju - klaidinga (False)

def pateik_klausimą(klausimas_ir_atsakymas):
    # ištraukiame klausimą ir atsakymą iš sąrašo
    # Ši funkcija priima dviejų elementų sąrašą, klausimą ir atsakymą.  
    klausimas = klausimas_ir_atsakymas[0]   
    atsakymas = klausimas_ir_atsakymas[1]
    # užduodame klausimą vartotojui
    duotas_atsakymas = input(klausimas)
    # palyginame vartotojo atsakymą su teisingu atsakymu
    if atsakymas == duotas_atsakymas:
        print("Teisingai")
        return True
    else:
        print("Neteisingai. Teisingas atsakymas: ", atsakymas)
        return False

# Šis kodas apims visus klausimus
def atlikti_testus(klausimai):
    if len(klausimai) == 0:
        print("Nepateiktas nei vienas klausimas.")
        # `return` išeis iš funkcijos
        return
    indeksas = 0
    teisingai = 0
    while indeksas < len(klausimai):
        # patikriname klausimą
        # Atkreipk dėmesį, kad tai yra klausimų ir atsakymų sąrašo ištraukimas iš sąrašų sąrašo.
        if pateik_klausimą(klausimai[indeksas]): 
            teisingai = teisingai + 1
        # pareiname prie kito klausimo
        indeksas = indeksas + 1
    # atkreipk dėmesį į skaičiavimo tvarką: pirmiausia padaugini, tada padalini
    print("Atsakei teisingai į ", teisingai * 100 / len(klausimai),\
           "% klausimų iš ", len(klausimai))

#rodomas klausimų ir atsakymų sąrašas
def rodyk_klausimus():
    k = 0
    while k < len(klausimai):
        a = 0
        print("K:" , klausimai[k][a])
        a = 1
        print("A:" , klausimai[k][a])
        k = k + 1

# dabar apibrėžiu meniu funkciją
def meniu():
    print("-----------------")
    print("Meniu:")
    print("1 - Atlikti testą")
    print("2 - Peržiūrėti klausimų ir atsakymų sąrašą")
    print("3 - Peržiūrėti meniu")
    print("5 - Išeiti")
    print("-----------------")

pasirinkimas = "3"
while pasirinkimas != "5":
    if pasirinkimas == "1":
        atlikti_testus(klausimai)
    elif pasirinkimas == "2":
        rodyk_klausimus()
    elif pasirinkimas == "3":
        meniu()
    print()
    pasirinkimas = input("Pasirinkite savo parinktį iš aukščiau pateikto meniu: ")

2. Parašyk programą, kuri ištrintų pasikartojančius elementus iš sąrašo.

Sprendimas

pradinis_sąrašas = ["a", "b", "c", "a"]
naujas_sąrašas = []
indeksas = 0

while indeksas < len(pradinis_sąrašas):
    if pradinis_sąrašas[indeksas] not in naujas_sąrašas:
        naujas_sąrašas.append(pradinis_sąrašas[indeksas])
    indeksas = indeksas + 1
        
print(naujas_sąrašas)

3. Parašyk programą, kuri rastų didžiausią ir mažiausią sąrašo skaičius.

Sprendimas

pradinis_sąrašas = [5, 25, 0, 100, 6, -6, 500]
didžiausias = pradinis_sąrašas[0]
mažiausias = pradinis_sąrašas[0]
indeksas = 0

while indeksas < len(pradinis_sąrašas):
    if pradinis_sąrašas[indeksas] > didžiausias:
        didžiausias = pradinis_sąrašas[indeksas]
    if pradinis_sąrašas[indeksas] < mažiausias:
        mažiausias = pradinis_sąrašas[indeksas]
    indeksas = indeksas + 1
        
print ("Didžiausias skaičius: ", didžiausias)
print ("Mažiausias skaičius: ", mažiausias)

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

x = [1,2,3,4,5,6,7,8,9,10]

y = [11,12,13,14,15,16,17,18,19,20]

Sprendimas
x = [1,2,3,4,5,6,7,8,9,10] y = [11,12,13,14,15,16,17,18,19,20] c = [] for i in x: if i % 3 == 0: c.append(i) for i in y: if i % 5 == 0: c.append(i) print(c)

Knyga

⬅️ Funkcijų apibrėžimas

Sąrašai

Integruotosios funkcijos ➡️