Métodos más comunes para cadenas en Python

Varios métodos de cadena analizan cadenas o crean valores de cadena transformados. Esta sección describe los métodos que utilizará con más frecuencia.

Los métodos upper(), lower(), isupper() y islower()

Los métodos de cadena upper() y lower() devuelven una nueva cadena en la que todas las letras de la cadena original se han convertido a mayúsculas o minúsculas, respectivamente. Los caracteres que no son letras en la cadena permanecen sin cambios. Introduzca lo siguiente en el shell interactivo:

>>> spam = 'Hello, world!'
>>> spam = spam.upper()
>>> spam
'HELLO, WORLD!'
>>> spam = spam.lower()
>>> spam
'hello, world!'

Tenga en cuenta que estos métodos no cambian la cadena en sí, sino que devuelven una nueva cadena. Si quieres cambiar la cadena original, tienes que llamar a upper() o lower() sobre la cadena y luego asignar la nueva cadena a la variable donde se almacenó la original. Por eso debes usar spam = spam.upper() para cambiar la cadena en spam en lugar de simplemente spam.upper(). (Esto es igual que si una variable eggs contiene el valor 10. Escribir eggs + 3 no cambia el valor de eggs, pero eggs = eggs + 3 sí).

Los métodos upper() y lower() son útiles si necesitas hacer una comparación que no distinga entre mayúsculas y minúsculas. Por ejemplo, las cadenas 'great' y 'GREat' no son iguales entre sí. Pero en el siguiente pequeño programa, no importa si el usuario escribe Great, GREAT, o grEAT, porque la cadena se convierte primero a minúsculas.

print('How are you?')
feeling = input()
if feeling.lower() == 'great':
    print('I feel great too.')
else:
    print('I hope the rest of your day is good.')

Cuando se ejecuta este programa, se muestra la pregunta, y si se introduce una variación de great, como GREat, se obtendrá el resultado I feel great too. Si añades código a tu programa para manejar variaciones o errores en la entrada del usuario, como las mayúsculas inconsistentes, harás que tus programas sean más fáciles de usar y menos propensos a fallar.

How are you?
GREat
I feel great too.

Puedes ver la ejecución de este programa en https://autbor.com/convertlowercase/. Los métodos isupper() e islower() devolverán un valor booleano True si la cadena tiene al menos una letra y todas las letras son mayúsculas o minúsculas, respectivamente. En caso contrario, el método devuelve False. Introduzca lo siguiente en el intérprete de comandos interactivo, y observe lo que devuelve cada llamada al método:

>>> spam = 'Hello, world!'
>>> spam.islower()
False
>>> spam.isupper()
False
>>> 'HELLO'.isupper()
True
>>> 'abc12345'.islower()
True
>>> '12345'.islower()
False
>>> '12345'.isupper()
False

Dado que los métodos de cadena upper() y lower() devuelven cadenas, puedes llamar a métodos de cadena en esos valores de cadena devueltos también. Las expresiones que hacen esto se verán como una cadena de llamadas a métodos. Introduzca lo siguiente en el shell interactivo:

>>> 'Hello'.upper()
'HELLO'
>>> 'Hello'.upper().lower()
'hello'
>>> 'Hello'.upper().lower().upper()
'HELLO'
>>> 'HELLO'.lower()
'hello'
>>> 'HELLO'.lower().islower()
True

Los métodos isX()

Junto con islower() e isupper(), hay otros métodos de cadena que tienen nombres que comienzan con la palabra is. Estos métodos devuelven un valor booleano que describe la naturaleza de la cadena. Estos son algunos de los métodos de cadena isX más comunes:

isalpha()

Devuelve True si la cadena está formada sólo por letras y no está en blanco

isalnum()

Devuelve True si la cadena está formada sólo por letras y números y no está en blanco

isdecimal()

Devuelve True si la cadena está formada sólo por caracteres numéricos y no está en blanco

isspace()

Devuelve True si la cadena está formada sólo por espacios, tabulaciones y nuevas líneas y no está en blanco

istitle()

Devuelve True si la cadena está formada sólo por palabras que comienzan con una letra mayúscula seguida sólo por letras minúsculas

Introduzca lo siguiente en el shell interactivo:

