String en Python

From ChuWiki
Jump to navigation Jump to search

Vamos a ver cómo usar los string en Python y las operaciones más habituales, como buscar substring dentro de la cadena, buscar y reemplazar, formatearla, recorrerla, etc.

El caso de partir una cadena lo tratamos por separado en el tutorial Metodo String split de Python

Declarar el string[edit]

En Python podemos delimitar un string usando las comillas simples ', las comillas dobles " o incluso triples comillas """. Los dos primeros casos son exactamente iguales, no hay diferencia. Podemos usar uno u otro indistintamente, o podemos elegir uno u otro en función de que haya comillas simples o dobles dentro de nuestra cadena. Por ejemplo, si dentro de nuestra cadena hay comillas simples, podemos delimitar la cadena con comillas dobles, para evitar conflictos.

Las comillas triples permiten escribir varias líneas de texto sin necesidad de preocuparse de poner caracteres de retorno de carro \n. Python respetará lo que pongamos entre comillas triples tal cual está, incluido el formato, sangrado, etc.

# Comillas dobles. Podemos poner dentro comillas simples sin problemas
cadena = "Hola ' Mundo"

# Comilas simples. Podemos poner dentro comillas dobles sin problemas
cadena2 = 'Otro " Hola Mundo '

# Triples comillas. Podemos poner dentro lo que queramos (salvo comillas triples) sin problemas.
cadena3 = """En un lugar '
de la Mancha "
de cuyo nombre
no quiero acordarme"""

Caracteres especiales en el string[edit]

Como en otros lenguajes, Python tiene caracteres especiales que interpreta dentro de los string. Por ejemplo \n es un retorno de carro (nueva línea), \t es un tabulador. En string and bytes literals tienes una tabla completa con todos los caracteres de escape de los string de Python.

Podemos, al definir una cadena, usar una r justo delante de la apertura de las comillas. Esto evitará que Python interprete los caracteres especiales y los tratará como caracteres normales.

# Saldrán dos líneas en pantalla, una con Hola, la otra con Mundo
cadena = "Hola\nMundo"  

# Saldrá una única línea en pantalla y la \ y la n será visibles como caracteres normales.
cadena2 = r"Hola\nMundo"

Recorrer el string[edit]

Bucle for sobre string[edit]

Con un bucle for podemos recorrer los caracteres de la cadena de uno en uno sin problemas.

cadena = "Hola Mundo"
for letra in cadena:
   print(letra)

Acceder a los caracteres de un string[edit]

También es posible acceder directamente a los caracteres de la cadena usando la notación de corchetes [] poniendo como índice la posición del caracter deseado, empezando en cero. Si usamos índices negativos, empieza a contar desde el final de la cadena, siendo -1 el último carácter del string.

cadena = "Hola Mundo"

# Saca por pantalla la 'a' de 'Hola Mundo'
print (cadena[3])

# Saca por pantalla el último carácter, la 'o'
print (cadena[-1])

No es posible, sin embargo, asignar un nuevo carácter a esa posición del string. cadena[3]='p' dará error.

Longitud de un string[edit]

La función len de Python nos permite saber la longitu de una cadena.

cadena = "Hola Mundo"

print ( len(cadena) )     # Saca 10, que es la longitud de la cadena

Extraer, Buscar, Reemplazar substring en string[edit]

Extraer substring[edit]

Podemos extraer una parte del string usando la notación de corchetes con dos índices [inicio:fin]. La notación [:fin] es desde el primer carácter hasta el carácter fin. La notación [inicio:] indica desde el carácter inicio hasta final de string. Si usamos índices negativos, se cuenta desde el final de la cadena hacia el principio. Por ejemplo, el índice -1 es el último carácter. Veamos código de ejemplo de todo esto

cadena = "Hola Mundo"

# Saca por pantalla 'ol'
print (cadena[1:3])

#Saca por pantalla 'Hol'
print (cadena[:3])

# Saca por pantalla ' Mundo' (con el espacio delante)
print (cadena[4:])

# Saca por pantalla 'un'
print (cadena[-4:-2])

