Listy w Pythonie: tworzenie, indeksowanie, append, sortowanie i iteracja

Listy to uporządkowane, modyfikowalne sekwencje

Lista to najczęściej używany typ kolekcji w Pythonie. Jeśli przechowujesz uporządkowany zestaw wartości, który może się zmieniać (dodawanie, usuwanie, sortowanie, aktualizacja), lista prawie zawsze jest właściwym wyborem.

Tworzysz ją nawiasami kwadratowymi:

fruits = ["apple", "banana", "cherry"]
numbers = [1, 2, 3, 4]
mixed = [1, "two", 3.0, True]
empty = []

print(fruits)
print(numbers)
print(mixed)
print(empty)

Listy mogą przechowywać wszystko, nawet inne listy. W praktyce większość list zawiera jeden rodzaj rzeczy (listę użytkowników, listę liczb), bo tak najłatwiej o nich myśleć.

Indeksowanie

Każdy element ma pozycję, liczoną od 0. Dostęp uzyskujesz nawiasami kwadratowymi:

fruits = ["apple", "banana", "cherry"]

print(fruits[0])    # 'apple'
print(fruits[1])    # 'banana'
print(fruits[-1])   # 'cherry': ujemne indeksy liczą od końca
print(fruits[-2])   # 'banana'

Odwołanie do nieistniejącego indeksu zgłasza IndexError. Jeśli możesz wyjść poza zakres, najpierw sprawdź długość albo opakuj dostęp w try.

Wycinki (slicing)

Wycinek daje ci zakres elementów. Składnia to list[start:stop:step], tak samo jak w napisach:

nums = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

print(nums[2:5])      # [2, 3, 4]
print(nums[:3])       # [0, 1, 2]: od początku
print(nums[7:])       # [7, 8, 9]: do końca
print(nums[::2])      # [0, 2, 4, 6, 8]: co drugi element
print(nums[::-1])     # odwrócona kopia

Dwie rzeczy, które warto zapamiętać:

• Wycinek zawsze zwraca nową listę. Zmiana wycinka nie wpływa na oryginał.
• Indeks stop nie wchodzi do wyniku: nums[2:5] daje indeksy 2, 3 i 4, bez 5.

Jak dodawać elementy: append, extend i insert

Trzy metody "dodawania do listy" robią różne rzeczy, a mylenie ich to częste źródło błędów:

items = ["a", "b", "c"]

items.append("d")       # dodaje JEDEN element na końcu
items.insert(0, "z")    # wstawia JEDEN element pod podany indeks
items.extend(["e", "f"])  # dodaje KAŻDY element z innego iterowalnego obiektu

print(items)

• append(x) dodaje x jako pojedynczy element, nawet jeśli x jest listą. items.append([1, 2]) dodaje całą listę jako jeden wpis.
• extend(iterable) dodaje każdy element z obiektu iterowalnego. items.extend([1, 2]) dodaje dwa wpisy.
• insert(i, x) wstawia element pod podany indeks i przesuwa wszystko od i włącznie o jedną pozycję dalej.

+= z listą po prawej stronie działa jak extend:

items = ["a", "b"]
items += ["c", "d"]
print(items)

A do usuwania:

items = ["a", "b", "c", "b", "d"]

items.remove("b")       # usuwa pierwsze wystąpienie "b"
print(items)

last = items.pop()      # usuwa i zwraca ostatni element
print(last, items)

second = items.pop(0)   # usuwa i zwraca element o indeksie 0
print(second, items)

Jeśli spróbujesz wywołać remove() dla czegoś, czego nie ma na liście, Python zgłosi ValueError. Jeśli potrzebujesz "usuń, jeśli jest", najpierw sprawdź in albo użyj try.

Możesz też usuwać po indeksie przez del:

items = [10, 20, 30, 40, 50]
del items[1]
print(items)

Długość, przynależność, zliczanie

nums = [4, 8, 15, 16, 23, 42, 16]

print(len(nums))         # 7
print(16 in nums)        # True
print(nums.count(16))    # 2
print(nums.index(23))    # 4: indeks pierwszego 23

