Zanurkuj w Pythonie/Listy

Z Wikibooks, biblioteki wolnych podręczników.

Spis treści 1 Listy 1.1 Definiowanie list 1.2 Dodawanie elementów do listy 1.3 Przeszukiwanie list 1.4 Usuwanie elementów z listy 1.5 Używanie operatorów na listach 1.6 Materiały dodatkowe

[edytuj] Listy

Listy są jednym z najważniejszych typów danych. Można się z nimi spotkać w Visual Basicu. W tym języku są określane jako tablice.

Listy przypominają tablice w Perlu. W Perlu zmienna, która przechowuje listę rozpoczyna się od znaku @, natomiast w Pythonie nazwa może być dowolna, ponieważ Python automatycznie rozpoznaje typ.

Listy w Pythonie to coś więcej niż tablice w Javie (chociaż można to traktować jako jedno). Lepszą analogią jest klasa ArrayList, w której można przechowywać dowolny obiekt i dynamicznie dodawać nowe pozycje.

[edytuj] Definiowanie list

>>> li = ["a", "b", "mpilgrim", "z", "przykład"]    #(1)
>>> li
['a', 'b', 'mpilgrim', 'z', 'przykład']
>>> li[0]                                           #(2)
'a'
>>> li[4]                                           #(3)
'przykład'

1. Najpierw zdefiniowaliśmy listę pięcioelementową. Zauważmy, że lista zachowuje swój oryginalny porządek i nie jest to przypadkowe. Lista jest uporządkowanym zbiorem elementów ograniczonym nawiasem kwadratowym.
2. Lista może być używana tak jak tablica zaczynająca się od 0. Pierwszym elementem niepustej listy o nazwie li jest zawsze li[0].
3. Ostatnim elementem pięcioelementowej listy jest li[4], ponieważ indeksy są liczone zawsze od 0.

>>> li
['a', 'b', 'mpilgrim', 'z', 'przykład']
>>> li[-1]                                     #(1)
'przykład'
>>> li[-3]                                     #(2)
'mpilgrim'

1. Za pomocą ujemnych indeksów odnosimy się do elementów idących od końca do początku tzn. li[-1] oznacza ostatni element, li[-2] przedostatni, li[-3] odnosi się do 3 od końca elementu itd. Ostatnim elementem niepustej listy jest zawsze li[-1].
2. Jeśli ciężko ci zrozumieć o co w tym wszystkim chodzi, możesz pomyśleć o tym w ten sposób: li[-n] == li[len(li) - n]. len to funkcja zwracająca ilość elementów listy. Tak więc w tym przypadku li[-3] == li[5 - 3] == li[2].

>>> li
['a', 'b', 'mpilgrim', 'z', 'przyklad']
>>> li[1:3]                                 #(1)
['b', 'mpilgrim']
>>> li[1:-1]                                #(2)
['b', 'mpilgrim', 'z']
>>> li[0:3]                                 #(3)
['a', 'b', 'mpilgrim']

1. Możesz pobrać podzbiór listy, który jest nazywany "wycinkiem" (ang. slice), poprzez określenie dwóch indeksów. Zwracaną wartością jest nowa lista zawierająca wszystkie elementy z listy rozpoczynające się od pierwszego wskazywanego indeksu (w tym przypadku li[1]) i idąc w górę kończy na drugim wskazywanym indeksie, nie dołączając go (w tym przypadku li[3]). Kolejność elementów względem wcześniejszej listy jest także zachowana.
2. Możemy także podać ujemną wartość któregoś indeksu. Wycinanie wtedy także dobrze zadziała. Jeśli to pomoże, możemy pomyśleć tak: czytamy listę od lewej do prawej, pierwszy indeks określa pierwszy potrzebny element, a drugi określa element, którego nie chcemy. Zwracana wartość zawiera wszystko między tymi dwoma przedziałami.
3. Listy są indeksowane od zera tzn. w tym przypadku li[0:3] zwraca pierwsze trzy elementy listy, rozpoczynając od li[0], a kończąc na li[2], ale nie dołączając li[3].

>>> li
['a', 'b', 'mpilgrim', 'z', 'przykład']
>>> li[:3]                                    #(1)
['a', 'b', 'mpilgrim']
>>> li[3:]                                    #(2) (3)
['z', 'przykład']
>>> li[:]                                     #(2) (4)
['a', 'b', 'mpilgrim', 'z', 'przykład']