# Saca por pantalla 'undo'
print (cadena[-4:])

# Saca por pantalla 'Hola Mun'
print (cadena[:-2])

Saber si un string contiene un substring o carácter : in[edit]

Podemos usar el operador in de Python para saber si una cadena contiene una determinada subcadena o un carácter concreto. Veamos un ejemplo

cadena = "Hola Mundo"

# Sacan True por pantalla.
print ( "o" in cadena )
print ( "Hola" in cadena )

# Sacan False por pantalla.
print ( "p" in "Hola Mundo" )
print ( "Pepe" in "Hola Mundo" )


Buscar un substring en el string : find[edit]

El método find de string nos permite buscar una subcadena dentro de la cadena. Este método admite hasta tres parámetros. La cadena a buscar, el índice a partir del cual empezar a buscar y el índice a partir del cual dejar de buscar. Nos devuelve la posición en donde ha encontrado la cadena, o -1 si no la encuentra. Veamos ejemplos

cadena = "Hola Mundo"

print(cadena.find("Hola"))        # Devuelve posición 0
print(cadena.find("Mundo"))       # Devuelve posición 5

print(cadena.find("Hola", 3))     # Devuelve -1, a partir de la posición 3 de "Hola Mundo" no hay ningún "Hola"
print(cadena.find("Mundo", 3))    # Devuelve 5, a partir de la posición 3 de "Hola Mundo" hay un "Mundo".

print(cadena.find("Hola", 0, 5))  # Devuelve 0, hay un "Hola" entre la posición 0 y 5 de "Hola Mundo".
print(cadena.find("Mundo", 0, 5)) # Devuelve -1, no hay un "Mundo" entre la posición 0 y 5 de "Hola Mundo".

find devuelve la primera posición en donde encuentra el substring dentro del string. Alternativamente, el método rfind nos devuelve la última posición donde encuentra el substring. También admite parámetros de índice de inicio y fin de búsqueda. Un ejemplo

cadena = "un uno, un dos, un tres"

print (cadena.find("un"))    # El primer "un" está en la posición 0, devuelve 0
print (cadena.rfind("un"))   # El último "un" está en la posición 16, devuelve 16

Contar número de veces que el substring aparece en el string : count[edit]

El método count nos dice cuántas veces aparece el substring dentro del string. Admite un parámetro que es el substring a buscar, y opcionalmente otros dos, los índices de inicio y fin de búsqueda. Veamos ejemplos

cadena = "un uno, un dos, un tres"

print (cadena.count("un"))        # Saca 4, hay 4 "un" en cadena.
print (cadena.count("un",10))     # Saca 1, hay 1 "un" a partir de la posición 10 de cadena.
print (cadena.count("un",0,10))   # Saca 3, hay 3 "un" entre la posición 0 y la 10.

Reemplazar substring en string : replace[edit]

El método replace nos permite obtener una copia de la cadena original (no reemplaza en la cadena original) en la que se reemplaza el substring que se le indique por uno nuevo. Admite tres parámetros, el primero es el substring que tiene que buscar, el segundo es el nuevo substring que tiene que poner y el tercero, opcional, es cuántas veces tiene que hacer el reemplazo. Veamos ejemplos

cadena = "un uno, un dos, un tres"

print (cadena.replace("un", "XXX"))        # saca por pantalla "XXX XXXo, XXX dos, XXX tres"
print (cadena.replace("un", "XXX", 2))     # Sólo reemplaza 2 "un", así que saca por pantalla "XXX XXXo, un dos, un tres"

Mayúsculas / Minúsculas[edit]

Todos estos métodos buscan mayúsculas y minúsculas tal cual, por lo que no es lo mismo una "A" que una "a". Si queremos hacer las búsquedas ignorando si es mayúscula o minúscula, tenemos dos opciones:

  • Usar string.lower() o string.upper() para convertir todo a minúsculas o mayúsculas antes de hacer las búsquedas. Por supuesto, los substring que busquemos también deben estar todo en minúscula o mayúscula.
  • Usar expresiones regulares. En el enlace puedes ver detalles.

Formatear string[edit]

