6.

Cadenas y estructuras de datos

6.1. Cadenas de texto

Una cadena de texto es un conjunto de caracteres (letras, números, símbolos de puntuación, etc.). Ya
conocemos las ideas básicas:

Indicamos su valor entre comillas, ya sean simples o dobles:

nombre = 'Nacho'
asignatura = "Programación"

y, opcionalmente, podemos indicar el nombre del tipo de datos (“str”, abreviatura de “string”):

nombre : str = 'Nacho'

asignatura : str = "Programación"

El hecho de poder emplear tanto las comillas simples como las dobles hace que sea fácil escribir textos
que contengan comillas:

frase1 = 'Nacho dijo "hola"'

frase2 ="Peter's house"

Como también hemos visto, podemos leer textos que introduzca el usuario con “input”:

nombre = input("Dime tu nombre")

Y podemos “concatenar” (formar dos cadenas a partir de una) con el símbolo de la suma:

nombre = input("Dime tu nombre")

saludo = "Hola"
respuesta = saludo + ", " + nombre
print(respuesta)

Pero también podemos hacer otras muchas cosas. Por ejemplo, podemos obtener letras de ese texto,
indicando su posición entre corchetes (comenzando por cero), así:

nombre = input("Dime tu nombre ")

inicial = nombre[0]
terceraLetra = nombre[2]

También es posible conocer la cantidad de letras que forma un texto con una función llamada “len”
(abreviatura de “length”, longitud):

nombre = input("Dime tu nombre ")

longitud = len(nombre)
ultimaLetra = nombre[ longitud-1 ]

Una forma alternativa de saber la última letra es mirando la posición -1. Una posición negativa (que es
algo que no permiten todos los lenguajes) indica que queremos contar desde el final:

nombre = input("Dime tu nombre ")

ultimaLetra = nombre[ -1 ]

También podemos hacer otras manipulaciones, como obtener la cadena convertida a mayúsculas o a
minúsculas, pero el formato no es el mismo que el que se emplea para saber la longitud. En vez de usar
una función a la que indicamos con qué cadena queremos trabajar, lo que haremos es añadir un punto
y un nombre de operación a la cadena (son lo que más adelante llamaremos “métodos”):

nombre = input("Dime tu nombre ")

mayusculas = [Link]()
minusculas = [Link]()

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 45

