API de strings de Python para entrevistas
Practique los patrones de split, join, replace, find, ord/chr y formato de strings que aparecen en problemas de entrevistas sobre análisis y transformación.
API de strings de Python para entrevistas es una lección gratuita de Coding Interview Prep en CoddyKit. Esta es la lección 1 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Coding Interview Prep, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Coding Interview Prep incluye 4 lecciones en total.
Las cadenas son inmutables en Python
Las cadenas de Python son inmutables: no puede cambiar un carácter directamente. Toda operación de cadenas que parece modificar una cadena en realidad crea una nueva. Esto significa que s[0] = 'X' genera un TypeError. Cuando necesite manipular una cadena directamente, conviértala primero en una lista de caracteres, realice el trabajo y después reconstruya la cadena con ''.join(chars). Este es el patrón estándar en entrevistas para problemas de modificación de cadenas.
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() y join(): analizar y construir
s.split(sep) divide una cadena usando un delimitador y devuelve una lista de subcadenas. sep=None (valor predeterminado) divide por cualquier espacio en blanco y descarta las cadenas vacías; es ideal para analizar entradas separadas por espacios. 'sep'.join(iterable) concatena cadenas colocando un separador entre ellas. La expresión ' '.join(words) es la forma eficiente de construir una cadena separada por espacios a partir de una lista; no utilice nunca + dentro de un bucle.
# 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) devuelve el índice de la primera aparición de sub, o -1 si no se encuentra. s.index(sub) hace lo mismo, pero genera ValueError si no está presente; en código de entrevistas, prefiera find para evitar excepciones no gestionadas. El operador in para cadenas realiza una búsqueda de subcadenas O(n×m), igual que find. Utilice los parámetros opcionales start y end para buscar dentro de un segmento sin copiarlo.
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() y métodos de mayúsculas y minúsculas
s.replace(old, new, count=-1) devuelve una nueva cadena en la que se reemplazan todas las apariciones, o las primeras count, de un texto. s.strip() elimina los espacios en blanco iniciales y finales, o los caracteres especificados. Los métodos de mayúsculas y minúsculas lower(), upper(), capitalize() y swapcase() crean nuevas cadenas; recuerde utilizar sus valores devueltos, ya que no modifican la cadena. Normalizar las mayúsculas y minúsculas antes de comparar es fundamental en problemas que no distinguen entre ellas.
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() e isalnum()
Los métodos de cadenas que funcionan como predicados devuelven valores booleanos y son O(k), donde k es la longitud del patrón. s.startswith(prefix) y s.endswith(suffix) aceptan tuplas para varias alternativas. s.isalpha(), s.isdigit(), s.isalnum() y s.isspace() comprueban clases de caracteres. Se utilizan en problemas de entrevistas sobre palíndromos válidos, números válidos y análisis de 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() y aritmética ASCII
ord(c) devuelve el punto de código Unicode del carácter c. chr(n) convierte un entero de nuevo en un carácter. Para las letras minúsculas, ord(c) - ord('a') produce un valor de 0 a 25; es una forma clara de construir arreglos de frecuencias de tamaño fijo 26 sin un mapa hash, lo que en la práctica es más rápido para el alfabeto inglés. Esta técnica aparece en problemas de anagramas y palíndromos.
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)Formatear cadenas para la salida
En las entrevistas de programación, a veces es importante generar una salida clara. Python ofrece tres estilos de formato: formato con % (antiguo), .format() (clásico) y f-strings (moderno y preferido). Las f-strings son las más legibles y admiten expresiones directamente: f'{value:.2f}' formatea un número de coma flotante con 2 decimales. Saber formatear números, rellenar cadenas y mostrar tablas rápidamente reduce el tiempo de depuración bajo presión.
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'Construcción eficiente de cadenas con join()
Concatenar cadenas con + dentro de un bucle crea una nueva cadena en cada iteración, con un coste total O(n²) para n caracteres. El patrón correcto es añadir las partes a una lista y llamar a ''.join(parts) al final, lo que tiene un coste O(n). Este es uno de los antipatrones de rendimiento más comunes en Python. En una entrevista, mencionar esta diferencia demuestra que comprende el modelo de memoria 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'Analizar enteros y números de coma flotante desde cadenas
Convertir entre cadenas y números es fundamental en los problemas de análisis. int(s) y float(s) analizan cadenas numéricas; generan ValueError si la entrada no es válida. Para un análisis más seguro, utilice un bloque try-except. Los métodos de cadenas isdigit() e isnumeric() permiten validar previamente la entrada antes de convertirla. Problemas como «atoi» (de cadena a entero) requieren gestionar espacios iniciales, signos y desbordamientos.
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')) # 4193Segmentación de cadenas en problemas de algoritmos
La segmentación de cadenas se utiliza constantemente, pero tiene costes ocultos: s[i:j] crea una nueva cadena de longitud j-i en O(j-i). Cuando necesite pasar subcadenas a funciones recursivas, considere pasar índices (start, end) en lugar de la subcadena real para evitar el coste de asignación O(n²). Esta optimización es importante en problemas como el de la subcadena palindrómica más larga, donde se prueban muchas subcadenas.
# 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)) # FalseReferencia rápida de strings para entrevistas
Memorice estos métodos de strings para las entrevistas:
split / join— analizar y construirstrip / lstrip / rstrip— recortar espacios en blancolower / upper— normalizar mayúsculas y minúsculasfind / index— localizar subcadenasreplace— realizar sustitucionesisalnum / isalpha / isdigit— comprobar clases de caracteresord / chr— realizar operaciones aritméticas ASCII para problemas con alfabetos fijosstartswith / endswith— comprobar prefijos y sufijos
# 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')) # FalseComprobación rápida
Compruebe su comprensión de los conceptos de Data Structures & Algorithms — Coding Interview Prep de esta lección.
Resumen de la lección
En esta lección aprendió: las strings de Python son inmutables: para modificarlas debe convertirlas en una lista, modificarla y volver a unirla, ord/chr permiten usar arrays de frecuencias de tamaño fijo 26 para problemas con letras minúsculas, que son más rápidos que los mapas hash para alfabetos acotados, y construir strings con + dentro de un bucle cuesta O(n²): acumule siempre los elementos en una lista y use ''.join() al final para obtener O(n). A continuación exploraremos la técnica de la ventana deslizante para problemas de subcadenas.
Preguntas frecuentes
¿La lección «API de strings de Python para entrevistas» es gratis?
Sí — el texto completo de «API de strings de Python para entrevistas» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Coding Interview Prep, actualiza a CoddyKit PRO. El curso de Coding Interview Prep incluye 4 lecciones en total.
¿Qué aprenderé en «API de strings de Python para entrevistas»?
Practique los patrones de split, join, replace, find, ord/chr y formato de strings que aparecen en problemas de entrevistas sobre análisis y transformación. Practicas Coding Interview Prep con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Coding Interview Prep?
No se requiere experiencia previa. Coding Interview Prep en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 1 de 4.
¿Cuánto tiempo toma la lección «API de strings de Python para entrevistas»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Coding Interview Prep?
Sí. Cada lección de Coding Interview Prep incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- API de strings de Python para entrevistas
- Ventana deslizante para subcadenas
- Anagramas y mapas de frecuencia de caracteres
- Codificación, inversión y palíndromos de strings