Lista

Listoille löytyy valmiina koko joukko hyödyllisiä operaatioita, joita esitellään tutorialin luvussa 5.1. More on Lists sekä The Python Standard Libraryn dokumentaation luvussa 4.6 Sequence Types.

Alla on muutama esimerkki listan käsittelystä.

l0 = [] # Using a pair of square brackets to denote the empty list

l1 = [3, 8, 7] # Using square brackets, separating items with commas

l2 = [['a', 1], 'b'] # The same as above, but contains elements of different types and one sublist

l3 = [ i for i in range(2,20,2) ] # Using a list comprehension

l4 = list(range(10)) # Using the type constructor: list() or list(iterable)

r = range(10) # This is an iterable, not a list

l0 == [] # True

l1 == [8, 7, 3] # False

l1 == [3, 8, 7] # True

s = [ -9, 5, 23, 6, 2, 10, 5, 6, -1, 100 ]
t = list(range(4))
x = 2
x in s                     # True
x not in s                 # False
-10 in list(range(2))      # False
10 not in list(range(100)) # False
s + t                      # [-9, 5, 23, 6, 2, 10, 5, 6, -1, 100, 0, 1, 2, 3]
t * 5                      # [0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3, 0, 1, 2, 3]
22 * [ 0 ]                 # [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]
s[2]                       # 23
s[20]                      # IndexError: list index out of range
(t*5)[2:10]                # [2, 3, 0, 1, 2, 3, 0, 1]
(t*5)[2:20:3]              # [2, 1, 0, 3, 2, 1]
([3, 5, 1]*2).index(5)     # 1
([3, 5, 1]*2).index(5, 2)  # 4
([1, 2]*100).count(1)      # 100
[1, 2, 3].count(4)         # 0

>>> l = [6, 3, 5, 8, 9, 1]
>>> l.sort()
>>> l
[1, 3, 5, 6, 8, 9]
>>> l2 = [('a', 7), ('d', 1), ('x', 3)]
>>> l2.sort(key=lambda e: e[1])
>>> l2
[('d', 1), ('x', 3), ('a', 7)]

[i**2 for i in range(10) if i % 2 == 0]

>>> [(x, y) for x in [1,2,3] for y in [3,1,4] if x != y]
[(1, 3), (1, 4), (2, 3), (2, 1), (2, 4), (3, 1), (3, 4)]

Monikko eli tuple

Monikko on muuten sama kuin lista, mutta se on muuttumaton. Sillä on siis kaikki muuttumattomien sekvenssien operaatiot, mutta ei muuttuvien sekvenssien operaatioita eikä myöskään listan sort-operaatiota (sehän muuttaa listan sisältöä).

t0 = () # Using a pair of square brackets to denote the empty tuple

t1 = (3, 8, 7) # Using square brackets, separating items with commas

t2 = (['a', 1], 'b') # The same as above, but contains elements of different types (one is a list, which is mutable)

t3 = tuple(range(10)) # Using the type constructor: tuple() or tuple(iterable)

x = (i for i in range(2,20,2) if i % 3 == 0)

Range.

Aiemmin peruskurssilla on jo käytetty rangea for-silmukassa ja yllä käytimme sitä comprehensionissa. Mikä tämä range oikein on?

Range on muuttumaton tasavälinen sekvenssi numeroita laskevassa tai nousevassa järjestyksessä. Se poikkeaa kuitenkin samansisältöisestä tuplesta siinä, että sekvenssin numeroita ei lasketa heti ja kerralla vaan niitä tuotetaan tarpeen mukaan. Tämä on usein huomattavan tehokasta.

Rangella on alaraja, yläraja sekä askel. Rangen voi luoda kolmella tavalla

Operaatio	Kuvaus
range(ylä)	Numerot väliltä 0 ... ylä-1
range(ala,ylä)	Numerot väliltä ala ... ylä-1 (ala <= ylä) tai väliltä ala ... ylä-1 (ylä < ala)
range(ala,ylä,askel)	Kuin yllä, mutta askelen välein ylös tai alas

Rangen alkioista saa listan tai tuplen kietaisemalla ympärille list() tai tuple() -konstruktorin.

Esimerkkejä rangesta:

>>> r=range(10)
>>> r
range(0, 10)
>>> list(r)
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
>>> list(range(3, 15))
[3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14]
>>> list(range(20, 1, -3))
[20, 17, 14, 11, 8, 5, 2]

Joukot: set ja frozenset

Joukko on järjestämätön kokoelma alkioita, jossa kukin alkio esiintyy vain kerran. Tätä varten Python tarjoaa kaksi valmista tyyppiä set ja frozenset. Edellinen on muuttuva ja jälkimmäinen muuttumaton tyyppi. Voidaan ajatella, että niiden suhde toisiinsa on vastaava kuin tyyppien list ja tuple. Alkioita vertaillaan == operaatiolla, eli joukon millekään alkioparille a ja b ei päde a == b.

Joukkoja voi luoda seuraavasti:

