Listor

Innehåll

Listor#

En lista består av en följd av element. Elementen kan vara av av godtycklig datatyp, t. ex. heltal, flyttal, strängar, listor, etc. Listor används bl. a. som det som i många språk kallas för arrayer. Till skillnad från språk som Java och C++ kan elementen i en och samma lista vara av olika typ.

Listobjekt är, till skillnad från strängar och tupler, ändringsbara (eng. mutable). Det betyder att element i en lista kan tas bort, läggas till och bytas ut.

Listkonstruktor#

Listor kan skapas genom att man räknar upp komponenterna inom hakparenteser ([]).
Exempel:

x = 3
lst = [1, x, x+4, 'a+b', [1, 3]]
print(lst)  # Skriver ut [1, 3, 7, 'a+b', [1, 3]]
lst = [x**2 for x in range(1, 6)]
print(lst)  # Skriver ut [1, 4, 9, 16, 25]

Listor kan skapas från andra objekt med list-funktionen:

lst = list('abcd')        # Skapar en lista från en sträng
print(lst)                # Skriver ut ['a', 'b', 'c', 'd']
lst = list((1, 2, 2, 1))  # Skapar en lista från en tupel
print(lst)                # Skriver ut [1, 2, 2, 1]

Operatorer för listor#

Observera att dessa är i stort sett samma som för strängar och tupler.

Listor kan konkateneras med +-operatorn.
Listor kan mångfaldigas med *-operatorn.
Enskilda element kan nås med indexering.
Enskilda element eller sekvenser av element kan bytas ut med tilldelningsoperatorn =.
Dellistor kan skapas med skivningsoperatorerna (eng. slicing operators)
[start:stop]- och [start:stop:increment]-uttrycken.
Medlemsskap kan testas med operatorerna in och not in.

lst = [1, 2, 'a', [3.5 + 2, 4]]
print(lst)            # Skriver ut [1, 2, 'a', [5.5, 4]]
print(lst + 2*['x'])  # Skriver ut [1, 2, 'a', [5.5, 4], 'x', 'x']
lst[2] = 3
print(lst)            # Skriver ut [1, 2, 3, [5.5, 4]]
lst[2:] = [1, 3, 5]
print(lst)            # Skriver ut [1, 2, 1, 3, 5]
lst[2:] = ['x', 'y']
print(lst)            # Skriver ut [1, 2, 'x','y']
lst[2:] = []
print(lst)            # Skriver ut [1, 2]
print(1 in lst)       # Skriver ut True
print(1 not in lst)   # Skriver ut False

Funktioner för listor#

Funktion	Betydelse	Exempel
len	Antal element (på toppnivå) i listan.	`len([1, 2, [a, b,c]])` -> 3
list	Skapar nytt listobjekt från lista, sträng eller tupel.	`list('ab')` -> [’a’, ’b’]
max	Största elementet.	`max([1, 2, 3])` -> 3
min	Minsta elementet.	`min([1, 2, 3])` -> 1
str	Returnerar listan som en sträng.	`str([1, 2])` -> ’[1, 2]’
sum	Summan av elementen. Elementen måste vara numeriska.	`sum([1, 2, 3])` -> 6
sorted	Returnerar en sorterad lista. Elementen måste ha storleksrelationer.	`sorted([2, 3, 1])` -> [1, 2, 3] `sorted(['y','x'])` -> [’x’, ’y’]

Listmetoder#

Listklassen har ett stort antal metoder. Se den officiella dokumentationen för en fullständig förteckning och detaljer.

