09- 💬 Strings en Python: Manejo y uso básico

Acordeon de los indices

Índice de los temas

• Strings en Python
• Asignación de Cadena en Python
• Cadenas Multilínea en Python
• Cadenas como Matrices en Python
• Bucle a través de una Cadena en Python
• Longitud de una Cadena en Python
• Verificar Subcadena en Python
• Verificación de Ausencia de Subcadena en Python

---

Contenido de los Temas

Strings en Python

🐍 Strings en Python: La Base del Texto

En Python, los **strings** son secuencias inmutables de caracteres que se utilizan para representar texto. 📝 Imagina una fila de letras, números, símbolos o espacios, todos unidos para formar una palabra, una frase o incluso un párrafo entero. Los strings son fundamentales para cualquier programa que necesite interactuar con el usuario, mostrar información o manipular datos textuales. ✨

🛠️ Formas de Crear Strings

Python te ofrece varias maneras de "construir" tus strings, dándote flexibilidad según la situación:

1. Comillas Simples ('...')

Son la forma más básica de crear un string. Útiles para cadenas de texto sencillas que no contienen comillas simples en su interior. 💬

mensaje = 'Hola, ¿cómo estás?'
print(mensaje)
tipo = type(mensaje)
print(f"El tipo de la variable 'mensaje' es: {tipo}") # Output: 

2. Comillas Dobles ("...")

Funcionan de manera idéntica a las comillas simples. La principal ventaja es que puedes incluir comillas simples dentro del string sin necesidad de "escaparlas". 🗣️

cita = "Ella dijo: '¡Qué día tan bonito!'"
print(cita)

3. Triple Comillas ('''...''' o """...""")

Estas son tus aliadas para crear strings que ocupan múltiples líneas. También son convenientes si tu string necesita contener tanto comillas simples como dobles. 📜

poema = '''Las nubes viajan,
llevando en su danza
gotas de esperanza.'''
print(poema)

codigo_html = """

    
Título
    
Un párrafo de texto.

"""
print(codigo_html)

🔗 Operaciones Básicas con Strings

Una vez que tienes tus strings, Python te permite realizar varias operaciones interesantes con ellos:

1. Concatenación (+)

Puedes unir dos o más strings para formar uno nuevo utilizando el operador `+`. ¡Como pegar palabras! 🧩

parte1 = "Hola"
parte2 = ", mundo!"
saludo_completo = parte1 + parte2
print(saludo_completo) # Output: Hola, mundo!

2. Repetición (*)

El operador `*` te permite repetir un string un cierto número de veces. ¡Como multiplicar palabras! ✖️

eco = "¡Boo! " * 3
print(eco) # Output: ¡Boo! ¡Boo! ¡Boo!

3. Acceso por Índice ([])

Como mencionamos antes, puedes acceder a caracteres individuales de un string utilizando su índice. Recuerda que la indexación comienza en 0. 📍

mi_string = "Python"
primer_caracter = mi_string[0] # 'P'
tercer_caracter = mi_string[2] # 't'
ultimo_caracter = mi_string[-1] # 'n' (índice negativo para el último)
print(f"El primer carácter es: {primer_caracter}")
print(f"El tercer carácter es: {tercer_caracter}")
print(f"El último carácter es: {ultimo_caracter}")

4. Slicing ([:])

El "slicing" te permite extraer porciones de un string especificando un rango de índices. ¡Como cortar un trozo de texto! 🔪

mi_string = "Aprendiendo"
subcadena1 = mi_string[0:5]  # Desde el índice 0 hasta el 4 (no incluye el 5) -> "Apren"
subcadena2 = mi_string[7:]   # Desde el índice 7 hasta el final -> "diendo"
subcadena3 = mi_string[:4]   # Desde el inicio hasta el índice 3 -> "Apren"
subcadena4 = mi_string[:]    # Copia completa del string -> "Aprendiendo"
subcadena5 = mi_string[::2]  # Cada dos caracteres -> "Aedo"
print(f"Subcadena 1: {subcadena1}")
print(f"Subcadena 2: {subcadena2}")
print(f"Subcadena 3: {subcadena3}")
print(f"Subcadena 4: {subcadena4}")
print(f"Subcadena 5: {subcadena5}")

