Cómo comprobar si una cadena comienza con un prefijo en Python

Introducción

En este laboratorio, aprenderás cómo comprobar si una cadena comienza con un prefijo específico en Python utilizando el método startswith(). Esta habilidad es crucial para tareas como la validación de datos y el procesamiento de archivos.

Crearás un script de Python para demostrar el uso de prefijos de cadenas. El script definirá una cadena y luego utilizará startswith() para comprobar si comienza con "Hello" y "Goodbye", imprimiendo los resultados en la consola. Luego ejecutarás el script y observarás la salida.

Skills Graph

%%%%{init: {'theme':'neutral'}}%%%% flowchart RL python(("Python")) -.-> python/BasicConceptsGroup(["Basic Concepts"]) python(("Python")) -.-> python/FunctionsGroup(["Functions"]) python/BasicConceptsGroup -.-> python/strings("Strings") python/FunctionsGroup -.-> python/build_in_functions("Build-in Functions") subgraph Lab Skills python/strings -.-> lab-559583{{"Cómo comprobar si una cadena comienza con un prefijo en Python"}} python/build_in_functions -.-> lab-559583{{"Cómo comprobar si una cadena comienza con un prefijo en Python"}} end

Comprender los prefijos de cadenas

En este paso, aprenderás sobre los prefijos de cadenas en Python y cómo utilizarlos para comprobar si una cadena comienza con un prefijo específico. Comprender los prefijos de cadenas es esencial para diversas tareas, como la validación de datos, el procesamiento de archivos y el análisis de comandos.

Un prefijo de cadena es una secuencia de caracteres que aparece al principio de una cadena. Por ejemplo, la cadena "Hello, world!" tiene el prefijo "Hello". Python proporciona un método incorporado llamado startswith() que te permite comprobar si una cadena comienza con un prefijo específico.

Comencemos creando un script de Python para demostrar cómo utilizar los prefijos de cadenas.

Abre el editor de VS Code en el entorno de LabEx.
Crea un nuevo archivo llamado prefix_example.py en el directorio ~/project.
```
touch ~/project/prefix_example.py
```

Abre el archivo prefix_example.py en el editor y agrega el siguiente código:

message = "Hello, LabEx!"

## Check if the string starts with "Hello"
if message.startswith("Hello"):
    print("The string starts with 'Hello'")
else:
    print("The string does not start with 'Hello'")

## Check if the string starts with "Goodbye"
if message.startswith("Goodbye"):
    print("The string starts with 'Goodbye'")
else:
    print("The string does not start with 'Goodbye'")

Este código define una variable de cadena message y luego utiliza el método startswith() para comprobar si la cadena comienza con "Hello" y "Goodbye". La salida indicará si la cadena comienza con los prefijos especificados.

Guarda el archivo prefix_example.py.
Ejecuta el script utilizando el comando python en la terminal:
```
python ~/project/prefix_example.py
```
Deberías ver la siguiente salida:
```
The string starts with 'Hello'
The string does not start with 'Goodbye'
```
Esta salida confirma que la cadena message comienza con "Hello" pero no con "Goodbye".

El método startswith() es una herramienta poderosa para comprobar los prefijos de cadenas en Python. En los siguientes pasos, explorarás técnicas más avanzadas para utilizar los prefijos de cadenas, como manejar la sensibilidad a mayúsculas y minúsculas y comprobar múltiples prefijos.

Utilizar el método startswith()

En este paso, profundizarás en el método startswith() y explorarás sus capacidades con diferentes argumentos. Aprenderás cómo comprobar prefijos en posiciones específicas dentro de una cadena y cómo comprobar múltiples prefijos.

El método startswith() puede aceptar argumentos opcionales para especificar las posiciones de inicio y finalización de la comprobación del prefijo. La sintaxis es la siguiente:

string.startswith(prefix, start, end)

prefix: El prefijo a comprobar.
start: La posición de inicio de la comprobación (opcional).
end: La posición de finalización de la comprobación (opcional).

Modifiquemos el archivo prefix_example.py para demostrar estas características.

Abre el archivo prefix_example.py en el editor de VS Code.

Modifica el código para incluir lo siguiente:

message = "Hello, LabEx!"

## Check if the string starts with "Hello"
if message.startswith("Hello"):
    print("The string starts with 'Hello'")
else:
    print("The string does not start with 'Hello'")

## Check if the string starts with "LabEx" starting from position 7
if message.startswith("LabEx", 7):
    print("The string starts with 'LabEx' at position 7")
else:
    print("The string does not start with 'LabEx' at position 7")

## Check if the string starts with "Hello" within the first 5 characters
if message.startswith("Hello", 0, 5):
    print("The string starts with 'Hello' within the first 5 characters")
else:
    print("The string does not start with 'Hello' within the first 5 characters")

En este código, hemos agregado dos comprobaciones más utilizando el método startswith() con los argumentos start y end. La primera comprobación verifica si la cadena comienza con "LabEx" a partir de la posición 7. La segunda comprobación verifica si la cadena comienza con "Hello" dentro de los primeros 5 caracteres.

