Podstawy programowania w języku Python I

Listy i krotki

Temat 5 · jedna nazwa, wiele wartości

Listy i krotki

Jedna nazwa, wiele wartości:

lista [ ]: można ją zmieniać (dokładać, usuwać, sortować)
krotka ( ): po utworzeniu się nie zmienia; to rekord o stałych polach

Reguła na cały temat:

metoda po kropce (L.sort()) ZMIENIA listę i zwraca None
funkcja z listą w nawiasie (sorted(L), len(L)) ZWRACA wynik i listy nie rusza

Listy i krotki · 1

Tworzenie listy

Nawiasy kwadratowe, elementy po przecinku. Lista może być pusta.

Kod

oceny = [4, 5, 3, 5, 4]
pusta = []
mieszana = ["Ala", 21, 4.5]     # można, ale zwykle elementy są jednego typu
print(oceny)

print(len(oceny), len(pusta))

print(type(oceny))

print(5 in oceny, 2 in oceny)   # in: czy wartość jest w liście

Wynik programu

▶ Całość albo ⏭ Krok[4, 5, 3, 5, 4]
5 0
<class 'list'>
True False

Listy i krotki · 2

Indeksy: numeracja od 0, ujemne od końca

 element:   4   5   3   5   4
 indeks:    0   1   2   3   4
 od końca: -5  -4  -3  -2  -1

Kod

oceny = [4, 5, 3, 5, 4]
print(oceny[0])   # pierwszy

print(oceny[2])

print(oceny[-1])   # ostatni, bez znajomości długości

print(oceny[len(oceny) - 1])   # to samo, dłużej

napis = "Python"                # napis indeksuje się tak samo
print(napis[0], napis[-1])

Wynik programu

▶ Całość albo ⏭ Krok4
3
4
4
P n

Listy i krotki · 3

Wycinki: L[start:stop:krok]

start wchodzi, stop NIE wchodzi (jak w range), krok: co który element. Wycinek zawsze tworzy NOWĄ listę.

Kod

L = [0, 1, 2, 3, 4, 5]
print(L[1:4])

print(L[:3])   # od początku

print(L[3:])   # do końca

print(L[1:-1])   # bez pierwszego i ostatniego

print(L[::2])   # co drugi

print(L[::-1])   # odwrócona kopia

print("kajak"[::-1])

a, b = 1, 3                     # "od a do b WŁĄCZNIE" -> b + 1
print(L[a:b + 1])

Wynik programu

▶ Całość albo ⏭ Krok[1, 2, 3]
[0, 1, 2]
[3, 4, 5]
[1, 2, 3, 4]
[0, 2, 4]
[5, 4, 3, 2, 1, 0]
kajak
[1, 2, 3]

Listy i krotki · 4

Lista jest mutowalna: zmiana elementu i metody

Przypisanie pod indeks podmienia element.

Kod

L = [10, 20, 30]
L[0] = 99
print(L)

kolejka = ["Ala", "Bartek"]
kolejka.append("Cela")          # dokłada na koniec
kolejka.insert(0, "Darek")      # wstawia na pozycję 0
print(kolejka)

kolejka.remove("Bartek")        # usuwa pierwsze wystąpienie wartości
ostatni = kolejka.pop()         # zdejmuje ostatni i ZWRACA go
pierwszy = kolejka.pop(0)       # zdejmuje element o indeksie 0
print(kolejka, ostatni, pierwszy)

Wynik programu

▶ Całość albo ⏭ Krok[99, 20, 30]
['Darek', 'Ala', 'Bartek', 'Cela']
['Ala'] Cela Darek

Listy i krotki · 5

Pułapka: metoda zwraca None

append(), insert(), remove(), sort(), reverse() zmieniają listę i zwracają None. Wywołuj je w osobnej linii, BEZ przypisania.

Kod

L = [1, 2]
wynik = L.append(3)
print(L)

print(wynik)

# L = L.append(3)   ŹLE: L staje się None i lista przepada

Wynik programu

▶ Całość albo ⏭ Krok[1, 2, 3]
None

Listy i krotki · 6

Funkcje wbudowane i metody informacyjne

Kod

oceny = [4, 5, 3, 5, 4]
czasy = [12.5, 11.2, 13.0]
print(min(czasy), max(czasy), sum(czasy))

print(f"Średnia: {sum(czasy) / len(czasy):.2f}")

print(oceny.count(5))   # ile razy występuje 5

print(oceny.index(3))   # indeks pierwszego wystąpienia 3

A = [1, 2]
B = [3, 4]
print(A + B)   # nowa lista, A i B bez zmian

A.extend(B)                     # dokleja B do A (zmienia A)
print(A)

Wynik programu

▶ Całość albo ⏭ Krok11.2 13.0 36.7
Średnia: 12.23
2
2
[1, 2, 3, 4]
[1, 2, 3, 4]