🔑 Inmutabilidad de los Strings

Es importante recordar que los strings en Python son **inmutables**. Esto significa que una vez que creas un string, no puedes cambiar sus caracteres directamente. Cualquier operación que parezca modificar un string en realidad crea un string nuevo. 🛡️

mi_string = "Hola"
# mi_string[0] = 'J'  # Esto generaría un error (TypeError: 'str' object does not support item assignment)

nuevo_string = 'J' + mi_string[1:] # Creamos un nuevo string combinando partes
print(nuevo_string) # Output: Jola

¡Y eso es una buena introducción al mundo de los strings en Python! Hemos cubierto cómo crearlos, algunas operaciones básicas y la importante propiedad de su inmutabilidad. ¿Hay algún aspecto de los strings que te gustaría que exploráramos con más detalle o algún ejemplo específico que te gustaría ver?

Asignación de Cadena en Python

🏷️ Asignación de Cadena en Python: Dando Nombre al Texto

La **asignación de cadena** en Python es el proceso de guardar un string (que ya hemos aprendido a crear) dentro de una **variable**. 🏷️ Una variable es como una etiqueta que le pones a un valor para poder referirte a él más tarde en tu código. Al asignar un string a una variable, le das un nombre con el que puedes trabajar y manipular ese texto. 🧮

➡️ El Operador de Asignación (=)

En Python, utilizamos el signo igual (`=`) como el operador de asignación. La sintaxis es simple: escribes el nombre de la variable a la izquierda del signo igual y el string que quieres guardar a la derecha. ➡️

nombre_de_variable = "El string que queremos guardar"

💡 Ejemplos Prácticos de Asignación

Veamos algunos ejemplos para entender cómo funciona esto en diferentes situaciones:

1. Asignando un string simple

Guardamos una frase corta en una variable llamada `mensaje`. 💬

mensaje = "¡Hola desde Python!"
print(mensaje) # Output: ¡Hola desde Python!

2. Asignando un nombre

Almacenamos un nombre en la variable `nombre`. 👤

nombre = "Carlos"
print(f"Mi nombre es: {nombre}") # Output: Mi nombre es: Carlos

3. Asignando un string multilínea

Las triple comillas son perfectas para asignar bloques de texto más largos a una variable. 📜

descripcion = """Este es un texto
que ocupa varias líneas
y se guarda en una sola variable."""
print(descripcion)

4. Asignando el resultado de una operación con strings

Podemos asignar a una variable el resultado de concatenar o manipular otros strings. ➕

primera_parte = "El lenguaje "
segunda_parte = "Python es poderoso."
mensaje_completo = primera_parte + segunda_parte
print(mensaje_completo) # Output: El lenguaje Python es poderoso.

5. Reasignando una variable

Una variable puede contener diferentes strings en diferentes momentos de la ejecución de tu programa. Al asignarle un nuevo valor, el valor anterior se reemplaza. 🔄

texto = "Valor inicial"
print(texto) # Output: Valor inicial

texto = "Nuevo valor"
print(texto) # Output: Nuevo valor

📌 Puntos Importantes sobre la Asignación

• **Nombre de la Variable:** Elige nombres descriptivos para tus variables. Esto hace que tu código sea más fácil de entender. Por ejemplo, `nombre_usuario` es mejor que `n`. 🏷️
• **Tipos de Datos:** Aunque estamos asignando strings, Python es un lenguaje de tipado dinámico, lo que significa que no necesitas declarar explícitamente el tipo de dato de la variable. Python lo infiere automáticamente. 🐍
• **Inmutabilidad:** Recuerda que aunque reasignes una variable con un nuevo string, el string original (si todavía existe alguna referencia a él) no ha sido modificado. Simplemente la variable ahora apunta a un nuevo string. 🛡️

En resumen, la asignación de cadena es un paso fundamental para trabajar con texto en Python. Te permite darle un nombre a tus strings para poder utilizarlos y manipularlos a lo largo de tu código. ¿Hay alguna pregunta sobre cómo asignar cadenas a variables o algún escenario específico que te gustaría explorar?

