11 metod listy, które musisz znać w języku Python

Spis treści:

W tym przewodniku zgłębisz tajniki operowania listami w Pythonie, poznając techniki dodawania, modyfikowania i usuwania ich elementów.

Listy stanowią fundament programowania w Pythonie, będąc jedną z pierwszych struktur danych, z którymi się zetkniesz. W kolejnych akapitach przyjrzymy się bliżej podstawom list, a następnie przeanalizujemy zestaw praktycznych metod, które usprawnią Twoją pracę z nimi.

Zacznijmy!

Listy w Pythonie – wprowadzenie

W Pythonie lista to uporządkowany zbiór elementów, które mogą być różnego rodzaju. Możliwe jest iterowanie po elementach listy za pomocą pętli, takich jak pętla `for`, co umożliwia łatwy dostęp do poszczególnych elementów.

Listy, jak wszystkie obiekty iterowalne w Pythonie, są indeksowane od zera i obsługują mechanizm wycinania (slicing).

Listy są strukturami mutowalnymi, co oznacza, że można je modyfikować bezpośrednio. Dotyczy to dodawania nowych elementów, usuwania istniejących, sortowania w określonym porządku, odwracania kolejności i wielu innych operacji. Wbudowane metody list w Pythonie ułatwiają realizację tych zadań.

Przejdźmy teraz do analizy wybranych, przydatnych metod operowania listami.

Metody wbudowane do operacji na listach w Pythonie

W tej części skupimy się na praktycznym zastosowaniu kilku kluczowych metod. Każda z nich zostanie zilustrowana przykładami kodu.

Posłużymy się listą `pgm_langs`, zawierającą nazwy popularnych języków programowania.

pgm_langs = ['Python','Go','Rust','JavaScript']

Wstawianie elementów do listy za pomocą metody `insert()`

Metoda `insert()` pozwala na wstawienie nowego elementu na liście w wybranej pozycji (określonej indeksem). Wymaga ona podania dwóch argumentów:

Indeksu, na którym ma być umieszczony nowy element, oraz
Samego elementu do wstawienia.

Wstawmy „Scala” na pozycji o indeksie 1, wykorzystując metodę `insert()`.

pgm_langs = ['Python','Go','Rust','JavaScript']
pgm_langs.insert(1,'Scala')
print(pgm_langs)
# Output: ['Python', 'Scala', 'Go', 'Rust', 'JavaScript']

Dodawanie elementu na koniec listy za pomocą metody `append()`

Metoda `append()` pozwala na dodanie pojedynczego elementu na końcu listy.

Dodajmy łańcuch znaków „Java” na koniec naszej listy przy użyciu metody `append()`.

pgm_langs.append('Java')
print(pgm_langs)
# Output: ['Python', 'Scala', 'Go', 'Rust', 'JavaScript', 'Java']

Rozszerzanie listy o elementy iterowalne za pomocą `extend()`

Metoda `append()` jest idealna do dodawania pojedynczych elementów. Jak jednak dodać do listy całą kolekcję, na przykład inną listę? Tu z pomocą przychodzi metoda `extend()`, która pozwala rozszerzyć listę o elementy z obiektu iterowalnego.

Rozszerzmy listę `pgm_langs` o elementy z listy `more_langs`, wykorzystując metodę `extend()`.

more_langs = ['C++','C#','C']
pgm_langs.extend(more_langs)
print(pgm_langs)
# Output: ['Python', 'Scala', 'Go', 'Rust', 'JavaScript', 'Java', 'C++', 'C#', 'C']

Można również iterować po elementach obiektu iterowalnego i dodawać je do listy pojedynczo za pomocą `append()`, ale `extend()` jest znacznie bardziej zwięzłe i wygodne.

for lang in more_langs:
    pgm_langs.append(lang)

Odwracanie kolejności elementów na liście za pomocą `reverse()`

Aby odwrócić kolejność elementów na liście, wystarczy wywołać metodę `reverse()`.

Spójrzmy, jak zmieniła się lista `pgm_langs` po zastosowaniu `reverse()`.

pgm_langs.reverse()
print(pgm_langs)
# Output: ['C', 'C#', 'C++', 'Java', 'JavaScript', 'Rust', 'Go', 'Scala', 'Python']

Sortowanie listy za pomocą `sort()`

Metoda `sort()` pozwala posortować elementy listy w miejscu. W przypadku listy łańcuchów znaków, takich jak `pgm_langs`, sortowanie odbywa się w porządku alfabetycznym.