>>> s={32, 55, 7, 32, 11, 8}
>>> s
{8, 32, 11, 55, 7}
>>> set([9, 11, 2, 11, 9])
{9, 2, 11}
>>> set('joukko merkkijonon merkeistä')
{'j', 'n', 'e', 'ä', 's', 't', 'i', 'm', 'r', 'u', 'k', 'o', ' '}

Huomaa, että merkintä {} ei luo tyhjää joukkoa vaan tyhjän dict-olion.

Sanakirja eli dict

Sanakirja on olio joka yhdistää avaimen johonkin arvoon. Tätä varten on tarjolla tyyppi dict, jonka oliot ovat muuttuvia.

Avain voi olla miltei mikä tahansa olio; ainoa rajoite on, että oliolla on oltava operaatio hash. Tätä ei ole määritetty muuttuville olioille, joiden yhtäsuuruutta verrataan olion identiteetin sijaan sisällön perusteella. Näitä ovat list, set ja dict -oliot. Lisäksi tuple ja frozenset -oliot, jotka sinänsä ovat muuttuvia, mutta joihin sisältyy list, set ja dict -olioita eivät kelpaa. Huomaa, että itse määritettyjen luokkien oliot kelpaavat, koska niitä verrataan aina olion identiteetin eikä sisällön perusteella.

Avaimelle talletettava arvo puolestaan voi olla aivan mikä tahansa.

Sanakirjan voi luoda kahdella tavalla, joko antamalla avain - arvo parit sulkujen {} välissä tai dict-konstruktorilla.

d1 = {}

d2 = { 'Antti': 10, 'Pentti': 20 }

d3 = { 10: 'Antti' }

d4 = { 'Antti': [1, 2, 3], ('x', 'y'): { (1, 2): 3 }}

# Five ways to create the same dict

a = dict(one=1, two=2, three=3)

b = {'one': 1, 'two': 2, 'three': 3}

c = dict(zip(['one', 'two', 'three'], [1, 2, 3]))

d = dict([('two', 2), ('one', 1), ('three', 3)])

e = dict({'three': 3, 'one': 1, 'two': 2})

a == b == c == d == e

Seuraavat operaatiot ovat tarjolla:

Operaatio	Kuvaus
len(d)	Avain - arvo -parien määrä
d[key]	Palauta avaimeen liittyvä arvo. Tuota KeyError jos avainta ei löydy d:stä.
d[key] = value	Aseta arvo avaimelle
del d[key]	Poista avain - arvo -pari tuota KeyError jos avainta ei löydy
key in d	Onko avain määritetty
key not in d	Edellisen negaatio
iter(d)	Palauta iteraattori, joka tuottaa kaikki avaimet
d.clear()	Poista kaikki avain - arvo -parit
d.copy()	Palauta matala kopio
classmethod fromkeys(seq[, value])	Tee dict, jossa on seq:n sisältämät avaimet ja niiden jokaisen arvona on value (oletusarvo None)
d.get(key[, default])	Palauta avaimen arvo tai default, jos ei määritetty.
d.items()	Palauta iterable (view), joka sisältää avain - arvo -parit
keys()	Palauta iterable (view), joka sisältää avaimet.
d.pop(key[, default])	Poista avain ja palauta sitä vastaava arvo tai default. Jos avainta ei löydy tuota KeyError.
d.popitem()	Poista mielivaltainen avain ja sitä vastaava arvo. Tuota KeyError, jos d tyhjä.
d.setdefault(key[, default])	Kuin get yllä, mutta myös asettaa arvoksi default, jos avainta ei löydy.
d.update([other])	Vaihda d:n avain - arvo -pareiksi otherin vastaavat.
values()	Palauta iterable (view), joka sisältää arvot.

Merkkijono str

Merkkijono on keskeinen Pythonin tarjoama tyyppi. Merkkijonoja voi luoda monella tavalla: merkkijonoliteraaleilla, yhdistelemällä merkkijonoja toisiinsa sekä formatoimalla.

Merkkijonoliteraaleja voi tehdä seuraavasti:

'Simple string using single quotes'

"The same with double quotes"

"You can put ' characters in a string with double quotes"

'You can put " characters in a string with double quotes'

"You can escape chars with special meaning. Like \' or \\"

"""Multiple line literals can
be easily created using
three " characters as separators"""

'''
The same can be done with ' characters.
'''

r'A raw string literal takes even backslashes \ literally'

Merkkijonoja liimataan toisiinsa + operaattorilla:

s="""You can glue all kinds of string literals or
string variables together."""
t="Isn't this nice"

s+'\n\n'+ t

Formatoituja eli muotoiltuja merkkijonoja voi muodostaa joko metodilla str.format tai vanhemmalla printf-tyylisellä menetelmällä, joka on peräisin C-ohjelmointikielestä. Nämä molemmat sisältävät joukon merkintätapoja, joilla merkkijonoista saa siistin näköisiä.

Metodia str.format varten on määritetty oma kielensä (ks. The Python Standard Library: 6.1.3. Format String Syntax.

Merkkijono-operaatioita on tarjolla paljon, joten itse ei monesti tarvi ohjelmoida tarvitsemaansa toimintoa. Merkkijonojen dokumentaatioon kannattaa tutustua Python Standard Libraryn luvussa 4.7. Text Sequence Type.

Palaute