cadenas

Equivalente en Java: —->

Las cadenas son un tipo de dato que contienen literales. Podrían ser constantes y variables. Son constantes cuando su contenido no va a variar a lo largo de la ejecución del código. Las variables contiene literales que pueden variar mientras se ejecuta dicho código.

Las cadenas constantes se suelen definir en el código utilizando mayúsculas. Las variables se definen siempre en minúsculas.

NOMBRE="Me llamo Eduardo"
edad="Tengo 60 años"
print(NOMBRE+". "+edad+".")

Si lo ejecutamos:

Me llamo Eduardo. Tengo 60 años.

Existen muchos métodos aplicables tanto a las variables como a las constantes, que nos permiten obtener determinados datos a partir del dato original.

nombre_dato.upper ( ) Nos facilitará el mismo literal, cuyos caracteres han sido pasados todos a mayúsculas.

nombre_dato.lower ( ) Nos faciiltará el mismo literal, cuyos caracteres han sido pasados todos a minúsculas.

NOMBRE="Me llamo Eduardo"
edad="Tengo 60 años"
nombre_mayuscula=NOMBRE.upper()
edad=edad.lower()
print(nombre_mayuscula+", "+edad+".")

Al ejecutar:

ME LLAMO EDUARDO, tengo 60 años.

nombre_cadema.center (longitud, caracter_relleno ) Obtenemos una cadena de la longitud que se indique. La cadena se centrará y se rellenará a izquierda y derecha con el carácter indicado. Si no se indica ningún carácter, se rellenará con espacios en blanco.

mi_cadena="Madrid"
su_cadena=mi_cadena.center(20)
print("["+su_cadena+"]")

tu_cadena=mi_cadena.center(20,"*")
print("["+tu_cadena+"]")

Ejecutamos:

[       Madrid       ]
[*******Madrid*******]

Cadenas con formato. También llamadas cadenas «f». Nos van a permitir unir en una sola cadena variables que contengan datos numéricos con variables de tipo cadena.

cadena_1="Nací en Madrid."
edad=25
otracadena=f"{cadena_1} Tengo {edad} años."
print(otracadena) 

Nací en Madrid. Tengo 25 años.

Este tipo de cadena, también nos van a permitir formatear la salida de datos numéricos. Estos datos numéricos podrán ser justificados a la izquierda, derecha o centrados. Según el número de decimales que se indiquen, el datos podrá ser redondeado.

En el siguiente caso se indica que se presente el dato con dos decimales y se redondea al decimal superior porque el tercer decimal es igual o superior a 5. Los espacios sobrantes, se indica que se rellenen con *

mi_numero = 12.3456
centrado = f"{mi_numero:*^14.2f}"
izquierda= f"{mi_numero:*>14.2f}"
derecha= f"{mi_numero:*<14.2f}"

print(centrado)
print(izquierda)
print(derecha) 

****12.35*****
*********12.35
12.35*********

También podríamos formatear la salida de datos numéricos tipo entero simplemente sustituyendo la f del final de la instrucción con una d

mi_numero = 123456
centrado = f"{mi_numero:#^14d}"
izquierda= f"{mi_numero:0>14d}"
derecha= f"{mi_numero:*<14d}"

print(centrado)
print(izquierda)
print(derecha)

####123456####
00000000123456
123456********

Caracteres especiales. Dentro de una cadena, se pueden añadir ciertos caracteres especiales que cumplen una determinada función. Todos ellos tienen en común que van precedidos de la contrabarra ‘\’. Los más destacados son:

• \n Equivale a un salto de línea.
• \t Inserta un tabulador entra la palabra anterior y la siguiente.
• \» o \’ Incluye el carácter comilla doble (o simple) en una cadena.
• \\ Incluye una barra invertida dentro de una cadena.

print("Esta cadena \t está tabulada.\nEsta\t \"también\".")

Esta cadena      está tabulada.
Esta     "también".

Cadena dentro de otra. Existen dos métodos principalmente para comprobar si una cadena está incluida dentro de otra. El primero consiste en comprobarlo con la instrucción «if cadena in otracadena«.

cadena="Hola, me llamo Eduardo."
nombre="Eduardo"
if nombre in cadena:
    print("Mi nombre está en la cadena.")
else:
    print("Mi nombre no está en la cadena.")

Mi nombre está en la cadena.

La otra es utilizando el método cadena.find( ).  Con esta función podemos buscar una cadena dentro de otra. Nos da un entero que indica la posición en la cual comienza esa cadena. Si no encuentra la cadena solicitada, da como resultado -1

micadena="Hola. Me llamo Eduardo. Tengo 35 años."
encontrada=micadena.find("Eduardo")
print (f"La cadena Eduardo comienza en la posición: {encontrada}")
noencontrada=micadena.find("Pedro")
print (noencontrada)

La cadena Eduardo comienza en la posición: 15
-1

