Listy

Tworzenie list

Python nie operuje wektorami takimi, jakie występują w innych językach programowania – skończonymi ciągami obiektów takiego samego typu. Listy w Pythonie to ciągi elementów różnych typów, choć oczywiście mogą to być elementy wyłącznie liczbowe lub tekstowe. Listy tworzy się tworząc ciąg elementów rozdzielonych przecinkami i obejmując je nawiasami kwadratowymi. Można je przyporządkować jakiemuś literałowi.

c=[1,2,’a’,’2b’,True]print(a,’\n’, b,’\n’,c)

a=[1,2,3,4,5,6]
b=['a','b','c','d','e','f']

>>>
[1, 2, 3, 4, 5, 6] 
['a', 'b', 'c', 'd', 'e', 'f'] 
[1, 2, 'a', '2b', True]

Obiekty typu lista wyświetlają się dokładnie tak, jak zostały napisane.

Elementami listy mogą być inne listy.

a=[1,2,3,4,5,6]
b=[4,3,2,1,6,5]
c=[7,8,5,4]
mat=[a,b,c]
print(mat)

		
>>>
[[1, 2, 3, 4, 5, 6], [4, 3, 2, 1, 6, 5], [7, 8, 5, 4]]

Umożliwia to przechowanie w liście wektorów liczbowych o różnej długości.

Funkcja range

Funkcja range pełni ważną rolę w programowaniu i dlatego została wyróżniona w osobnym podrozdziale. Jest to funkcja trzyargumentowa i wszystkie jej argumenty muszą być liczbami całkowitymi. Gdy zapisze się ją z dwoma argumentami, to domyślnie trzeci argument ma wartość 1. Gdy zapisze się ją z jednym argumentem to domyślnie pierwszy ma wartość 0, a trzeci jeden. Zapis ‘range(n,m,k)’ oznacza automatyczne wygenerowanie liczb [a,a+k,a+2k,…a+ik] dla takiego i, że m < a+ik oraz m >= a+(i+1)k. Liczby te można zobaczyć jako listę, gdy użyje się funkcji ‘list()’.

print(list(range(7)))
print(list(range(1,7)))
print(list(range(1,17,3)))
print(list(range(1,-17,-3)))

>>>
[0, 1, 2, 3, 4, 5, 6]
[1, 2, 3, 4, 5, 6]
[1, 4, 7, 10, 13, 16]
[1, -2, -5, -8, -11, -14]

Funkcja range() powszechnie używana jest w iteracjach do wykonywania jakiś operacji na wszystkich elementach listy. Jej wartości traktuje się jako pozycje elementów różnych list i innych podobnych struktur.

Automatyczne tworzenie list

W programach bardzo często przetwarza się jedną listę na drugą. Jednym z narzędzi do szybkiego tworzenia list są wytworniki. Występują one w pięciu postaciach:

• prostej,
• prostej warunkowej,
• rozszerzonej,
• rozszerzonej z jednym warunkiem,
• rozszerzonej z wieloma warunkami.

Postać prosta ma następującą składnię:

‘Sekwencja’ jest pewną listą, a lista ta może zawierać wytworniki. Umożliwia to tworzenie następujących list:

import math
print([math.sin(math.pi/x) for x in [1,2,3]])
print([math.sin(math.pi/x) for x in [2*y for y in [1,2,3]]])
print([math.sin(math.pi/x) for x in [2*y for y in [z/3 for z in [1,2,3]]]])

>>>
[1.2246467991473532e-16, 1.0, 0.8660254037844386]
[1.0, 0.7071067811865476, 0.49999999999999994]
[-1.0, 0.7071067811865476, 1.0]

Prosta postać warunkowa pozwala na umieszczanie na listach tylko te elementy, które spełniają pewien warunek. Jest to klasyczne filtrowanie listy za pomocą warunku logicznego. Jej składnia jest następująca:

