Manipulación de cadenas comunes en Python

En esta guía, aprenda sobre la manipulación común de cadenas en Python, con operadores, len(), find(), count(), slicing, replace(), beginwith(), endwith(), formateo, join(), cambio de mayúsculas y minúsculas. etc.

Introducción

Python es un lenguaje de programación multiparadigma, de tipo dinámico y de alto nivel, y en particular viene con una gran cantidad de herramientas integradas para diversas tareas, lo que reduce la cantidad de esfuerzo necesario para crear rápidamente prototipos y probar ideas. Las cadenas son una de las estructuras de datos más utilizadas en informática y, naturalmente, la manipulación de cadenas es un procedimiento común.

En esta guía, aprenderá cómo realizar la manipulación de cadenas en Python.

Cadenas y manipulación de cadenas

Las cadenas son secuencias (o más bien... cadenas) de caracteres. Por lo general, se implementan como una matriz de caracteres, que juntos actúan como un solo objeto, en la mayoría de los lenguajes de programación. Dicho esto, la manipulación de cadenas se reduce a cambiar los caracteres en la matriz, en cualquier forma.

{.icon aria-hidden=“true”}

Nota: En la mayoría de los lenguajes, incluido Python, las cadenas son inmutables; una vez creadas, no se puede cambiar una cadena. Si desea cambiar una cadena, bajo el capó se crea una nueva cadena, que consta del original y el cambio que desea realizar. Esto se debe a que las cadenas se usan con mucha frecuencia y se pueden "agrupar" en un grupo común, desde el cual los objetos se pueden reutilizar para cadenas que son iguales (lo que sucede con bastante frecuencia). En la mayoría de los casos, esto reduce la sobrecarga de inicialización de objetos en la memoria del sistema y aumenta el rendimiento del lenguaje. Esto también se conoce como String Interning.

En Python, para declarar una cadena, se incluye una secuencia de caracteres entre comillas simples, dobles o triples (con o sin el constructor str()):

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
# Single quote
welcome = 'Good morning, Mark!'
# Double quote
note = "You have 7 new notifications."
# Triple quote allow for multi-row strings
more_text= """
    Would
    you
    like
    to
    read
    them?
"""

También podrías inicializar explícitamente un objeto de cadena usando el constructor str():

1
2
welcome1 = 'Good morning Mark!'
welcome2 = str('Good morning Mark!')

Dependiendo de la versión de Python que esté usando, así como del compilador, la segunda línea internará o no internará la cadena. La función id() incorporada se puede usar para verificar esto: devuelve la ID del objeto en la memoria:

1
2
print(id(welcome1)) # 1941232459688
print(id(welcome2)) # 1941232459328

En todos los términos prácticos, realmente no necesita preocuparse por la interconexión de cadenas o su rendimiento en su aplicación.

{.icon aria-hidden=“true”}

Nota: Otra nota de implementación es que Python no admite un tipo de carácter, a diferencia de otros lenguajes que convierten matrices de un tipo carácter en un tipo cadena. En Python, el carácter es una cadena de longitud 1.

Si marca el tipo de cualquiera de los objetos que hemos creado, será recibido con str:

1
print(type(welcome1)) # class <'str'>

La clase de cadena proporciona una lista bastante larga de métodos que se pueden usar para manipular/alterar cadenas (todos los cuales devuelven una copia modificada, ya que las cadenas son inmutables). Además, los operadores estándar se anularon para el uso específico de cadenas, por lo que puede "agregar" cadenas juntas, usando operadores como +.

