Järjendid
Seni oleme programmides hoidnud andmeid eraldi muutujates: iga arvu või sõne oleme salvestanud teistest eraldi. Tihtipeale on kasulik paigutada andmeid ühisesse andmestruktuuri, mis muudab nende kasutamise lihtsamaks. Pythonis on üheks selliseks struktuuriks järjend (inglise keeles list). (Arvesta sellega, et erinevates programmeerimiskeeltes ja õppematerjalides võivad terminid erineda.)
Järjend koosneb elementidest, mis loetletakse nurksulgudes üksteisest komadega eraldatult. Näiteks on kaks järjendit
nädalapäevad = ["esmaspäev", "teisipäev", "kolmapäev", "neljapäev", "reede", "laupäev", "pühapäev"] temperatuurid = [-4, 2, 6, 4, 4]
Järjendis võib esineda korduvaid elemente, näiteks järjendis temperatuurid on element väärtusega 4 kaks korda.
Eeltoodud järjendites on esimeses ainult sõned ja teises ainult täisarvud. Tegelikult võivad Pythonis ühe järjendi elemendid olla ka erinevat tüüpi, aga tavaliselt me seda võimalust ei kasuta.
Katseta, mis tüüpi näitab Python ise muutuja temperatuurid puhul:
temperatuurid = [-4, 2, 6, 4, 4] print(type(temperatuurid))
Järjendiga seotud operatsioonid. Indeksid
Vaatleme mõningaid järjenditega seotud operatsioone.
Järjendi loomine
nädalapäevad = ["esmaspäev", "teisipäev", "kolmapäev", "neljapäev", "reede", "laupäev", "pühapäev"]
Järjendi ekraanile väljastamine
print(nädalapäevad)
Elementide arvu (järjendi pikkuse) leidmine
nädalapäevi = len(nädalapäevad)
print(f"Järjendis on {nädalapäevi} elementi.")
Järjendisse kuulumise kontroll
if "palgapäev" in nädalapäevad:
print("Palgapäev on järjendis.")
else:
print("Palgapäev ei ole järjendis.")
Konkreeetse elemendi väärtus indeksi (järjekorranumbri) abil
print(nädalapäevad[1])
Indeks märgitakse nurksulgudesse.
Pane tähele, et nädalapäevad[1] annab meile järjendi teise elemendi, mitte esimese. Tavapäraselt algavad programmides indeksid arvust 0, mis vastab esimesele elemendile. Tõepoolest
print(nädalapäevad[0])
annab järjendi (argikeelselt) esimese elemendi. Seetõttu tuleb olla tähelepanelik, kas räägitakse esimesest elemendist või elemendist indeksiga 1.
Kuna loendamine algab nullist, siis viimase elemendi indeks on ühe võrra väiksem järjendi pikkusest: järjendi nädalapäevad puhul on viimase elemendi indeks 6, sest elemente on 7.
Katseta:
nädalapäevad = ["esmaspäev", "teisipäev", "kolmapäev", "neljapäev", "reede", "laupäev", "pühapäev"] print(nädalapäevad[6]) print(nädalapäevad[7])
Kui üritada kasutada indeksit, millele vastavat elementi järjendis ei ole, siis ilmub veateade IndexError: list index out of range.
Sõned kui järjendid
Paljud järjendite operatsioonid (kuid mitte kõik) on lubatud sõnede peal. Sõne puhul on elementideks sõne üksikud sümbolid:
linn = "Tartu" print(linn[2])
Katseta, mis täht eelneva programmiga ekraanile väljastatakse?
Viilutamine
Viilutamine on operatsioon, millega moodustatakse järjendi põhjal alamjärjend (sõne puhul alamsõne). Arvesta, et viilude loomine ei muuda esialgset järjendit. Katseta järgnevaid näiteid:
a = ['A', 'B', 'C', 'D', 'E'] print(a[0:2]) print(a[:2]) print(a[2:5]) print(a[2:]) print(a[-2:])
Enne koolonit kirjutatakse indeks, millest alates tuleb elemente kopeerida (selle indeksiga element kaasa arvatud). Kooloni järele kirjutatakse indeks, mille juures tuleb kopeerimine lõpetada (selle indeksiga element jääb tulemusest välja). Kui algav indeks kirjutamata jätta, siis alustatakse järjendi algusest. Kui lõpetav indeks kirjutamata jätta, siis kopeeritakse kuni järjendi lõpuni (viimane element kaasa arvatud).
Järgmises näites viilutatakse erinevaid sõnesid – nii neid, mis on muutujale väärtuseks antud, kui ka neid, mis pole.
sõne1 = 'Tartu'
print(sõne1[1:4])
sõne2 = sõne1
print(sõne2[-2:])
print("Väike-Maarja"[4:9])
Veel operatsioone
Toome siin välja tabeli, milles on nii juba mainitud kui mainimata operatsioone, mida järjenditega sooritada. Sarnaselt viilutamisele ei muuda need operatsioonid järjendit ennast. Katseta neid ka ise!
| Avaldis | Väärtus | Selgitus |
|---|---|---|
| len([2, 1, 4, 3, -5]) | 5 | Elementide arv |
| min([2, 1, 4, 3]) | 1 | Minimaalne element |
| max([2, 1, 4, 3]) | 4 | Maksimaalne element |
| sum([2, 1, 4, 3]) | 10 | Elementide summa |
| sorted([2, 1, 4, 3]) | [1, 2, 3, 4] | Tagastab järjestatud järjendi |
| 3 in [2, 1, 4, 3] | True | Kas esineb selline element? |
| [2, 1] + [3, 1] | [2, 1, 3, 1] | Järjendite liitmine |
| [2, 1, 4, 1].count(1) | 2 | Elemendi esinemiste arv |
| [1, 2, 3] == [2, 1, 3] | False | Elementide järjekord on oluline |
Järjendile ühe elemendi liitmiseks saab kasutada ka meetodit append. Erinevalt eespool toodud operatsioonidest muutub sel juhul järjend ise. Järgnevas näites on toodud kaks viisi, kuidas järjendile element juurde lisada.
a = [5, 8] a.append(7) print(a) b = [5, 8] b += [7] print(b)
Järjendi video
Enesekontroll
Negatiivsed indeksid
Vahel võib tulla ette, et soovime ekraanile väljastada järjendi viimast elementi teadmata kui pikk järjend on. Selleks, et ei peaks lugema hakkama, mitmes viimane element on, on Pythonis negatiivsed indeksid.
järjend = [1,2,3,4,5,6,7] print(järjend[-1])
Ekraanile ilmub kõige tagumine element ehk 7. Sarnaselt saab eelviimase elemendi kätte indeksiga -2.
Funktsiooniga range järjendite loomine
Funktsiooni range saab kasutada ühe, kahe või kolme argumendiga selliselt, et funktsiooni list abil luua täisarvulisi järjendeid:
>>> list(range(5)) [0, 1, 2, 3, 4] >>> list(range(0, 5)) [0, 1, 2, 3, 4] >>> list(range(2, 5)) [2, 3, 4] >>> list(range(0, 15, 2)) [0, 2, 4, 6, 8, 10, 12, 14] >>> list(range(5, 0, -1)) [5, 4, 3, 2, 1] >>> list(range(0, 5, 1)) [0, 1, 2, 3, 4]
Ühe argumendiga variandi puhul algab loetelu 0-st ning lõpeb enne näidatud argumendi väärtuseni jõudmist. Kahe argumendi puhul algab loetelu esimese argumendi väärtusest ja lõpeb enne teise argumendini jõudmist. Kolme argumendi puhul näitab kolmas argument väärtuste kasvamise sammu.
Funktsioon split
Tihti on tarvis teha mingi sõne pisut suuremateks juppideks kui üksikud tähed – näiteks võib olla vaja jagada sõnena esitatud lause eraldi sõnadeks. Selle jaoks saab kasutada sõnemeetodit split.
>>>"Tere Maailm!".split()
['Tere', 'Maailm!']
>>> "t;ere;31;p;äeva".split(";")
['t', 'ere', '31', 'p', 'äeva']
Kui split-i kasutada ilma argumentideta, siis tehakse lõikamine tühikute, tabulaatorite ja reavahetuste kohalt. Kui anda ette mingi muu sümbol, siis lõigatakse sõne juppideks just selle sümboli kohalt.
Käsu split „vastand“ on meetod join:
>>> ' '.join(['Tere', 'hommikust']) 'Tere hommikust' >>> ';'.join(['CY2X44', '3', '66', 'T']) 'CY2X44;3;66;T'
Enesekontroll
Järjendite viilutamine
Kirjutades nurksulgudesse indeksi asemel indeksivahemiku on järjendist (ja sõnedest) võimalik võtta alamjärjendeid (alamsõnesid):
>>> a = ['a', 'b', 'c', 'd', 'e', 'f'] >>> a[0:2] ['a', 'b'] >>> a[:2] ['a', 'b'] >>> a[2:6] ['c', 'd', 'e', 'f'] >>> a[2:] ['c', 'd', 'e', 'f'] >>> a[-2:] ['e', 'f'] >>> s = "Tere" >>> s[0:3] 'Ter'
Koolonist vasakule tuleb kirjutada see indeks, millest alates tuleb elemente tulemusse kopeerida, ning koolonist paremale see indeks, mille juures tuleb kopeerimine lõpetada (st selle indeksiga element jääb tulemusest välja). Kui vasak indeks jätta kirjutamata, siis alustatakse esimesest elemendist, ja kui parem indeks jätta kirjutamata, siis kopeeritakse kuni järjendi lõpuni (viimane element kaasa arvatud).