Cadenas Multilínea en Python

📄 Cadenas Multilínea en Python: Texto que Fluye

Las **cadenas multilínea** en Python son una forma poderosa de definir strings que abarcan varias líneas de texto en tu código. 📜 Son especialmente útiles cuando necesitas incluir bloques de texto extensos, como poemas, código HTML o SQL incrustado, sin tener que recurrir a caracteres de escape para los saltos de línea. ¡Hacen que tu código sea mucho más legible en estos casos! 👓

✨ La Magia de las Triple Comillas

La clave para crear cadenas multilínea en Python reside en el uso de las **triple comillas**: puedes usar tres comillas simples (`'''...'''`) o tres comillas dobles (`"""..."""`). Ambas formas funcionan exactamente igual para este propósito. ✨

# Usando triple comillas simples
mi_poema = '''En mitad del invierno inclemente,
aprendí por fin que había en mí un verano invencible.
- Albert Camus'''
print(mi_poema)

# Usando triple comillas dobles
codigo_sql = """
SELECT *
FROM tabla_usuarios
WHERE edad > 25;
"""
print(codigo_sql)

➡️ Cómo Funcionan las Cadenas Multilínea

Cuando defines un string utilizando triple comillas, todos los saltos de línea y los espacios en blanco que incluyas dentro de las comillas se conservarán como parte del string. ¡Tal cual lo escribes, así se guarda! ➡️

mensaje_con_espacios = """
Este mensaje
  tiene
    espacios
      al principio de cada línea.
"""
print(repr(mensaje_con_espacios))
# Output (aproximado): '\nEste mensaje\n  tiene\n    espacios\n      al principio de cada línea.\n'

En el ejemplo anterior, usamos la función `repr()` para mostrar la representación "cruda" del string, incluyendo los caracteres de escape como `\n` (salto de línea). Esto ilustra cómo los saltos de línea se almacenan literalmente en el string.

💡 Casos de Uso Comunes

Las cadenas multilínea son increíblemente útiles en varios escenarios:

1. Documentación (Docstrings)

Se utilizan para escribir la documentación de funciones, clases y módulos. Estas docstrings, encerradas en triple comillas, son accesibles mediante el atributo `__doc__`. 📚

def saludar(nombre):
    """Esta función saluda a la persona que se le pasa como argumento.

    Args:
        nombre (str): El nombre de la persona a saludar.

    Returns:
        str: Un saludo personalizado.
    """
    return f"¡Hola, {nombre}!"

print(saludar.__doc__)

2. Bloques de Código Embebido

Como vimos con el ejemplo de SQL o HTML, son perfectas para incluir fragmentos de código en otros lenguajes dentro de tu código Python. 💻

3. Textos Largos y Formateados

Si necesitas almacenar o mostrar grandes cantidades de texto con un formato específico, las cadenas multilínea son la solución ideal. 📝

carta = """Estimado [Nombre del Destinatario],

Espero que esta carta le encuentre bien. Le escribo para informarle sobre...

Atentamente,
[Su Nombre]
"""
print(carta)

📌 Consideraciones al Usar Cadenas Multilínea

• **Espacios en Blanco Iniciales:** Ten cuidado con los espacios o tabulaciones al principio de las líneas dentro de las triple comillas, ya que se incluirán en el string. Si no los necesitas, asegúrate de que las líneas estén alineadas al margen izquierdo. 🧹
• **Legibilidad:** Aunque son excelentes para bloques de texto largos, evita usarlas para strings cortos en una sola línea, ya que las comillas simples o dobles son más concisas. ✍️

En resumen, las cadenas multilínea en Python te permiten manejar texto extenso y formateado de manera sencilla y legible en tu código. ¡Son una herramienta muy útil para diversas tareas! ¿Tienes alguna pregunta sobre cómo o cuándo usar las cadenas multilínea?

Cadenas como Matrices en Python

