Listy w Pythonie? Co z nimi robić? Do czego mogą się przydać? W trzeciej lekcji „Python dla inżynierów” dowiesz się co to są listy i jak z nimi pracować, żeby życie było prostsze ;)
Tzw. listy w programowaniu są niezwykle ważne (w niektórych językach – jak Delphi – listy określa się jako tablice). Pozwalają one na zorganizowanie i przez to znaczne przyspieszenie obliczeń. Dzięki listom będziesz mógł efektywnie wykonywać 'masowe’ obliczenia, czyli za jednym zamachem będziesz w stanie przeprowadzić wiele obliczeń na raz. Przykład: zwymiarowanie 100 belek w jednym algorytmie. Zastosowanie list pozwala też na automatyzację obliczeń – większość programów w budownictwie i nie tylko bazuje na tego typu elementach.
Działanie na listach w Pythonie otwiera ogromne możliwości obliczeniowe. W połączeniu z takimi obiektami Pythona jak pętle, funkcje i dedykowane biblioteki (tych rzeczy nauczę Cię w kolejnych lekcjach) jesteś w stanie zaprogramować niemal każdy problem. Tutaj, z racji że wciąż poznajesz Pythona, będę ograniczać się do operowania tylko na listach bez połączenia ich z innymi elementami Pythona (jak wspomniane pętle czy funkcje).
Po przerobieniu dzisiejszej lekcji będziesz potrafić takie rzeczy jak:
- Tworzenie list
- Indeksowanie i wycinanie list
- Podstawowe operacje na listach
- Listy zagnieżdżone
- Wprowadzenie do wyrażeń listowych
- Przykład zastosowania list
1. Tworzenie list
Lista jest to zmienna zawierająca uporządkowany zbiór elementów. Podobnie jak napisy (strings) tworzy ciąg elementów. W odróżnieniu od napisów, listy są modyfikowalne, czyli można dodawać i zmieniać poszczególne elementy danej listy.
Listę tworzymy za pomocą nawiasów kwadratowych []
, gdzie pomiędzy nimi wypisane są jej elementy rozdzielone przecinkami ,
. Przykład:
1 |
moja_lista = [1,2,3] # definiowanie trzyelementowej listy i przypisanie jej do zmiennej 'moja_lista' |
Elementami listy mogą być dowolne typy danych dostępnych w Pythonie.
1 2 3 4 5 6 |
# Lista składająca się z kilku typów danych x = 3 moja_lista = [1, 'dwa', 3.45, x] # Lista może też być pusta (pusty zbiór elementów) pusta_lista = [] |
2. Indeksowanie i wycinanie list
Podobnie jak przy napisach (strings) możemy się odwołać do wybranego elementu listy. Elementom listy przyporządkowane są konkretne numery indeksu. I tak: pierwszy element listy ma zawsze numer 0, drugi – 1 itd. Najlepiej wyjaśnię Ci to za pomocą prostego rysunku poniżej.
Rys. 1 Konwencja numeracji elementów listy
Weźmy teraz przykład:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
nowa_lista = [1,2,3,4,5] # Wywołanie elementu listy za pomocą indeksu moja_lista[1] # zwróci nam wartość drugiego elementu listy, czyli tutaj liczba 2 moja_lista[3] # = 4 moja_lista[10] # Indeks poza zakresem listy, Python zwróci tutaj błąd: 'IndexError: list index out of range' # Możemy też wywołać element listy licząc ostatniego elementu moja_lista[-1] # = 5 moja_lista[-2] # = 4 # Wycinanie ('slicing') wybranego ciągu elementów z listy moja_lista[1:] # Dostaniemy tutaj listę składającą się z czterech elementów [2,3,4,5] moja_lista[1:3] # Fragment listy obejmujący elementy od drugiego do trzeciego [2,3] |
Inne przykłady wycinania (slicing) elementów z listy:
moja_lista[:3]
– elementy od pierwszego (domyślnie jeśli nie podano) do trzeciego:[1,2,3]
moja_lista[2:]
– od trzeciego do ostatniego[3,4,5]
moja_lista[:]
– wszystkie elementy listy[1,2,3,4,5]
moja_lista[-2:]
– dwa ostatnie elementy[4,5]
moja_lista[:-1]
– od pierwszego do przedostatniego[1,2,3,4]
moja_lista[3:-3]
– od czwartego do czwartego od końca[3]
moja_lista[::2]
– Wyświetl wszystko, ale co drugi element listy[1,3,5]
moja_list[::-1]
– odwrócenie kolejności listy – wyświetlenie elementów od końca do początku[5, 4, 3, 2, 1]
3. Podstawowe operacje na listach
W poprzedniej lekcji, gdzie omawiałem napisy (strings) w Pythonie pokazałem kilka prostych metod, dzięki którym możemy modyfikować obiekty. Podobnie jest z listami. Sprawdźmy, co niektóre z nich robią w połączeniu z listami.
Łączenie list
1 2 3 4 5 |
moja_lista + ['nowy element'] # dostaniemy [1,2,3,'nowy element'] moja_lista + [4, 5] # = [1,2,3,4,5] lista2 = ['a','b','c'] moja_lista + lista2 # = [1,2,3,'a','b','c'] |
Uwaga: To 'dodawanie’ za pomocą +
nie zmieniło zawartości listy pierwotnej moja_lista
. Mamy tu do czynienia tylko z łączeniem dwóch list. moja_lista
i lista2
pozostają co prawda bez zmian, ale dostajemy nową listę zawierającą obie wcześniejsze listy.
Aby dodać element do listy na stałe musisz przypisać jej zawartość na nowo:
1 2 |
# Przypisanie na nowo zawartości listy moja_lista = moja_lista + ['dodaj element na stale'] |
Dostaniemy zmienioną czteroelementową listę [1,2,3, 'dodaj element na stale']
.
Powielanie listy
Listy możemy też powielać za pomocą *
:
1 2 |
# Powielanie listy moja_lista * 3 |
Takie 'mnożenie’ nie zwróci nam nowej listy [3,6,9]
, tylko będzie to zwielokrotnienie listy. Wynik będzie taki: [1, 2, 3, 1, 2, 3, 1, 2, 3]
.
Zastępowanie elementu listy
A co jeśli chcemy zmienić jakiś element listy? Nic prostszego! Należy tylko odwołać się do wybranego elementu tej listy i podać jego nową wartość.
1 2 |
# Zastępowanie elementu listy moja_lista[0] = 'zastap element' |
W wyniku pierwszego zabiegu element listy o indeksie 0 zostanie zastąpiony przez nowy element i moja_lista
będzie wyglądać tak: ['zastap element',2,3]
.
Jak widzisz listy w Pythonie są bardzo elastyczne. Możesz je dowolnie modyfikować i co ważne – w odróżnieniu do wielu innych języków programowania – nie trzeba podawać w ogóle jaki rozmiar ma mieć lista. Jeśli programowałeś w innych językach na pewno wiesz o czym mówię i o ile łatwiej pracować na listach w Pythonie.
Metody wbudowane
Podobnie jak wyżej, przy okazji omawiania poprzedniej lekcji dotyczącej napisów wspomniałem o tzw. metodach wbudowanych (built-in methods). Dzięki takim 'zaszytym’ funkcjom możesz znacznie ułatwić sobie pracę również na listach. Zobacz jak one działają!
Dodawanie elementów do listy
1 2 3 4 5 6 7 8 9 10 11 |
moja_lista = [1,2,3] # Długość listy (liczba elementów) len(moja_lista) # Dodawanie elementów do listy moja_lista.append('dodaj element') # Dodawanie elementu na koniec listy print(moja_lista) moja_lista.insert(1,'dodaj drugi element') # Dodawanie elementu w miejsce o indeksie 1 print(moja_lista) |
Python zwróci nam odpowiednio:
1 2 3 |
3 [1,2,3,'dodaj element'] [1, 'dodaj drugi element', 2, 3, 'dodaj element'] |
Funkcja len()
zwróciła, że moja_lista
zawiera trzy elementy. Zauważyłeś też pewnie, że funkcja .append(x)
dodała nowy element na koniec listy? Teraz moja_lista
składać się będzie z czterech elementów. Funkcja .append()
zawsze dodaje element na koniec listy. Z kolei za pomocą .insert(i,x)
możesz wstawić nowy element x
do listy w dowolnie wybranym miejscu – nowe miejsce w liście wskazujemy za pomocą indeksu i
. I tak moja_lista
powiększyła się o kolejny element, który wstawiłem na drugim miejscu (indeks 1), kolejne elementy listy 'przesuną’ się o 1 miejsce w prawo.
W odróżnieniu od wcześniejszego przykładu z łączeniem list za pomocą znaku +
(moja_lista + ['nowy element']
), funkcje .append()
i .insert()
zmieniają zawartość samej listy i nie ma potrzeby przypisywać dla niej na nowo zmiennej.
Usuwanie elementów z listy
Elementy listy można również usuwać – służą do tego funkcje .pop()
oraz .remove()
.
1 2 3 4 5 6 7 8 9 10 |
# Usuwanie elementu listy za pomocą .pop() nowa_lista = ['a','b','c','a'] nowa_lista.pop() # Usunięcie ostatniego elementu listy (odwrotność funkcji .append()) nowa_lista.pop(0) # Usunięcie z listy elementu o indeksie 0 print(nowa_lista) # Usuwanie elementu listy za pomocą .remove() nowa_lista = ['a','b','c','a'] nowa_lista.remove('a') # Usunięcie z listy pierwszego wystąpienia zmiennej 'a' print(nowa_lista) |
Wynikiem będzie:
1 2 |
['b','c'] ['b','c','a'] |
Obie funkcje .pop()
i .remove()
służą właściwie do tego samego, ale podejście do przeszukiwania listy w celu usunięcia elementu jest różne. Pierwsza funkcja usuwa element po numerze indeksu, druga natomiast wyszukuje pierwsze wystąpienia podanej zmiennej w liście.
Przeszukiwanie list
Jeśli chcemy przeszukać listę (np. sprawdzić czy dany element występuje w liście lub sprawdzić na którym jest miejscu) to mamy do dyspozycji kilka funkcji:
1 2 3 4 5 |
nowa_lista = ['a','b','c','a'] 'a' in nowa_lista # Prawda (True) jeśli element występuje w liście, w przeciwnym przypadku fałsz (False) nowa_lista.index('a') # Zwraca indeks pierwszego wystąpienia szukanego elementu w liście nowa_lista.index('a',1,10) # Jak wyżej tylko przeszukuje listę w zakresie indeksów od 1 do 10 |
Wynik:
1 2 3 |
True 0 3 |
Możesz też policzyć liczbę wystąpień szukanego elementu w liście, jak też znaleźć największy lub najmniejszy element listy:
1 2 3 |
nowa_lista.count('a') # Zwraca liczbę wystąpień elementu listy max(nowa_lista) # Zwraca największy element listy min(nowa_lista) # Najmniejszy element listy |
Jak widzisz funkcje max()
, min()
działają nie tylko na liczbach ale również i na innych typach zmiennych (w tym przykładzie są to napisy). Typów jednak nie można mieszać – Python wyrzuci błąd. Jeśli chodzi o napisy (stringi) to określenie wartości maksymalnej (minimalnej) opiera się na kolejności znaków w tablicy ASCII.
Z naszego przykładu dostaniemy odpowiednio:
1 2 3 |
2 'c' 'a' |
Modyfikowanie kolejności elementów w liście
Funkcje .reverse()
oraz .sort()
modyfikują kolejność elementów listy. Za pomocą .reverse()
możemy odwrócić kolejność danej listy. Z kolei jeśli chcesz uporządkować listę składającą się z napisów albo z liczb to możesz użyć funkcji .sort()
. Jest to funkcja, która domyślnie układa elementy listy w porządku alfabetycznym lub liczby w kolejności rosnącej. Prosty przykład wyjaśni działanie obu funkcji:
1 2 3 4 5 6 7 |
nowa_lista = ['a','b','c','a'] # Odwracanie kolejności listy nowa_lista.reverse() # Sortowanie elementów listy nowa_lista.sort() |
W rezultacie otrzymamy dwie zmienione listy – pierwsza z odwróconą kolejnością, druga uporządkowana alfabetycznie:
1 2 |
['a', 'c', 'b', 'a'] ['a', 'a', 'b', 'c'] |
4. Listy zagnieżdżone
Listy, w niektórych językach nazywane tablicami (np. Delphi/Pascal), wykorzystywane są często do 'masowych’ obliczeń. Przykładem może być metoda elementów skończonych (MES). Obliczenia w tej metodzie oparte są przede wszystkim na działaniach na macierzach (np. macierz sztywności, obciążeń etc.). Python pozwala na tworzenie dowolnych macierzy, które definiuje się przez tzw. zagnieżdżanie list, czyli lista w liście. Weźmy przykład:
1 2 3 4 5 6 7 8 9 10 11 12 |
# Mamy trzy listy lista_1 = [1, 2, 3] lista_2 = [4, 5, 6] lista_3 = [7, 8, 9] # Łączmy je w jedną macierz tablica = [lista_1, lista_2, lista_3] # Zobaczmy teraz jak wygląda nasza macierz i jak odwołujemy się do jej elementów: tablica # Wywołanie całej macierzy tablica[0] # Wywołanie pierwszego wiersza macierzy tablica[0][0] # Wywołanie pierwszego elementu z wiersza pierwszego macierzy |
W rezultacie Python zwróci nam:
1 2 3 |
[[1, 2, 3], [4, 5, 6], [7, 8, 9]] [1, 2, 3] 1 |
Dostaliśmy macierz 9-elementową o wymiarze 3×3. Jak widzisz definiowanie macierzy jest proste. Odwoływanie się do wybranego elementu macierzy jest identyczne jak w listach (w końcu macierz to lista w liście :)). Należy tylko pamiętać, że pierwszy indeks dotyczy numeru wiersza macierzy (czyli w poziomie), a drugi numeru elementu w tym wierszu. Rysunek poniżej powinien pomóc Ci w zapamiętaniu kolejności odwoływania.
Rys. 2 Konwencja odwoływania się do list zagnieżdżonych
5. Wprowadzenie do wyrażeń listowych
Inną bardzo użyteczną funkcją Pythona są wyrażenia listowe (list comprehensions). Tutaj nie będę tego szerzej rozwijał z racji, że jest to bardziej zaawansowany temat. W skrócie mogę powiedzieć, że wyrażenia listowe pozwalają odwzorować pewną listę na inną wykonując na każdym elemencie tej listy pewną funkcję. Żeby jednak nie wyglądało to na wiedzę tajemną, pokażę Ci prosty przykład wykorzystania tego typu wyrażeń.
Przykład: Weźmy zdefiniowaną wyżej tablica
i za pomocą wyrażenia listowego stworzę listę, która będzie zawierać pierwszą kolumnę tej macierzy (mówiąc ściśle: pierwszy element każdego wiersza).
1 2 |
kolumna_1 = [wiersz[0] for wiersz in tablica] print(kolumna_1) |
Wynik tej operacji wygląda tak [1,4,7]
.
Użyłem tutaj pętli for
. Nie martw się jeśli nie wszystko rozumiesz – możesz śmiało przeskoczyć ten przykład. Wrócę do tematu pętli w kolejnych lekcjach.
6. Przykład zastosowania list
Za przykład wykorzystania list w obliczeniach inżynierskich posłuży lista zagnieżdżona (macierz) oraz wyrażenie listowe.
W przykładzie chodzi o to, że mamy 3 belki o zróżnicowanych przekrojach i siłach osiowych i należy obliczyć pole przekroju i naprężenie normalne dla każdej z tych belek.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# Dane belka1 = [0.2, 0.5] # Wymiary przekroju belki w [m], lista zawiera odpowiednio szerokość (b) i wysokość (h) przekroju belka2 = [0.3, 0.6] # Jak wyżej belka3 = [0.4, 0.4] # Jak wyżej F = [200, 300, 400] # Siły podłużne w [kN] odpowiednio w kolejnych belkach (1,2,3) # Obliczenia belki = [belka1, belka2, belka3] # zbiór belek jako macierz pole = [] # lista pól przekroju poszczególnych belek (tutaj pusta) sigma = [] # lista naprężeń normalnych belek (tutaj pusta) for i in range(len(belki)): pole.append(belki[i][0] * belki[i][1]) sigma.append(F[i] / pole[i] / 1000) # Wydruk wyników print('Naprężenia normalne w belkach:') print(" - Pole przekroju belki 'i': ", pole, 'm2') print(" - Naprężenie normalne w belce 'i': ", sigma, 'MPa') |
Wynikiem będzie zapis:
1 2 3 |
Naprężenia normalne w belkach: - Pole przekroju belki 'i': [0.1, 0.18, 0.16] m2 - Naprężenie normalne w belce 'i': [2.0, 1.67, 2.50] MPa |
Podsumowanie
Super, dużo za nami! Dzięki tej lekcji potrafisz tworzyć listy i odwoływać się do nich. Umiesz operować na listach – powielać je, dodawać lub usuwać elementy. Wiesz jak przeszukiwać listy i zmieniać kolejność ich elementów, wiesz też jak zagnieżdżać listy tworząc macierze.
Ćwiczenie czyni mistrza! Ściągnij spakowany plik .py z kodem, który pokazałem w tej lekcji, i spróbuj własnych sił.
W następnej lekcji zajmiemy się tzw. krotkami (tuples)!
Wpisy z cyklu „Python dla inżynierów„:
- Wprowadzenie do Pythona i Liczby
- Napisy (Strings)
- Listy
- (w opracowaniu)
Dzięki naprawdę bardzo pomogło.
Bardzo przydatny poradnik, zwięźle i przejrzyście. Dzięki przykładom da się bardzo szybko zrozumieć działanie.
Dzięki za pomoc
Patryk
Służę pomocą :)
Cześć.
Jest jeszcze jedna ciekawa instrukcja umożliwiająca poszerzenie listy o nowe elementy.Jest nią .extend() .Zaletą tej funkcji jest możliwość wprowadzenia wielu elementów do już istniejącej listy nie tworząc w ten sposób listy zagnieżdżonej w liście jak to jest w przypadku funkcji .append().
Przykład:
b = [1,2,3]
b.append([10,20])
print (b)
[1,2,3,[10,20]]
Jak dodamy jedną wartość metodą .append() do listy to wtedy nie ma problemu,lecz jeśli więcej jak jedną wówczas tworzymy listę w liście. Możemy tego nie chcieć i funkcja .extend jest wówczas przydatniejsza.
przykład
a = [1,2,3]
a.extend ([10,20])
print (a)
[1,2,3,10,20]
Tym sposobem nie tworzymy listy w liście.
Pozdrawiam
Grzesiek
Dzięki Grzesiek za przywołanie extend(). Działa dokładnie tak, jak piszesz.