API des chaînes Python pour les entretiens
Étudiez split, join, replace, find, ord/chr et les schémas de formatage des chaînes qui apparaissent dans les problèmes d’entretien portant sur l’analyse et la transformation.
API des chaînes Python pour les entretiens est une leçon Coding Interview Prep gratuite sur CoddyKit. Ceci est la leçon 1 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Coding Interview Prep, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Coding Interview Prep comprend 4 leçons au total.
Les chaînes sont immuables en Python
Les chaînes Python sont immutables : vous ne pouvez pas modifier un caractère en place. Toute opération sur une chaîne qui semble la modifier en crée en réalité une nouvelle. Ainsi, s[0] = 'X' déclenche une TypeError. Lorsque vous avez besoin d’une manipulation en place, convertissez d’abord la chaîne en liste de caractères, effectuez vos opérations, puis utilisez ''.join(chars) pour la reconstruire. C’est le modèle standard des problèmes d’entretien portant sur la modification des chaînes.
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() et join() : analyser et construire
s.split(sep) découpe une chaîne selon un séparateur et renvoie une liste de sous-chaînes. sep=None, la valeur par défaut, découpe selon tout espace blanc et supprime les chaînes vides : c’est idéal pour analyser une entrée séparée par des espaces. 'sep'.join(iterable) concatène les chaînes en plaçant un séparateur entre elles. L’expression ' '.join(words) est la manière efficace de construire une chaîne séparée par des espaces à partir d’une liste : n’utilisez jamais + dans une boucle.
# 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() et in
s.find(sub) renvoie l’indice de la première occurrence de sub, ou -1 si elle est introuvable. s.index(sub) fait de même, mais déclenche une ValueError si la sous-chaîne est absente. Dans le code d’entretien, préférez find afin d’éviter les exceptions non gérées. L’opérateur in appliqué aux chaînes effectue une recherche de sous-chaîne en O(n×m), comme find. Utilisez les paramètres facultatifs start et end pour effectuer la recherche dans une tranche sans la copier.
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) # 3replace(), strip() et méthodes de casse
s.replace(old, new, count=-1) renvoie une nouvelle chaîne dans laquelle toutes les occurrences, ou les count premières, ont été remplacées. s.strip() supprime les espaces blancs au début et à la fin, ou les caractères indiqués. Les méthodes de casse lower(), upper(), capitalize() et swapcase() créent de nouvelles chaînes : retenez leurs valeurs de retour, car elles ne modifient pas la chaîne. Normaliser la casse avant une comparaison est essentiel dans les problèmes insensibles à la casse.
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')) # Truestartswith(), endswith() et isalnum()
Les méthodes de chaîne qui servent de prédicats renvoient une valeur booléenne et s’exécutent en O(k), où k est la longueur du motif. s.startswith(prefix) et s.endswith(suffix) acceptent des tuples pour gérer plusieurs possibilités. s.isalpha(), s.isdigit(), s.isalnum() et s.isspace() testent des catégories de caractères. Elles sont utilisées dans les problèmes d’entretien portant sur les palindromes valides, les nombres valides et l’analyse d’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() et arithmétique ASCII
ord(c) renvoie le point de code Unicode du caractère c. chr(n) reconvertit un entier en caractère. Pour les lettres minuscules, ord(c) - ord('a') donne une valeur de 0 à 25 : c’est une manière simple de construire des tableaux de fréquences de taille fixe 26 sans table de hachage, généralement plus rapide pour l’alphabet anglais. Cette technique apparaît dans les problèmes d’anagrammes et de palindromes.
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)Formatage des chaînes pour la sortie
Lors des entretiens de programmation, une sortie bien présentée peut parfois être importante. Python propose trois styles de formatage : le formatage avec % (ancien), .format() (classique) et les chaînes f (moderne et recommandé). Les chaînes f sont les plus lisibles et prennent directement en charge les expressions : f'{value:.2f}' formate un nombre flottant avec 2 décimales. Savoir formater rapidement les nombres, compléter les chaînes et afficher des tableaux réduit le temps consacré au débogage sous pression.
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'Construire efficacement des chaînes avec join()
La concaténation de chaînes avec + dans une boucle crée une nouvelle chaîne à chaque itération, ce qui coûte au total O(n²) pour n caractères. Le modèle correct consiste à ajouter les parties à une liste, puis à appeler ''.join(parts) à la fin, en O(n). C’est l’un des anti-modèles de performance les plus courants en Python. En entretien, mentionner ce compromis montre que vous comprenez le modèle mémoire de 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'Analyser des entiers et des nombres flottants depuis des chaînes
La conversion entre chaînes et nombres est fondamentale dans les problèmes d’analyse. int(s) et float(s) analysent les chaînes numériques ; elles déclenchent une ValueError lorsque l’entrée est invalide. Pour une analyse plus sûre, utilisez un bloc try-except. Les méthodes de chaîne isdigit() et isnumeric() permettent de valider l’entrée avant la conversion. Les problèmes de type « atoi », c’est-à-dire de conversion d’une chaîne en entier, nécessitent de gérer les espaces initiaux, les signes et les dépassements de capacité.
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')) # 4193Découpage des chaînes dans les problèmes d’algorithmique
Le découpage des chaînes est utilisé constamment, mais il entraîne des coûts cachés : s[i:j] crée une nouvelle chaîne de longueur j-i en O(j-i). Lorsque vous devez transmettre des sous-chaînes à des fonctions récursives, envisagez de transmettre des indices, (start, end), plutôt que la sous-chaîne elle-même afin d’éviter un coût d’allocation total en O(n²). Cette optimisation est importante dans les problèmes de sous-chaîne palindromique la plus longue, où de nombreuses sous-chaînes sont testées.
# 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)) # FalseRéférence rapide sur les chaînes
Gardez mentalement ces méthodes sur les chaînes pour les entretiens :
split / join— analyser et construirestrip / lstrip / rstrip— supprimer les espaces superfluslower / upper— uniformiser la cassefind / index— localiser des sous-chaînesreplace— effectuer des substitutionsisalnum / isalpha / isdigit— vérifier la catégorie des caractèresord / chr— effectuer des calculs ASCII pour les problèmes à alphabet fixestartswith / endswith— vérifier les préfixes et les suffixes
# 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')) # FalseVérification rapide
Vérifiez votre compréhension des concepts de Structures de données et algorithmes — préparation aux entretiens de programmation présentés dans cette leçon.
Récapitulatif de la leçon
Dans cette leçon, vous avez appris que : les chaînes Python sont immuables — pour les modifier, il faut les convertir en liste, effectuer la modification, puis les recombiner, ord/chr permettent d'utiliser des tableaux de fréquences de taille fixe égale à 26 pour les problèmes portant sur des lettres minuscules, plus rapides que les tables de hachage pour les alphabets bornés, et construire des chaînes avec + dans une boucle coûte O(n²) — accumulez toujours les éléments dans une liste et utilisez ''.join() à la fin pour obtenir O(n). Nous allons maintenant étudier la technique de la fenêtre glissante pour les problèmes portant sur les sous-chaînes.
Questions Fréquemment Posées
La leçon « API des chaînes Python pour les entretiens » est-elle gratuite ?
Oui — le texte complet de « API des chaînes Python pour les entretiens » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Coding Interview Prep, passe à CoddyKit PRO. Le cours Coding Interview Prep comprend 4 leçons au total.
Qu'est-ce que j'apprendrai dans « API des chaînes Python pour les entretiens » ?
Étudiez split, join, replace, find, ord/chr et les schémas de formatage des chaînes qui apparaissent dans les problèmes d’entretien portant sur l’analyse et la transformation. Tu pratiques Coding Interview Prep avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.
Dois-je avoir de l'expérience pour commencer Coding Interview Prep ?
Aucune expérience préalable n'est requise. Coding Interview Prep sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 1 sur 4.
Combien de temps prend la leçon « API des chaînes Python pour les entretiens » ?
La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.
Peux-tu écrire et exécuter du code dans cette leçon Coding Interview Prep ?
Oui. Chaque leçon Coding Interview Prep inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.
Toutes les leçons de ce cours
- API des chaînes Python pour les entretiens
- Fenêtre glissante pour les sous-chaînes
- Anagrammes et tables de fréquences de caractères
- Codage, inversion et palindromes de chaînes