<0xF0><0x9F><0x97><0x84>️ Cadenas como Matrices en Python: Accediendo a los Caracteres

En Python, una de las características fundamentales de los **strings** es que se pueden considerar como **secuencias indexadas** o, dicho de otra manera, como **matrices (arrays)** de caracteres. 📦 Esto significa que cada carácter dentro de un string tiene una posición específica, a la que puedes acceder utilizando un **índice**. ¡Es como tener una dirección para cada letra! 📍

🔑 La Indexación en Strings

La indexación en Python siempre comienza desde **0** para el primer elemento de la secuencia. En el caso de los strings, el primer carácter tiene el índice 0, el segundo tiene el índice 1, y así sucesivamente. También puedes utilizar **índices negativos** para acceder a los caracteres desde el final del string, donde -1 representa el último carácter, -2 el penúltimo, y así sucesivamente. ➕➖

mi_cadena = "Python"

# Índices positivos
primera_letra = mi_cadena[0]  # 'P'
segunda_letra = mi_cadena[1] # 'y'
tercera_letra = mi_cadena[2] # 't'
cuarta_letra = mi_cadena[3]  # 'h'
quinta_letra = mi_cadena[4]  # 'o'
sexta_letra = mi_cadena[5]   # 'n'

print(f"Primera letra (índice 0): {primera_letra}")
print(f"Segunda letra (índice 1): {segunda_letra}")
print(f"Tercera letra (índice 2): {tercera_letra}")
print(f"Cuarta letra (índice 3): {cuarta_letra}")
print(f"Quinta letra (índice 4): {quinta_letra}")
print(f"Sexta letra (índice 5): {sexta_letra}")

# Índices negativos
ultima_letra = mi_cadena[-1]   # 'n'
penultima_letra = mi_cadena[-2] # 'o'

print(f"Última letra (índice -1): {ultima_letra}")
print(f"Penúltima letra (índice -2): {penultima_letra}")

✂️ Slicing de Strings

Además de acceder a caracteres individuales, puedes extraer **subcadenas** o "slices" de un string especificando un rango de índices. La sintaxis para el slicing es `[inicio:fin:paso]`, donde:

• `inicio`: Es el índice donde comienza la subcadena (inclusive). Si se omite, se asume el inicio del string.
• `fin`: Es el índice donde termina la subcadena (exclusivo). Si se omite, se asume el final del string.
• `paso`: Especifica el incremento entre los índices. Si se omite, se asume 1.

mi_largo_string = "AprendiendoPython"

# Obtener una subcadena desde el índice 0 hasta el 7 (sin incluir el 7)
subcadena1 = mi_largo_string[0:7] # "Aprendi"
print(f"Subcadena 1: {subcadena1}")

# Obtener una subcadena desde el índice 8 hasta el final
subcadena2 = mi_largo_string[8:]  # "endoPython"
print(f"Subcadena 2: {subcadena2}")

# Obtener una subcadena desde el inicio hasta el índice 7 (sin incluir el 7)
subcadena3 = mi_largo_string[:7]  # "Aprendi"
print(f"Subcadena 3: {subcadena3}")

# Obtener el string completo (copia)
subcadena4 = mi_largo_string[:] # "AprendiendoPython"
print(f"Subcadena 4: {subcadena4}")

# Obtener caracteres con un paso de 2
subcadena5 = mi_largo_string[::2] # "AedoPto"
print(f"Subcadena 5: {subcadena5}")

# Invertir el string usando un paso de -1
string_invertido = mi_largo_string[::-1] # "nohtyPogninedrpA"
print(f"String invertido: {string_invertido}")

⚠️ ¡Cuidado con los Índices Fuera de Rango!

Intentar acceder a un índice que está fuera del rango del string (es decir, un índice menor que 0 o mayor o igual a la longitud del string) provocará un error de tipo `IndexError`. ¡Python te avisará si intentas ir más allá de los límites! 🛑

mi_corto_string = "Hola"
# error = mi_corto_string[4] # Esto causará un IndexError

📌 La Inmutabilidad y la Indexación