A la función .find se le puede añadir un segundo parámetro que indique a partir de qué posición queremos empezar a buscar la palabra que buscamos. En el siguiente código buscamos una cadena dentro de un texto largo. Cada vez que encuentre la cadena buscada, imprime su posición y pasa a buscar a partir de esa posición (añadiendo +1). Acaba cuando ya no encuentra la palabra y da como resultado -1:

cadena_larga="""Esta cadena, es solo una
cadena de prueba, para ver cuántas veces
está la palabra cadena, incluida en 
esta cadena."""

palabra_encontrada=cadena_larga.find("cadena")
while palabra_encontrada !=-1:  ##(-1 =no se encontró)
    print(palabra_encontrada)
    palabra_encontrada=cadena_larga.find("cadena",palabra_encontrada+1)

5
25
82
108

               Debemos tener en cuenta que el primer carácter de la cadena se corresponde con la posición cero, y que después de cada línea está incluido (aunque no se ve) el carácter especial   \n. Si se sustituye «cadena» por «\n» en las dos sentencias find del código anterior, nos aparecerán todas las posiciones donde aparece el salto de línea. Al ejecutarlo así nos dará:

24
65
102

Unión de cadenas. Podemos unir dos o más cadenas, simplemente utilizando el signo de «+»

cadena_1="Cadena izquierda."
cadena_2="------------"
cadena_3="Cadena derecha."
cadena_4=cadena_1+cadena_2+cadena_3
print(cadena_4)

Cadena izquierda.------------Cadena derecha.

cadena.replace ( ) Con este método podemos reemplazar una cadena por otra.

mi_cadena="Hola. Me llamo Eduardo. Tengo 35 años."
reemplazada=mi_cadena.replace("35","40")
print (reemplazada)

Hola. Me llamo Eduardo. Tengo 40 años.

El método reemplaza todas las apariciones del primer argumento por lo indicado en el segundo argumento. Si el segundo argumento es una cadena vacía, lo que sucedería es que se eliminaría cualquier aparición del primer argumento.
Por otro lado, si ponemos un tercer argumento, los reemplazos quedan limitados a la cantidad indicada en ese tercer argumento: 

mi_cadena="Hooola. Soy una cadenaaaa."
nueva_cadena=mi_cadena.replace("a","A")
print(nueva_cadena)
otra_cadena=mi_cadena.replace("a","")
print(otra_cadena)
otra_mas=mi_cadena.replace("o","",2)
print(otra_mas)

HooolA. Soy unA cAdenAAAA.
Hoool. Soy un cden.
Hola. Soy una cadenaaaa.

len (cadena) . Con este método podemos obtener la longitud en caracteres de una cadena.

mi_cadena="La playa estaba desierta. Hacía viento."
longitud=len(mi_cadena)
print(longitud)

39

Las cadenas son listas. Podemos acceder a segmentos de una cadena, de la misma manera que se puede acceder a los elementos de una lista. Esto es así porque una cadena es una lista de caracteres.

mi_cadena="El gobierno central acaba de convocar elecciones."
cadena_1=mi_cadena[:5]
cadena_2=mi_cadena[6:22]
cadena_3=mi_cadena[24:-5]
cadena_4=mi_cadena[-5:]
print(cadena_1)
print(cadena_2)
print(cadena_3)
print(cadena_4)

El go
ierno central ac
a de convocar elecci
ones.

               El número a la izquierda de los dos puntos indica cuando se empieza a cortar (el número 0 es el primer carácter). El número a la derecha indica cuando se finaliza, teniendo en cuenta que finaliza en el elemento anterior al que indica el número. Si no se indica finalización (como en cadena_4), se llega hasta el final.

               Por otro lado, no podemos modificar una cadena con métodos de listas (del, append o insert). Para poder modificar una cadena, debemos de servirnos de otros métodos, generalmente basados en crear una nueva cadena a partir de otra u otras.

list (cadena) . Podemos obtener una lista con todos los caracteres contenidos en una cadena.

mi_cadena="Hoy está lloviendo."
lista_caracteres=list(mi_cadena)
print(lista_caracteres)

['H', 'o', 'y', ' ', 'e', 's', 't', 'á', ' ', 'l', 'l', 'o', 'v', 'i', 'e', 'n', 'd', 'o', '.']

cadena.count (subcadena). Este método permite contar las veces que aparece una determinada cadena dentro de otra.

mi_cadena="Hola, soy una cadena, solo una. Pero mejor una que ninguna."
contador=mi_cadena.count("una")
print(f"La palabra \"una\" aparece {contador} veces.")

La palabra "una" aparece 4 veces.

Comparar cadenas. Podemos comparar si una cadena es igual a otra.

cadena_1="Hola."
cadena_2="Hola."
if cadena_1==cadena_2:
    print("Las dos cadenas son iguales.")
else:
    print("Las dos cadenas son diferentes.")

Las dos cadenas son iguales.