1. Jeśli lewy indeks wynosi 0, możemy go opuścić, wartość 0 jest domyślna. li[:3] jest tym samym, co li[0:3] z poprzedniego przykładu.
2. Podobnie, jeśli prawy indeks jest długością listy, możemy go pominąć. Tak więc li[3:] jest tym samym, co li[3:5], ponieważ lista ta posiada pięć elementów.
3. Zauważmy pewną symetryczność. W pięcioelementowej liście li[:3] zwraca pierwsze 3 elementy, a li[3:] zwraca dwa ostatnie (a w sumie 3 + 2 = 5). W rzeczywistości li[:n] będzie zwracał zawsze pierwsze n elementów, a li[n:] pozostałą liczbę, bez względu na szerokość listy (n może być większe od długości listy).
4. Jeśli obydwa indeksy zostaną pominięte, wszystkie elementy zostaną dołączone. Nie jest to jednak to samo, co oryginalna lista li. Jest to nowa lista, która posiada wszystkie takie same elementy. li[:] tworzy po prostu kompletną kopię listy.

[edytuj] Dodawanie elementów do listy

>>> li
['a', 'b', 'mpilgrim', 'z', 'przykład']
>>> li.append("nowy")                                 #(1)
>>> li
['a', 'b', 'mpilgrim', 'z', 'przykład', 'nowy']
>>> li.insert(2, "nowy")                              #(2)
>>> li
['a', 'b', 'nowy', 'mpilgrim', 'z', 'przykład', 'nowy']
>>> li.extend(["dwa", "elementy"])                    #(3)
>>> li
['a', 'b', 'nowy', 'mpilgrim', 'z', 'przykład', 'nowy', 'dwa', 'elementy']

1. Dodajemy pojedynczy element do końca listy za pomocą metody append.
2. Za pomocą insert wstawiamy pojedynczy element do listy. Numeryczny argument jest indeksem, pod którym ma się znaleźć wstawiana wartość; reszta elementów, która znajdowała się pod tym indeksem lub miała większy indeks, zostanie przesunięta o jeden indeks dalej. Zauważmy, że elementy w liście nie muszą być unikalne i mogą się powtarzać; w przykładzie mamy dwa oddzielne elementy z wartością 'nowy' -- li[2] i li[6].
3. Za pomocą extend łączymy listę z inną listą. Nie możemy wywołać extend z wieloma argumentami, trzeba ją wywoływać z pojedynczym argumentem -- listą. W tym przypadku ta lista ma dwa elementy.

>>> li = ['a', 'b', 'c']
>>> li.extend(['d', 'e', 'f'])             #(1)
>>> li
['a', 'b', 'c', 'd', 'e', 'f']
>>> len(li)                                #(2)
6
>>> li[-1]
'f'
>>> li = ['a', 'b', 'c']
>>> li.append(['d', 'e', 'f'])             #(3)
>>> li
['a', 'b', 'c', ['d', 'e', 'f']]
>>> len(li)                                #(4)
4
>>> li[-1]
['d', 'e', 'f']

1. Listy posiadają dwie metody -- extend i append, które wyglądają na to samo, ale w rzeczywistości są całkowicie różne. extend wymaga jednego argumentu, który musi być listą i dodaje każdy element z tej listy do oryginalnej listy.
2. Rozpoczęliśmy z listą trójelementową ('a', 'b' i 'c') i rozszerzyliśmy ją o inne trzy elementy ('d', 'e' i 'f') za pomocą extend, tak więc mamy już sześć elementów.
3. append wymaga jednego argumentu, który może być dowolnym typem danych. Metoda ta po prostu dodaje dany element na koniec listy. Wywołaliśmy append z jednym argumentem, który jest listą z trzema elementami.
4. Teraz oryginalna lista, pierwotnie zawierająca trzy elementy, zawiera ich cztery. Dlaczego cztery? Ponieważ ostatni element przed chwilą do niej wstawiliśmy. Listy mogą wewnątrz przechowywać dowolny typ danych, nawet inne listy. Nie używajmy append, jeśli zamierzamy listę rozszerzyć o kilka elementów.

[edytuj] Przeszukiwanie list

>>> li
['a', 'b', 'nowy', 'mpilgrim', 'z', 'przykład', 'nowy', 'dwa', 'elementy']
>>> li.index("przykład")                                                   #(1)
5
>>> li.index("nowy")                                                       #(2)
2
>>> li.index("c")                                                          #(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: list.index(x): x not in list
>>> "c" in li                                                              #(4)
False

1. index znajduje pierwsze wystąpienie pewnej wartość w liście i zwraca jego indeks.
2. index znajduje pierwsze wystąpienie wartości w liście. W tym przykładzie, 'nowy' występuje dwa razy -- w li[2] i li[6], ale metoda index będzie zawsze zwracać pierwszy indeks, czyli 2.
3. Jeśli wartość nie zostanie znaleziona, Python zgłosi wyjątek. Takie zachowanie nie jest często spotykane w innych językach, w wielu językach w takich przypadkach zostaje zwrócony niepoprawny indeks. Takie zachowanie Pythona jest dosyć dobrym posunięciem, ponieważ umożliwia szybkie wychwycenie błędu w kodzie, a dzięki temu program nie będzie błędnie działał operując na niewłaściwym indeksie.
4. Aby sprawdzić czy jakaś wartość jest w liście używamy słowa kluczowego in, który zwraca True, jeśli wartość zostanie znaleziona lub False jeśli nie.

