Liste, tuple e slicing
Padroneggi le operazioni sulle liste Python, la sintassi dello slicing e l'immutabilità delle tuple con esempi pratici tratti dalle classiche sfide di programmazione
Liste, tuple e slicing è una lezione Coding Interview Prep gratuita su CoddyKit. Questa è la lezione 1 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Coding Interview Prep, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Coding Interview Prep include 4 lezioni in totale.
List Python: array dinamici
Una list di Python è un array dinamico che può contenere qualsiasi elemento e cresce automaticamente. È ordinata, modificabile e consente un accesso immediato O(1) tramite indice. Il codice mostra le nozioni di base.
nums = [3, 1, 4, 1, 5]
print(nums[0]) # 3
print(nums[-1]) # 5 (last element)
nums.append(9)
print(len(nums)) # 6Operazioni comuni sulle list
Le memorizzi bene: append e pop alla fine sono O(1), mentre insert all'inizio è O(n). Eviti remove nei cicli stretti: ogni volta esegue una nuova scansione.
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]La sintassi dello slicing
Lo slicing si legge come lst[start:stop:step] e si arresta subito prima di stop. Il trucco classico: uno step di -1 inverte una list senza modificarla. Il codice illustra ogni forma.
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] reversedLo slicing crea copie superficiali
Un dettaglio utile da ricordare: lo slicing crea sempre una nuova list, quindi modificare lo slice non modifica l'originale. Tuttavia, la copia è superficiale: le list annidate al suo interno continuano a essere condivise. Faccia attenzione.
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!Tuple: sequenze immutabili
Una tuple usa le parentesi tonde e non può essere modificata una volta creata. Poiché è hashable, può essere usata come chiave di un dict o come elemento di un set: è perfetta per le coppie (row, col) nei problemi su griglia.
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 7Quando usare tuple o list
Scelga una tuple quando i dati non devono cambiare e una list quando devono poter cambiare. Le tuple usano anche un po' meno memoria, un vantaggio che si somma nei grandi heap di 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 5Errori off-by-one nello slicing
Gli errori off-by-one sono la trappola principale nei problemi sugli array. Ricordi che lst[i:j] restituisce esattamente j-i elementi. Per dividere a metà, la parte sinistra è lst[:mid] e quella destra è 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)Indici negativi nei colloqui tecnici
Python supporta gli indici negativi: lst[-1] è l'ultimo elemento, mentre lst[-2] è quello precedente. Preferisca lst[-1] a lst[len(lst)-1]: gli intervistatori notano la versione più pulita.
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]Ordinamento e confronto delle list
L'ordinamento di Python usa Timsort (O(n log n), stabile). lst.sort() modifica la list in-place; sorted(lst) ne restituisce una nuova. Usi l'opzione key per definire un ordinamento personalizzato. Veda il codice.
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]Modificare le list durante l'iterazione
Una trappola classica: non aggiunga né rimuova mai elementi mentre scorre una list: salterebbe elementi o provocherebbe un errore. Costruisca invece una nuova list con una 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]Tuple unpacking nei cicli
Il tuple unpacking mantiene puliti i cicli: enumerate fornisce (index, value) e zip percorre insieme due list. La sintassi *rest raccoglie la coda in una variabile separata. Veda il codice.
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]Verifica rapida
Verifica rapida: mostri quanto ha appreso su list, tuple e slicing di Python. Ce la può fare. 💪
Riepilogo della lezione
Riepilogo: le list sono array dinamici con append O(1), lo slicing restituisce sempre una nuova copia e le tuple sono immutabili e hashable. Prossimo argomento: dict e set.
Domande Frequenti
La lezione «Liste, tuple e slicing» è gratuita?
Sì — il testo completo di «Liste, tuple e slicing» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Coding Interview Prep, passa a CoddyKit PRO. Il corso Coding Interview Prep include 4 lezioni in totale.
Cosa imparerò in «Liste, tuple e slicing»?
Padroneggi le operazioni sulle liste Python, la sintassi dello slicing e l'immutabilità delle tuple con esempi pratici tratti dalle classiche sfide di programmazione Eserciti Coding Interview Prep con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.
Ho bisogno di esperienza per iniziare Coding Interview Prep?
Non è richiesta alcuna esperienza precedente. Coding Interview Prep su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 1 di 4.
Quanto tempo richiede la lezione «Liste, tuple e slicing»?
La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.
Posso scrivere ed eseguire codice in questa lezione Coding Interview Prep?
Sì. Ogni lezione Coding Interview Prep include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.
Tutte le lezioni di questo corso
- Liste, tuple e slicing
- Dizionari e set in Python
- Comprehension e funzioni built-in
- Funzioni, closure e lambda