Learn PythonStrings
El texto aparece en casi todos los programas que escribes. Nombres, mensajes, puntajes, etiquetas. En Python, a cualquier fragmento de texto se le llama string: cualquier valor que envuelvas entre comillas. Simples o dobles, ambas funcionan igual.
greeting = "Hello, world"
username = 'alice'El único momento en que la elección de comillas importa es cuando tu texto contiene comillas. Usa el estilo opuesto para no tener que escaparlas:
note = "It's a great day" # apóstrofe adentro, usa comillas dobles
message = 'She said "hello"' # comillas dobles adentro, usa comillas simples
escaped = "She said \"hello\"" # o escápalas con una barra invertidaInmutabilidad
Los strings son inmutables: una vez que creas uno, no puedes cambiarlo. Piensa en un string como algo fijo desde el momento en que se crea. Cualquier operación que parezca modificar un string en realidad está produciendo uno completamente nuevo. El original queda exactamente igual que antes.
name = "alice"
name = name.upper() # "ALICE" es un string nuevo; "alice" no cambiaLa consecuencia directa: no puedes cambiar un carácter en una posición específica. Python lanzará un error si lo intentas.
name = "alice"
name[0] = "A" # TypeError: 'str' object does not support item assignmentPara obtener un string modificado, construye uno nuevo usando slicing o un método. Ambos se explican más abajo.
name[0] = "A" no funciona, lanza un TypeError. Indexación y slicing
Cada carácter de un string tiene una posición numerada, empezando desde cero. Puedes leer caracteres individuales poniendo ese número de posición entre corchetes. Los números negativos cuentan hacia atrás desde el final.
word = "Python"
# 012345
print(word[0]) # "P"
print(word[2]) # "t"
print(word[5]) # "n"
print(word[-1]) # "n" (último carácter)
print(word[-2]) # "o" (penúltimo carácter)-1 siempre es el último carácter, -2 el penúltimo, y así sucesivamente. Son útiles cuando quieres el final de un string sin saber su longitud exacta.
El slicing extrae un fragmento. [start:stop] incluye start y excluye stop:
word = "Python"
print(word[0:2]) # "Py" (posiciones 0 y 1)
print(word[2:]) # "thon" (posición 2 hasta el final)
print(word[:3]) # "Pyt" (desde el inicio hasta la posición 2)
print(word[:]) # "Python" (una copia de todo el string)
print(word[::2]) # "Pto" (cada segundo carácter)
print(word[::-1]) # "nohtyP" (invertido)Tres patrones son los que más vas a usar: word[:n] para los primeros n caracteres, word[n:] para todo desde la posición n en adelante, word[-n:] para los últimos n caracteres. word[::-1] invierte un string. Se ve raro la primera vez, pero es idiomático en Python y lo verás seguido.
word[0] es el primer carácter y word[-1] es el último. Un slice toma un rango: word[start:stop] conserva start y se detiene justo antes de stop. word[::-1] invierte el string, lo cual se ve raro la primera vez y después lo usas para siempre. Métodos esenciales de strings
Los strings vienen con un conjunto de métodos incorporados: operaciones que llamas directamente sobre cualquier valor de tipo string. Escribes el string (o la variable que lo contiene), luego un punto, y luego el nombre del método. Cada método devuelve un string nuevo. El original nunca cambia.
Mayúsculas y minúsculas
text = "Hello, World"
text.lower() # "hello, world"
text.upper() # "HELLO, WORLD"
text.title() # "Hello, World" (cada palabra capitalizada)
text.capitalize() # "Hello, world" (solo la primera palabra)lower() y upper() son los dos que más vas a usar. lower() es particularmente útil al comparar texto: "Alice" y "alice" se vuelven lo mismo una vez que llamas .lower() en ambos lados.
Espacios en blanco
text = " hello "
text.strip() # "hello" (ambos lados)
text.lstrip() # "hello " (solo a la izquierda)
text.rstrip() # " hello" (solo a la derecha)strip() elimina los espacios de ambos extremos de un string. Lo vas a usar casi siempre que manejes entradas del usuario o texto de un archivo, porque los espacios sueltos causan fallas silenciosas: "alice" != "alice ".
Búsqueda
text = "Hello, world"
text.find("world") # 7
text.find("Python") # -1 (no encontrado)
text.count("l") # 3
text.startswith("Hello") # True
text.endswith("world") # Truefind() devuelve la posición donde empieza un fragmento de texto dentro de tu string. Si no está ahí, devuelve -1. Usa startswith() y endswith() cuando solo te importa si el string empieza o termina con algo específico.
Reemplazo
text = "Hello, world"
text.replace("world", "Python") # "Hello, Python"
text.replace("l", "L") # "HeLLo, worLd" (todas las ocurrencias)
text.replace("l", "L", 1) # "HeLlo, world" (solo la primera)replace() intercambia cada ocurrencia de un fragmento de texto por otro y te devuelve un string nuevo. El original no cambia. Pasa un tercer argumento si solo quieres reemplazar la primera ocurrencia.
División y unión
split() corta un string en pedazos según un separador y te los devuelve como una lista. Tú le dices en qué cortar:
csv_row = "Ana,28,Ciudad de México"
parts = csv_row.split(",") # ["Ana", "28", "Ciudad de México"]
" hello world ".split() # ["hello", "world"]split() devuelve una lista, una secuencia ordenada de valores. Tienen su propio capítulo, Lists; por ahora, trátalas como la secuencia de partes que split() produce y join() consume.
join() hace lo contrario: combina una lista de strings en uno solo. El string antes de .join() se coloca entre cada elemento:
words = ["Hello", "world"]
" ".join(words) # "Hello world"
", ".join(words) # "Hello, world"
"".join(words) # "Helloworld"El patrón para recordar: separador.join(lista_de_strings). El separador va a la izquierda, la lista a la derecha. " ".join(words) pone un espacio entre cada palabra. "".join(words) las pega sin nada en medio.
.lower() y .upper() para cambiar mayúsculas y minúsculas, .strip() para quitar espacios sueltos, .find() para ubicar texto (devuelve -1 cuando no está), .replace() para intercambiar texto, y .split() junto con sep.join() para separar un string y volver a armarlo. f-strings
Los f-strings incrustan valores directamente dentro del texto. Pon f antes de la comilla de apertura, y luego envuelve cualquier variable o expresión en llaves. Python lo completa cuando el código se ejecuta. También puedes agregar dos puntos después del valor para controlar cómo se muestra.
name = "Ana"
score = 94.5
print(f"Hello, {name}!") # "Hello, Ana!"
print(f"Score: {score:.1f}%") # "Score: 94.5%"
print(f"2 + 2 = {2 + 2}") # "2 + 2 = 4"
print(f"Name: {name.upper()}") # "Name: ANA"El format spec después de : controla cómo se muestra el valor:
| Spec | Significado | Ejemplo |
|---|---|---|
.2f | 2 decimales | f"{3.14159:.2f}" → "3.14" |
.0% | porcentaje, sin decimales | f"{0.94:.0%}" → "94%" |
, | separador de miles | f"{1000000:,}" → "1,000,000" |
>10 | alinea a la derecha en 10 caracteres | f"{'hi':>10}" → " hi" |
.2f es el que más vas a usar: cada vez que muestres un decimal y quieras un número prolijo en vez de una fila larga de dígitos. Todo lo demás en la tabla está ahí para cuando lo necesites. Puedes poner cualquier variable, operación aritmética o llamada a un método dentro de las {}.
f antes de la comilla de apertura, envuelve cualquier variable, suma o llamada a un método en {}, y Python coloca el resultado ahí cuando la línea se ejecuta. Los dos puntos dentro de las llaves controlan el aspecto: :.2f para dos decimales es el que más vas a usar. Mucho más prolijo que pegar texto con +. Strings de varias líneas
Para escribir un string que abarque más de una línea, usa comillas triples: tres " al inicio y tres al final. Python conserva todos los saltos de línea y espacios exactamente como los escribiste.
message = """
Estimada Ana,
Gracias por tu pedido.
Saludos,
El Equipo
"""Secuencias de escape
Algunos caracteres son difíciles de escribir directamente dentro de un string. Python usa secuencias de escape: una barra invertida seguida de una letra que representa algo. Las dos que vas a usar constantemente son \n para un salto de línea y \t para una tabulación.
| Secuencia | Carácter |
|---|---|
\n | Salto de línea |
\t | Tabulación |
\\ | Barra invertida literal |
\" | Comilla doble |
\' | Comilla simple |
print("Line one\nLine two") # dos líneas de salida
print("Name:\tAna") # Name: Ana
path = r"C:\Users\Ana\Documents" # string crudo, sin procesamiento de escapes\n inicia una línea nueva, \t inserta una tabulación, \\ es una barra invertida real. Esas dos, \n y \t, son las que realmente vas a escribir. Pon una r antes de la comilla y las barras invertidas vuelven a ser simples, útil para rutas de Windows. Verificar el contenido de un string
Python tiene métodos que responden preguntas de sí/no sobre lo que contiene un string. Devuelven True o False. El más útil al principio: isdigit() te permite verificar si un string son todos números antes de convertirlo, así evitas que se caiga con una entrada inesperada.
"42".isdigit() # True
"hello".isalpha() # True
"hello42".isalnum() # True
" ".isspace() # True
"Hello".islower() # False
"HELLO".isupper() # Trueis* responden preguntas de sí o no y devuelven True solo cuando cada carácter cumple. El que vas a usar primero: llama a isdigit() antes de int() para asegurarte de que el texto realmente sea un número, así una entrada rara no te hace fallar. En la práctica
Elimina espacios, normaliza mayúsculas y minúsculas, y luego extrae lo que necesitas. Esta secuencia maneja casi cualquier texto proporcionado por el usuario:
raw_input = " [email protected] "
email = raw_input.strip().lower() # "[email protected]"
at_pos = email.find("@")
username = email[:at_pos]
domain = email[at_pos + 1:]
print(f"User: {username}") # "ana"
print(f"Domain: {domain}") # "ejemplo.com"Referencia de métodos
| Método | Qué hace |
|---|---|
.lower() / .upper() | Convierte a minúsculas / mayúsculas |
.title() / .capitalize() | Capitaliza cada palabra / solo la primera |
.strip() / .lstrip() / .rstrip() | Elimina espacios en blanco alrededor |
.find(sub) | Índice de la primera coincidencia, o -1 |
.count(sub) | Cuántas veces aparece sub |
.startswith(s) / .endswith(s) | Verificación de prefijo / sufijo |
.replace(old, new) | Reemplaza ocurrencias |
.split(sep) | Divide en una lista |
sep.join(iterable) | Une elementos en un string |
.isdigit() / .isalpha() / .isalnum() | Verificaciones de tipo de carácter |