Operadores para la manipulación de cadenas {#operadores para la manipulación de cadenas}

Los operadores son la piedra angular de todos los lenguajes, y normalmente se redondean en operadores aritméticos (+, -, *, /), operadores relacionales (<, >, <= , >=, =, ==) y operadores lógicos (& o AND, | o OR), etc. Para que el trabajo con cadenas sea intuitivo, los operadores de Python han sido anulado para permitir el uso directo de cadenas!

Suma de cadenas

Además de sumar números enteros, el operador + se puede usar para combinar/concatenar dos cadenas:

1
2
3
string_1 = "Hello"
string_2 = " World!"
print(string_1 + string_2) # Hello World!

Multiplicación de cadenas {#multiplicación de cadenas}

Un operador a menudo subestimado es el operador de multiplicación - *. Se puede utilizar para crear instancias de varias cadenas o secuencias, como parte de una sola cadena:

1
2
string = 'Recursion...' * 5
print(string) # Recursion...Recursion...Recursion...Recursion...Recursion...

Dado que las expresiones se evalúan de derecha a izquierda, puede multiplicar una cadena y luego agregarla a otra cadena:

1
2
string = "I think I'm stuck in a " + "loop... " * 5
print(string) # I think I'm stuck in a loop... loop... loop... loop... loop... 

Asignación de cadenas con adición

El operador +=, conocido como el operador "inplace", es un operador abreviado. Acorta la suma de dos operandos insertando la variable de referencia asignada como primer operando en la suma:

1
2
3
4
5
s = 'Hello'
# Equivalent to:
# s = s + 'World'
s += 'World'
print(s) # HelloWorld

Funciones para la manipulación de cadenas {#funciones para la manipulación de cadenas}

largo()

La función len() está integrada en el espacio de nombres de Python y, por lo tanto, puede llamarse como una función de conveniencia global. Se utiliza para evaluar la longitud de una secuencia: una lista, una tupla, etc. Dado que las cadenas son listas, ¡su longitud también se puede evaluar con la función len()!

1
print(len("It's been 84 years...")) # 21

Toma cualquier secuencia iterable como entrada y devuelve su longitud como un número entero.

encontrar()

El método find() busca la aparición de un patrón en una cadena y devuelve su posición inicial (índice en el que comienza); de lo contrario, devuelve -1:

1
2
3
4
text = "Writing Python is quite fun."

print(text.find("quite")) # 18
print(text.find("at"))  # -1

El método find() toma dos argumentos opcionales adicionales: beg y end. str define la cadena que se buscará, beg es el índice inicial (0 por defecto) y end es el índice final de la cadena que se establece en la longitud de la cadena por defecto. Al modificarlos, puede cambiar el espacio de búsqueda del patrón:

1
2
3
4
5
6
text = "I haven't been this choked up since I got a hunk of moussaka caught in my throat! - Hades."
text2 = "I"

print(text.find(text2))     # 0
print(text.find(text2, 10)) # 36
print(text.find(text2, 40)) # -1

{.icon aria-hidden=“true”}

Nota: El método rfind() encuentra la última ocurrencia.

contar()

El método count() busca la subcadena proporcionada en el texto dado (sensible a mayúsculas y minúsculas) y devuelve un número entero que indica el número de ocurrencias de ese patrón en la cadena:

1
2
3
text = "The flower that blooms in adversity is the most rare and beautiful of all – Mulan."
text_count = text.count('i') 
print("The count of 'i' is", text_count) # The count of 'i' is 4

De forma predeterminada, el conteo comienza en 0 y continúa hasta el final de la cadena, pero se puede proporcionar un índice inicial y final:

1
2
3
4
text = "The flower that blooms in adversity is the most rare and beautiful of all – Mulan."
                     # str, beg, end
text_count = text.count('i', 0, 5) 
print("The count of 'i' is", text_count) # The count of 'i' is 0

rebanar

Slicing es una notación poderosa y versátil que se puede usar para segmentar secuencias. Al usar la notación de corchetes, como cuando se accede a elementos de una secuencia iterable, también puede acceder a una porción de elementos, entre un índice inicial y final:

1
2
text = "Hello, World!"
print(text[6:12]) # World

La notación de corte acepta tres entradas: iterable[start:stop:step]. start es el índice inicial (inclusivo), stop es el índice final (exclusivo) y step es el incremento (que también puede ser un número negativo). Intentemos dividir la cadena entre el índice 2 (inclusive) y el 7 (exclusivo) con un paso de 2:

1
2
text = 'The code runs fast'
print(text[2:7:2]) # ecd

comienza con() y termina con()

El método startswith() en Python determina si una cadena comienza con una subcadena proporcionada, mientras que el método endswith() comprueba si una cadena termina con una subcadena y ambos devuelven un valor booleano:

1
2
3
4
text = "hello world"

print(text.startswith("H")) # False
print(text.endswith("d")) # True

{.icon aria-hidden=“true”}

Nota: Tanto startswith() como endswith() distinguen entre mayúsculas y minúsculas.

Formateo de cadenas

Agregar y quitar espacios

El método strip() elimina los espacios en blanco desde el principio y el final de la línea, lo que lo convierte en un enfoque fácil para eliminar los caracteres vacíos finales. Para eliminar simplemente el espacio a la derecha o a la izquierda, use rstrip() o lstrip():

1
2
3
4
5
text = '         a short break         '
text.strip() # 'a short break'

text.rstrip() #'         a short break'
text.lstrip() #'a short break         '

For a dedicated guide to removing whitespaces from strings - read our Guía del método strip() de Python!

Cambio de mayúsculas y minúsculas de una cadena - upper(), lower(), capitalize(), title(), swapcase()

¡Cambiar el caso de una cadena es bastante sencillo! Los métodos upper(), lower(), capitalize(), title() y swapcase() se pueden usar para cambiar las mayúsculas y minúsculas de una cadena:

1
2
3
4
5
6
7
text = "When life gets you down you know what you've gotta do? Just keep swimming! – Finding Nemo"

print(text.upper())      # Uppercases all characters
print(text.lower())      # Lowercases all characters
print(text.title())      # Title-case
print(text.capitalize()) # Capitalizes the first character
print(text.swapcase())   # Swaps whatever case for each character

Esto resulta en:

1
2
3
4
5
WHEN LIFE GETS YOU DOWN YOU KNOW WHAT YOU'VE GOTTA DO? JUST KEEP SWIMMING! – FINDING NEMO
when life gets you down you know what you've gotta do? just keep swimming!  finding nemo
When Life Gets You Down You Know What You'Ve Gotta Do? Just Keep Swimming! – Finding Nemo
When life gets you down you know what you've gotta do? just keep swimming!  finding nemo
wHEN LIFE GETS YOU DOWN YOU KNOW WHAT YOU'VE GOTTA DO? jUST KEEP SWIMMING!  fINDING nEMO

División y particionamiento de cadenas con split() y partición()

Para encontrar una subcadena y luego dividir la cadena en función de su ubicación, necesitará los métodos partition() y split(). Ambos devolverán una lista de cadenas con la división aplicada. Ambos distinguen entre mayúsculas y minúsculas.

El método partition() devuelve la subcadena antes de la primera aparición del punto de división, el punto de división en sí mismo y la subcadena posterior:

1
2
3
text = "To be or not to be, that is the question"

print(text.partition('to be')) # ('To be or not ', 'to be', ', that is the question')

Mientras tanto, split() divide la cadena en cada espacio en blanco por defecto, produciendo una lista de palabras separadas en una cadena:

1
2
text = "To be or not to be, that is the question"
print(text.split()) # ['To', 'be', 'or', 'not', 'to', 'be,', 'that', 'is', 'the', 'question']

Naturalmente, también puede dividir por cualquier otro carácter proporcionado en la llamada split():

1
2
text = "To be or not to be, that is the question"
print(text.split(',')) # ['To be or not to be', ' that is the question']

Unión de cadenas con join()

El método join() funciona en iterables que contienen exclusivamente instancias de cadenas, uniendo todos los elementos en una cadena. Vale la pena señalar que el método se llama en una cadena que indica el delimitador, no la cadena en la que está uniendo los iterables:

1
2
text = ['One', 'Two', 'Three', 'Four']
print(', '.join(text)) # One, Two, Three, Four

Para obtener una guía más detallada sobre cómo unir listas en cadenas, incluidos diferentes tipos de datos, lea nuestro Python: convertir lista en cadena con join ()

Sustitución de subcadenas

¡Reemplazar una subcadena, sin saber dónde se encuentra, es bastante fácil! Con el método replace(), puede proporcionar el patrón que se reemplazará y el nuevo patrón que se insertará en ese espacio:

1
2
text = "Because of what you have done, the heavens are now part of man's world"
print(text.replace("man's", "human's")) # Because of what you have done, the heavens are now part of the human world

Conclusión

En este artículo, hemos repasado algunas de las técnicas, operadores y métodos/funciones comunes de manipulación de cadenas, con guías asociadas más detalladas.

Licensed under CC BY-NC-SA 4.0