Coding Interview Prep · Lezione

API delle stringhe Python per i colloqui

Eserciti split, join, replace, find, ord/chr e gli schemi di formattazione delle stringhe presenti nei problemi di colloquio su parsing e trasformazione

API delle stringhe Python per i colloqui è 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.

Le stringhe sono immutabili in Python

Le stringhe Python sono immutabili: non è possibile modificare un carattere in-place. Ogni operazione su una stringa che sembra modificarla crea in realtà una nuova stringa. Ciò significa che s[0] = 'X' genera un TypeError. Quando serve una manipolazione in-place, converta prima la stringa in una lista di caratteri, esegua le operazioni necessarie e poi ricostruisca la stringa con ''.join(chars). Questo è il modello standard nei colloqui tecnici per i problemi che richiedono di modificare stringhe.

s = 'hello'
# s[0] = 'H'  # TypeError!

# In-place mutation pattern:
chars = list(s)
chars[0] = 'H'
result = ''.join(chars)
print(result)  # 'Hello'

# Reversing a string
print(s[::-1])           # 'olleh'
print(''.join(reversed(s)))  # 'olleh'

split() e join(): analisi e costruzione

s.split(sep) divide una stringa in corrispondenza di un delimitatore e restituisce una lista di sottostringhe. sep=None (impostazione predefinita) divide in corrispondenza di qualsiasi spazio bianco e scarta le stringhe vuote: è ideale per analizzare input separati da spazi. 'sep'.join(iterable) concatena le stringhe inserendo un separatore tra loro. L'espressione idiomatica ' '.join(words) è il modo efficiente per costruire una stringa separata da spazi a partire da una lista: non usi mai + in un ciclo.

# split
sentence = '  hello   world  '
words = sentence.split()    # ['hello', 'world']
print(words)

csv = 'a,b,c,d'
parts = csv.split(',')      # ['a', 'b', 'c', 'd']
print(parts)

# join
print(' '.join(words))      # 'hello world'
print(','.join(['x','y','z']))  # 'x,y,z'

# Reverse words in a sentence
print(' '.join(sentence.split()[::-1]))  # 'world hello'

find(), index() e in

s.find(sub) restituisce l'indice della prima occorrenza di sub oppure -1 se non viene trovata. s.index(sub) fa la stessa cosa, ma genera ValueError se la sottostringa è assente: nel codice dei colloqui tecnici è preferibile usare find per evitare eccezioni non gestite. L'operatore in per le stringhe esegue una ricerca di sottostringhe O(n×m), come find. Usi i parametri opzionali start e end per cercare all'interno di una porzione senza crearne una copia.

s = 'abcabcabc'
print(s.find('bc'))          # 1  (first occurrence)
print(s.find('bc', 2))       # 4  (search from index 2)
print(s.find('xyz'))         # -1 (not found)
print('abc' in s)            # True

# Count occurrences manually
count = 0
start = 0
while True:
    idx = s.find('bc', start)
    if idx == -1: break
    count += 1
    start = idx + 1
print(count)  # 3

replace(), strip() e metodi per le maiuscole e minuscole

s.replace(old, new, count=-1) restituisce una nuova stringa in cui sono state sostituite tutte le occorrenze (oppure le prime count). s.strip() rimuove gli spazi bianchi iniziali e finali (o i caratteri specificati). I metodi per le maiuscole e minuscole lower(), upper(), capitalize() e swapcase() creano nuove stringhe: ricordi che restituiscono dei valori, non modificano la stringa. Normalizzare le maiuscole e minuscole prima del confronto è essenziale nei problemi senza distinzione tra maiuscole e minuscole.

s = '  Hello, World!  '
print(s.strip())          # 'Hello, World!'
print(s.strip().lower())  # 'hello, world!'

print('banana'.replace('a', 'o'))   # 'bonono'
print('banana'.replace('a', 'o', 2)) # 'bonona'

# Normalise for comparison
def same_ignoring_case(a, b):
    return a.lower() == b.lower()

print(same_ignoring_case('Racecar', 'racecar'))  # True

startswith(), endswith() e isalnum()