Guarda el archivo prefix_example.py.
Ejecuta el script utilizando el comando python en la terminal:
```
python ~/project/prefix_example.py
```
Deberías ver la siguiente salida:
```
The string starts with 'Hello'
The string starts with 'LabEx' at position 7
The string does not start with 'Hello' within the first 5 characters
```
Esta salida demuestra cómo se pueden utilizar los argumentos start y end para comprobar prefijos en posiciones específicas dentro de una cadena.

Ahora, exploremos cómo comprobar múltiples prefijos utilizando una tupla.

Modifica el archivo prefix_example.py para incluir lo siguiente:

message = "Hello, LabEx!"

## Check if the string starts with "Hello" or "Hi"
if message.startswith(("Hello", "Hi")):
    print("The string starts with 'Hello' or 'Hi'")
else:
    print("The string does not start with 'Hello' or 'Hi'")

## Check if the string starts with "Goodbye" or "Welcome"
if message.startswith(("Goodbye", "Welcome")):
    print("The string starts with 'Goodbye' or 'Welcome'")
else:
    print("The string does not start with 'Goodbye' or 'Welcome'")

En este código, hemos agregado dos comprobaciones más utilizando una tupla de prefijos. La primera comprobación verifica si la cadena comienza con "Hello" o "Hi". La segunda comprobación verifica si la cadena comienza con "Goodbye" o "Welcome".

Guarda el archivo prefix_example.py.
Ejecuta el script utilizando el comando python en la terminal:
```
python ~/project/prefix_example.py
```
Deberías ver la siguiente salida:
```
The string starts with 'Hello' or 'Hi'
The string does not start with 'Goodbye' or 'Welcome'
```
Esta salida demuestra cómo comprobar múltiples prefijos utilizando una tupla con el método startswith().

Manejar la sensibilidad a mayúsculas y minúsculas

En este paso, aprenderás cómo manejar la sensibilidad a mayúsculas y minúsculas al comprobar prefijos de cadenas. Por defecto, el método startswith() es sensible a mayúsculas y minúsculas, lo que significa que distingue entre letras mayúsculas y minúsculas. Explorarás técnicas para realizar comprobaciones de prefijos sin tener en cuenta la capitalización.

Para realizar una comprobación de prefijo sin tener en cuenta la capitalización, puedes convertir tanto la cadena como el prefijo a minúsculas (o mayúsculas) antes de utilizar el método startswith(). Esto garantiza que la comparación se realice sin considerar la capitalización de las letras.

Modifiquemos el archivo prefix_example.py para demostrar cómo manejar la sensibilidad a mayúsculas y minúsculas.

Abre el archivo prefix_example.py en el editor de VS Code.

Modifica el código para incluir lo siguiente:

message = "Hello, LabEx!"

## Case-sensitive check for "hello"
if message.startswith("hello"):
    print("The string starts with 'hello' (case-sensitive)")
else:
    print("The string does not start with 'hello' (case-sensitive)")

## Case-insensitive check for "hello"
if message.lower().startswith("hello".lower()):
    print("The string starts with 'hello' (case-insensitive)")
else:
    print("The string does not start with 'hello' (case-insensitive)")

En este código, hemos agregado dos comprobaciones para el prefijo "hello". La primera comprobación es sensible a mayúsculas y minúsculas y fallará porque la cadena comienza con "Hello" (letra H mayúscula). La segunda comprobación no es sensible a mayúsculas y minúsculas y tendrá éxito porque convertimos tanto la cadena como el prefijo a minúsculas antes de la comparación.

Guarda el archivo prefix_example.py.
Ejecuta el script utilizando el comando python en la terminal:
```
python ~/project/prefix_example.py
```
Deberías ver la siguiente salida:
```
The string does not start with 'hello' (case-sensitive)
The string starts with 'hello' (case-insensitive)
```
Esta salida demuestra cómo realizar comprobaciones de prefijos sin tener en cuenta la capitalización convirtiendo tanto la cadena como el prefijo a minúsculas antes de utilizar el método startswith().

También puedes utilizar el método upper() para convertir ambas cadenas a mayúsculas para una comparación sin tener en cuenta la capitalización. Lo importante es asegurarse de que ambas cadenas estén en la misma capitalización antes de utilizar startswith().

Resumen

En este laboratorio (lab), aprendiste sobre los prefijos de cadenas en Python y cómo utilizar el método startswith() para comprobar si una cadena comienza con un prefijo específico. Creaste un script de Python para demostrar el uso de startswith(), comprobando si una cadena dada comienza con "Hello" y "Goodbye", y observando la salida correspondiente según la coincidencia del prefijo.

El laboratorio enfatizó la importancia de entender los prefijos de cadenas para tareas como la validación de datos y el análisis de comandos (command parsing). Adquiriste experiencia práctica en el uso del método startswith() para determinar si una cadena comienza con una secuencia particular de caracteres, y observaste cómo el método devuelve True o False según la coincidencia.