Listy i krotki · 7

Budowanie listy w pętli

Pusta lista PRZED pętlą, append() W pętli, wynik PO pętli.

Kod

kwadraty = []
for i in range(5):
    kwadraty.append(i * i)
print(kwadraty)

liczby = [3, -2, 7, 0, -5, 4]
dodatnie = []
for x in liczby:
    if x > 0:
        dodatnie.append(x)
print(dodatnie)

Wynik programu

▶ Całość albo ⏭ Krok[0, 1, 4, 9, 16]
[3, 7, 4]

Listy i krotki · 8

Po elementach czy po indeksach?

for x in L          -> dostajesz wartości (do odczytu)
for i in range(len(L)) -> dostajesz indeksy (gdy trzeba PODMIENIĆ elementy)

Kod

oceny = [4, 5, 3, 5, 4]
L = [3, -1, 0, -5, 2]
for i in range(len(L)):
    if L[i] < 0:
        L[i] = 0
print(L)

for nr, ocena in enumerate(oceny, start=1):   # numer i wartość naraz
    print(nr, ocena, end="  ")
print()

Wynik programu

▶ Całość albo ⏭ Krok[3, 0, 0, 0, 2]
1 4  2 5  3 3  4 5  5 4

Listy i krotki · 9

Druga nazwa to NIE kopia

B = A daje tej samej liście drugą etykietę. Kopia: copy(), list() albo [:].

Kod

A = [1, 2, 3]
B = A
B.append(4)
print(A)   # A też się zmieniła!

C = A.copy()
C.append(5)
print(A, C)

Wynik programu

▶ Całość albo ⏭ Krok[1, 2, 3, 4]
[1, 2, 3, 4] [1, 2, 3, 4, 5]

Listy i krotki · 10

Sortowanie: sort() czy sorted()?

Kod

wyrazy = ["gruszka", "jabłko", "banan"]
print(sorted(wyrazy))

print(wyrazy)   # bez zmian

wyrazy.sort()
print(wyrazy)

punkty = [40, 95, 72, 88]
print(sorted(punkty, reverse=True))   # malejąco

# Napisy sortują się znak po znaku: wielkie litery przed małymi,
# a liczby zapisane jako napisy układają się "dziwnie".
print(sorted(["ala", "Zebra", "kot"]))

print(sorted(["10", "9", "100"]))

print(sorted([10, 9, 100]))

sort()   -> sortuje W MIEJSCU, zwraca None, oryginalna kolejność przepada
sorted() -> zwraca NOWĄ posortowaną listę, oryginał zostaje

Wynik programu

▶ Całość albo ⏭ Krok['banan', 'gruszka', 'jabłko']
['gruszka', 'jabłko', 'banan']
['banan', 'gruszka', 'jabłko']
[95, 88, 72, 40]
['Zebra', 'ala', 'kot']
['10', '100', '9']
[9, 10, 100]

Listy i krotki · 11

Odwracanie kolejności (to NIE jest sortowanie)

Kod

L = ["a", "b", "c", "d"]
print(L[::-1])   # nowa lista

for x in reversed(L):           # przejście od końca
    print(x, end=" ")
print()

L.reverse()                     # w miejscu, zwraca None
print(L)

Wynik programu

▶ Całość albo ⏭ Krok['d', 'c', 'b', 'a']
d c b a 
['d', 'c', 'b', 'a']

Listy i krotki · 12

split() i join(): napis <-> lista

split() tnie napis na listę, join() skleja listę napisów w jeden napis. Separator stoi PRZED kropką: "-".join(lista)

Kod

zdanie = "ala ma kota"
slowa = zdanie.split()
print(slowa)

print("-".join(slowa))

print(", ".join(sorted(slowa)))

wiersz = "Anna;87;matematyka"
print(wiersz.split(";"))

# join() przyjmuje tylko napisy: liczby trzeba zamienić przez str()
liczby = [1, 2, 3]
napisy = []
for x in liczby:
    napisy.append(str(x))
print(" ".join(napisy))

Wynik programu

▶ Całość albo ⏭ Krok['ala', 'ma', 'kota']
ala-ma-kota
ala, kota, ma
['Anna', '87', 'matematyka']
1 2 3

Listy i krotki · 13

Krotki: rekord o stałych polach

Nawiasy okrągłe. Odczyt jak w liście (indeksy, wycinki, len, in, for), ale zmienić się jej nie da.

Kod

punkt = (10, 20)
student = ("Anna", 22, 4.5)
print(student[0], student[-1], len(student))

print(type(punkt))

jedna = (5,)                    # krotka jednoelementowa: przecinek obowiązkowy!
nie_krotka = (5)                # to zwykła liczba 5 w nawiasie
print(type(jedna), type(nie_krotka))

# punkt[0] = 99   ŹLE: TypeError, krotki nie da się zmienić