>>> 'hello'.isalpha()
True
>>> 'hello123'.isalpha()
False
>>> 'hello123'.isalnum()
True
>>> 'hello'.isalnum()
True
>>> '123'.isdecimal()
True
>>> '    '.isspace()
True
>>> 'This Is Title Case'.istitle()
True
>>> 'This Is Title Case 123'.istitle()
True
>>> 'This Is not Title Case'.istitle()
False
>>> 'This Is NOT Title Case Either'.istitle()
False

Los métodos de cadena isX() son útiles cuando se necesita validar la entrada del usuario. Por ejemplo, el siguiente programa pide repetidamente a los usuarios su edad y una contraseña hasta que proporcionan una entrada válida. Abra una nueva ventana del editor de archivos e introduzca este programa, guardándolo como validateInput.py:

while True:
    print('Enter your age:')
    age = input()
    if age.isdecimal():
        break
    print('Please enter a number for your age.')

while True:
    print('Select a new password (letters and numbers only):')
    password = input()
    if password.isalnum():
        break
    print('Passwords can only have letters and numbers.')

En el primer bucle while, pedimos al usuario su edad y almacenamos su entrada en age. Si la edad es un valor válido (decimal), salimos de este primer bucle while y pasamos al segundo, que pide una contraseña. En caso contrario, informamos al usuario de que debe introducir un número y le pedimos de nuevo que introduzca su edad. En el segundo bucle while, pedimos una contraseña, almacenamos la entrada del usuario en password, y salimos del bucle si la entrada fue alfanumérica. Si no lo es, no estamos satisfechos, así que le decimos al usuario que la contraseña debe ser alfanumérica y le pedimos de nuevo que la introduzca.

Cuando se ejecuta, la salida del programa tiene el siguiente aspecto:

Enter your age:
forty two
Please enter a number for your age.
Enter your age:
42
Select a new password (letters and numbers only):
secr3t!
Passwords can only have letters and numbers.
Select a new password (letters and numbers only):
secr3t

Puedes ver la ejecución de este programa en https://autbor.com/validateinput/. Llamando a isdecimal() e isalnum() sobre las variables, podemos comprobar si los valores almacenados en esas variables son decimales o no, alfanuméricos o no. Aquí, estas pruebas nos ayudan a rechazar la entrada forty two pero aceptar 42, y rechazar secr3t! pero aceptar secr3t.

Los métodos startswith() y endswith()

Los métodos startswith() y endswith() devuelven True si el valor de la cadena a la que se llama comienza o termina (respectivamente) con la cadena pasada al método; en caso contrario, devuelven False. Introduzca lo siguiente en el shell interactivo:

>>> 'Hello, world!'.startswith('Hello')
True
>>> 'Hello, world!'.endswith('world!')
True
>>> 'abc123'.startswith('abcdef')
False
>>> 'abc123'.endswith('12')
False
>>> 'Hello, world!'.startswith('Hello, world!')
True
>>> 'Hello, world!'.endswith('Hello, world!')
True

Estos métodos son alternativas útiles al operador == igual si necesita comprobar sólo si la primera o la última parte de la cadena, en lugar de todo el conjunto, es igual a otra cadena.

Los métodos join() y split()

El método join() es útil cuando se tiene una lista de cadenas que deben unirse en un único valor de cadena. El método join() se llama a una cadena, se le pasa una lista de cadenas y devuelve una cadena. La cadena devuelta es la concatenación de cada cadena de la lista pasada. Por ejemplo, introduzca lo siguiente en el shell interactivo:

>>> ', '.join(['cats', 'rats', 'bats'])
'cats, rats, bats'
>>> ' '.join(['My', 'name', 'is', 'Simon'])
'My name is Simon'
>>> 'ABC'.join(['My', 'name', 'is', 'Simon'])
'MyABCnameABCisABCSimon'

Observa que la cadena a la que llama join() se inserta entre cada cadena del argumento de la lista. Por ejemplo, cuando se llama a join(['cats', 'rats', 'bats']) sobre la cadena ', ', la cadena devuelta es 'cats, rats, bats'.

Recuerde que join() se llama sobre un valor de cadena y se le pasa un valor de lista. El método split() hace lo contrario: Se llama a un valor de cadena y devuelve una lista de cadenas. Introduzca lo siguiente en el shell interactivo:

>>> 'My name is Simon'.split()
['My', 'name', 'is', 'Simon']

Por defecto, la cadena 'My name is Simon' se divide siempre que se encuentren caracteres de espacio en blanco como el espacio, el tabulador o la nueva línea. Estos caracteres de espacio en blanco no se incluyen en las cadenas de la lista devuelta. Puede pasar una cadena delimitadora al método split() para especificar una cadena diferente sobre la que dividir. Por ejemplo, introduzca lo siguiente en el shell interactivo:

>>> 'MyABCnameABCisABCSimon'.split('ABC')
['My', 'name', 'is', 'Simon']
>>> 'My name is Simon'.split('m')
['My na', 'e is Si', 'on']

Un uso común de split() es dividir una cadena multilínea a lo largo de los caracteres de nueva línea. Introduzca lo siguiente en el shell interactivo:

>>> spam = '''Dear Alice,
How have you been? I am fine.
There is a container in the fridge
that is labeled "Milk Experiment."

Please do not drink it.
Sincerely,
Bob'''
>>> spam.split('\n')
['Dear Alice,', 'How have you been? I am fine.', 'There is a container in the
fridge', 'that is labeled "Milk Experiment."', '', 'Please do not drink it.',
'Sincerely,', 'Bob']

Pasando a split() el argumento '\n' podemos dividir la cadena multilínea almacenada en spam a lo largo de las nuevas líneas y devolver una lista en la que cada elemento corresponde a una línea de la cadena.

Dividir cadenas con el método partition()

El método de cadena partition() puede dividir una cadena en el texto antes y después de una cadena separadora. Este método busca en la cadena a la que se llama la cadena separadora que se le pasa, y devuelve una tupla de tres subcadenas para las subcadenas «antes», «separadora» y «después». Introduzca lo siguiente en el shell interactivo:

>>> 'Hello, world!'.partition('w')
('Hello, ', 'w', 'orld!')
>>> 'Hello, world!'.partition('world')
('Hello, ', 'world', '!')

Si la cadena separadora que se pasa a partition() aparece varias veces en la cadena a la que llama partition(), el método divide la cadena sólo en la primera aparición:

>>> 'Hello, world!'.partition('o')
('Hell', 'o', ', world!')

Si no se encuentra la cadena separadora, la primera cadena devuelta en la tupla será la cadena completa, y las otras dos cadenas estarán vacías:

>>> 'Hello, world!'.partition('XYZ')
('Hello, world!', '', '')

Puedes utilizar el truco de la asignación múltiple para asignar las tres cadenas devueltas a tres variables:

>>> before, sep, after = 'Hello, world!'.partition(' ')
>>> before
'Hello,'
>>> after
'world!'

El método partition() es útil para dividir una cadena siempre que necesites las partes before, incluidas y after de una cadena separadora concreta.

Justificar el texto con los métodos rjust(), ljust() y center()

Los métodos de cadena rjust() y ljust() devuelven una versión rellena de la cadena a la que se llama, con espacios insertados para justificar el texto. El primer argumento de ambos métodos es una longitud entera para la cadena justificada. Introduzca lo siguiente en el shell interactivo:

>>> 'Hello'.rjust(10)
'     Hello'
>>> 'Hello'.rjust(20)
'              Hello'
>>> 'Hello, World'.rjust(20)
'         Hello, World'
>>> 'Hello'.ljust(10)
'Hello     '

'Hello'.rjust(10) dice que queremos ajustar a la derecha 'Hello' en una cadena de longitud total 10. 'Hello' tiene cinco caracteres, por lo que se añadirán cinco espacios a su izquierda, dándonos una cadena de 10 caracteres con 'Hello' justificada a la derecha.

Un segundo argumento opcional para rjust() y ljust() especificará un carácter de relleno que no sea un espacio. Introduzca lo siguiente en el shell interactivo:

>>> 'Hello'.rjust(20, '*')
'***************Hello'
>>> 'Hello'.ljust(20, '-')
'Hello---------------'

El método de cadena center() funciona como ljust() y rjust() pero centra el texto en lugar de justificarlo a la izquierda o a la derecha. Introduzca lo siguiente en el shell interactivo:

>>> 'Hello'.center(20)
'       Hello        '
>>> 'Hello'.center(20, '=')
'=======Hello========'

Estos métodos son especialmente útiles cuando necesitas imprimir datos tabulares que tengan un espaciado correcto. Abre una nueva ventana del editor de archivos e introduce el siguiente código, guardándolo como picnicTable.py:

def printPicnic(itemsDict, leftWidth, rightWidth):
    print('PICNIC ITEMS'.center(leftWidth + rightWidth, '-'))
    for k, v in itemsDict.items():
        print(k.ljust(leftWidth, '.') + str(v).rjust(rightWidth))

picnicItems = {'sandwiches': 4, 'apples': 12, 'cups': 4, 'cookies': 8000}
printPicnic(picnicItems, 12, 5)
printPicnic(picnicItems, 20, 6)

Puedes ver la ejecución de este programa en https://autbor.com/picnictable/. En este programa, definimos un método printPicnic() que tomará un diccionario de información y utilizará center(), ljust(), y rjust() para mostrar esa información en un formato similar al de una tabla bien alineada.

El diccionario que pasaremos a printPicnic() es picnicItems. En picnicItems, tenemos 4 sándwiches, 12 manzanas, 4 tazas y 8.000 galletas. Queremos organizar esta información en dos columnas, con el nombre del artículo a la izquierda y la cantidad a la derecha.

Para ello, decidimos qué anchura queremos que tengan las columnas de la izquierda y de la derecha. Junto con nuestro diccionario, pasaremos estos valores a printPicnic().

La función printPicnic() toma un diccionario, un leftWidth para la columna izquierda de una tabla, y un rightWidth para la columna derecha. Imprime un título, PICNIC ITEMS, centrado sobre la tabla. Luego, recorre el diccionario, imprimiendo cada par clave-valor en una línea con la clave justificada a la izquierda y rellenada con puntos, y el valor justificado a la derecha y rellenado con espacios.

Después de definir printPicnic(), definimos el diccionario picnicItems y llamamos a printPicnic() dos veces, pasándole diferentes anchos para las columnas izquierda y derecha de la tabla.

Cuando se ejecuta este programa, los elementos de picnic se muestran dos veces. La primera vez la columna de la izquierda tiene 12 caracteres de ancho, y la de la derecha 5 caracteres. La segunda vez tienen 20 y 6 caracteres de ancho, respectivamente.

---PICNIC ITEMS--
sandwiches..    4
apples......   12
cups........    4
cookies..... 8000
-------PICNIC ITEMS-------
sandwiches..........     4
apples..............    12
cups................     4
cookies.............  8000

El uso de rjust(), ljust() y center() le permite asegurarse de que las cadenas están perfectamente alineadas, incluso si no está seguro de cuántos caracteres tienen sus cadenas.

Eliminación de espacios en blanco con los métodos strip(), rstrip() y lstrip()

A veces puede querer eliminar los caracteres de espacio en blanco (espacio, tabulador y nueva línea) del lado izquierdo, del lado derecho o de ambos lados de una cadena. El método strip() devolverá una nueva cadena sin ningún carácter de espacio en blanco al principio o al final. Los métodos lstrip() y rstrip() eliminarán los caracteres de espacio en blanco de los extremos izquierdo y derecho, respectivamente. Introduzca lo siguiente en el shell interactivo:

>>> spam = '    Hello, World    '
>>> spam.strip()
'Hello, World'
>>> spam.lstrip()
'Hello, World    '
>>> spam.rstrip()
'    Hello, World'

Opcionalmente, un argumento de cadena especificará qué caracteres de los extremos deben ser eliminados. Introduzca lo siguiente en el shell interactivo:

>>> spam = 'SpamSpamBaconSpamEggsSpamSpam'
>>> spam.strip('ampS')
'BaconSpamEggs'

Si le pasas a strip() el argumento 'ampS', le dirás que elimine las apariciones de a, m, p y la S mayúscula de los extremos de la cadena almacenada en spam. El orden de los caracteres en la cadena pasada a strip() no importa: strip('ampS') hará lo mismo que strip('mapS') o strip('Spam').

Deja una respuesta