Tutorial de cadenas en Python

Trocear cadenas en Python

Como las cadenas son una secuencia de caracteres, puedes acceder a ellas mediante el troceado y la indexación, igual que harías con las listas o tuplas de Python. Las cadenas se indexan con respecto a cada carácter de la cadena y la indexación comienza en 0:

En la cadena anterior, el primer índice es C y tiene índice 0. El último carácter es un punto . que es el 16.º carácter de la cadena. También puedes acceder a los caracteres en sentido contrario a partir de -1, lo que significa que también puedes utilizar -1 como valor índice para acceder a . en la cadena. También hay un espacio en blanco entre Chocolate y cookie, que también forma parte de la cadena y tiene su propio índice, 9º en este caso. Puedes comprobarlo al trocear.

Como cada carácter de una cadena de Python tiene un número de índice correspondiente, puedes acceder a las cadenas y manipularlas de la misma forma que otros tipos de datos secuenciales. El troceado es una técnica de Python que te permite obtener un elemento específico o un subconjunto de elementos de un objeto contenedor utilizando sus valores de índice. El troceado te ahorra tener que escribir sentencias de bucle para recorrer los índices de tu cadena y encontrar o acceder a determinadas subcadenas.

snack = "Chocolate cookie."
print(snack[0])
print(snack[9])
print(snack[-1])

C

.

Supongamos que quieres extraer la subcadena "galleta" de la cadena siguiente. ¿Cómo lo harías?

En estos casos, utiliza el troceado de rango.

La sintaxis para el troceado de rangos es la siguiente: [Start index (included): Stop index (excluded)]

snack = "Chocolate cookie."
print(snack[10:16])

cookie

También podrías hacerlo con un valor negativo para el índice de parada:

print(snack[10:-1]) # -1: since the stop index is excluded in slicing.

cookie

Trocear sin especificar el índice de parada significa que capturas los caracteres desde el índice de inicio hasta el último índice de la frase. Del mismo modo, trocear con el índice de inicio omitido significa que empiezas desde el primer índice de la cadena hasta el índice de parada:

# Stop value not provided
print(snack[0:]) 

# Start value not provided (Stop value excluded according to syntax)
print(snack[:-1])

# This is also allowed
print(snack[:])

Chocolate cookie.
Chocolate cookie
Chocolate cookie.

El troceado de cadenas también puede aceptar un tercer parámetro, el stride, que se refiere a cuántos caracteres quieres avanzar después de recuperar el primer carácter de la cadena. El valor de stride se establece de forma predeterminada en 1.

Veamos stride en acción para entenderlo mejor:

number_string = "1020304050"
print(number_string[0:-1:2])

12345

Consejo: Algo muy chulo que puedes hacer con la zancada es invertir una cuerda:

print(number_string[::-1]) #

0504030201

el valor de -1 para la zancada te permite empezar desde el carácter final y moverte de uno en uno.

Alternativamente, si proporcionas -2 como valor, empiezas desde el carácter final y te mueves dos caracteres cada vez:

print(number_string[::-2]) #

00000

Operaciones comunes con cadenas

Trocear, trocear con rango son las operaciones habituales que tendrías que realizar con cadenas. También existe la concatenación de cadenas, que es tan sencilla como sumar:

string1 = 'Chocolate'
string2 = 'cookie'

snack = string1 + " " + string2
print(snack)

Chocolate cookie

Sin embargo, esto no funcionará si intentas concatenar una cadena con algún otro tipo de dato.

cost = 15
string1 = "The total in Euro is: "

bill = string1 + cost
print(bill)

---------------------------------------------------------------------------

TypeError                                 Traceback (most recent call last)

<ipython-input-218-7d5c5248b927> in <module>()
      2 string1 = "The total in Euro is: "
      3 
----> 4 bill = string1 + cost
      5 print(bill)


TypeError: Can't convert 'int' object to str implicitly

Aquí has intentado concatenar una cadena con un valor entero, lo cual no está permitido. El intérprete no puede entender implícitamente si estás intentando realizar una simple suma de enteros o una concatenación de cadenas. Sin embargo, prueba esto ahora:

bill = string1 + str(cost)
print(bill)

The total in Euro is: 15