Veamos cómo obtener string formateados en python que contienen números con determinados formatos, sangrados, etc.

Convertir número a string con formato[edit]

En python tenemos tres formas de conseguir un string en el que vayan formateados números y otras variables. La forma antigua es usar el operador %

el operador %[edit]

Se usa una expresión como la siguiente "string con formato" % valores. Veamos ejemplos

# print ( "string formato" % valores)
# Un ejemplo concreto

# Esto saca en pantalla "El valor es 11"
print ("El valor es %d" % 11)

# Si hay varios valores, van entre paréntesis
# Esto saca en pantalla "Los valores son 11 y 33"
print ("Los valores son %d y %d" % (11,33))

Si hay varios valores, los ponemos entre paréntesis. En el ejemplo, dentro del string de formato, %d es para números enteros, sin decimales. Si queremos decimales, debemos usar %f.

También es posible indicar cuántas cifras enteras y decimales que queremos, si queremos que vayan ceros delante, si queremos ceros detrás, etc. Unos ejemplos

print ("Entero con 5 cifras, espacios por delante %5d" % 11)    # saca tres espacios y un 11, en total 5 caracteres.
print ("Entero con 5 cifras, ceros por delante %05d" % 11)      # saca 00011
print ("Flotante con 2 decimales %.2f" % 12.34567)              # saca 12.35 (redondea el 4 a 5)
print ("Flotante con 2 decimales, diez cifras, espacios por delante %10.2f" % 12.34567)  # Saca 5 espacios y 12.35, total 10 caracteres.
print ("Flotante con 2 decimales, diez cifras, ceros por delante %010.2f" % 12.34567)    # Saca 0000012.35

Los ejemplos son bastante auto explicativos. Únicamente los dos últimos, hay que tener en cuenta que al decir 10 cifras con 2 decimales, las 10 cifras incluyen el punto decimal y los dos decimales, así que ese 10 realmente significa 7 cifras enteras, un punto decimal y dos decimales.

En el siguiente enlace puedes ver todos los caracteres de conversión de string formateados.

Existe otro método más moderno que es el método format() de string.

el método format() de string[edit]

Se pueden definir variables y poner llaves {} en el string donde van a ir los números o caracteres. Entre paréntesis pasamos los valores. Unos ejemplos sencillos

# saca "El valor es 12
print ("El valor es {}".format(12))

# saca "El valor es 12.3456
print ("El valor es {}".format(12.3456))

# Tres conjuntos {}, el primero para el primer parámetro de format(), el segundo para el segundo
# y así sucesivamente.
# saca "Los valores son 1, 2 y 3"
print ("Los valores son {}, {} y {}".format(1,2,3))

# Entre las llaves podemos poner la posición del parámetro. {2} es el tercer parámetro de format()
# {0} es el primer parámetro de format.
# saca "Los valores son 3, 2 y 1"
print ("Los valores son {2}, {1} y {0}".format(1,2,3))

Si a los parámetros les damos nombre, podemos usar ese nombre en vez de su número de posición

# saca "2 y 1"
print ("{pepe} y {juan}".format(juan=1, pepe=2))

Podemos dar formato a los números para indicar cuántas cifras y decimales queremos, siguiendo una sintaxis similar al operador % que acabamos de ver. También podemos mezclar este formato con el número o nombre de posición del parámetro.

# saca "Valor formateado      12.35"
print ("Valor formateado {:10.2f}".format(12.34567))   

# saca "pi = 3.1416 y e = 2.7183"
print ("pi = {pi:6.4f} y e = {e:6.4f}".format(pi=math.pi, e=math.e))

vemos que el formato entre llaves es {nada, posicion o nombre : formato}. En realidad el formato admite más cosas, pero no nos metemos en ello ahora.

Si la variable es una clase con atributos, un dict, un array, etc, podemos hacer referencia en el formato a uno de sus elementos/atributos de la siguiente forma

theDict = {'one':1, 'two':2, 'three':3}

# Sin poner nada
print ("el dict['two'] es {[two]}".format(theDict))

# Con la posición del argumento
print ("el dict['two'] es {0[two]}".format(theDict))

