Listy, krotki i wycinki
Opanują Państwo operacje na listach w Pythonie, składnię wycinków oraz niezmienność krotek, korzystając z praktycznych przykładów inspirowanych klasycznymi zadaniami programistycznymi.
Listy, krotki i wycinki to bezpłatna lekcja Coding Interview Prep na CoddyKit. To lekcja 1 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Coding Interview Prep, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Coding Interview Prep zawiera 4 lekcji w sumie.
Listy w Pythonie: tablice dynamiczne
Pythonowy list to dynamiczna tablica, która może przechowywać dowolne elementy i samodzielnie się powiększa. Jest uporządkowana, modyfikowalna i zapewnia natychmiastowy dostęp przez indeks w czasie O(1). Kod pokazuje podstawy.
nums = [3, 1, 4, 1, 5]
print(nums[0]) # 3
print(nums[-1]) # 5 (last element)
nums.append(9)
print(len(nums)) # 6Typowe operacje na listach
Warto znać je na pamięć: dodawanie za pomocą append i usuwanie za pomocą pop na końcu listy zajmują O(1), ale insert na początku zajmuje O(n). Należy unikać remove w ciasnych pętlach — za każdym razem ponownie przeszukuje całą listę.
stack = []
stack.append(1)
stack.append(2)
stack.append(3)
print(stack.pop()) # 3 O(1)
print(stack) # [1, 2]
# insert at index 0 is O(n)
stack.insert(0, 0)
print(stack) # [0, 1, 2]Wyjaśnienie składni wycinków
Wycinek zapisuje się jako lst[start:stop:step] i kończy tuż przed stop. Klasyczny trik: krok równy -1 odwraca listę bez jej modyfikowania. Kod omawia każdą postać zapisu.
a = [0, 1, 2, 3, 4, 5]
print(a[1:4]) # [1, 2, 3]
print(a[:3]) # [0, 1, 2]
print(a[3:]) # [3, 4, 5]
print(a[::2]) # [0, 2, 4] every other
print(a[::-1]) # [5, 4, 3, 2, 1, 0] reversedWycinki tworzą płytkie kopie
Warto pamiętać o pewnej pułapce: wycinek zawsze tworzy nową listę, więc modyfikacja wycinka nie zmienia oryginału. Kopia jest jednak płytka, dlatego zagnieżdżone listy znajdujące się wewnątrz nadal są współdzielone. Proszę o tym pamiętać.
original = [1, 2, 3]
copy = original[:] # shallow copy
copy[0] = 99
print(original) # [1, 2, 3] unchanged
# Nested list pitfall
nested = [[1, 2], [3, 4]]
shallow = nested[:]
shallow[0][0] = 99
print(nested) # [[99, 2], [3, 4]] changed!Krotki: niezmienne sekwencje
Typ tuple używa nawiasów i po utworzeniu nie może być zmieniany. Ponieważ jest haszowalny, może być kluczem słownika lub elementem zbioru — doskonale nadaje się do przechowywania par (wiersz, kolumna) w zadaniach na siatkach.
point = (3, 7)
print(point[0]) # 3
# Use as dict key
grid = {}
grid[(0, 0)] = 'start'
grid[(2, 3)] = 'end'
print(grid[(0, 0)]) # start
# Unpacking
x, y = point
print(x, y) # 3 7Kiedy używać krotki, a kiedy listy
Proszę wybrać tuple, gdy dane nie powinny się zmieniać, a list, gdy powinny być modyfikowalne. Krotki zajmują też nieco mniej pamięci, co ma znaczenie w dużych kopcach używanych w algorytmie Dijkstry.
import sys
a_list = [1, 2, 3, 4, 5]
a_tuple = (1, 2, 3, 4, 5)
print(sys.getsizeof(a_list)) # e.g. 104 bytes
print(sys.getsizeof(a_tuple)) # e.g. 80 bytes
# Tuple returned from function
def min_max(nums):
return min(nums), max(nums)
lo, hi = min_max([3, 1, 4, 1, 5])
print(lo, hi) # 1 5Błędy typu off-by-one przy wycinkach
Błędy typu off-by-one są najczęstszą pułapką w zadaniach dotyczących tablic. Proszę pamiętać, że lst[i:j] zwraca dokładnie j-i elementów. Aby podzielić listę w połowie, lewa część to lst[:mid], a prawa to lst[mid:].
lst = [1, 2, 3, 4, 5, 6]
mid = len(lst) // 2 # 3
left = lst[:mid] # [1, 2, 3]
right = lst[mid:] # [4, 5, 6]
print(left, right)
# How many elements?
print(len(lst[2:5])) # 3 (indices 2,3,4)Ujemne indeksy na rozmowach rekrutacyjnych
Python ma ujemne indeksy: lst[-1] oznacza ostatni element, a lst[-2] — element przedostatni. Proszę używać lst[-1] zamiast lst[len(lst)-1] — rekruterzy zauważają czytelniejszy zapis.
s = 'abcde'
print(s[-1]) # 'e'
print(s[-3:]) # 'cde'
print(s[:-2]) # 'abc' (all except last 2)
nums = [10, 20, 30, 40]
print(nums[-2]) # 30
nums[-1] = 99
print(nums) # [10, 20, 30, 99]Sortowanie i porównywanie list
Sortowanie w Pythonie korzysta z algorytmu Timsort (O(n log n), stabilnego). lst.sort() zmienia listę w miejscu, natomiast sorted(lst) zwraca nową listę. Opcji key należy używać do definiowania własnej kolejności. Szczegóły pokazano w kodzie.
words = ['banana', 'fig', 'apple', 'kiwi']
words.sort(key=len)
print(words) # ['fig', 'kiwi', 'apple', 'banana']
nums = [3, 1, 4, 1, 5]
print(sorted(nums, reverse=True)) # [5, 4, 3, 1, 1]
print(nums) # unchanged: [3, 1, 4, 1, 5]Modyfikowanie list podczas iteracji
To klasyczna pułapka: nigdy nie należy dodawać ani usuwać elementów podczas przechodzenia po liście — można wtedy pominąć elementy lub doprowadzić do awarii. Zamiast tego proszę utworzyć nową listę za pomocą wyrażenia listowego.
# WRONG — skips elements
nums = [1, 2, 3, 4, 5]
for n in nums:
if n % 2 == 0:
nums.remove(n) # skips 4!
print(nums) # [1, 3, 5]... but 4 got skipped? Actually removes 2,4
# CORRECT — build new list
nums = [1, 2, 3, 4, 5]
nums = [n for n in nums if n % 2 != 0]
print(nums) # [1, 3, 5]Rozpakowywanie krotek w pętlach
Rozpakowywanie krotek upraszcza pętle: enumerate zwraca (index, value), a zip przechodzi jednocześnie po dwóch listach. Składnia *rest umieszcza pozostałą część w osobnej zmiennej. Szczegóły pokazano w kodzie.
nums = [10, 20, 30]
for i, v in enumerate(nums):
print(i, v)
# 0 10 / 1 20 / 2 30
a = [1, 2, 3]
b = ['x', 'y', 'z']
for x, y in zip(a, b):
print(x, y)
first, *rest = [1, 2, 3, 4]
print(first, rest) # 1 [2, 3, 4]Szybki sprawdzian
Szybki sprawdzian — proszę pokazać, ile udało się zapamiętać o listach, krotkach i wycinkach w Pythonie. Na pewno dadzą Państwo radę. 💪
Podsumowanie lekcji
Podsumowanie: listy to dynamiczne tablice z operacją append w czasie O(1), wycinki zawsze zwracają świeżą kopię, a krotki są niezmienne i haszowalne. Następnie zajmiemy się słownikami i zbiorami.
Często zadawane pytania
Czy lekcja „Listy, krotki i wycinki” jest bezpłatna?
Tak — pełny tekst „Listy, krotki i wycinki” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Coding Interview Prep, przejdź na CoddyKit PRO. Kurs Coding Interview Prep zawiera 4 lekcji w sumie.
Co nauczysz się w „Listy, krotki i wycinki”?
Opanują Państwo operacje na listach w Pythonie, składnię wycinków oraz niezmienność krotek, korzystając z praktycznych przykładów inspirowanych klasycznymi zadaniami programistycznymi. Ćwiczysz Coding Interview Prep z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.
Czy potrzebuję doświadczenia, aby zacząć Coding Interview Prep?
Nie wymagamy żadnego doświadczenia. Coding Interview Prep w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 1 z 4.
Ile czasu zajmuje lekcja „Listy, krotki i wycinki”?
Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.
Czy mogę pisać i uruchamiać kod w tej lekcji Coding Interview Prep?
Tak. Każda lekcja Coding Interview Prep zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.
Wszystkie lekcje w tym kursie
- Listy, krotki i wycinki
- Słowniki i zbiory w Pythonie
- Wyrażenia składane i funkcje wbudowane
- Funkcje, domknięcia i lambda