Wynik programu

▶ Całość albo ⏭ KrokAnna 4.5 3
<class 'tuple'>
<class 'tuple'> <class 'int'>

Listy i krotki · 14

Rozpakowanie: pola do osobnych zmiennych

Liczba zmiennych po lewej = liczba pól po prawej.

Kod

student = ("Anna", 22, 4.5)
imie, wiek, srednia = student
print(f"{imie} ma {wiek} lat i średnią {srednia}")

x, y = 3, 5                     # po prawej powstaje krotka (3, 5)
x, y = y, x                     # zamiana wartości bez zmiennej pomocniczej
print(x, y)

Wynik programu

▶ Całość albo ⏭ KrokAnna ma 22 lat i średnią 4.5
5 3

Listy i krotki · 15

Lista krotek = lista rekordów

Każdy element to krotka o tym samym kształcie. Rozpakowanie od razu w nagłówku pętli.

Kod

wyniki = [("Ala", 12.5), ("Bartek", 11.2), ("Cela", 13.0)]
for imie, czas in wyniki:
    print(f"{imie}: {czas:.2f} s")

# Krotki sortują się po PIERWSZYM polu (przy remisie po drugim),
# więc do rankingu wg czasu ustawiamy czas na początku: (czas, imie).
ranking = []
for imie, czas in wyniki:
    ranking.append((czas, imie))
ranking.sort()
lider = ranking[0][0]           # pierwsze pole pierwszego rekordu
# enumerate daje (numer, rekord), a (czas, imie) od razu rozpakowuje rekord
for miejsce, (czas, imie) in enumerate(ranking, start=1):
    print(f"{miejsce}. {imie} {czas:.2f} s (+{czas - lider:.2f} s)")

Wynik programu

▶ Całość albo ⏭ KrokAla: 12.50 s
Bartek: 11.20 s
Cela: 13.00 s
1. Bartek 11.20 s (+0.00 s)
2. Ala 12.50 s (+1.30 s)
3. Cela 13.00 s (+1.80 s)

Listy i krotki · 16

Obliczenia na rekordach: magazyn

Te same wzorce co przy pętlach: akumulator, filtr, szukanie maksimum.

Kod

magazyn = [("Srubki", 100, 0.20), ("Mlotki", 3, 25.00), ("Gwozdzie", 4, 0.50)]
wartosc = 0
do_zamowienia = []
najlepszy, najlepsza_wartosc = "", 0
for nazwa, ilosc, cena in magazyn:
    wartosc += ilosc * cena
    if ilosc < 5:
        do_zamowienia.append(nazwa)
    if ilosc * cena > najlepsza_wartosc:     # > : przy remisie zostaje pierwszy
        najlepszy, najlepsza_wartosc = nazwa, ilosc * cena
print(f"Wartość magazynu: {wartosc:.2f}")

print("Najcenniejszy:", najlepszy)

print("Do zamówienia:", do_zamowienia)

Wynik programu

▶ Całość albo ⏭ KrokWartość magazynu: 97.00
Najcenniejszy: Mlotki
Do zamówienia: ['Mlotki', 'Gwozdzie']

Listy i krotki · 17

Lista list: tabela

M[wiersz][kolumna]. Przechodzimy dwiema pętlami zagnieżdżonymi.

Kod

M = []
for i in range(1, 4):
    wiersz = []
    for j in range(1, 4):
        wiersz.append(i * j)
    M.append(wiersz)
print(M)

print(M[1][2])   # wiersz 1, kolumna 2

for wiersz in M:
    napisy = []
    for x in wiersz:
        napisy.append(str(x))
    print(" ".join(napisy))   # (bez spacji na końcu)

Wynik programu

▶ Całość albo ⏭ Krok[[1, 2, 3], [2, 4, 6], [3, 6, 9]]
6
1 2 3
2 4 6
3 6 9

Listy i krotki · 18

Dwie liczby z jednej linii: split + rozpakowanie

Kod

x, y = input().split()          # ['3', '5'] -> dwie zmienne (napisy!)
x = int(x)
y = int(y)
print(x + y)   # bez int() byłoby "35"

Dane wejściowe

Wynik programu

▶ Całość albo ⏭ Krok8

Listy i krotki · 19

Mini ETL: wiersze tekstu -> lista rekordów

1) split(";")  2) rozpakowanie  3) konwersja typu  4) krotka + append()

Kod

n = int(input())
rekordy = []
for _ in range(n):
    imie, czas = input().split(";")
    rekordy.append((imie, float(czas)))
print(rekordy)

najszybszy = rekordy[0]         # szukanie minimum jak w temacie o pętlach
for rekord in rekordy:
    if rekord[1] < najszybszy[1]:
        najszybszy = rekord
print("Najszybszy:", najszybszy[0])

Dane wejściowe