Esto se debe a que convertiste explícitamente un entero en un valor de cadena y luego aplicaste la concatenación. Para saber más sobre las conversiones de tipos de datos, consulta este tutorial.

Para repetir una cadena, utiliza la operación *.

single_word = 'hip '
line1 = single_word * 2 + 'hurray! '
print(line1 * 3)

hip hip hurray! hip hip hurray! hip hip hurray! 

También puedes comprobar la propiedad de pertenencia en una cadena utilizando in y not in:

sub_string1 = 'ice'
sub_string2 = 'glue'
string1 = 'ice cream'
if sub_string in string1:
    print("There is " + sub_string + " in " + string1)
if sub_string2 not in string1:
    print("Phew! No " + sub_string2 + " in " + string1)

There is ice in ice cream
Phew! No glue in ice cream

Python proporciona muchos métodos incorporados o funciones de ayuda para manipular cadenas. Sustituir una subcadena, poner en mayúsculas determinadas palabras de un párrafo, encontrar la posición de una cadena dentro de otra son algunas de las operaciones que puedes hacer con estos métodos incorporados.

Echa un vistazo a algunos de ellos en detalle:

• str.capitalize(): devuelve una copia de la cadena con su primer carácter en mayúscula.

str.capitalize('cookie')

'Cookie'

• str.islower(): devuelve verdadero si todos los caracteres de la cadena están en minúsculas, falso en caso contrario.

snack = 'cookie'
snack.islower()

True

• str.find(substring): devuelve el índice más bajo de la cadena donde se encuentra la subcadena. También puedes especificar el índice inicial y final dentro de la cadena donde quieres que se busque la subcadena. Devuelve -1 si no se encuentra la subcadena.

str1 = 'I got you a cookie'
str2 = 'cook'
str1.find(str2)

12

• str.count(substring): cuenta cuántas veces aparece una subcadena en la cadena. También puedes especificar el índice de inicio y de fin de la cadena.

str1 = 'I got you a cookie, do you like cookies?'
str2 = 'cookie'
str1.count(str2)

2

• str.isspace(): devuelve True si solo hay caracteres de espacio en blanco en la cadena, false en caso contrario. Los caracteres de espacio en blanco son los caracteres como espacio, tabulador, línea siguiente, etc.

Esto puede ser útil cuando se trabaja con conjuntos de datos de la vida real, que no siempre codifican el espaciado adecuado durante la conversión de un formato a otro.

str_space = '   '
str_space.isspace()

True

str_tab = '\t'
str_tab.isspace()

True

str_nextline = '''\n'''
str_nextline.isspace()

True

Nota: ¿Te has fijado en \t, \n más arriba? Se llaman caracteres de escape. Empiezan por \ (barra invertida). Internamente, no se interpretan como cadenas normales, sino como caracteres especiales que representan otra cosa. Por ejemplo - \t representa una pestaña. Hay muchos más personajes de evasión y puedes leer más sobre ellos aquí.

• str.lstrip(): elimina todos los espacios en blanco iniciales de la cadena. Esta es otra función que puede ser útil cuando trabajas con conjuntos de datos reales.

str1 = " I can't hear you. Are you alright? "
str2 = " Yes, all is good."
str3 = str1.lstrip() + str2.lstrip()
print(str3)

I can't hear you. Are you alright? Yes, all is good.

• str.isdigit(): devuelve True si la cadena solo contiene dígitos y False en caso contrario.

number_string = "1020304050"
number_string.isdigit()

True

• str.replace(substring, new): sustituye todas las apariciones de la subcadena en la cadena por nueva. También puedes definir un tercer argumento max, que sustituye como máximo max apariciones de la subcadena en la cadena. Recuerda que no se trata de una sustitución in situ, lo que significa que la propiedad inmutable se mantiene y que en realidad se forma una cadena nueva.

string1 = 'hip hip hurray! hip hip hurray! hip hip hurray!'
string2 = string1.replace('hip', 'Hip')
print(string1)
print(string2)

hip hip hurray! hip hip hurray! hip hip hurray!
Hip Hip hurray! Hip Hip hurray! Hip Hip hurray!

string1.replace('hip', 'Hip', 2)