import math
print([math.sin(math.pi/x) for x in [1,2,3,4,5,6] if x<4])
print([math.sin(math.pi/x) for x in [2*y for y in [1,2,3,4,5,6] if not y>=4]])
print([math.sin(math.pi/x) for x in [2*y for y in [z/3 for z in [1,2,3,4,5,6] if z<4]]])

>>>
[1.2246467991473532e-16, 1.0, 0.8660254037844386]
[1.0, 0.7071067811865476, 0.49999999999999994]
[-1.0, 0.7071067811865476, 1.0]

Program ten daje takie same wyniki jak poprzedni.

Warunek może być rozbudowany przez operatory logiczne and, or, not.

Postać rozszerzona wytwornika to wielokrotne zastosowanie for. Ma następującą składnię:

Przykładem zastosowania tej formy tworzenia list może być określenie współrzędnych punktów jakiegoś obszaru, gdzie planowany jest eksperyment terenowy.

tabela = [(x,y) for x in range(8)
for y in range(3)]
print(tabela)

tabela = [(x,y) for x in range(8)
    for y in range(3)]
print(tabela)

>>>
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), 
 (2, 0), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), 
 (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), 
 (6, 0), (6, 1), (6, 2), (7, 0), (7, 1), (7, 2)]

>>>
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), 
 (2, 0), (2, 1), (2, 2), (3, 0), (3, 1), (3, 2), 
 (4, 0), (4, 1), (4, 2), (5, 0), (5, 1), (5, 2), 
 (6, 0), (6, 1), (6, 2), (7, 0), (7, 1), (7, 2)]

Oba programy dają ten sam wynik, co pokazuje, że w przypadku wytworników list wcięcia kodu nie są ważne.

Jeżeli zależy nam na utworzeniu listy, gdy jakiś warunek jest spełniany przez obie zmienne (typu ‘if x<y’) można go napisać na końcu. Powstanie w ten sposób postać rozszerzona wytwornika z jednym warunkiem o następującej składni:

for zmienna_k in sekwencja k
if warunek]

Poniżej pokazano przykład zastosowania takiego wytwornika.

iloczyny = [x*y for x in range(1,10)
    for y in range(1,10)
    if x+y<7]
print(iloczyny)

>>>
[1, 2, 3, 4, 5, 2, 4, 6, 8, 3, 6, 9, 4, 8, 5]

Każde, albo niektóre z wyrażeń ‘for zmienna_k in sekwencja_k’ mogą być obdarzone warunkami, które musi spełniać k-ta zmienna. Powstanie w ten sposób postać rozszerzona wytwornika z wieloma warunkami. Ma on składnię:

for zmienna_k in sekwencja_k if warunek_3
if warunek]

Przykład:

sumy = [x+y for x in range(1,10) if x%2
    for y in range(1,10) if not y%3
    if x*y>17]
print(sumy)

		
>>>
[9, 12, 11, 14, 10, 13, 16, 12, 15, 18]

Program utworzył listę z sumami dwóch cyfr nieparzystej x (x%2 jest resztą z dzielenia x przez 2 traktowaną jako True) oraz podzielnej przez 3, o ile ich iloczyn jest większy od 17.

Odwołanie się do wybranych elementów listy

Do poszczególnych elementów listy możemy dostać za pomocą nawiasów kwadratowych i indeksu. Trzeba jednak pamiętać, że Pythonie zawsze liczy się elementy list od 0.

a=[1,2,3,4,5,6][1]
b=['a','b','c','d','e','f']
c=[1,2,'a','2b',True]
print(a,'\n', b[0],'\n',c[4])

>>>
2 
  a 
  True

Wykonanie tego programu powoduje wyświetlenie 2, a i True.

Odwołania się poprzez indeksy w nawiasach kwadratowych na listach działa tak samo, jak na tekstach. Można zatem używać wyrażeń n1:n2, :n1, n2:, -n:.

a=[1,2,3,4,5,6,'liczby',True]
print(a[5:7], a[:7], a[5:])
print(a[-7:], a[:-5])