Aunque puedes acceder a los caracteres de un string mediante la indexación, recuerda que los strings son **inmutables**. Esto significa que no puedes modificar un carácter individual directamente utilizando su índice. Cualquier intento de hacerlo resultará en un error. 🛡️

mi_string_inmutable = "Casa"
# mi_string_inmutable[0] = 'M' # Esto generará un TypeError

Para "modificar" un string, en realidad creas un nuevo string basado en el original y las modificaciones deseadas.

En resumen, entender cómo los strings funcionan como matrices en Python te permite acceder y manipular partes específicas de tus cadenas de texto de manera muy灵活. ¡Es una habilidad fundamental para trabajar con datos textuales! ¿Tienes alguna pregunta sobre la indexación o el slicing de strings?

Bucle a través de una Cadena en Python

<0xF0><0x9F><0x94><0x81> Bucle a través de una Cadena en Python: Recorriendo el Texto

Cuando trabajas con strings en Python, a menudo necesitas procesar cada carácter individualmente. Los **bucles** son la herramienta perfecta para esta tarea, permitiéndote iterar o "recorrer" cada carácter de una cadena de texto y realizar alguna acción con él. 🚶‍♀️🚶‍♂️

🔄 El Bucle `for` con Strings

La forma más común y elegante de iterar sobre los caracteres de un string en Python es utilizando un bucle `for`. La sintaxis es muy intuitiva: para cada `carácter` *en* la `cadena`, haz algo.

mi_cadena = "Python"

for letra in mi_cadena:
    print(letra)

En este ejemplo, la variable `letra` tomará el valor de cada carácter en `mi_cadena` en cada iteración del bucle. La salida sería:

Python

💡 Ejemplos Prácticos de Iteración

Veamos algunos ejemplos de cómo puedes utilizar bucles para realizar tareas útiles con strings:

1. Contar las vocales

Podemos usar un bucle para contar cuántas vocales hay en una frase. 🗣️

frase = "Esta es una frase con algunas vocales."
contador_vocales = 0
vocales = "aeiouAEIOU"

for caracter in frase:
    if caracter in vocales:
        contador_vocales += 1

print(f"La frase contiene {contador_vocales} vocales.")

2. Invertir una cadena (otra forma)

Aunque el slicing con paso -1 es una forma concisa de invertir un string, también puedes hacerlo con un bucle. 🔄

cadena_original = "Hola"
cadena_invertida = ""

for caracter in cadena_original:
    cadena_invertida = caracter + cadena_invertida

print(f"Cadena original: {cadena_original}")
print(f"Cadena invertida: {cadena_invertida}") # Output: aloH

En este caso, en cada iteración, el carácter actual se añade al *principio* de la `cadena_invertida` que se está construyendo.

3. Filtrar caracteres específicos

Puedes usar un bucle para crear una nueva cadena que contenga solo ciertos tipos de caracteres. ⚙️

texto_con_numeros = "Texto123con456números789."
solo_letras = ""

for caracter in texto_con_numeros:
    if caracter.isalpha(): # Comprueba si el carácter es una letra
        solo_letras += caracter

print(f"Texto original: {texto_con_numeros}")
print(f"Solo letras: {solo_letras}") # Output: Textoconnúmeros

🔢 El Bucle `while` con Strings (Menos Común)

Aunque el bucle `for` es la opción más idiomática para iterar sobre strings, también podrías usar un bucle `while` si necesitas un control más explícito sobre el índice. Sin embargo, esto suele ser más verboso y propenso a errores si no se maneja el índice correctamente. ⚠️

mi_cadena = "Python"
indice = 0
longitud = len(mi_cadena)

while indice < longitud:
    print(mi_cadena[indice])
    indice += 1

Este ejemplo produce la misma salida que el bucle `for` anterior, pero requiere una gestión manual del índice.

📌 Consideraciones al Iterar

• **Legibilidad:** El bucle `for` es generalmente más fácil de leer y entender para la iteración de strings. 👓
• **Inmutabilidad:** Recuerda que dentro del bucle, estás accediendo a los caracteres del string original, que no se modifica. Si necesitas crear una nueva cadena basada en la iteración, debes construirla explícitamente (como en los ejemplos de inversión y filtrado). 🛡️

