PROGRAMOWANIE I ALGORYTMY

szkoła fraktal
Zapraszamy na zajęcia przygotowujące do matury z informatyki

Serwis algorytm.edu.pl zaprasza na kompleksowe zajęcia przygotowujące do matury z informatyki (nowa podstawa programowa)

październik — kwiecień, rok szkolny 2022/2023

więcej informacji pod adresem szkola-fraktal.pl

Listy w Pythonie — tablice jednowymiarowe


powrót

Przydatne metody: append, clear, copy, count, extend, index, insert, pop, remove, reverse, sort.

Listy są bardzo elastycznym narzędziem w Pythonie, które potrafią przechowywać wiele elementów różnych typów. Są podobne do tablic w C++, z tą różnicą, że można w nich przechowywać dane różnego typu. Część elementów może być liczbami, inna część ciągami znaków, a jeszcze inna np. listami. Poszczególne elementy listy możemy modyfikować.

Inicjacja listy

Pustą listę możemy stworzyć w następujący sposób:

nazwa_listy = []

Dodawanie elementów do listy

Aby dodać kolejne elementy użyjemy metody append(element) np.

x = [] # tworzymy pustą listę
x.append(3) # dodaj liczbę 3 jako pierwszy element
x.append(4) # dodaj liczbę 4 jako drugi element
x.append("ala ma kota") # dodaj napis "ala ma kota" jako trzeci element
print(x)
Wyjście
[3, 4, 'ala ma kota']

Odwoływanie się do elementów listy

Wyobraź sobie, że wrzucasz poszczególne elementy listy do szufladek. Pierwsza szufladka ma numer 0, druga ma numer 1, trzecia 2 itd., czyli podobnie jak w wielu innych językach programowania. Aby odwołać się do któregoś z elementów, musisz podać nazwę listy a następnie nawias kwadratowy, a w nim numer szufladki (indeks), do której chcesz się odwołać. Możesz odwoływać się do elementów listy poprzez kolejne ujemne numery szufladek. Żeby wypisać ostatni element listy, możesz odwołać się za pomocą numeru -1, do przedostatniego elementu odwołasz się za pomocą indeksu -2 itd.

x = [2, 4, "ala ma kota", 3.14]
print(x[0]) # wypisanie pierwszego elementu listy (2)
print(x[3]) # wypisanie czwartego elementu listy (3.14)
print(x[-1]) # wypisanie ostatniego elementu listy (3.14)
# print(x[5]) # operacja niedozwolona, ponieważ nie istnieje szufladka z numerem 5
Wyjście
2
3.14
3.14

Łączenie list

Listy możemy połączyć za pomocą operatora "+".

x = [1, 2, 3]
y = [3, 4, 5]
x = x + y # lub x += y
print(x)
Wyjście
[1, 2, 3, 3, 4, 5]

Powielanie list

Listy możemy powielić za pomocą operatora "*".

x = [1, 2, 3]
x = x * 5 # lub x *= y
print(x)
Wyjście
[1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3, 1, 2, 3]

Fragmenty list

Jeśli chcemy wyłuskać n (n > 0) początkowych elementów listy, musimy użyć konstrukcji:

lista[:n]

Np.:

x = [1, 2, 3, 4, 5]
print(x[:3]) # wyłuskanie trzech początkowych elementów listy
Wyjście
[1, 2, 3]

Można użyć także konstrukcji:

lista[:-n] # dla n > 0

W tym przypadku zostaną wyłuskane początkowe elementy bez n końcowych.

x = [1, 2, 3, 4, 5]
print(x[:-3]) # wyłuskanie trzech początkowych elementów listy
Wyjście
[1, 2]

Przydatne metody dla list

append(element)

Dodanie elementu na koniec listy:

x = [1, 2, 3, 4, 5]
x.append(111)
print(x)
Wyjście
[1, 2, 3, 4, 5, 111]
clear()

Wyczyszczenie zawartości listy:

x = [1, 2, 3, 4, 5]
print(x)
x.clear()
print(x)
Wyjście
[1, 2, 3, 4, 5]
[]
copy()