I metodi predicati delle stringhe restituiscono valori booleani e hanno complessità O(k), dove k è la lunghezza del modello. s.startswith(prefix) e s.endswith(suffix) accettano tuple per gestire più alternative. s.isalpha(), s.isdigit(), s.isalnum() e s.isspace() verificano le classi di caratteri. Vengono usati nei problemi dei colloqui tecnici sulla validità dei palindromi, sui numeri validi e sull'analisi degli URL.

print('hello'.startswith('hel'))   # True
print('hello'.endswith(('lo', 'la')))  # True

# isalnum for palindrome filtering
def clean(s):
    return ''.join(c.lower() for c in s if c.isalnum())

print(clean('A man, a plan, a canal: Panama'))
# 'amanaplanacanalpanama'
print(clean('123abc!@#'))
# '123abc'

ord(), chr() e aritmetica ASCII

ord(c) restituisce il punto di codice Unicode del carattere c. chr(n) riconverte un intero in un carattere. Per le lettere minuscole, ord(c) - ord('a') restituisce un valore da 0 a 25: è un modo semplice per costruire array di frequenze di dimensione fissa 26 senza una mappa hash, più veloce in pratica per l'alfabeto inglese. Questa tecnica compare nei problemi sugli anagrammi e sui palindromi.

print(ord('a'))   # 97
print(ord('z'))   # 122
print(chr(65))    # 'A'

# Frequency array for lowercase letters
def char_freq(s):
    freq = [0] * 26
    for c in s:
        freq[ord(c) - ord('a')] += 1
    return freq

print(char_freq('anagram'))  # [3,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,1,0,0,0,0,0,0,0,0]
# index 0='a'(3), 6='g'(1), 12='m'(1), 17='r'(1)

Formattazione delle stringhe per l'output

Nei colloqui di programmazione, a volte è importante produrre un output ordinato. Python offre tre stili di formattazione: la formattazione con % (obsoleta), .format() (classica) e le f-string (moderne e preferibili). Le f-string sono le più leggibili e supportano direttamente le espressioni: f'{value:.2f}' formatta un numero a virgola mobile con 2 cifre decimali. Sapere rapidamente come formattare i numeri, allineare le stringhe e stampare tabelle riduce il tempo dedicato al debug sotto pressione.

name = 'Alice'
score = 95.678

# f-string (preferred in interviews)
print(f'{name}: {score:.1f}')      # Alice: 95.7
print(f'{name:>10}: {score:05.1f}') # right-align

# Zero-pad an integer
print(f'{42:04d}')   # 0042

# Join and format a list
nums = [1, 2, 3, 4]
print(', '.join(str(n) for n in nums))  # '1, 2, 3, 4'

Costruzione efficiente di stringhe con join()

La concatenazione di stringhe con + in un ciclo crea una nuova stringa a ogni iterazione, con un costo totale O(n²) per n caratteri. Il modello corretto consiste nell'aggiungere le parti a una lista e chiamare ''.join(parts) alla fine, con costo O(n). Questo è uno degli anti-pattern più comuni nelle prestazioni del codice Python. In un colloquio tecnico, menzionare questo compromesso dimostra che comprende il modello di memoria di Python.

# SLOW: O(n^2) due to repeated string allocation
def build_bad(chars):
    s = ''
    for c in chars:
        s += c  # creates a new string each time!
    return s

# FAST: O(n)
def build_good(chars):
    parts = []
    for c in chars:
        parts.append(c)
    return ''.join(parts)  # single allocation

# Or even more concise:
def build_best(chars):
    return ''.join(chars)

print(build_best(['h','e','l','l','o']))  # 'hello'

Analisi di interi e numeri a virgola mobile dalle stringhe

La conversione tra stringhe e numeri è fondamentale nei problemi di analisi. int(s) e float(s) analizzano le stringhe numeriche e generano ValueError in caso di input non valido. Per un'analisi più sicura, usi un blocco try-except. I metodi delle stringhe isdigit() e isnumeric() consentono di verificare preventivamente i dati prima della conversione. Problemi come «atoi» (da stringa a intero) richiedono di gestire spazi iniziali, segni e overflow.