Metod	Betydelse	Exempel
append	Lägger till ett element sist.	lst = [1, 2] lst.append(3) print(lst) -> [1, 2, 3]
clear	Tar bort alla element ur listan.
copy	Skapar en kopia av listan, dvs. ett nytt objekt med samma innehåll.
count	Räknar antalet förekomster av ett visst element.	[1, [1, 2], 1].count(1) -> 2 [1, [1, 2], 1].count([1, 2]) -> 1
extend	Lägger till alla element från en annan lista.	lst = [3, 5] lst.extend([1, 5]) print(lst) -> [3, 5, 1, 5]
index	Returnerar index för första förekomst av ett element.	lst = [3, 5, 1, 5] lst.index(5) -> 1 lst.index(1) -> 2
insert	Stoppar in ett nytt element på angivet index.	lst = [3, 5, 1, 5] lst.insert(2, 'b') print(lst) -> [3, 5, 'b', 1, 5]
pop	Tar bort och returnerar sista elementet.	lst = [3, 5, 'b', 1, 5] x = lst.pop() print(x) -> 5 print(lst) -> [3, 5, 'b', 1]
remove	Tar bort första förekomst av angivet element.	lst = [3, 5, 'b', 1] lst.remove('b') print(lst) -> [3, 5, 1]
reverse	Vänder på listan.	lst = [3, 5, 1] lst.reverse() print(lst) -> [1, 5, 3]
sort	Sorterar listan.	lst = [1, 5, 3] lst.sort() print(lst) -> [1, 3, 5]

Observera: Alla metoderna utom copy, count och index modifierar listan.

Att skriva ut listor#

Uttrycket print(lista) skriver hela listan på en rad medan koden

for e in lista:
    print(e)

skriver ett element per rad.

Hur ska man göra om man vill skriva t.ex. fem element per rad?

Funktionen print har en nyckelordsparameter end som avgör vad som ska skrivas som sista värde. Dess defaultvärde är '\n', vilket således ger ett radbyte. Om man anger end='' som parameter undviker man alltså radbyte. Om man håller reda på hur många värden som skrivits ut kan man se till att radbrytningen bara sker t.ex. efter vart femte element.

Koden

lista = [4, 8, 12, 31, 23, -2, 81, 97, 42, 36, 17, 8, 26, 0]
n = 0  # Antalet utskrivna värden
for x in lista:
    print(x, end='')
    n += 1
    if n % 5 == 0 or n == len(lista):
        print()  # Radbyte
    else:
        print(' ', end='')  # Mellanrum, inget radbyte

ger utskriften

4 8 12 31 23
-2 81 97 42 36
17 8 26 0

(Utskriften blir snyggare om man i print-satsen ser till att varje värde tar lika stor plats t.ex. genom att skriva print(f'{x:5d}', end=''). Se minilektionen om formatering!

I ovanstående lösning räknar vi själva index i listan. Python har dock en funktion enumerate som kan göra det automatiskt:

lista = [4, 8, 12, 31, 23, -2, 81, 97, 42, 36, 17, 8, 26, 0]
for i, x in enumerate(lista, start=1):
    print(f'{x:5d}', end='')
    if i % 5 == 0 or i == len(lista):
        print()  # Radbyte
    else:
        print(' ', end='')  # Mellanrum, inget radbyte

som ger utskriften

    4     8    12    31    23
   -2    81    97    42    36
   17     8    26     0

start-parametern till enumerate anger att den ska börja räkna från 1 i stället för 0 (annars blir radindelningen fel).

Listbyggare#

Python har en konstruktion som på engelska heter list comprehension, vilket vi översätter till listbyggare. Detta är ett enkelt och elegant sätt att konstruera listor. Vi demonstrerar det med några exempel:

Kod	Värde	Kommentar
lst = [x for x in range(8)]		Skapar en lista från ett range-objekt
lst	[0, 1, 2, 3, 4, 5, 6, 7]
[x*x for x in lst]	[0, 1, 4, 9, 16, 25, 36, 49]	Kvadrater på talen i listan
[x for x in lst if x % 2 == 1]	[1, 3, 5, 7]	Alla udda tal i listan
[xx for x in lst if xx % 2 == 0]	[0, 4, 16, 36]	Alla jämna kvadrater