>>>
[6, 'liczby'] [1, 2, 3, 4, 5, 6, 'liczby'] [6, 'liczby', True]
[2, 3, 4, 5, 6, 'liczby', True] [1, 2, 3]

Edycja list

Poprzez odwołanie się do konkretnego elementu możemy zmienić jego wartość w liście.

a=[1,2,3,4,5,6,'liczby',True]
a[0]='jeden'
print(a)

>>>
  ['jeden', 2, 3, 4, 5, 6, 'liczby', True]

Działania na listach

Listy możemy łączyć za pomocą działania + i powielać za pomocą działania *.

a=[1,2,3,4,5,6,'liczby',True]
print(a+['a'])
print(a+a)
print(a*2)

>>>
[1, 2, 3, 4, 5, 6, 'liczby', True, 'a']
[1, 2, 3, 4, 5, 6, 'liczby', True, 1, 2, 3, 4, 5, 6, 'liczby', True]
[1, 2, 3, 4, 5, 6, 'liczby', True, 1, 2, 3, 4, 5, 6, 'liczby', True]

Relacje między listami

Przy pomocy relacji ‘in’ można sprawdzić czy jakiś element znajduje się gdzieś w liście.

a=[1,2,3,4,5,6]
c=[1,2,3,4,5]
print(6 in a)
print(6 in c)
print(c in a)

>>>
True
False
False

Relacja ‘in’ nie sprawdza czy jakaś lista jest podlistą innej listy, ale czy jest jej elementem.

Relacja ‘==’ oraz ‘is’ dają tylko wtedy wartość True, gdy listy składają się z tej samej ilości elementów i elementy na tej samej pozycji są sobie równe.

a=b=[1,2,3,4,5,6,'liczby',True]
c=[1,2,3,4,5,6,'liczby']
print(a==b, a is b)
print(a==c, a is c)

>>>
True True
False False

Relacje ‘<‘, ‘<=’, ‘>’ i ‘>=’ między listami dają także tylko jedną odpowiedź True lub False. Porównanie list zaczyna się od pierwszych elementów list aż znajdą się elementy różne na tych samych pozycjach i dla nich ustalona będzie wartość False lub True wyświetlana później w odpowiedzi. Ponadto obowiązuje zasada, że ciąg krótszy jest mniejszy od dłuższego złożonego na początku z tych samych elementów co ciąg krótszy.

a=[1,2,3,4,5,6]
b=[1,2,3,4,5,7]
c=[1,2,3,4,5]
print(a<B, a a<="b,">b, a>=b)
print(a<C, a a<="c,">c, a>=c)

>>>
True True False False
False False True True

Metody działające na listach

Metody to rodzaje funkcji kilkuargumentowych działających na listach (i innych zmiennych), w których jednym argumentem jest zmienna, a pozostałymi pewne wielkości, które ją modyfikują. W odróżnieniu od funkcji, metody pisze się dopisując kropkę do zmiennej, po niej nazwę metody, a w nawiasach wartości pozostałych argumentów. Medoty definiuje się wtedy, gdy takie modyfikacje mają pewne naturalne podłoże (sposób wykonywania podobnych operacji na papierze).

Metoda ‘append’ pozwala na dodanie elementów na końcu listy. Metoda ‘insert’ pozwala na dodaniu elementu w środku listy, na i-tym miejscu pamiętając, że numerowanie elementów rozpoczyna się od 0. Wygląda to następująco:

panny=['Weronika','Julia']
print(panny)
panny.append('Nikola')
print(panny)
panny.insert(0,'Natalia')
print(panny)

>>>
['Weronika', 'Julia']
['Weronika', 'Julia', 'Nikola']
['Natalia', 'Weronika', 'Julia', 'Nikola']

‘

Metoda ‘append’ umożliwia dołączanie na końcu listy jednego elementu. Metoda ‘extend’ jest wydłużeniem listy o podaną listę elementów. Różnica między tymi metodami jest widoczna, gdy próbujemy dodać na końcu listy element, który jest listą.