'Hip Hip hurray! hip hip hurray! hip hip hurray!'

• str.split(delimiter=""): divide la cadena según el delimitador (espacio si no se indica) y devuelve una lista de subcadenas.

dessert = 'Cake, Cookie, Icecream'
list_dessert = string1.split(',')

Puedes encontrar una lista exhaustiva de métodos de cadena en Python aquí.

Formateo de cadenas

Python admite múltiples formas de dar formato a una cadena. En esta sección, ¡aprenderás más sobre estas cadenas de formato!

% Formateo

El módulo % es una operación incorporada en Python. Se conoce como operador de interpolación. Tendrás que indicar % seguido del tipo de dato que hay que formatear o convertir. A continuación, la operación % sustituye la frase '%datatype' por cero o más elementos del tipo de datos especificado:

print("I bought %d Euro worth of %s!" %(200, 'cookies'))

I bought 200 Euro worth of cookies!

Has visto que %d se utiliza para los números enteros y %s para las cadenas. Algunos de los otros tipos de conversión disponibles son: o para valores octales, x para hexadecimales, f para formato decimal de coma flotante, c para un solo carácter (acepta enteros o cadenas de un solo carácter).

La clase formateador

La clase formatter es una de las clases de cadena incorporadas. Ofrece la posibilidad de realizar sustituciones complejas de variables y formatear valores utilizando el método format(). Te permite crear y personalizar tus propios comportamientos de formateo de cadenas reescribiendo los métodos públicos que contiene: format(), vformat(). Tiene algunos métodos que deben ser sustituidos por subclases: parse(), get_field(), get_value(), check_unused_args(), format_field() y convert_field(). Sin embargo, en aras de la simplicidad, solo verás en acción la funciónformat() más utilizada...

print("I bought {0} Euro worth of {1}!".format(200,'cookies')) #Accessing values by position

I bought 200 Euro worth of cookies!

print("I bought {total} Euro worth of {item}!".format(total = 200, item = 'cookies')) #Accessing values by name

I bought 200 Euro worth of cookies!

'{:#<10}'.format('Cake') #Left aligment for word 'Cake' according to right alignment, gaps filled with '#'

'Cake######'

'{:#^10}'.format('Cake') #Centre aligment for word 'Cake' according to right alignment, gaps filled with '#'

'###Cake###'

'{:#>10}'.format('Cake') #Right aligment for word 'Cake' according to right alignment, gaps filled with '#'

'######Cake'

for num in range(1,10): 
        print('{0:{width}}'.format(num, width=5), end=' ')

    1     2     3     4     5     6     7     8     9 

Cadenas de plantillas

En lugar de las sustituciones normales basadas en %, las plantillas admiten sustituciones basadas en $. La razón de ser de la introducción de las plantillas en la versión 2.4 de Python era que, aunque el formato de cadena % es potente y rico, son propensas a errores y también bastante estrictas en cuanto a los formatos que siguen a "%", lo que las hace complejas. Un error común con el formato % es olvidar el carácter de formato final, por ejemplo: el e en %(variabl)e.

Las plantillas tienen algunos métodos definidos en su interior: substitute() y safe_substitute(). A continuación te explicamos cómo puedes utilizarlos:

from string import Template #First you will need to import 'Tempalte' class

money = dict(who = 'You', to_whom = 'baker')
Template('$who owe the $to_whom a total of $$100').substitute(money)

'You owe the baker a total of $100'

¿Notas el $$ en el ejemplo anterior?

Esto se debe a que con la plantilla $$ es un carácter de escape que se sustituye por un único $. Es una de las reglas de la plantilla. Otra regla para la plantilla es cómo defines el identificador dentro de tu plantilla, existe la sintaxis habitual: $identifier, pero también tienes ${identifier}.

Eso significa que ${identifier}es lo mismo que $identifier, pero puede utilizarse para situaciones como:

word = dict(noun = 'feed')
Template('Please don\'t stop ${noun}ing me').substitute(word)

"Please don't stop feeding me"

Veamos cómo puedes utilizar substitute() y safe_substitute().

fact = Template('$alter_ego is weak but wait till he transforms to $superhero!')
fact.substitute(alter_ego='Bruce Banner', superhero='Hulk')