# con el nombre del argumento
print ("el dict['two'] es {someName[two]}".format(someName=theDict))

f-string[edit]

A partir de python 3.6 tenemos f-string o string literal format (como quiera que se traduzca eso). Simplemente es un string precedido por una f y en él podemos poner variables entre llaves {}, que serán reemplazados por los valores de las variables. Unos ejemplos simples

theDict = {'one':1, 'two':2, 'three':3}
valor=12.3456

print (f"El valor es {valor}")
print ( f"El valor es {valor:10.2f}")
print ( f"el dict[two] es {theDict['two']}")

Vemos que simplemente hay que poner el nombre de la variable entre llaves {} y que podemos separar, como hasta ahora, con : el formato para los números e incluso podemos poner elementos de un dict, o de un array.

Todo junto: Una tabla con las columnas alineadas[edit]

Vamos a hacer un ejemplo con todo esto. Imagina que quieres sacar por pantalla una tabla con cuatro columnas. Las tres primeras de texto y la última con números. La primera columna alineada a la izquierda, la segunda al centro, la tercera a la derecha y los números alienados a la derecha por el punto decimal.

El código para hacer esto se parece al siguiente

# Los textos para la cabecera de la tabla
cabecera = ('texto izquierda','texto derecha','texto centrado','numero')

# Los valores. Declaramos y vamos rellenando con un bucle
valores = []

for valor in range(10):
    valores.append((f'texto {valor}',f'texto {valor}',f'texto {valor}', 53/(valor+1)))

# Sacamos la cabecera, 20 caracteres cada columna mas un | de separación
print (f'{cabecera[0]:<20} |',f'{cabecera[1]:>20} |',f'{cabecera[2]:^20} |',f'{cabecera[3]:>20}')

# Sacamos los valores, 20 caracteres cada columna mas un | de separación
for valor in valores:
    print (f'{valor[0]:<20} |',f'{valor[1]:>20} |',f'{valor[2]:^20} |',f'{valor[3]:20.4f}')

Lo explicamos un poco, aunque casi con los comentarios vale. Las primeras líneas son para obtener datos que pintar. Ponemos texto estilo texto 1, texto 2, etc. Para la columna de números hacemos una cuenta cualquiera para que no salga siempre el mismo número 53/(valor+1). Lo del +1 es para evitar la división por cero y lo del 53 es por coger un número primo y que salgan decimales.

De todas las opciones para formato, hemos elegido f-string. Para conseguir que ocupen la cantidad de espacios que queremos usamos los siguientes formatos:

  • {:<20} 20 caracteres, alineando a la izquierda. Se añaden espacios detrás hasta completar 20. Lo de "a la izquierda" lo indica el carácter <
  • {:>20} 20 caracteres, alineando a la derecha. Se añaden espacios delante hasta completar 20. Lo de "a la derecha" lo indica el carácter >
  • {:^20} 20 caracteres, alineando en el centro. Se añaden espacios por delante y por detrás hasta completar 20, pero de forma que nuestro texto quede centrado. Lo de "centrado" lo indica el carácter ^
  • {:20.4f}. Para el número decimos que queremos en total 20 cifras/huecos con 4 decimales.

El resultado de ejecutar este código dará una tabla como la siguiente

texto izquierda      |        texto derecha |    texto centrado    |               numero
texto 0              |              texto 0 |       texto 0        |              53.0000
texto 1              |              texto 1 |       texto 1        |              26.5000
texto 2              |              texto 2 |       texto 2        |              17.6667
texto 3              |              texto 3 |       texto 3        |              13.2500
texto 4              |              texto 4 |       texto 4        |              10.6000
texto 5              |              texto 5 |       texto 5        |               8.8333
texto 6              |              texto 6 |       texto 6        |               7.5714
texto 7              |              texto 7 |       texto 7        |               6.6250
texto 8              |              texto 8 |       texto 8        |               5.8889
texto 9              |              texto 9 |       texto 9        |               5.3000

Enlaces[edit]

  • Todos los métodos de string en la documentación oficial. Ahí puedes ver también todos los símbolos que se pueden poner en los formatos.