def my_atoi(s):
    s = s.lstrip()  # remove leading spaces
    if not s: return 0
    sign = 1
    idx = 0
    if s[0] in '-+':
        sign = -1 if s[0] == '-' else 1
        idx = 1
    num = 0
    while idx < len(s) and s[idx].isdigit():
        num = num * 10 + int(s[idx])
        idx += 1
    result = sign * num
    INT_MAX, INT_MIN = 2**31 - 1, -(2**31)
    return max(INT_MIN, min(INT_MAX, result))

print(my_atoi('   -42'))          # -42
print(my_atoi('4193 with words'))  # 4193

Slicing delle stringhe nei problemi di algoritmi

Lo slicing delle stringhe viene usato continuamente, ma comporta costi nascosti: s[i:j] crea una nuova stringa di lunghezza j-i in tempo O(j-i). Quando deve passare sottostringhe a funzioni ricorsive, valuti la possibilità di passare gli indici (start, end) anziché la sottostringa effettiva, per evitare il costo di allocazione O(n²). Questa ottimizzazione è importante in problemi come la sottostringa palindromica più lunga, in cui vengono testate molte sottostringhe.

# Naive: O(n^3) because slicing inside nested loops
def is_palindrome_naive(s):
    return s == s[::-1]  # O(n) slice + O(n) compare

# Pass indices to avoid allocating substrings
def is_palindrome_range(s, left, right):
    while left < right:
        if s[left] != s[right]:
            return False
        left += 1; right -= 1
    return True  # O(right-left) time, O(1) space

print(is_palindrome_range('racecar', 0, 6))  # True
print(is_palindrome_range('hello',   0, 4))  # False

Riferimento rapido alle stringhe per i colloqui tecnici

Tenga a mente questi metodi per le stringhe in vista dei colloqui tecnici:

split / join — analisi e costruzione
strip / lstrip / rstrip — rimozione degli spazi bianchi
lower / upper — normalizzazione delle maiuscole e minuscole
find / index — ricerca di sottostringhe
replace — sostituzioni
isalnum / isalpha / isdigit — verifiche della classe dei caratteri
ord / chr — aritmetica ASCII per problemi con alfabeti fissi
startswith / endswith — verifiche di prefissi e suffissi

# Combining methods: reverse words, preserve spaces
def reverse_words(s):
    return ' '.join(reversed(s.split()))

print(reverse_words('  hello   world  '))
# 'world hello'

# Check anagram using sorted strings
def is_anagram(s, t):
    return sorted(s) == sorted(t)

print(is_anagram('anagram', 'nagaram'))  # True
print(is_anagram('rat', 'car'))          # False

Verifica rapida

Verifichi la Sua comprensione dei concetti di Data Structures & Algorithms — Coding Interview Prep presentati in questa lezione.

Riepilogo della lezione

In questa lezione ha imparato che: le stringhe Python sono immutabili: per modificarle è necessario convertirle in una lista, apportare le modifiche e poi ricomporle con join, ord/chr consentono di usare array di frequenze di dimensione fissa pari a 26 per i problemi con lettere minuscole, più veloci delle hash map per gli alfabeti limitati e costruire stringhe con + all'interno di un ciclo ha un costo O(n²): accumuli sempre i valori in una lista e utilizzi ''.join() alla fine per ottenere O(n). Prossimamente esploreremo la tecnica della finestra scorrevole per i problemi sulle sottostringhe.

Domande Frequenti

La lezione «API delle stringhe Python per i colloqui» è gratuita?

Sì — il testo completo di «API delle stringhe Python per i colloqui» è 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 «API delle stringhe Python per i colloqui»?

Eserciti split, join, replace, find, ord/chr e gli schemi di formattazione delle stringhe presenti nei problemi di colloquio su parsing e trasformazione 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 «API delle stringhe Python per i colloqui»?

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

API delle stringhe Python per i colloqui
Sliding window per le sottostringhe
Anagrammi e mappe delle frequenze dei caratteri
Codifica, inversione e palindromi delle stringhe

← Torna a Coding Interview Prep