Przed wersją 2.2.1 Python nie posiadał oddzielnego boolowskiego typu danych. Aby to zrekompensować, Python mógł interpretować większość typów danych jako bool (czyli wartość logiczną np. w instrukcjach if) według poniższego schematu: 0 jest fałszem; wszystkie inne liczby są prawdą. Pusty łańcuch znaków ("") jest fałszem, wszystkie inne są prawdą. Pusta lista ([]) jest fałszem; wszystkie inne są prawdą. Pusta krotka (()) jest fałszem; wszystkie inne są prawdą. Pusty słownik ({}) jest fałszem; wszystkie inne są prawdą.

Wszystkie powyższe punkty stosowane są w Pythonie 2.2.1 i nowszych, ale obecnie można także używać typu logicznego bool, który może przyjmować wartość True (prawda) lub False (fałsz). Zwróćmy uwagę, że wartości te, tak jak cała składnia języka Python, są wrażliwe na wielkość liter.

[edytuj] Usuwanie elementów z listy

>>> li
['a', 'b', 'nowy', 'mpilgrim', 'z', 'przykład', 'nowy', 'dwa', 'elementy']
>>> li.remove("z")                                                            #(1)
>>> li
['a', 'b', 'nowy', 'mpilgrim', 'przykład', 'nowy', 'dwa', 'elementy']
>>> li.remove("nowy")                                                         #(2)
>>> li
['a', 'b', 'mpilgrim', 'przykład', 'nowy', 'dwa', 'elementy']
>>> li.remove("c")                                                            #(3)
Traceback (most recent call last):
  File "<stdin>", line 1, in ?
ValueError: list.remove(x): x not in list
>>> li.pop()                                                                  #(4)
'elementy'
>>> li
['a', 'b', 'mpilgrim', 'przykład', 'nowy', 'dwa']

1. remove usuwa pierwszą występującą wartość w liście.
2. remove usuwa tylko pierwszą występującą wartość. W tym przypadku 'nowy' występuje dwa razy, ale li.remove("nowy") usuwa tylko pierwsze wystąpienie.
3. Jeśli wartość nie zostanie znaleziona w liście, Python wygeneruje wyjątek. Naśladuje on w takich sytuacjach postępowanie metody index.
4. pop jest ciekawą metodą, która wykonuje dwie rzeczy: usuwa ostatni element z listy i zwraca jego wartość. Metoda ta różni się od li[-1] tym, że li[-1] zwraca jedynie wartość, ale nie zmienia listy, a od li.remove(value) tym, że li.remove(value) zmienia listę, ale nie zwraca wartości.

[edytuj] Używanie operatorów na listach

>>> li = ['a', 'b', 'mpilgrim']
>>> li = li + ['przykład', 'nowy']            #(1)
>>> li
['a', 'b', 'mpilgrim', 'przykład', 'nowy']
>>> li += ['dwa']                             #(2)
>>> li
['a', 'b', 'mpilgrim', 'przykład', 'nowy', 'dwa']
>>> li = [1, 2] * 3                           #(3)
>>> li
[1, 2, 1, 2, 1, 2]

1. Aby połączyć dwie listy, można też skorzystać z operatora +. Za pomocą lista = lista + innalista uzyskujemy ten sam wynik, co za pomocą list.extend(innalista), ale operator + zwraca nową listę, podczas gdy extend zmienia tylko istniejącą listę. Ogólnie extend jest szybszy, szczególnie na dużych listach.
2. Python posiada także operator +=. Operacja li += ['dwa'] jest równoważna li.extend(['dwa']). Operator += działa zarówno na listach, łańcuchach znaków jak i może być nadpisany dla dowolnego innego typu danych.
3. Operator * zwielokrotnia podaną listę. li = [1, 2] * 3 jest równoważne z li = [1, 2] + [1, 2] + [1, 2], które łączy trzy listy w jedną.

[edytuj] Materiały dodatkowe

• How to Think Like a Computer Scientist uczy podstaw związanych z wykorzystywaniem list, a także nawiązuje do przekazywania listy jako argument funkcji.
• Python Tutorial pokazuje, że listy można wykorzystywać jako stos lub kolejkę.
• Python Knowledge Base odpowiada na często zadawane pytania dotyczące list, a także posiada także wiele przykładów kodów źródłowych wykorzystujących listy.
• Python Library Reference opisuje wszystkie metody, które zawiera lista.