Listor, tupler och slicing
Bemästra Python-operationer för listor, slicing-syntax och tupelns oföränderlighet med praktiska exempel från klassiska programmeringsutmaningar.
Listor, tupler och slicing är en gratis lektion i Förberedelse inför kodningsintervjuer på CoddyKit. Detta är lektion 1 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Förberedelse inför kodningsintervjuer, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Förberedelse inför kodningsintervjuer innehåller totalt 4 lektioner.
Python-listor: dynamiska arrayer
En Python-list är en dynamisk array som kan innehålla vad som helst och växer automatiskt. Den är ordnad, förändringsbar och ger omedelbar åtkomst i O(1) via index. Koden visar grunderna.
nums = [3, 1, 4, 1, 5]
print(nums[0]) # 3
print(nums[-1]) # 5 (last element)
nums.append(9)
print(len(nums)) # 6Vanliga listoperationer
Lär er dessa utantill: append och pop i slutet tar O(1), men insert i början tar O(n). Undvik remove i täta loopar – listan genomsöks på nytt varje gång.
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]Slicing-syntax förklarad
Slicing skrivs som lst[start:stop:step] och stannar precis före stop. Det klassiska tricket: ett steg på -1 vänder en lista utan att ändra den. Koden går igenom varje form.
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] reversedSlicing skapar grunda kopior
Bra att känna till: slicing skapar alltid en ny lista, så ändringar i utsnittet påverkar inte originalet. Kopian är dock grund, vilket innebär att kapslade listor fortfarande delas. Var uppmärksam på det.
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!Tupler: oföränderliga sekvenser
En tuple använder parenteser och kan inte ändras när den väl har skapats. Eftersom den är hashbar kan den användas som en dict-nyckel eller medlem i en set – perfekt för par som (row, col) i problem med rutnät.
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 7När ska tuple användas i stället för list
Välj en tuple när datan inte ska ändras och en list när den ska kunna ändras. Tupler använder dessutom lite mindre minne, vilket märks i stora heapar i Dijkstra.
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 5Off-by-one-fel vid slicing
Off-by-one-buggar är den vanligaste fallgropen i arrayproblem. Kom ihåg att lst[i:j] ger exakt j-i element. För att dela vid mitten är vänsterdelen lst[:mid] och högerdelen 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)Negativa index på tekniska intervjuer
Python har negativa index: lst[-1] är det sista elementet och lst[-2] det näst sista. Föredra lst[-1] framför lst[len(lst)-1] – intervjuare lägger märke till den renare varianten.
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]Sortering och jämförelse av listor
Pythons sortering använder Timsort (O(n log n) och stabil). lst.sort() ändrar listan på plats, medan sorted(lst) returnerar en ny lista. Använd alternativet key för en anpassad ordning. Se koden.
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]Ändra listor under iteration
En klassisk fallgrop: lägg aldrig till eller ta bort element medan ni loopar över en lista – ni kan hoppa över element eller få ett fel. Skapa i stället en ny lista med en comprehension.
# 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]Uppackning av tupler i loopar
Uppackning av tupler håller loopar rena: enumerate ger (index, value) och zip går igenom två listor tillsammans. Syntaxen *rest samlar resten i en egen variabel. Se koden.
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]Snabbtest
Snabbtest – visa vad ni har lärt er om Python-listor, tupler och slicing. Det här klarar ni. 💪
Sammanfattning av lektionen
Sammanfattning: listor är dynamiska arrayer med O(1) för append, slicing returnerar alltid en ny kopia och tupler är oföränderliga och hashbara. Nästa steg: dictionaries och sets.
Lär dig Förberedelse inför kodningsintervjuer med en AI-lärare – gratis
Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.
- Kurser
- 90
- Lektioner
- 360
Vanliga frågor
Är lektionen ”Listor, tupler och slicing” gratis?
Ja – hela texten till ”Listor, tupler och slicing” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Förberedelse inför kodningsintervjuer, kan Ni uppgradera till CoddyKit PRO. Kursen i Förberedelse inför kodningsintervjuer innehåller totalt 4 lektioner.
Vad lär jag mig i ”Listor, tupler och slicing”?
Bemästra Python-operationer för listor, slicing-syntax och tupelns oföränderlighet med praktiska exempel från klassiska programmeringsutmaningar. Ni övar på Förberedelse inför kodningsintervjuer med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.
Behöver jag någon erfarenhet för att börja lära mig Förberedelse inför kodningsintervjuer?
Du behöver inga förkunskaper. Utbildningen i Förberedelse inför kodningsintervjuer på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 1 av 4.
Hur lång tid tar lektionen ”Listor, tupler och slicing”?
De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.
Kan jag skriva och köra kod i den här Förberedelse inför kodningsintervjuer-lektionen?
Ja. Varje Förberedelse inför kodningsintervjuer-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.
Alla lektioner i den här kursen
- Listor, tupler och slicing
- Dictionaries och mängder i Python
- Comprehensions och inbyggda funktioner
- Funktioner, closures och lambda