Hay otros muchos métodos relacionados con cadenas. Tres de ellos, cuyo uso es frecuente, son
“.find(subcadena)”, para buscar si contiene un cierto texto (da como resultado un número a partir de 0,
o bien -1 si no aparece), “replace(textoInicial, textoSustituto” para reemplazar un cierto texto por otro, y
“.strip()”, para eliminar los espacios iniciales y finales:

nombre = input("Dime tu nombre ")

print("Sin espacios iniciales ni finales se convierte en", [Link]())
print("Sin ningún espacio pasa a ser", [Link](" ",""))
print('Y si cambiamos las "a" por "o" obtenemos', [Link]("a","o"))
posicion_a = [Link]("a")
if posicion_a >= 0:
print('Tiene una letra "a" en la posición', posicion_a)
else:
print('No contiene ninguna letra "a"')

También es frecuente que nos interese obtener subcadenas (fragmentos de la cadena inicial), y eso se
puede conseguir indicando la posición inicial y la final entre corchetes y separadas por un símbolo de
“dos puntos” (cuidado: al igual que en los “range” que hemos usado en los “for”, la posición final no se
llega a alcanzar):

nombre = input("Dime tu nombre ")

print("Sus dos primeras letras son", nombre[0:2])
print("La segunda y la tercera son", nombre[1:3])

Y al igual que ocurría en los rangos de la orden “for”, también se puede indicar un tercer dato, que es el
incremento.

nombre = input("Dime tu nombre ")

print("De la cuarta letra a la segunda son", nombre[3:0:-1])

Y el primer dato y el segundo son opcionales, de modo que se pueden hacer construcciones como:

nombre = input("Dime tu nombre ")

print("Desde la segunda letra obtenemos:", nombre[1:])
print("Hasta la segunda letra obtenemos:", nombre[:2])
print("Y todo al revés obtenemos:", nombre[::-1])

Su resultado sería:

Dime tu nombre Nacho

Desde la segunda letra obtenemos: acho
Hasta la tercera letra obtenemos: Na
Y todo al revés obtenemos: ohcaN

Ejercicio propuesto 6.1.1: Pide al usuario el nombre del mes actual y muéstralo en mayúsculas.

Ejercicio propuesto 6.1.2: Pide al usuario el nombre del mes actual y escribe su inicial.

Ejercicio propuesto 6.1.3: Pide al usuario el nombre del mes actual y escríbelo al revés (de la última letra a la
primera).

Ejercicio propuesto 6.1.4: Pide al usuario el nombre del mes actual y escríbelo en minúsculas después de
cambiar todas las letras “e” por “a”.

Ejercicio propuesto 6.1.5: Pide al usuario el nombre del mes actual y responde su contiene o no el texto “bre”.

Ejercicio propuesto 6.1.6: Pide al usuario que escriba una palabra y respóndele si es palíndromo (se lee igual
de izquierda a derecha que de derecha a izquierda).

Ejercicio propuesto 6.1.7: Pide su nombre y su (primer) apellido al usuario, A partir de estos datos, deberá crear
una cadena que contenga el apellido, una coma, un espacio y el nombre, y deberá mostrarla en pantalla. Por
ejemplo, si el nombre es “Nacho” y el apellido es “Cabanes”, la cadena resultante será “Cabanes, Nacho”

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 46

Ejercicio propuesto 6.1.8: Crea una función que, a partir de una cadena que se le pase como parámetro,
devuelva esa cadena alternando letras mayúsculas y minúsculas (por ejemplo, a partir de “Nacho” se obtendría
“NaChO”). Pruébala en un programa.

Ejercicio propuesto 6.1.9: Pide su nombre al usuario y dile cuántas vocales contiene.

6.2. Listas
Cuando tengamos que manejar muchos datos distintos (por ejemplo, resultados de 40 competidores en
una prueba de atletismo), no será razonable usar muchas variables distintas. En lugar de eso,
emplearemos colecciones de datos, que permitan guardar todos ellos bajo un mismo nombre e indicar
de qué posición queremos obtener (o almacenar) el dato que nos interese en cada momento. Las más
frecuentes son las listas y los diccionarios, aunque estudiaremos también otras dos estructuras de datos
que se usan con menos frecuencia.

Una lista (en inglés, “list”) es una colección de datos, en la que se puede ir añadiendo nuevos datos, así
como obtener uno desde cualquier posición. La forma más habitual de añadir datos es con “.append()”,
que incluye un nuevo dato detrás de los existentes, y para obtener un dato usaremos corchetes (igual
que hacíamos para extraer letras de una cadena de texto):

numeros = [1, 2, 3, 4]
print("El primer número es", numeros[0])
[Link](5)
print("El último número es", numeros[-1])

Se puede insertar un dato en cualquier posición, no necesariamente al final, usando insert(posición,

valor):

numeros = [1, 2, 3, 4]
[Link](2, 10)
print("El último número es", numeros[-1])

Al igual que en las cadenas, podemos usar la función “len” para saber la cantidad de elementos:

numeros = [1, 2, 3, 4]
print("Cantidad de datos:", len(numeros))

Es muy frecuente querer recorrer toda la lista de principio a fin, y en ese caso podemos usar una orden
“for”, así:

numeros = [1, 2, 3, 4]
[Link](5)
[Link](2, 10)
for n in numeros:
print(n)

Este programa daría como resultado:

1
2
10
3
4
5

Eso sí, la orden “for” en ese formato sólo se puede utilizar para recorrer la lista de principio a fin, visitando
todos sus elementos. Si queremos recorrerla en orden inverso, o extraer sólo los datos que hay en un
rango de posiciones, nos podemos ayudar de un “range”:

numeros = [1, 2, 3, 4]
for pos in range(len(numeros)-1, -1, -1):
print(numeros[pos])

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 47

Que mostraría:

4
3
2
1

Y, al igual que en las cadenas, se puede indicar rangos dentro de los corchetes, pero esto tiene el
inconveniente de que crea una copia temporal de la lista, lo que puede resultar más lento, especialmente
si la lista tiene muchos elementos:

numeros = [10, 20, 30, 40]

for n in numeros[2:4]:
print(n)
print
for n in numeros[::-1]:
print(n)

Cuyo resultado sería:

30
40

40
30
20
10

También se puede eliminar un elemento (y obtenerlo) con “.pop(posición)”. Si no indicamos posición, se

eliminará de la última, como en este ejemplo:

numeros = [1, 2, 3, 4]
[Link](5)
[Link](2, 10)
for n in numeros:
print(n, end = " ")
print()

# Quitamos el último
ultimo = [Link]()
# Y el cuarto
cuarto = [Link](3)
print("El cuarto dato era", cuarto)
# Y mostramos como queda ahora
for n in numeros:
print(n, end = " ")
print()

Y el resultado de ese programa sería:

1 2 10 3 4 5
El cuarto dato era 3
1 2 10 4

Al contrario que en la mayoría de lenguajes, Python permite usar una única orden “print” para mostrar
todo el contenido de una lista de forma sencilla (pero, a cambio, aparecerán los datos separados por
comas y con los corchetes exteriores, por lo que no siempre será un formato que se pueda utilizar
directamente). Por ello, una versión alternativa del programa anterior podría ser ésta:

numeros = [1, 2, 3, 4]
[Link](5)
[Link](2, 10)
print(numeros)

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 48

# Quitamos el último
ultimo = [Link]()
# Y el cuarto
cuarto = [Link](3)
print("El cuarto dato era", cuarto)
# Y mostramos como queda ahora
print(numeros)

Cuyo resultado sería:

[1, 2, 10, 3, 4, 5]
El cuarto dato era 3
[1, 2, 10, 4]

Y podemos ordenar los datos con “.sort()”:

numeros = [4, 1, 3, 2]
[Link]()
for n in numeros:
print(n)

En un caso real, es muy frecuente que no existan datos iniciales, sino que haya que comenzar con una
lista vacía (que se indicará como dos corchetes sin nada entre ellos) y se vayan añadiendo datos con
“.append()”:

numeros = []

for i in range(5):
dato = int(input(f"Dame el dato {i+1}: "))
[Link](dato)

[Link]()
print("Los datos ordenados son:")
for n in numeros:
print(n, end = " ")

El resultado de este programa sería:

Dame el dato 1: 20
Dame el dato 2: 15
Dame el dato 3: 28
Dame el dato 4: 3
Dame el dato 5: 41
Los datos ordenados son:
3 15 20 28 41

Ejercicio propuesto 6.2.1: Pide al usuario 10 números y luego muestra los que son pares.

Ejercicio propuesto 6.2.2: Pide al usuario 10 números y luego muestra los que están en posiciones pares (el
segundo, el cuarto, el sexto, el octavo y el décimo).

Ejercicio propuesto 6.2.3: Pide al usuario números enteros, hasta que introduzca 0 para terminar. Luego dile
cuántos números ha introducido y muestra todos ellos.

Ejercicio propuesto 6.2.4: Pide al usuario números reales, hasta que introduzca 0 para terminar. Luego dile
cual es la media aritmética de esos números, y cuales de ellos están por encima de la media.

Ejercicio propuesto 6.2.5: Pide al usuario los nombres de varias personas, hasta que introduzca una cadena
vacía para indicar que ha terminado (y que no deberás almacenar). Después muéstralos en orden inverso (del
último que ha introducido al primero).

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 49

Ejercicio propuesto 6.2.6: Pide al usuario los nombres de varias personas, hasta que introduzca una cadena
vacía para indicar que ha terminado (y que no deberás almacenar). Después muéstralos ordenados
alfabéticamente.

Ejercicio propuesto 6.2.7: Para una competición deportiva, queremos guardar los tiempos (en segundos, con
decimales) que 10 deportistas han tardado en completar una cierta prueba. Luego queremos mostrar el tiempo
de la persona más rápida. Intenta hacerlo buscando el dato que es mayor (o igual) que todos los demás, sin
ayudarte de “.sort()” para sin ordenar.

Ejercicio propuesto 6.2.8: Para una competición deportiva, queremos guardar los nombres de 10 deportistas
y los tiempos (en segundos, con decimales) que han tardado en completar una cierta prueba. Luego queremos
mostrar el tiempo y el nombre de la persona más rápida. Utiliza dos listas, una de las cuales almacenará los
tiempos y otra los nombres.

Ejercicio propuesto 6.2.9: Crea un programa que pida al usuario 10 palabras, las guarde en una lista y luego
le pregunte de forma repetitiva qué texto quiere buscar. Le responderá si dicho texto era alguno de los que se
habían introducido inicialmente. Dejará de repetirse cuando se introduzca “fin”.

Nota: En muchos lenguajes de programación existen también los arrays, que algunos autores traducen
como “arreglos”, y que son estructuras cuyo manejo es parecido al de las listas, pero cuyo tamaño no
puede cambiar, sino que se debe elegir al principio (y, por tanto, no tienen órdenes equivalentes a
“append”, “insert” ni “pop”).

6.3. Tuplas
Las tuplas (“tuple”) son muy parecidas a las listas, pero se indican entre paréntesis en vez de corchetes,
y son “inmutables” (no se pueden modificar):

meses = ("enero", "febrero", "marzo")

print(meses[1])

Puede parecer que no tiene sentido su existencia, porque están más limitadas que las listas, pero tienen
varias ventajas frente a ellas:

• No se pueden modificar por error. Si queremos datos que tengan un valor inicial que no deba
cambiar, será preferible emplear tuplas en vez de listas.

• Son más eficientes en cuanto a uso de memoria que las listas.

• Son más rápidas de consultar que las listas.

Ejercicio propuesto 6.3.1: Pide al usuario un número entero del 1 al 12 y escribe el nombre del mes
correspondiente (1=enero, 12=diciembre), usando una tupla para almacenar los nombres.

Ejercicio propuesto 6.3.2: Prepara una tupla con los nombres de los días de la semana. Luego pide al usuario
el nombre de un día y respóndele si se trata de un día válido, comprobando esa tupla.

6.4. Conjuntos
Los conjuntos (“set”) son otro tipo de colecciones de datos, poco frecuentes, que tienen la peculiaridad
de que no permiten datos duplicados (si intentamos añadir un dato que ya existía, no se guardará):

frutas = {"manzana", "pera", "plátano", "manzana"}

[Link]("pera")
print(frutas)

Como puedes observar, para añadir un nuevo dato a un conjunto no se emplea “.append()” sino “.add”.
El resultado de este programa sería:

{'plátano', 'pera', 'manzana'}

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 50

Son útiles cuando nos interesa sólo comprobar la pertenencia de un dato a un conjunto, o bien cuando
nos interesa realizar operaciones entre conjuntos (por ejemplo, conocer la intersección entre dos
bloques de datos, o el resultado de su unión). Las operaciones que podemos realizar son:

Operación Operador Descripción

Unión conjunto1 | conjunto2 Elementos de ambos conjuntos (sin duplicados)

Intersección conjunto1 & conjunto2 Elementos comunes en ambos conjuntos

Diferencia conjunto1 - conjunto2 Elementos de conjunto1 que no están en

conjunto2

Diferencia simétrica conjunto1 ^ conjunto2 Elementos que están en uno u otro, pero no en
ambos

Superconjunto conjunto1 >= conjunto2 ¿conjunto1 contiene a conjunto2 ?

Subconjunto conjunto1 <= conjunto2 ¿conjunto1 es subconjunto de conjunto2 ?

Igualdad conjunto1 == conjunto2 ¿Ambos conjuntos tienen los mismos elementos?

Y vamos a verlas en la práctica, con datos de ejemplo:

c1 = {1, 2, 3, 4, 5}
c2 = {3, -1, 7}

print("c1=",c1)
print("c2=",c2)
print("Unión: ", c1 | c2)
print("Intersección: ", c1 & c2)
print("Diferencia: ", c1 - c2)
print("Diferencia simétrica: ", c1 ^ c2)
print("Son iguales? ", c1 == c2)
print("El primero contiene al segundo? ", c1 >= c2)
print("El segundo contiene al primero? ", c1 <= c2)

Y su resultado sería:

c1= {1, 2, 3, 4, 5}
c2= {3, -1, 7}
Unión: {1, 2, 3, 4, 5, 7, -1}
Intersección: {3}
Diferencia: {1, 2, 4, 5}
Diferencia simétrica: {1, 2, 4, 5, 7, -1}
Son iguales? False
El primero contiene al segundo? False
El segundo contiene al primero? False

Ejercicio propuesto 6.4.1: Pide al usuario números enteros, hasta que introduzca 0 para terminar. Luego dile
cuántos números distintos ha introducido y muestra todos esos números (sin duplicados).

6.5. Diccionarios (“dict”)

Los diccionarios (“dict”) son estructuras de datos en las que no hay un dato asociado a cada posición
numérica, como ocurría con las listas y las tuplas, sino que lo que actúa de índice puede ser cualquier
otro tipo de dato. Estas estructuras se conocen como “pares clave:valor”. Por ejemplo, podríamos
almacenar información sobre una persona con:

persona = {
"nombre": "Nacho",
"edad": 30,

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 51

 "estatura": 1.85,
"activo": True
}
print(persona["nombre"])

O la información de un libro con:

libro1 = {
"autor": "Stephen King",
"titulo": "It",
"paginas": 1100
}

print( libro1 )
print( libro1["autor"] )

O datos para un traductor con algo como:

inglesEspanol = {
"hello": "hola",
"bye": "adiós",
"tomorrow": "mañana",
"yesterday": "ayer"
}

print( "hello =", inglesEspanol["hello"] )

print( "yesterday =", inglesEspanol["yesterday"] )

Podemos obtener la lista de todas las claves con “.keys()”, la de todos los valores con “.values()”,
comprobar si un dato aparece con “in”, y borrar un dato con “.del(clave)”, así:

inglesEspanol = {
"hello": "hola",
"bye": "adiós",
"tomorrow": "mañana",
"yesterday": "ayer"
}

print( "Claves:", [Link]() )

print( "Valores:", [Link]() )
for valor in [Link]():
print(valor)
if "well" in inglesEspanol:
print('La traducción de "well" es:', inglesEspanol["well"])
del inglesEspanol["bye"]
print( inglesEspanol )

Ejercicio propuesto 6.5.1: Pide al usuario el nombre de un mes y responde cuántos días tiene (suponiendo un
año no bisiesto), usando un diccionario.

Ejercicio propuesto 6.5.2: Vamos a suponer la siguiente equivalencia (que no es totalmente real) entre el
sistema norteamericano de notas y el sistema español clásico: A = Sobresaliente, B = Notable, C= Aprobado, D
= Suspenso, F = Suspenso. Crea un diccionario que la represente y úsalo en un programa que pregunte al
usuario una nota norteamericana y escriba su equivalente español clásico.

6.6. Estructuras combinadas

Es frecuente no utilizar estas estructuras de datos de forma combinada. Por ejemplo, para guardar datos
de varios libros nos podría interesar tener una lista de diccionarios:

libros = [
{

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 52

 "autor": "Stephen King",
"titulo": "It",
"paginas": 1100
},
{
"autor": "J.K. Rowling",
"titulo": "Harry Potter y la piedra filosofal",
"paginas": 223
},
{
"autor": "Gabriel García Márquez",
"titulo": "Cien años de soledad",
"paginas": 417
}
]

Y esa lista se podría recorrer para mostrar su contenido, empleando una orden “for”:

for libro in libros:

print(f"Título: {libro['titulo']}")
print(f"Autor: {libro['autor']}")
print(f"Páginas: {libro['paginas']}")
print("-" * 30)

Y no es difícil añadir un nuevo libro:

autor = input("Autor del libro: ")

titulo = input("Título del libro: ")
paginas = int(input("Páginas: "))

nuevoLibro = {
"autor": autor,
"titulo": titulo,
"paginas": paginas
}

[Link](nuevoLibro)

Para borrar libros, tenemos dos alternativas. Si conocemos la posición, podemos emplear “del”, así:

# Borramos el segundo libro

del libros[1]

Si preferimos borrar por título (o por cualquier otro campo), deberemos buscar con un “for”, e utilizar
“remove”, de la siguiente manera:

tituloBorrar = input("Título del libro a borrar: ")

for libro in libros:

if libro["titulo"].lower() == [Link]():
[Link](libro)
print("Libro eliminado.")

Ejercicio propuesto 6.6.1: Crea un programa básico que permita anotar tareas. De cada tarea nos interesará
su descripción y su prioridad (del 1 al 10). El usuario debe poder mostrar todas las tareas, así como eliminar
una que ya haya completado.

6.7. Creación de listas con “for”

Como curiosidad un poco más avanzada, se puede crear una lista a partir de una orden “for”, usando un
formato especialmente compacto.

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 53

Por ejemplo, si queremos crear una lista que contenga los cuadrados de los números del 1 al 10, nuestro
primer planteamiento podría ser el siguiente:

cuadrados = []
for x in range(1, 11):
[Link](x**2)
print(cuadrados)

Pero también es posible hacerlo de la siguiente forma, indicando una orden “for” dentro de los corchetes:

cuadrados = [x**2 for x in range(1, 11)]

print(cuadrados)

De igual modo, podríamos preparar una lista que contuviese 100 datos con el valor 0, de la siguiente
forma:

datos = [0 for x in range(100)]

Ejercicio propuesto 6.7.1: Crea una lista con los números 10, 20, 30, 40, 50 … hasta el 100, usando el formato
compacto.

Introducción a la programación (con Python), por Nacho Cabanes v0.02, página 54