in to czytelny sposób sprawdzenia, czy lista zawiera wartość. Jeśli będziesz zadawać to pytanie wiele razy dla dużej listy, użyj zamiast niej zbioru: sprawdzenie przynależności w zbiorze to O(1), a w liście O(n).

Sortowanie

Są dwa sposoby i wybór ma znaczenie:

nums = [5, 2, 9, 1, 7]

# W miejscu: zmienia listę, zwraca None.
nums.sort()
print(nums)    # [1, 2, 5, 7, 9]

# Zwraca nową posortowaną listę, oryginał zostaje bez zmian.
original = [5, 2, 9, 1, 7]
sorted_nums = sorted(original)
print(sorted_nums, original)

Oba przyjmują reverse=True do sortowania malejąco:

nums = [5, 2, 9, 1, 7]
nums.sort(reverse=True)
print(nums)    # [9, 7, 5, 2, 1]

Oraz funkcję key do własnej kolejności:

words = ["banana", "apple", "kiwi", "strawberry"]
words.sort(key=len)
print(words)    # ['kiwi', 'apple', 'banana', 'strawberry']

key jest stosowany do każdego elementu, a porównywany jest jego wynik. Typowe przypadki: sortowanie po długości, po konkretnym atrybucie albo po napisie zamienionym na małe litery.

Odwracanie

Trzy warianty, zależnie od potrzeb:

items = [1, 2, 3, 4]

# W miejscu: zmienia listę, zwraca None.
items.reverse()
print(items)

# Wycinek: zwraca nową, odwróconą listę.
original = [1, 2, 3, 4]
copy = original[::-1]
print(copy, original)

# reversed(): zwraca leniwy iterator.
for n in reversed([1, 2, 3, 4]):
    print(n)

Zmiany w miejscu używaj, gdy nie potrzebujesz oryginału. Wycinka, gdy chcesz nową kopię. reversed(), gdy chcesz tylko przejść po elementach od końca bez tworzenia nowej listy.

Pułapka wspólnej referencji

Listy są modyfikowalne, a zmienne to referencje. To znaczy, że dwie zmienne mogą wskazywać tę samą listę:

a = [1, 2, 3]
b = a
b.append(4)

print(a)    # [1, 2, 3, 4]: a też się zmieniła!

b = a nie skopiowało listy; sprawiło, że b jest drugą nazwą tej samej listy. Jeśli chcesz kopię, poproś o nią wprost:

a = [1, 2, 3]
b = a.copy()   # albo list(a), albo a[:]
b.append(4)

print(a, b)    # [1, 2, 3]  [1, 2, 3, 4]

To zaskakuje każdego programistę Pythona przynajmniej raz. Pamiętaj: = między dwiema listami nie kopiuje.

Pętle i budowanie list

Podstawowy wzorzec znasz już ze strony o pętli for:

scores = [45, 72, 33, 90, 58, 61]
passing = []

for score in scores:
    if score >= 60:
        passing.append(score)

print(passing)

To czytelne i zawsze będzie w porządku. Gdy poczujesz się pewniej, odpowiednik w postaci list comprehension robi to samo w jednej linii:

scores = [45, 72, 33, 90, 58, 61]
passing = [s for s in scores if s >= 60]
print(passing)

Comprehensions omówimy szczegółowo dwie strony dalej.

Krótka ściąga

Metody, które warto znać, w skrócie:

• append(x): dodaje na końcu
• extend(iter): dodaje każdy element z obiektu iterowalnego
• insert(i, x): wstawia pod indeks i
• pop() / pop(i): usuwa i zwraca
• remove(x): usuwa pierwsze wystąpienie x
• sort() / sort(key=...) / sort(reverse=True)
• reverse()
• index(x): pozycja pierwszego x
• count(x): liczba wystąpień x
• copy(): płytka kopia

Co dalej

Listy to koń pociągowy. Teraz przyjrzymy się krotkom, ich niemodyfikowalnym kuzynom, i temu, kiedy lepiej sięgnąć po krotkę.