En resumen, los bucles (`for` en particular) son herramientas esenciales para procesar el contenido de los strings carácter por carácter, permitiéndote realizar una amplia variedad de tareas, desde contar elementos hasta transformar el texto. ¿Tienes alguna pregunta sobre cómo usar bucles con strings o algún escenario específico que te gustaría explorar?

Longitud de una Cadena en Python

📏 Longitud de una Cadena en Python: ¿Cuántos Caracteres Son?

A menudo, cuando trabajamos con strings, necesitamos saber cuántos caracteres contiene. Esto puede ser útil para validar la entrada del usuario, limitar la longitud de un texto o simplemente para obtener información sobre el tamaño de nuestros datos textuales. Python nos proporciona una función muy sencilla para esto: `len()`. 📐

✨ La Función `len()`

La función incorporada `len()` en Python toma un objeto (que puede ser una secuencia como un string, una lista, una tupla, etc.) y devuelve el número de elementos que contiene. En el caso de un string, `len()` devuelve el número total de caracteres en esa cadena. ¡Es tan fácil como contar! 🔢

mi_cadena = "Hola Mundo!"
longitud = len(mi_cadena)
print(f"La longitud de la cadena '{mi_cadena}' es: {longitud}") # Output: La longitud de la cadena 'Hola Mundo!' es: 11

Como puedes ver, `len()` cuenta todos los caracteres, incluyendo espacios y signos de puntuación.

💡 Ejemplos Prácticos de Uso de `len()`

Veamos algunos escenarios donde la función `len()` puede ser muy útil:

1. Validar la longitud de la entrada del usuario

Si estás pidiendo a un usuario que ingrese un nombre de usuario con una longitud mínima y máxima, `len()` es tu mejor amigo. 🔒

nombre_usuario = input("Ingrese su nombre de usuario: ")
longitud_nombre = len(nombre_usuario)

if longitud_nombre < 5:
    print("El nombre de usuario debe tener al menos 5 caracteres.")
elif longitud_nombre > 15:
    print("El nombre de usuario no puede tener más de 15 caracteres.")
else:
    print("Nombre de usuario válido.")

2. Limitar la visualización de un texto

A veces, quieres mostrar solo una parte de un texto largo y añadir puntos suspensivos si excede un cierto límite. ✂️

texto_largo = "Este es un texto muy largo que podría no caber en la pantalla por completo."
limite = 20

if len(texto_largo) > limite:
    texto_cortado = texto_largo[:limite] + "..."
    print(texto_cortado) # Output: Este es un texto mu...
else:
    print(texto_largo)

3. Iterar sobre un string usando índices

Aunque el bucle `for` es más directo, a veces necesitas usar un bucle `while` y la longitud del string para acceder a los caracteres por índice. 🔄

mi_string = "Ejemplo"
indice = 0
longitud = len(mi_string)

while indice < longitud:
    print(f"Carácter en el índice {indice}: {mi_string[indice]}")
    indice += 1

4. Comprobar si un string está vacío

Un string vacío tiene una longitud de 0. Puedes usar `len()` para verificar si un string está vacío. ∅

entrada = input("Ingrese algo (opcional): ")
if len(entrada) == 0:
    print("No ingresaste nada.")
else:
    print(f"Ingresaste: {entrada}")

📌 La Importancia de `len()`

La función `len()` es una herramienta fundamental en Python y se utiliza con muchos tipos de secuencias, no solo strings. Su sencillez y utilidad la convierten en una parte esencial del kit de herramientas de cualquier programador de Python. 🛠️

En resumen, `len()` te proporciona una manera rápida y fácil de determinar la cantidad de caracteres en un string, lo cual es crucial para diversas tareas de manipulación y validación de texto. ¿Tienes alguna pregunta sobre cómo usar `len()` o algún otro escenario donde te gustaría verla en acción?

Verificar Subcadena en Python

🔎 Verificar Subcadena en Python: ¿Está Ahí?

