2.7. Lists

En lista är en muterbar, ordnad följd av värden. Till skillnad från strängar och bytes kan listor innehålla värden av vilka typer som helst, och du kan ändra, lägga till eller ta bort element på plats.

2.7.1. Skapa listor

Hakparenteser skapar en listliteral:

empty   = []
nums    = [1, 2, 3]
mixed   = [1, "two", 3.0, True, None]    # any types
nested  = [[1, 2], [3, 4], [5, 6]]       # lists of lists

Konstruktorn list bygger en lista från valfri itererbar:

>>> list("abc")
['a', 'b', 'c']
>>> list(range(5))
[0, 1, 2, 3, 4]

2.7.2. Längd, indexering och slicing

len() returnerar antalet element. Indexering och slicing fungerar på samma sätt som för strängar – positioner börjar på 0, negativa index räknas från slutet, och en slice utanför det giltiga intervallet klipps tyst i stället för att utlösa ett fel:

>>> nums = [10, 20, 30, 40, 50]
>>> len(nums)
5
>>> nums[0]
10
>>> nums[-1]
50
>>> nums[1:4]
[20, 30, 40]

Positiva index räknas från början; negativa index räknas från slutet.

Slice-syntaxen är en förkortning för ett slice-objekt som Python bygger bakom kulisserna. nums[1:4] är samma sak som nums[slice(1, 4)]. Du konstruerar sällan ett för hand, men slice() är ibland användbart för att lagra en slice som ett värde att återanvända:

head = slice(0, 3)
print(nums[head])             # [10, 20, 30]
print(letters[head])          # first three letters, same slice

2.7.3. Mutera en lista

Listor stöder indexerad och sliceindexerad tilldelning på plats:

>>> nums = [10, 20, 30]
>>> nums[0] = 99
>>> nums
[99, 20, 30]
>>> nums[1:3] = [200, 300, 400]    # slice can change the length
>>> nums
[99, 200, 300, 400]

De vanligaste listmetoderna:

• list.append() – lägger till ett enskilt element i slutet.

• list.extend() – lägger till varje element från en itererbar.

• list.insert() – infogar på en given position.

• list.remove() – tar bort den första förekomsten av ett värde.

• list.pop() – tar bort och returnerar ett element (det sista som standard).

• list.clear() – tar bort alla element.

• list.sort() – sorterar på plats. Skicka med reverse=True för fallande ordning.

• list.reverse() – vänder på plats.

>>> nums = []
>>> nums.append(1)
>>> nums.extend([2, 3])
>>> nums.insert(0, 99)
>>> nums
[99, 1, 2, 3]
>>> nums.pop()
3
>>> nums.sort()
>>> nums
[1, 2, 99]

Dessa metoder ändrar listan på plats och returnerar None. Att skriva

nums = nums.sort()    # nums is now None -- common bug

är nästan aldrig vad du vill; den ursprungliga nums har sorterats, men tilldelningen skriver sedan över namnet med returvärdet. Anropa antingen nums.sort() på en egen rad, eller använd den inbyggda sorted() för att få tillbaka en ny sorterad lista utan att mutera originalet.

2.7.4. Operatorer

• + konkatenerar två listor till en ny lista.

• * upprepar en lista.

• in testar medlemskap.

>>> [1, 2] + [3, 4]
[1, 2, 3, 4]
>>> [0] * 5
[0, 0, 0, 0, 0]
>>> 3 in [1, 2, 3]
True

2.7.5. Iterera över en lista

En for-loop går igenom elementen i ordning:

for n in [10, 20, 30]:
    print(n)

2.7.6. Alias och mutation

En lista är ett enda värde i minnet; flera namn kan peka på samma lista. Mutation genom ett namn syns genom alla andra namn som pekar på samma lista.

a och b pekar båda på samma lista. Mutation genom något av namnen ändrar vad alla andra namn ser.

>>> a = [1, 2, 3]
>>> b = a
>>> a.append(4)
>>> b
[1, 2, 3, 4]                # same object, change is visible

För att göra en oberoende kopia, sliceindexera hela listan eller anropa konstruktorn list:

>>> c = a[:]                # or list(a)
>>> a.append(5)
>>> c
[1, 2, 3, 4]                # c is unaffected

Detta kopierar endast listan på översta nivån; nästlade listor delas fortfarande mellan originalet och kopian.