Przeanalizujmy kod:

x = [1, 2, 3, 4, 5]
y = x
x[0] = 111
print(y)
Wyjście
[111, 2, 3, 4, 5]

W drugim wierszu kodu wykonaliśmy przypisanie y = x co spowodowało, że obiekty x i y wskazują na tą samą listę z danymi. Jeśli chcemy, aby zmienna y wskazywała na kopię listy zmiennej x, musimy użyć metody copy():

x = [1, 2, 3, 4, 5]
y = x.copy()
x[0] = 111
print(y)
Wyjście
[1, 2, 3, 4, 5]

Metoda copy() zwraca kopię listy obiektu x.

count(element)

Metoda zwraca liczbę wystąpień danego elementu w liście.

x = [1, 4, 4, 1, 4]
print(x.count(4))
Wyjście
3
extend(lista)

Metoda dodaje na koniec listy elementy innej listy.

x = [1, 4, 4, 1, 4]
y = ["a", "b"]
x.extend(y)
print(x)
Wyjście
[1, 4, 4, 1, 4, 'a', 'b']
index(element)

Metoda zwraca indeks (numer szufladki) pierwszego wystąpienia elementu w liście. Pamiętaj, że elementy indeksujemy począwszy od liczby zero.

x = [1, 4, 4, 1, 4, 5, 6, 6]
print(x.index(4))
print(x.index(5))
Wyjście
1
5

Metoda index może posiadać jeszcze dwa opcjonalne argumenty: indeks_początkowy oraz index_końcowy ograniczające zakres przeszukiwania listy:

x = [1, 4, 4, 1, 4, 5, 6, 6]
print(x.index(4, 4)) #  przeszukiwanie od 4 indeksu listy
print(x.index(1, 2, 5)) # przeszukujemy listę od 2 do 5 indeksu listy
Wyjście
4
3
insert(indeks, element)

Metoda wstawia nowy element listy w miejsce o inseksie indeks, przesuwając pozostałe elementy w prawo.

x = [1, 4, 4, 1, 4, 5, 6, 6]
print(x)
x.insert(2, "a")
print(x)
Wyjście
[1, 4, 4, 1, 4, 5, 6, 6]
[1, 4, 'a', 4, 1, 4, 5, 6, 6]

W przypadku, gdy dany indeks jest większy niż indeks ostatniego elementu, to element zostanie wstawiony na koniec listy.

pop(indeks)

Metoda usuwa element stojący na pozycji indeks, jednocześnie zwracając go. Jeśli użyjemy metodę pop() bez argumentu, to usunięty i zwrócony zostanie ostatni element listy.

x = [1, 4, 4, 1, 4, 5, 6, 6]
print(x.pop())
print(x)
print(x.pop(4))
print(x)
Wyjście
6
[1, 4, 4, 1, 4, 5, 6]
4
[1, 4, 4, 1, 5, 6]
remove(element)

Metoda usuwa pierwszy pasujący element z listy.

x = [1, 4, 4, 1, 4, 5, 6, 6]
print(x)
x.remove(4)
print(x)
Wyjście
[1, 4, 4, 1, 4, 5, 6, 6]
[1, 4, 1, 4, 5, 6, 6]
reverse()

Metoda odwraca kolejność elementów w liście.

x = [1, 2, 3, 4]
print(x)
x.reverse()
print(x)
Wyjście
[1, 2, 3, 4]
[4, 3, 2, 1]
sort()

Metoda porządkuje elementy listy.

Porządkowanie niemalejąco:

x = [2, 3, 1, 6, 0, 2]
print(x)
x.sort()
print(x)
Wyjście
[2, 3, 1, 6, 0, 2]
[0, 1, 2, 2, 3, 6]

Porządkowanie nierosnąco:

x = [2, 3, 1, 6, 0, 2]
print(x)
x.sort(reverse = True)
print(x)
Wyjście
[2, 3, 1, 6, 0, 2]
[6, 3, 2, 2, 1, 0]