A menudo, al trabajar con texto, necesitamos saber si un string más grande contiene una secuencia específica de caracteres, conocida como **subcadena**. Python nos ofrece varias formas eficientes de realizar esta verificación. ¡Es como buscar una palabra clave en un documento! 🕵️

🔑 El Operador `in`

La forma más sencilla y Pythonica de verificar si una subcadena está presente en un string es utilizando el operador `in`. Este operador devuelve un valor booleano (`True` o `False`) indicando si la subcadena se encuentra o no dentro del string. ✅/❌

frase = "El perro ladra fuerte."
subcadena1 = "perro"
subcadena2 = "gato"

if subcadena1 in frase:
    print(f"'{subcadena1}' está en la frase.") # Output: 'perro' está en la frase.

if subcadena2 in frase:
    print(f"'{subcadena2}' está en la frase.") # No se imprimirá
else:
    print(f"'{subcadena2}' no está en la frase.") # Output: 'gato' no está en la frase.

El operador `in` es sensible a mayúsculas y minúsculas. Por lo tanto, "Perro" no se consideraría la misma subcadena que "perro".

✨ Métodos de String para la Búsqueda

Python también proporciona varios métodos de string que te permiten realizar búsquedas más avanzadas:

1. `find()`

El método `find()` busca la primera ocurrencia de una subcadena dentro del string. Devuelve el índice donde se encuentra la subcadena si la halla, y `-1` si no la encuentra. 📍

texto = "Encontrando la aguja en el pajar."
sub = "aguja"
indice = texto.find(sub)
print(f"'{sub}' se encontró en el índice: {indice}") # Output: 'aguja' se encontró en el índice: 16

sub_no_encontrada = "alfiler"
indice_no_encontrado = texto.find(sub_no_encontrada)
print(f"'{sub_no_encontrada}' se encontró en el índice: {indice_no_encontrado}") # Output: 'alfiler' se encontró en el índice: -1

Puedes especificar un índice de inicio y fin opcional para limitar la búsqueda a una porción del string: `texto.find(sub, inicio, fin)`. 🔍

2. `index()`

El método `index()` es similar a `find()`, pero en lugar de devolver `-1` si la subcadena no se encuentra, lanza una excepción `ValueError`. ⚠️

texto = "La manzana es roja."
sub = "manzana"
indice = texto.index(sub)
print(f"'{sub}' se encontró en el índice: {indice}") # Output: 'manzana' se encontró en el índice: 4

sub_no_encontrada = "pera"
# indice_no_encontrado = texto.index(sub_no_encontrada) # Esto causará un ValueError

Al igual que `find()`, `index()` también acepta argumentos opcionales de inicio y fin para la búsqueda.

3. `startswith()` y `endswith()`

Estos métodos verifican si un string comienza o termina con una subcadena específica, respectivamente. Devuelven `True` o `False`. 🏁/🎯

archivo = "documento.pdf"
if archivo.endswith(".pdf"):
    print("Es un archivo PDF.") # Output: Es un archivo PDF.

saludo = "Hola, mundo!"
if saludo.startswith("Hola"):
    print("El saludo comienza con 'Hola'.") # Output: El saludo comienza con 'Hola'.

📌 ¿Cuándo usar qué?

• Usa el operador `in` para una verificación simple de existencia cuando solo necesitas un resultado booleano. ✅/❌
• Usa `find()` si necesitas saber el índice de la primera ocurrencia y quieres manejar el caso de no encontrar la subcadena de forma controlada (sin excepciones). 📍/-1
• Usa `index()` si necesitas el índice y quieres que se lance una excepción si la subcadena no está presente. 📍/`ValueError`
• Usa `startswith()` y `endswith()` para verificar los prefijos y sufijos de un string. 🏁/🎯

En resumen, Python te ofrece varias herramientas poderosas para verificar la presencia de subcadenas dentro de strings, cada una con sus propias ventajas según tus necesidades específicas. ¿Tienes alguna pregunta sobre cómo utilizar estos métodos o el operador `in`?

Verificación de Ausencia de Subcadena en Python

🚫 Verificación de Ausencia de Subcadena en Python: Cuando Algo No Está