'Bruce Banner is weak but wait till he transforms to Hulk!'

hero = dict(alter_ego='Peter Parker')
fact.substitute(hero)

---------------------------------------------------------------------------

KeyError                                  Traceback (most recent call last)

<ipython-input-244-c82f6a2ebc02> in <module>()
      1 hero = dict(alter_ego='Peter Parker')
----> 2 fact.substitute(hero)


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in substitute(*args, **kws)
    127             raise ValueError('Unrecognized named group in pattern',
    128                              self.pattern)
--> 129         return self.pattern.sub(convert, self.template)
    130 
    131     def safe_substitute(*args, **kws):


~/anaconda3/envs/tensorflow/lib/python3.5/string.py in convert(mo)
    117             named = mo.group('named') or mo.group('braced')
    118             if named is not None:
--> 119                 val = mapping[named]
    120                 # We use this idiom instead of str() because the latter will
    121                 # fail if val is a Unicode containing non-ASCII characters.


KeyError: 'superhero'

El ejemplo anterior da error, porque superhero no está definido. Sin embargo, prueba esto...

fact.safe_substitute(hero)

'Peter Parker is weak but wait till he transforms to $superhero!'

La safe_substitute() es una de las ventajas de utilizar plantillas.

¿Por qué tantas opciones de formato de cadena, te preguntarás?

Bueno, se trata principalmente de una cuestión de preferencias sintácticas. Normalmente se trata de un compromiso entre simplicidad y verbosidad, y también depende de tu familiaridad con las sintaxis existentes. Por ejemplo, el uso de % para formatear cadenas parecerá natural a las personas con conocimientos de programación en C. Las plantillas en Python son sencillas de escribir, mientras que utilizar format() puede ser más verboso pero tiene más funciones.

Literal de cadena formateada (f-cadena)

Este es otro método de formateo de cadenas añadido en la versión 3.6 de Python. Una cadena literal formateada o cadena f es una cadena literal que lleva como prefijo "f" o "F". Puedes definir los identificadores que se utilizarán en tu cadena entre llaves { }.

¿Por qué otra opción de formato de cadena? La practicidad y la sencillez son bellas, ¡y por eso!

Echa un vistazo a los siguientes ejemplos para ver por qué las cadenas f son realmente la forma más sencilla y práctica de formatear cadenas en Python.

alter_ego = 'Peter Parker' superhero = 'spiderman' f'{alter_ego} is weak but wait till he transforms to {superhero}!'

Nota: El código anterior solo funcionará con la versión 3.6 o superior de Python. Para comprobar la versión de Python que tienes instalada, escribe: python -V en el terminal. Si no, también puedes utilizar el módulo sys dentro de Python. Para utilizarlo, solo tienes que hacer lo siguiente

import sys
sys.version

Las cadenas formateadas son en realidad expresiones evaluadas en tiempo de ejecución, lo que significa que puedes utilizar cualquier expresión de Python dentro de las llaves de las f-cadenas, que es otra gran ventaja de utilizar f-cadena.

f'{alter_ego} is weak but wait till he transforms to {superhero.capitalize()}!'

¿No es ya genial el f-string? Pero espera, la cosa se pone aún mejor... las cadenas f también son más rápidas en comparación con los otros tres métodos que has visto antes. Esto se debe a que se analizan previamente y se almacenan en bytecode eficiente para una ejecución más rápida.

¡Tira de los hilos adecuados!

Has llegado al final del tutorial, ¡enhorabuena! Has visto qué son las cadenas, has aprendido sobre el troceado de cadenas y has visto algunas operaciones que se pueden realizar con cadenas. También has visto varias formas de dar formato a las cadenas. Pero recuerda, ¡la clave para dominar cualquier técnica es la práctica!

Las cadenas son uno de los varios tipos de datos de Python. Consulta el curso Tipos de datos para la ciencia de datos de DataCamp para aprender más sobre listas, diccionarios, tuplas y conjuntos. En este curso podrás utilizar tus conocimientos sobre tipos de datos. Trabajarás con datos de tránsito del área metropolitana de Chicago con fines de ciencia de datos. Acércate para verlo por ti mismo...