Wynik programu

▶ Całość albo ⏭ Krok[('Ala', 12.5), ('Bartek', 11.2), ('Cela', 13.0)]
Najszybszy: Bartek

Listy i krotki · 20

Typowe błędy

L = L.sort() / L = L.append(x): L staje się None (patrz komórka 5).
L[len(L)]: IndexError, ostatni indeks to len(L) - 1 (albo -1).
L[a:b] zamiast L[a:b + 1], gdy "od a do b włącznie".
B = A to nie kopia: zmiana przez B jest widoczna w A.
(5) to liczba, krotka jednoelementowa to (5,).
"-".join([1, 2, 3]): TypeError, join przyjmuje tylko napisy.
Liczby z input()/split() to napisy: sortują się jak tekst, trzeba int().

Kod

L = [3, 1, 2]
L_zle = L.sort()                # ŹLE: przypisanie wyniku sort()
print("Zły wynik:", L_zle)

print("A lista i tak:", L)

L = [10, 20, 30, 40, 50]
a, b = 1, 3                     # "elementy od indeksu 1 do 3 włącznie"
print(L[a:b])   # ŹLE: brakuje L[3]

print(L[a:b + 1])   # dobrze

Wynik programu

▶ Całość albo ⏭ KrokZły wynik: None
A lista i tak: [1, 2, 3]
[20, 30]
[20, 30, 40]

Checkpoint

Co wypisze ten kod?

Co wypisze każda linia? Przy wycinkach rozpisz najpierw indeksy. Potem ▶ Uruchom.

Kod

# A
L = [3, 1, 2]
wynik = L.sort()
print(L)
print(wynik)

# B
L = [0, 1, 2, 3, 4, 5]
print(L[1:-1:2])
print(L[:3])
print(L[::-1])

Wynik programu

Najpierw przewidź wynik, potem ▶ Całość albo ⏭ Krok.[1, 2, 3]
None
[1, 3]
[0, 1, 2]
[5, 4, 3, 2, 1, 0]

Ćwiczenia · temat 5

Zadania: co jest potrzebne

Zadanie	Narzędzie	Zadanie	Narzędzie
5.1 Maks. i min.	`max()`, `min()`	5.11 Średnia z części	`L[a:b + 1]`
5.2 Średnia skrajnych	`L[0]`, `L[-1]`	5.12 Mini ETL	`split(",")` → krotka
5.3 Łączenie list	`A + B`	5.13 Telemetria	licznik, `lo <= x <= hi`
5.4 Elementy w listę	`append()`	5.14 Rozpakowanie	`x, y = input().split()`
5.5 Lista kwadratów	pętla + `append()`	5.15 Krok, odwrócenie	`[2:7]`, `[::2]`, `[::-1]`
5.6 Zera zamiast ujemnych	`range(len(L))`	5.16 join vs pętla	`"-".join()`
5.7 Ile dodatnich	licznik	5.17 Lista zakupów	krotki `(priorytet, nr, nazwa)`
5.8 Ostatni znak	`s[-1]`	5.18 Ranking	krotki `(czas, imie)`
5.9 Sortowanie	`sorted()`, `reversed()`	5.19 Magazyn	akumulator, filtr, maksimum
5.10 Bez końców	`L[1:-1]`	5.20–5.22	warianty dla chętnych

Podsumowanie

Co zapamiętać

Lista czy krotka?

Zbiór elementów rośnie, kurczy się albo się zmienia -> lista
Stały zestaw pól o ustalonym znaczeniu (imię, czas) -> krotka

sort() czy sorted()?

Pierwotna kolejność nie będzie potrzebna -> L.sort() (w osobnej linii)
Pierwotna kolejność ma zostać -> nowa = sorted(L)

Listy i krotki

Temat 5 · jedna nazwa, wiele wartości

Listy i krotki

Tworzenie listy

Indeksy: numeracja od 0, ujemne od końca

Wycinki: L[start:stop:krok]

Lista jest mutowalna: zmiana elementu i metody

Pułapka: metoda zwraca None

Funkcje wbudowane i metody informacyjne

Budowanie listy w pętli

Po elementach czy po indeksach?

Druga nazwa to NIE kopia

Sortowanie: sort() czy sorted()?

Odwracanie kolejności (to NIE jest sortowanie)

split() i join(): napis <-> lista

Krotki: rekord o stałych polach

Rozpakowanie: pola do osobnych zmiennych

Lista krotek = lista rekordów

Obliczenia na rekordach: magazyn

Lista list: tabela

Dwie liczby z jednej linii: split + rozpakowanie

Mini ETL: wiersze tekstu -> lista rekordów

Typowe błędy

Co wypisze ten kod?

Zadania: co jest potrzebne

Co zapamiętać

Lista czy krotka?

sort() czy sorted()?

Notatki prowadzącego · slajd