pgm_langs.sort()
print(pgm_langs)
# Output: ['C', 'C#', 'C++', 'Go', 'Java', 'JavaScript', 'Python', 'Rust', 'Scala']

Aby posortować listę w odwrotnym porządku alfabetycznym, można przekazać argument `reverse=True` do metody `sort()`.

pgm_langs.sort(reverse=True)
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']

Jeśli chcesz dowiedzieć się więcej o sortowaniu list w Pythonie, odsyłam do dodatkowych materiałów.

Tworzenie płytkiej kopii listy za pomocą `copy()`

Czasami, zamiast modyfikować oryginalną listę, chcemy pracować na jej kopii. Metoda `copy()` tworzy płytką kopię listy.

Stwórzmy kopię listy `pgm_langs` i nazwijmy ją `pgm_langs_copy`. Następnie zmodyfikujmy pierwszy element w kopii, ustawiając go na „Haskell”, a potem wydrukujmy kopie.

pgm_langs_copy = pgm_langs.copy()
pgm_langs_copy[0]='Haskell'

print(pgm_langs_copy)
# Output: ['Haskell', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']

Jak widać, modyfikacja kopii nie wpłynęła na oryginalną listę `pgm_langs`. Dzieje się tak, ponieważ metoda `copy()` tworzy płytką kopię, a nie referencję do oryginalnej listy.

print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C#', 'C']

Zliczanie wystąpień elementu za pomocą `count()`

Metoda `count()` zwraca liczbę wystąpień danego elementu na liście.

W liście `pgm_langs` wszystkie elementy występują raz. Sprawdźmy, ile razy występuje element „Go”.

print(pgm_langs.count('Go'))
# Output: 1

Metoda `count()` jest jednym z narzędzi do usuwania duplikatów z list w Pythonie.

Pobieranie indeksu elementu za pomocą `index()`

Aby znaleźć indeks danego elementu na liście, można skorzystać z metody `index()`. Załóżmy, że chcemy poznać indeks elementu „C#” na liście `pgm_langs`. Użyjemy asercji do sprawdzenia, czy element o indeksie 7 to rzeczywiście „C#”.

print(pgm_langs.index('C#'))
# Output: 7
assert pgm_langs[7] == 'C#'

Usuwanie elementu z określonego indeksu za pomocą `pop()`

Teraz przejdziemy do metod usuwania elementów z list w Pythonie. Metoda `pop()` służy do usuwania i zwracania elementu z określonego indeksu. Z poprzedniego przykładu wiemy, że element „C#” znajduje się na indeksie 7.

Po wywołaniu `pop(7)` na liście `pgm_langs`, zobaczymy, że zwraca ona „C#”, który zostaje również usunięty z listy.

print(pgm_langs.pop(7))
# Output: 'C#'
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++', 'C']

Metoda `pop()` usuwa i zwraca element o danym indeksie. Jeśli indeks nie zostanie podany, `pop()` usunie i zwróci ostatni element z listy.

print(pgm_langs.pop())
# Output: 'C'
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Java', 'Go', 'C++']

Usuwanie elementów o zadanej wartości za pomocą `remove()`

Metoda `remove()` pozwala na usunięcie elementu z listy na podstawie jego wartości, a nie indeksu. Usuńmy element „Java” z listy `pgm_langs` za pomocą metody `remove()`.

pgm_langs.remove('Java')
print(pgm_langs)
# Output: ['Scala', 'Rust', 'Python', 'JavaScript', 'Go', 'C++']

Usuwanie wszystkich elementów listy za pomocą `clear()`

Jeśli chcesz usunąć wszystkie elementy z listy, można skorzystać z pętli i metody `remove()`, usuwając każdy element po kolei:

for lang in pgm_langs:
    pgm_langs.remove(lang)

Jednak istnieje szybszy i bardziej elegancki sposób – użycie metody `clear()`. Metoda ta usuwa wszystkie elementy z listy, pozostawiając pustą listę.

pgm_langs.clear()
print(pgm_langs)
# Output: []

Podsumowanie metod operacji na listach w Pythonie

Szybkie podsumowanie omówionych metod list i ich składni:

Podsumowanie

Mam nadzieję, że ten przewodnik pomógł Ci zrozumieć, jak efektywnie korzystać z metod operacji na listach w Pythonie. W ramach dalszej nauki zapoznaj się z krotkami w Pythonie i poznaj różnice między listami a krotkami.

Jeśli jesteś na początku swojej przygody z Pythonem, polecam Ci skorzystanie z dostępnych materiałów edukacyjnych dla początkujących.