Curso de introducción a la programación con Python¶
Autor: Luis Fernando Apáez Álvarez
-Curso PyM-
Clase 4: Cadenas de Texto
Fecha: 11 de Agosto del 2022
Autor: Luis Fernando Apáez Álvarez
-Curso PyM-
Clase 4: Cadenas de Texto
Fecha: 11 de Agosto del 2022
En esta clase trabajaremos con algunas propiedades adicionales de las cadenas de texto, pero antes requerimos de ver brevemente el tema de Listas en Python, para ello:
De manera intuitiva, podemos considerar el concepto de lista como una enumeración. Por ejemplo, cuando vamos al súper podemos crear una lista de las cosas que queremos comprar, digamos
De tal manera, la lista anterior se puede nombrar como lista del súper y sus elementos son productos, en este caso, alimenticios. Decimos, de lo anterior, que el elemento Refrescos de la lista ocupa la primer posición, que dentro de Python se le asigna el índice o lugar 0; las Botanas ocupan el segundo lugar de nuestra lista lista del súper, que Python le asigna el índice 0, y así sucesivamente. De manera totalmente análoga podemos definir una lista de números, digamos
lista de números: 1, 2, 3 ,4
donde, de nuevo, el primer elemento de la lista, el cual es el 1, Python le asigna la posición o índice 0 referente a dicha lista; también, podemos decir que el número 4 ocupa la posición número 3 de la lista.
Ahora bien, si queremos declarar una lista en Python ocuparemos corchetes, donde dentro de estos corchetes irán los elementos de la lista en cuestión separados por comas. Las listas en Python admiten datos de diferentes tipos, esto es, podemos definir una lista cuyos elementos sean de la clase int, u otros de la clase float, asimismo, podemos declarar que algunos de sus elementos sean cadenas de texto. Por ejemplo:
# declaramos nuestra lista del super
# los elementos de esta lista son solo cadenas de texto:
lista_super = ["Refrescos", "Botanas", "Leche"]
# vemos nuestra lista
print(lista_super)
# vemos de que tipo es la variable "lista_super"
print(type(lista_super))
['Refrescos', 'Botanas', 'Leche'] <class 'list'>
Podemos declarar también listas numéricas
# lista numerica
nums = [1, 2, 3, 4]
print(nums)
print(type(nums))
[1, 2, 3, 4] <class 'list'>
Además, podemos acceder a cada uno de los elementos de las listas utilizando los índices que Python asigna. Por ejemplo, de la lista nums podemos acceder al primer elemento, el cual tiene asociado el índice 0, como sigue
# Accedemos al primer elemento de la la lista nums
# para ello colocamos el nombre de la lista
# seguido de dos corchetes, donde dentro de estos
# corchetes colocamos el índice del elemento
# al cual queremos acceder
print(nums[0])
1
# o alternativamente:
print(f"El primer elemento de la lista nums es: {nums[0]}, con índice {0}")
print("-" * 60)
print(f"El primer elemento de la lista nums es: {nums[1]}, con índice {1}")
print("-" * 60)
print(f"El primer elemento de la lista nums es: {nums[2]}, con índice {2}")
print("-" * 60)
print(f"El primer elemento de la lista nums es: {nums[3]}, con índice {3}")
El primer elemento de la lista nums es: 1, con índice 0 ------------------------------------------------------------ El primer elemento de la lista nums es: 2, con índice 1 ------------------------------------------------------------ El primer elemento de la lista nums es: 3, con índice 2 ------------------------------------------------------------ El primer elemento de la lista nums es: 4, con índice 3
# o podemos ocupar tambien un bucle for:
for i in range(4):
print(f"El primer elemento de la lista nums es: {nums[i]}, con índice {i}")
print("-" * 60)
El primer elemento de la lista nums es: 1, con índice 0 ------------------------------------------------------------ El primer elemento de la lista nums es: 2, con índice 1 ------------------------------------------------------------ El primer elemento de la lista nums es: 3, con índice 2 ------------------------------------------------------------ El primer elemento de la lista nums es: 4, con índice 3 ------------------------------------------------------------
Pero vemos que el mensaje es erróneo pues, por ejemplo, en la segunda iteración del for diche El primer elemento cuando en realidad debería decir El segundo elemento, y así sucesivamente. Para solucionar dicho problema haremos uso de una lista auxiliar:
# Definimos una lista auxiliar
au = ["primer", "segundo", "tercero", "cuarto"]
for i in range(4):
print(f"El {au[i]} elemento de la lista nums es: {nums[i]}, con índice {i}")
print("-" * 60)
El primer elemento de la lista nums es: 1, con índice 0 ------------------------------------------------------------ El segundo elemento de la lista nums es: 2, con índice 1 ------------------------------------------------------------ El tercero elemento de la lista nums es: 3, con índice 2 ------------------------------------------------------------ El cuarto elemento de la lista nums es: 4, con índice 3 ------------------------------------------------------------
También podemos realizar lo mismo para la lista lista_super
# cambiamos a range(3) pues dicha lista solo tiene 3 elementos
for i in range(3):
print(f"El {au[i]} elemento de la lista súper es: {lista_super[i]}, con índice {i}")
print("-" * 70)
El primer elemento de la lista súper es: Refrescos, con índice 0 ---------------------------------------------------------------------- El segundo elemento de la lista súper es: Botanas, con índice 1 ---------------------------------------------------------------------- El tercero elemento de la lista súper es: Leche, con índice 2 ----------------------------------------------------------------------
Recordemos de clases pasadas que podíamos realizar iteraciones, por ejemplo, utilizando el bucle for, donde era necesario utilizar la función range(). De hecho, podemos ocupar dicha función fuera del contexto del bucle for, por ejemplo podemos definir una variable que almacene los valores generados por el range(5) como sigue
# range(3): 0,1,2
x = range(3)
# imprimimos la variable x
print(x)
print(type(x))
range(0, 3) <class 'range'>
vemos que lo generado pertenece a la clase range. Como sabemos, intuitivamente, range(3) genera los números 0, 1, 2, pero con la función print() no pudimos observar dichos números respecto a la variable x. Lo que hace la función range(3) es, justamente, generar dichos números, pero para poder acceder a ellos requeriremos utilizar la misma sintaxis que utilizabamos entorno a las listas, esto es, si queremos ver el primer valor del range(3) almacenado en la variable x escribimos
# primer elemento de la variable x (es decir
# primer elemento del range(3)):
print(x[0])
print("-" * 10)
# segundo elemento de la variable x
print(x[1])
print("-" * 10)
# tercer elemento de la variable x
print(x[2])
0 ---------- 1 ---------- 2
# o alternativamente
for i in x:
print("-" * 10)
print(x[i])
---------- 0 ---------- 1 ---------- 2
donde en vez de utilizar como estamos acostumbrados i in range(. . .) ocupamos i in x pues intuitivamente estamos declarando la misma instrucción pues la variable x es un rango.
Lo que ocurre detrás de ello puede ser representado mediante el siguiente diagrama
De manera general, también podremos iterar sobre listas y no sólo sobre rangos. La idea básica de ello radica en el concepto de recorrer. Cuando declaramos la instrucción for i in range(3) lo que está pasando es que la variable i del bucle está recorriendo cada valor generado por el rango, o en otras palabras, cada elemento del rango. Siguiendo este contexto, entonces también podemos iterar sobre listas, considerando que la variable del bucle for, digamos la i, recorrerá cada elemento de la lista. Por ejemplo, consideremos de nuevo la lista:
lista_super = ["Refrescos", "Botanas", "Leche"]
print(lista_super)
['Refrescos', 'Botanas', 'Leche']
Luego, podemos entonces iterar sobre los elementos de esta lista y, por ejemplo, obtener cada valor de ésta de manera individual:
for i in lista_super:
print(i)
Refrescos Botanas Leche
de donde:
la i está recorriendo cada elemento correspondiente a la lista lista_super.
Podemos considerar a las cadenas de texto como una agrupación de caracteres individuales. Por ejemplo, podemos considerar a la cadena "Hola Mundo" como la agrupación de los caracteres:
"H", "o", "l", "a", " ", "M", "u", "n", "d", "o",en este sentido, podemos decir que dicha cadena tiene como elementos a cada una de las cadenas de texto individuales anteriores. Gracias a lo anterior, podemos decir que las cadenas de texto contienen elementos, los cuales son los caracteres individuales que la conforman. Así, entonces también podemos iterar sobre cadenas, por ejemplo
# declaramos una variable de tipo string
msj = "Hola Mundo"
for i in msj:
print(i)
H o l a M u n d o
# o alternativamente
for i in msj:
print(i, end=" ")
H o l a M u n d o
de donde:
Luego, así como podíamos acceder a los elementos de un rango o los elementos de una lista mediante índices, también podemos hacerlo de la misma manera para las cadenas de texto:
msj = "Hola"
# Primer letra de la cadena msj
print(msj[0])
print("-" * 20)
# Segunda letra de la cadena msj
print(msj[1])
print("-" * 20)
# Tercer letra de la cadena msj
print(msj[2])
print("-" * 20)
# Cuarta letra de la cadena msj
print(msj[3])
H -------------------- o -------------------- l -------------------- a
# o alternativamente
for i in range(4):
print(msj[i])
H o l a
De tal manera, podemos iterar cadenas de manera directa:
for i in msj:
print(i)
o también hacerlo auxiliándonos del manejo de los índices:
# range(4): 0,1,2,3
for i in range(4):
print(msj[i])
Lo dicho anteriormente también se puede aplicar a listas.
Finalmente, podemos ver un ejemplo en el cual iteramos sobre una cadena y una lista al mismo tiempo
# Cadena de texto
msj = "Hola"
# Lista
msj_lista = ["Letra H", "Letra o", "Letra l", "Letra a"]
# iteracion a base de indices
for i in range(4):
print(f"{msj[i]} --> {msj_lista[i]}")
H --> Letra H o --> Letra o l --> Letra l a --> Letra a
Por otro lado, podemos conocer cuántos caracteres tiene un cadena de texto. Por ejemplo, si consideramos la cadena "Hola", tenemos que, en este caso, dicha cadena tiene en total 4 letras, por lo cual diremos que la longitud de "Hola" es de 4; también, podemos ver que la longitud de la cadena "Hola Mundo" es de 10, pues en este caso el espacio en blanco cuenta como un caracter.
En Python podemos utilizar la función len() la cual, en particular, nos dirá la longitud de una cadena de texto. Veamos:
msj = "Hola"
msj2 = "Hola Mundo"
print(f"Longitud de la cadena msj: {len(msj)}\nLongitud de la \
cadena msj2: {len(msj2)}")
Longitud de la cadena msj: 4 Longitud de la cadena msj2: 10
Asimismos, podemos ocupar esta función para conocer la longitud de listas:
# declaramos una lista de solo numeros
lista_nums = [1, 2, 3, 4, 5, 6, 7]
# podemos declarar tambien listas con elementos
# de distintos tipos de datos
lista_mix = ["Hola", True, 1, 3.1416, "Hola x2"]
print(f"Longitud de la lista lista_nums: {len(lista_nums)} \
\nLongitud de la lista lista_mix: {len(lista_mix)}")
Longitud de la lista lista_nums: 7 Longitud de la lista lista_mix: 5
# Asimismo, podemos obtener la longitud de un rango
# range(3): 0, 1, 2
print(len(range(3)))
3
Con base en ello, podemos recorrer, por ejemplo, los elementos de una cadena por medio de índices de una manera más sencilla:
msj = "Hola Mundo"
for i in range(len(msj)):
print(msj[i], end=" ")
H o l a M u n d o
Pues antes era necesario conocer previamente la longitud de la cadena para poder iterar, mediante índices, sobre ella. Ahora, el cálculo de la longitud de la cadena es automático mediante la función len().
# Requerimos, previamente, conocer la longitud
# de la cadena para colocar ese 10 dentro del
# range()
for i in range(10):
print(msj[i])
en cambio:
# No requerimos, previamente, conocer la longitud
# de la cadena pues la funcion len() realiza dicho
# calculo en automatico
for i in range(len(msj)):
print(msj[i])
Dada una cadena de texto podemos extraer de ella subcadenas. Por ejemplo, de la cadena "Hola Mundo", podemos extraer sólo el mensaje "Mundo". Para ello, lo primero que haremos será utilizar los índices de la cadena. Notemos que
msj = "Hola Mundo"
for i in range(len(msj)):
print(f"{msj[i]}: índice {i}")
H: índice 0 o: índice 1 l: índice 2 a: índice 3 : índice 4 M: índice 5 u: índice 6 n: índice 7 d: índice 8 o: índice 9
Así, vemos que la subcadena de nuestro interés ("Mundo") abarca del índice 5 al índice 9. De tal manera, para extraer la subcadena de interés, escribimos msj[5:10] que indica que queremos la subcadena a partir del caracter de índice 5 hasta el caracter de índice 9 (10-1). Esto es:
# Subcadena "Mundo"
print(msj[5:10])
Mundo
Del mismo modo, podemos obtener la subcadena "Hola":
# Subcadena "Hola"
# del caracter de indice 0 al
# caracter de indice 3 (4-1)
print(msj[0:4])
Hola
También, podemos obtener una cadena intermedia, digamos
print(msj[2:7])
la Mu
También, podemos contar cuántas veces aparece un caracter dentro de una cadena de texto, para lo cual utilizaremos el método count() sobre dicha cadena, donde el parámetro será el caracter del cual queremos contar el número de apariciones en la cadena dada. Por ejemplo
# Cadena de texto
msj = "Hola Mundo"
# contemos cuantas "o" tenemos en dicha cadena
print(msj.count("o"))
2
Nota: Recordemos que las cadenas de texto son de la clase str, de la clase string. Y como vimos en la clase anterior, dentro de las clases podemos definir métodos. Por ejemplo, en la clase Persona definimos el método hablar(), y para utilizarlo o mandarlo a invocar en un objeto en particular, digamos el objeto persona1, escribiamos persona1.hablar(). Siguiendo esta idea, es por ello que nosotros escribimos msj.count(), donde count() es un método de la clase str y la variable msj es un objeto ésta.
Continuando, lo anterior nos permite contar, digamos, el número total de espacios en blanco de una cadena:
# cadena de texto
msj2 = "Hola Mundo, cómo andas"
# contamos el numero total de
# espacios en blanco
print(msj2.count(" "))
3
Podremos además reemplazar subcadenas (o caracteres) dentro de nuestras cadenas de texto. Por ejemplo, en vez de considerar la cadena "Hola Mundo", podemos reemplazar la subcadena "Hola" por la cadena "Adios". Para ello utilizaremos el método replace( , ), donde en el primer parámetro colocaremos la subcadena (o caracteres) que queremos reemplazar en una cadena dada, y en el segundo parámetro la cadena de reemplazo. En nuestro ejemplo escribiríamos algo como replace("Hola", "Adios"), más especificamente:
# cadena de texto
msj = "Hola Mundo"
# Antes del reemplazo:
print(msj)
print("-" * 20)
# reemplazaremos "Hola" por "Adios"
# en la cadena anterior
print(msj.replace("Hola", "Adios"))
Hola Mundo -------------------- Adios Mundo
El reemplazo hecho se hizo de manera temporal, de este modo, si volvemos a imprimir la cadena msj vemos que
print(msj)
Hola Mundo
continúa con el mensaje original. Si es de nuestro interés cambiar el mensaje original, lo que haremos será efectuar una reasignación:
# cadena de texto
msj = "Hola Mundo"
# Antes del reemplazo:
print(msj)
print("-" * 20)
# reemplazaremos "Hola" por "Adios"
# en la cadena anterior, realizando una
# reasignacion
msj = msj.replace("Hola", "Adios")
# Despues del reemplazo:
print(msj)
Hola Mundo -------------------- Adios Mundo
Otro ejemplo, podemos cambiar caracteres individuales en vez de subcadenas:
# cadena de texto
msj = "Hola Mundo"
# Antes del reemplazo:
print(msj)
print("-" * 20)
# reemplazaremos las "o" por el "0"
# en la cadena anterior, realizando una
# reasignacion
msj = msj.replace("o", "0")
# Despues del reemplazo:
print(msj)
Hola Mundo -------------------- H0la Mund0
# O tambien:
# cadena de texto
msj = "Hola Mundo"
# Antes del reemplazo:
print(msj)
print("-" * 20)
# reemplazaremos las "o" por el "0"
# en la cadena anterior, realizando una
# reasignacion
msj = msj.replace("o", "1234")
# Despues del reemplazo:
print(msj)
Hola Mundo -------------------- H1234la Mund1234
Podemos convertir de mayúsculas a minúsculas y viceversa:
upper(): es el método para convertir todas las letras minúsculas de una cadena a mayúsculasmsj1 = "letras minúsculas"
print(msj1.upper())
LETRAS MINÚSCULAS
lower(): es el método para convertir todas las letras mayúsculas de una cadena a minúsculasmsj2 = "Este Texto Contiene Letras MaYúScUlaS (o Tal VeZ No)"
print(msj2.lower())
este texto contiene letras mayúsculas (o tal vez no)
Mediante este método podemos dividir cadenas de texto palabra por palabra, donde en automático se creará una lista cuyos elementos son, justamente, las palabras obtenidas de la cadena de texto resultado de la fragmentación. Por ejemplo, de la cadena "Hola Mundo", por medio del método split() conseguiremos la lista ["Hola" , "Mundo"]. El método split() requiere que especifiquemos el separador de palabras para la fragmentación a realizar. Por ejemplo, el separador para el caso de "Hola Mundo" será el espacio en blanco " ", el cual permite poder considerar de manera separada las cadena "Hola" y "Mundo". Así, escribiremos entonces, intuitivamente, split(" ").
Otro ejemplo, consideremos la cadena "Hola,mundo,qué hace,:D". Podemos separar cada una de las palabras de dicha cadena tomando como referencia las comas, esto es, separaremos cada palabra de la cadena utilizando como separador ",". Con lo cual obtendremos la lista de palabras ['Hola', 'mundo', 'qué hace', ':D']
Veamos los ejemplos anteriores en acción
# Cadena 1
msj1 = "Hola Mundo"
# Separaremos por espacios en blanco
# obtendremos una lista de las palabras separadas
print(msj1.split(" "))
['Hola', 'Mundo']
# Cadena 2
msj2 = "Hola,mundo,qué hace,:D"
# Separaremos por comas
print(msj2.split(","))
['Hola', 'mundo', 'qué hace', ':D']
# Podriamos almacenar dichas listas en algunas variables
# para utilizarlas despues
palabras_msj1 = msj1.split(" ")
palabras_msj2 = msj2.split(",")
print(palabras_msj1)
print(palabras_msj2)
print("-" * 30)
# Y como son listas, podemos acceder
# o iterar sobre ellas
for i in palabras_msj1:
print(i)
print("-" * 30)
for i in palabras_msj2:
print(i, end=" ")
print()
print("-" * 30)
# accedemos a un elemento en particular
# de la lista palabras_msj1
print(f"Es la primer palabra de la cadena msj: {palabras_msj1[0]}")
['Hola', 'Mundo'] ['Hola', 'mundo', 'qué hace', ':D'] ------------------------------ Hola Mundo ------------------------------ Hola mundo qué hace :D ------------------------------ Es la primer palabra de la cadena msj: Hola
Dentro de las cadenas de texto podemos "sumar" una, dos ó más de ellas, lo cual se conoce como concatenación. En realidad no estaremos sumando cadenas de texto pero si ocuparemos el operador +; lo que se estará efectuando es más bien una unión de cadenas. Por ejemplo
# Cadenas
cad1 = "Hola"
cad2 = " "
cad3 = "Mundo"
# Concatenacion de las tres cadenas
print(cad1 + cad2 + cad3)
print("-" * 20)
# O tambien de manera directa
# opcion 1
print(cad1 + cad2 + cad3 + "," + "qué hace," + ":D")
print("-" * 20)
# opcion 2: agregamos algunos espacios en blanco
print(cad1 + cad2 + cad3 + " , " + "qué hace, " + ":D")
Hola Mundo -------------------- Hola Mundo,qué hace,:D -------------------- Hola Mundo , qué hace, :D
De esta manera, considerando la lista que nos produce el método split(), podemos recuperar, a partir de ella, la cadena original. Por ejemplo
# Fragmentacion:
# Cadena
msj = "Hola mundo, qué hace :D"
# Separaremos por los espacios en blanco
# y guardamos la lista en una variable
palabras_msj = msj.split(" ")
print(palabras_msj)
['Hola', 'mundo,', 'qué', 'hace', ':D']
Procedemos a recuperar la cadena original concatenando las palabras individuales de la lista palabras_msj
# Mensaje original
# La lista palabras_msj tiene 5 elementos
msj2 = palabras_msj[0] + palabras_msj[1] + palabras_msj[2] + \
palabras_msj[3] + palabras_msj[4]
print(msj2)
Holamundo,quéhace:D
pero recordemos que la fragmentación se hizo con el separador " ", por lo que los elementos de la lista resultante no tendrán espacios en blanco. Arreglamos lo anterior agregando espacios en blanco
# Mensaje original
# La lista palabras_msj tiene 5 elementos
msj2 = palabras_msj[0] + " " + palabras_msj[1] + " " + palabras_msj[2] + " " + \
palabras_msj[3] + " " + palabras_msj[4]
print(msj2)
Hola mundo, qué hace :D
# Alternativamente:
# declaramos una cadena vacia que se le ira <sumando>
# las palabras de la lista palabras_msj
msj3 = ""
# implementamos un bucle for
for i in range(len(palabras_msj)):
# msj3 = msj3 + palabras_msj[i]
msj3 += palabras_msj[i]
print(msj3)
Holamundo,quéhace:D
# Mas aun, podemos agregar los espacios en blanco
# declaramos una cadena vacia que se le ira <sumando>
# las palabras de la lista palabras_msj
msj4 = ""
# implementamos un bucle for
for i in range(len(palabras_msj)):
# msj3 = msj3 + palabras_msj[i] + " "
msj4 += palabras_msj[i] + " "
print(msj4)
Hola mundo, qué hace :D
donde el proceso de lo anterior lo podemos visualizar paso a paso:
msj4 = ""
for i in range(len(palabras_msj)):
msj4 += palabras_msj[i] + " "
print(f"Hasta ahora la cadena msj4 es: {msj4}")
print("-" * 30)
print(msj4)
Hasta ahora la cadena msj4 es: Hola Hasta ahora la cadena msj4 es: Hola mundo, Hasta ahora la cadena msj4 es: Hola mundo, qué Hasta ahora la cadena msj4 es: Hola mundo, qué hace Hasta ahora la cadena msj4 es: Hola mundo, qué hace :D ------------------------------ Hola mundo, qué hace :D