Así como a menudo necesitamos verificar si una subcadena *está* presente en un string, también hay situaciones en las que necesitamos confirmar que una subcadena *no* se encuentra dentro de él. Python nos proporciona formas sencillas de realizar esta comprobación. ¡Es como asegurarte de que un ingrediente no esté en una receta! 🙅‍♀️

🔑 El Operador `not in`

La manera más directa y legible de verificar la ausencia de una subcadena es utilizando el operador `not in`. Al igual que `in`, `not in` devuelve un valor booleano (`True` o `False`). Devuelve `True` si la subcadena *no* se encuentra en el string, y `False` si sí está presente. 🚫✅

frase = "Me gusta el café por la mañana."
subcadena1 = "té"
subcadena2 = "café"

if subcadena1 not in frase:
    print(f"'{subcadena1}' no está en la frase.") # Output: 'té' no está en la frase.

if subcadena2 not in frase:
    print(f"'{subcadena2}' no está en la frase.") # No se imprimirá
else:
    print(f"'{subcadena2}' sí está en la frase.") # Output: 'café' sí está en la frase.

Al igual que el operador `in`, `not in` también es sensible a las mayúsculas y minúsculas.

💡 Usando Métodos de String para Verificar Ausencia

Aunque `not in` es la forma más idiomática, también podemos usar los métodos de búsqueda de strings para verificar la ausencia de una subcadena de manera indirecta:

1. Usando `find()`

Si el método `find()` devuelve `-1`, significa que la subcadena no se encontró en el string. Podemos usar esta información para verificar la ausencia. 📍/-1

texto = "Buscando algo que no está."
sub = "encontrado"

if texto.find(sub) == -1:
    print(f"'{sub}' no se encontró en el texto.") # Output: 'encontrado' no se encontró en el texto.
else:
    print(f"'{sub}' se encontró en el índice: {texto.find(sub)}")

2. Usando `index()` con manejo de excepciones

Si el método `index()` lanza un `ValueError`, sabemos que la subcadena no está presente. Podemos usar un bloque `try-except` para manejar esta situación. ⚠️

texto = "Intentando encontrar lo ausente."
sub = "presente"

try:
    indice = texto.index(sub)
    print(f"'{sub}' se encontró en el índice: {indice}")
except ValueError:
    print(f"'{sub}' no se encontró en el texto.") # Output: 'presente' no se encontró en el texto.

📌 ¿Cuándo usar `not in`?

El operador `not in` es generalmente la opción más clara y concisa cuando solo necesitas saber si una subcadena no está presente. Hace que tu código sea más fácil de leer y entender para esta tarea específica. 👍

💡 Ejemplos Prácticos de Verificación de Ausencia

Aquí tienes algunos ejemplos de cómo podrías usar `not in` en situaciones reales:

1. Filtrar contenido no deseado

Puedes usar `not in` para omitir líneas de un archivo que contengan ciertas palabras clave. 🚫

lineas = ["Esta línea es aceptable.", "Esta línea contiene la palabra prohibida.", "Otra línea ok."]
palabra_prohibida = "prohibida"
lineas_filtradas = []

for linea in lineas:
    if palabra_prohibida not in linea:
        lineas_filtradas.append(linea)

print(lineas_filtradas) # Output: ['Esta línea es aceptable.', 'Otra línea ok.']

2. Validar la entrada del usuario

Puedes asegurarte de que la entrada del usuario no contenga ciertos caracteres o palabras. 🔒

contrasena = input("Ingrese su contraseña: ")
caracter_no_permitido = ";"

if caracter_no_permitido not in contrasena:
    print("Contraseña válida.")
else:
    print("La contraseña contiene caracteres no permitidos.")

En resumen, la verificación de la ausencia de subcadenas es una tarea importante en el procesamiento de texto, y Python te facilita hacerlo de manera legible y eficiente con el operador `not in` y, de forma indirecta, con otros métodos de string. ¿Tienes alguna pregunta sobre cómo o cuándo usar estas técnicas?

---

Ir al indice

---

Publicar un comentario