W tym rozdziale nauczysz się posługiwać indeksami, by wskazać, pobrać i wydrukować element listy.
Już potrafisz sporo rzeczy zrobić ze stringami, zacznijmy od powtórki, czyli przygotowania ze stringa (tekstowego typu danych) listy, gdzie kryterium rozdzielania elementów listy będzie spacja. Wydrukuj listę, długość listy i typ danych.
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ – tak więc Python jest językiem z typami dynamicznymi, podobnie jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
print("Utworzona lista:")
print(lista)
print(f"\nLista ma:\n{str(len(lista))} elementów")
print(f"\nTypem danych zmiennej lista jest:\n{str(type(lista))}")
Zobaczmy efekt:
======================== RESTART: F:\python38\wpis 6.py ========================
Utworzona lista:
['W', 'Pythonie', 'wartości,', 'a', 'nie', 'zmienne,', 'posiadają', 'typ', '–', 'tak', 'więc', 'Python', 'jest', 'językiem', 'z', 'typami', 'dynamicznymi,', 'podobnie', 'jak', 'Lisp,', 'a', 'w', 'przeciwieństwie', 'do', 'Javy.', 'Wszystkie', 'wartości', 'przekazywane', 'są', 'przez', 'referencję.']
Lista ma:
31 elementów
Typem danych zmiennej lista jest:
<class 'list'>
>>> Skoro naszym ostatecznym zadaniem jest policzenie częstości występowania trzech kolejnych wyrazów, musisz poznać sposób na wydrukowanie takich trzech kolejnych wyrazów. Do osiągnięcia tego celu posłużysz się indeksami.
Zacznijmy od czegoś najprostszego, wydrukujesz pierwszy element listy, czyli literę W. Numer elementu, czyli jego indeks, podajesz w nawiasach kwadratowych [ ] zaraz za nazwą zmiennej. Sprawdźmy działanie. Pod zmienną pierwszy_element podstawiamy pierwszy element listy pierwszy_element = lista[1] i drukujemy go print(pierwszy_element).
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
pierwszy_element = lista[1]
print(pierwszy_element)
Efekt:
======================== RESTART: F:/python38/wpis 6.py ========================
Pythonie
>>> Zupełnie nie to czego się spodziewałeś. Python zaczyna numerację od zera. Pierwszy element ma indeks 0, drugi element ma indeks 1 itd. Poprawmy więc kod programu, dodajmy jeszcze wydrukowanie typu danych dla zmiennej pierwszy_element:
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
pierwszy_element = lista[0]
print(pierwszy_element)
print(type(pierwszy_element))
Efekt:
======================== RESTART: F:/python38/wpis 6.py ========================
W
<class 'str'>
>>> Teraz wydrukujmy ostatni element listy. Jak sprawdziliśmy lista ma 31 elementów:
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
ostatni_element = lista[31]
print(ostatni_element)
Efekt:
======================== RESTART: F:/python38/wpis 6.py ========================
Traceback (most recent call last):
File "F:/python38/wpis 6.py", line 8, in <module>
ostatni_element = lista[31]
IndexError: list index out of range
>>> Zamiast słowa referencję. otrzymaliśmy błąd! Błąd IndexError: list index out of range podpowiada nam co poszło nie tak. Mamy błąd indeksu (IndexError), mówiący, że chcemy zrobić coś z indeksem listy, który jest poza zakresem (list index out of range). Co dokładnie zrobiliśmy źle? Lista ma 31 elementów, ale indeks zaczyna się od 0. Dlatego chcąc dostać się do 31 elementu szukamy go pod 30 indeksem. Poprawmy program:
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
ostatni_element = lista[30]
print(ostatni_element)
Zobaczmy efekt:
======================== RESTART: F:/python38/wpis 6.py ========================
referencję.Jednak taka metoda dostępu do ostatniego elementu listy nie jest wygodna. O ile pierwszy element listy zawsze będzie pod indeksem 0, to indeks ostatniego elementu zależy od długości listy. Używając zdobytej wiedzy możesz zaproponować np. takie rozwiązanie:
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
ostatni_element = lista[len(lista) - 1]
print(ostatni_element)
Wiesz, że indeks jest liczbą. Wiesz, jak sprawdzić długość listy len(lista). Wiesz, jak odejmować liczby len(lista) - 1. No i wiesz, jak się posługiwać indeksami lista[len(lista) - 1]. Sprawdźmy poprawność takiego rozumowania krok po kroku. Najpierw wydrukujmy długość listy i numer ostatniego indeksu:
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
print(f"Lista ma {str(len(lista))} elementów")
print(f"Ostatni indeks listy ma wartość: {str(len(lista) - 1)}")
Efekt:
======================== RESTART: F:\python38\wpis 6.py ========================
Lista ma 31 elementów
Ostatni indeks listy ma wartość: 30
>>> Teraz mamy pewność, że podany wyżej sposób: ostatni_element = lista[len(lista) - 1] zadziała. Przetestujmy taki kod:
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
ostatni_element = lista[len(lista) - 1]
print(ostatni_element)
I zobaczmy efekt:
======================== RESTART: F:/python38/wpis 6.py ========================
referencję.
>>> Warto nauczyć się prostszego sposobu. Użyjesz ujemnego indeksu do wydrukowania ostatniego elementu. Logika tego podejścia jest następująca. Pod indeksem 1 jest druga wartość, pod indeksem 0 jest pierwsza wartość, pod indeksem -1 jest ostatnia wartość! Można pokazać to w ten sposób:
| „W” | „Pythonie” | „Wartości” |
| Indeks[0] | Indeks[1] | Indeks[2] |
| Indeks[-3] | Indeks[-2] | Indeks[-1] |
Przetestujmy rozwiązanie z ujemnym indeksem:
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
ostatni_element = lista[-1]
print(ostatni_element)
Efekt:
======================== RESTART: F:/python38/wpis 6.py ========================
referencję.
>>> Prawda, że prościej?
Wracając do głównego celu, nas nie interesuje pojedynczy element, chcemy użyć trzech elementów, czyli trzech kolejnych słów. W kwadratowych nawiasach możesz podać nie tylko pojedynczy indeks, ale też zakres indeksów, oddzielając pierwszy od ostatniego dwukropkiem :. Różnica jest taka, że podając zakres indeksów Python wyświetla od indeksu podanego jako pierwszy, ale kończy na wartości przedostatniej. Brzmi to mocno skomplikowanie, uprośćmy to przykładem. Chcesz wyświetlić pierwsze 3 elementy listy, numerowanie zaczyna się od 0, czyli wydawać by się mogło, że zakres indeksów będzie taki [0:2]. Do dzieła!
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
trzy_wyrazy = lista[0:2]
print(trzy_wyrazy)
Efekt:
======================== RESTART: F:/python38/wpis 6.py ========================
['W', 'Pythonie']
>>> Dostałeś dwa wyrazy, pisząc [0:2] informujesz Pythona, że chcesz zobaczyć co jest pomiędzy indeksami większym lub równymi 0 i mniejszym niż 2. Pamiętasz błąd po podaniu ostatni_element = lista[31]? Jeśli podasz zakres np. [0:31], błędu nie będzie, gdyż dla Pythona podałeś zakres pomiędzy indeksem większym lub równym 0 i mniejszym niż 31.
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
cala_lista = lista[0:31]
print(cala_lista)
Efekt:
======================== RESTART: F:\python38\wpis 6.py ========================
['W', 'Pythonie', 'wartości,', 'a', 'nie', 'zmienne,', 'posiadają', 'typ', '–', 'tak', 'więc', 'Python', 'jest', 'językiem', 'z', 'typami', 'dynamicznymi,', 'podobnie', 'jak', 'Lisp,', 'a', 'w', 'przeciwieństwie', 'do', 'Javy.', 'Wszystkie', 'wartości', 'przekazywane', 'są', 'przez', 'referencję.']
>>> Poprawmy program drukujący trzy wyrazy:
tekst_zrodlowy = "W Pythonie wartości, a nie zmienne, posiadają typ \
– tak więc Python jest językiem z typami dynamicznymi, podobnie \
jak Lisp, a w przeciwieństwie do Javy. Wszystkie wartości \
przekazywane są przez referencję."
lista = tekst_zrodlowy.split()
trzy_wyrazy = lista[0:3]
print(trzy_wyrazy)
I zobaczmy w końcu prawidłowy efekt:
======================== RESTART: F:\python38\wpis 6.py ========================
['W', 'Pythonie', 'wartości,']Sukces! Wiesz już co to są indeksy i jak ich używać by wydobyć z listy jej konkretny element, albo zakres elementów.
Zadanie domowe
Podążanie za instrukcjami, nawet jeśli je wszystkie wykonujesz samodzielnie, nie zrobi z ciebie programisty. Zadania domowe mogą wydawać się na początku trudne. Tu nie ma rozwiązania podanego na talerzu, użyj dowolnych źródeł, by znaleźć odpowiedź.
- Oprócz pojedynczego elementu i zakresu można też za pomocą indeksu wydobyć co „enty” element. Na dowolnej liście, dłuższej niż 6 elementów, użyj indeksu tak, by wydobyć co trzeci jej element.
- Używając bardzo podobnego pomysłu jaki potrzebny ci jest do wykonania pierwszego zadania, użyj indeksu tak, by wydrukować listę w odwrotnej kolejności, czyli od ostatniego elementu do pierwszego.