panny=['Weronika','Julia']
panny.append(['Natalia','Nikola'])
print(panny)
panny=['Weronika','Julia']
panny.extend(['Natalia','Nikola'])
print(panny)

>>>
['Weronika', 'Julia', ['Natalia', 'Nikola']]
['Weronika', 'Julia', 'Natalia', 'Nikola']

Przypisania tej samej wartości początkowej dwóm zmiennym metodą a=b=wartość w przypadku list nie działa już tak samo jak w przypadku zmiennych prostych. Można to zobaczyć na następującym przykładzie:

xxx=panny=[123,'Weronika','Julia']
panny.extend(['Natalia','Nikola'])
print(panny)
print(xxx)

	
xxx=[123,'Weronika','Julia']
panny=[123,'Weronika','Julia']
panny.extend(['Natalia','Nikola'])
print(panny)
print(xxx)

>>>
[123, 'Weronika', 'Julia', 'Natalia', 'Nikola']
[123, 'Weronika', 'Julia', 'Natalia', 'Nikola']

>>>
[123, 'Weronika', 'Julia', 'Natalia', 'Nikola']
[123, 'Weronika', 'Julia']

Pomimo pozornie takich samych programów pojawiły się różne wyniki. Przypisanie zmiennym a i b tej samej listy metodą a=b=lista powoduje, że zmiana listy ‘a’ pociąga za sobą automatyczną zmianę listy ‘b’. Trzeba o tym pamiętać tworząc programy przekształcające listy.

Metody te działają natychmiast po zastosowaniu i są pamiętane bez zmiany nazwy listy. Nie można wyników działania metody ‘append’ przypisać bezpośrednio jakiejś nowej zmiennej.

panny=['Natalia', 'Weronika', 'Julia', 'Nikola']
dzieci=panny.append('Maciek')
print(dzieci)

panny=['Natalia', 'Weronika', 'Julia', 'Nikola']
panny.append('Maciek')
dzieci=panny
print(dzieci)

>>>
None

>>>
['Natalia', 'Weronika', 'Julia', 'Nikola', 'Maciek']

Po prawej stronie pokazano prawidłowe wygenerowanie listy ‘dzieci’.

Metoda ‘index’ pokazuje pozycję danego elementu w liście. Przy tej metodzie przypisanie jej wyniku do jakiejś zmiennej jest możliwe.

litery=['a','b','e','c','a','d','ł','o']
print(litery.index('c'))
n=litery.index('d')
print(n)

>>>
3
5

Jeżeli element podany w nawiasie nie występuje w liście pojawi się błąd. Aby sprawdzić, czy jakiś element znajduje się na liście należy użyć relacji ‘in’.

Metoda count pozwala na liczenie liczb wystąpień danego elementu w liście.

litery=['a','b','e','c','a','d','ł','o']
a=litery.count('a')
print(a)

>>>
2

Często używaną metodą w stosunku do list jest ‘sort’. Jak łatwo się domyślić, porządkuje ona elementy listy z elementami liczbowymi w kolejności od najmniejszej do największej, a z elementami tekstowymi zgodnie kolejnością w kodzie ASCI. Inną metodą z tej samej kategorii jest ‘reverse’, która odwraca porządek listy.

wieloznaki=['abaaa','BBBbA','baAA','AB++','AB||aa','_abABB','!ab@','@ABA','aaaA']
wieloznaki.reverse()
print(wieloznaki)
wieloznaki.sort()
print(wieloznaki)
liczby=[1267,2321,-14,118.9,2.124,4.3,0.0021,-1.1111]
liczby.sort()
print(liczby)
liczby.reverse()
print(liczby)

>>>
['aaaA', '@ABA', '!ab@', '_abABB', 'AB||aa', 'AB++', 'baAA', 'BBBbA', 'abaaa']
['!ab@', '@ABA', 'AB++', 'AB||aa', 'BBBbA', '_abABB', 'aaaA', 'abaaa', 'baAA']
[-14, -1.1111, 0.0021, 2.124, 4.3, 118.9, 1267, 2321]
[2321, 1267, 118.9, 4.3, 2.124, 0.0021, -1.1111, -14]

Usuwanie elementów z listy można realizować za pomocą metody ‘remove’ lub ‘pop’. Metoda ‘remove’ usuwa element o danej wartości, a metoda ‘pop’ z podanej pozycji. Można też to zrobić za pomocą instrukcji ‘del’.

litery=['a','b','e','c','a','d','ł','o']
litery.remove('a')
print(litery)
litery=['a','b','e','c','a','d','ł','o']
litery.pop(7)
print(litery)
litery=['a','b','e','c','a','d','ł','o']
del litery[0], litery[-1], litery[litery.index('d')]
print(litery)

>>>
['b', 'e', 'c', 'a', 'd', 'ł', 'o']
['a', 'b', 'e', 'c', 'a', 'd', 'ł']
['b', 'e', 'c', 'a', 'ł']

Metoda ‘clear’ usuwa wszystkie elementy z listy.

litery=['a','b','e','c','a','d','ł','o']
litery.clear()
print(litery)

>>>
[]

Funkcje działające na listach

Funkcja type() pokazuje typ obiektu.

a=[1,2,3,4,5,6,'liczby',True]
print(type(a))

>>>
<class 'list'>	

Funkcja len() pozwala na obliczenie liczby elementów listy.

a=[1,2,3,4,5,6,'liczby',True]
c=[-11,-2,a]
print(a,"   długość=",len(a))
print(c,"   długość=",len(c))

>>>
[1, 2, 3, 4, 5, 6, 'liczby', True]   długość= 8
[-11, -2, [1, 2, 3, 4, 5, 6, 'liczby', True]]   długość= 3

Funkcja sum() pozwala na obliczenie sumę elementów listy. Elementami listy muszą być liczby lub wartości logiczne traktowane jako 0 i 1.

a=[1,2,3,4,5,6,True]
print(sum(a))

>>>
22

Dla list liczbowych ważną grupę funkcji stanowią funkcje statystyczne. Znajdują się one w bibliotece statistics. Są to:

1. correlation(x, y) dla list x i y równej długości.
2. covariance(x, y) dla list x i y równej długości.
3. fmean(data) konwertuje data do listy i wylicza średnią arytmetyczną.
4. geometric_mean(x) wylicza średnią geometryczną.
5. harmonic_mean(x) wylicza średnia harmoniczną.
6. linear_regression(x, y) wylicza oba współczynniki regresji liniowej.
7. mean(x) – wylicza średnią arytmetyczną.
8. median(x) – wylicza medianę .
9. median_grouped(x) – wylicza medianę.
10. median_low – spośród dwóch wartości środkowych w uporządkowanej liście wybiera liczbę mniejszą.
11. median_high(x) – spośród dwóch warości środkowych w uporządkowanej liście wybiera liczbę większą.
12. mode(lista) – podaje wartość, która najczęściej się powtarza. Lista nie musi być liczbowa.
13. multimode(lista) – podaje wszystkie najczęściej powtarzające się wartości. Lista nie musi być liczbowa
14. pstdev(data, mu=None) – wylicza odchylenie standardowe traktując dane jak całą populację.
15. pvariance(data,mu=None) – wylicza wariancję traktując dane jak cała populację.
16. quantiles(data, *, n=4, method=’exclusive’) wylicza kwantyle przy podziale ‘data’ na n części dwoma metodami ‘inclusive’ i ‘exclusive’.
17. stdev(data, xbar=None) – wylicza odchylenie standardowe.
18. variance(data, xbar=None) – wylicza wariancję.

Przykład zastosowania jednej z bardziej popularnych funkcji: linear_regression():

from statistics import linear_regression
x=[1,3,2,4,3,2,5,3,5,6,7,4,5,6,4,6,5,8]
y=[2,1,3,1,2,2,3,5,3,3,4,3,5,7,6,5,3,5]
print(linear_regression(x,y))

		
>>>
LinearRegression(slope=0.4718779790276454, intercept=1.4289799809342227)