Listas Diccionarios

Introducción a la programación
Listas y diccionarios
Índice
Listas y diccionarios....................................................................................................................1
1 Listas y diccionarios............................................................................................................3
2 Listas...................................................................................................................................3
2.1 El bucle for y la función range().................................................................................5
2.2 Empaquetando y desempaquetando listas...................................................................6
2.3 Lista de palabras a partir de un texto...........................................................................6
2.4 Enumerando listas........................................................................................................8
2.5 Slicing..........................................................................................................................8
2.6 Operadores disponibles para listas............................................................................10
2.7 Comprensión de listas................................................................................................11
3 Diccionarios.......................................................................................................................12
3.1 El bucle for para diccionarios....................................................................................13
3.2 Operadores y métodos disponibles para diccionarios................................................15
4 Ejercicios resueltos............................................................................................................16
5 Ejercicios propuestos.........................................................................................................18
Listas y diccionarios - 2
1 Listas y diccionarios
Python está fuertemente basado en listas, es decir, son un tipo prácticamente básico. No
solamente son equivalentes a los vectores (arrays) en otros lenguajes de programación, sino
que se utilizan en los retornos de las funciones (cuando se trata de más de un solo valor),
como soporte para cadenas, y también en los bucles for().
Si bien almacenar valores en variables individuales es correcto, pudiendo solucionar
muchos problemas, las listas permiten almacenar más de un valor, de hecho son colecciones
de valores que por los requisitos del problema precisamos tratar juntos.
Además, Python dispone de una herramienta muy importante en cuanto a manejo de
datos: los diccionarios. Al igual que las listas, forman parte del mismo Python, y su existencia
hace el código mucho más sencillo de escribir. Se trata básicamente de contenedores
relacionales, de manera que cada elemento es un par (clave, valor). Así, mediante una clave se
puede recuperar rápidamente un valor. Se puede entender como un par de vectores paralelos,
uno con las claves y otro con los valores. La posición en el vector de las claves para una clave
cualquiera, se corresponde con el valor en la misma posición.
2 Listas
Las listas son colecciones de elementos accesibles mediante su posición. Los literales de
listas se expresan como una sucesión de elementos separados por comas, y delimitados por
corchetes, como por ejemplo [1, 2, 3], que representa una colección de tres elementos, el
primero el uno, el segundo y el dos, y el tercero el tres. El literal de una lista vacía, es decir,
sin elementos, sería [].
La función len() devuelve el tamaño de la lista, y se puede acceder a cada posición de
la lista utilizando el mismo mecanismo que se estudió anteriormente para acceder a las
distintas posiciones de un texto: empleando índices entre corchetes, tanto positivos (contando
desde el principio de la cadena), como negativos (contando desde el final de la cadena).
Las listas solo están limitadas por la memoria disponible del ordenador, es decir, se
pueden introducir elementos de forma potencialmente ilimitada, no teniendo que pertenecer
necesariamente los valores introducidos al mismo tipo (enteros, flotantes, texto, etc.). Por otra
parte, es cierto que lo más común en una lista es que todos los elementos sean del mismo tipo,
pero el no tener esta limitación hace que el lenguaje de programación nos ofrezca
posibilidades aún más flexibles.
Finalmente, también es posible crear listas dentro de listas, como cualquier otro
elemento.
Sintaxis
l0 = [] # Crear lista vacía
l1 = [1, 2, 3, “hola”] # Crear una lista con distintos valores
print([3, 2, 1], l1) # Visualizar listas
l2 = l1 + [4] # Concatenar l1 y [4] y guardarla en l2
l0 += [1] # Añadir un elemento a la lista
A continuación se muestra un ejemplo muy simple en el que se crea una lista de tres
elementos y se accede a algunas de sus posiciones.
l = [1, 2, 3]
print(“Tamaño de la lista:”, len(l))
print(“Segundo elemento:”, l[1])
print(“Último elemento:”, l[-1])
El ejemplo anterior mostraría la siguiente salida:

Tamaño de la lista: 3
Segundo elemento: 2
Último elemento: 3
En el siguiente ejemplo, se visualizan todos los elementos de una lista en orden normal
e inverso, accediendo a sus posiciones mediante números enteros, positivos y negativos.
l = [4, 5, 6]
print(l[0], l[1], l[2])
print(l[-1], l[-2], l[-3])
La salida del ejemplo anterior sería:

4 5 6
6 5 4
En programa más abajo, se crea una lista formada por dos sublistas: la de los números
pares por debajo de 20, y la de los números impares en las mismas condiciones.
# Guarda y muestra los valores pares e impares por debajo de 20
valores_debajo20 = [[], []]
for i in range(1, 20):

if i % 2 == 0:
valores_debajo20[0] += [i]
else:
valores_debajo20[1] += [i]
print(“Valores pares por debajo de 20: ”, valores_debajo20[0])

print(“Valores impares por debajo de 20:”, valores_debajo20[1])
El ejemplo anterior mostraría la siguiente salida:

Valores pares por debajo de 20: [2, 4, 6, 8, 10, 12, 14, 16, 18]
Valores impares por debajo de 20: [1, 3, 5, 7, 9, 11, 13, 15, 17]
Como se puede ver en los anteriores ejemplos, una variable puede guardar una lista
mediante una simple asignación. Para crear una lista en una variable, se asigna a dicha
variable un literal de lista, como [] (la lista vacía), [1, 2] (una lista con los elementos 1 y 2), o
bien la función list() (de nuevo la lista vacía).
2.1 El bucle for y la función range()

Previamente se explicó el bucle for como un todo formado por la propia instrucción for y la
función range(i). En realidad, esto no es cierto: el bucle for opera exclusivamente sobre listas
(o sobre textos), y de hecho, la función range(i) devuelve una lista1: cuando se le pasa un
parámetro n, devuelve una lista desde 0 hasta n-1; cuando se le pasan dos parámetros n1 y n2,
devuelve una lista entre n1 y n2 – 1; cuando se le pasan tres parámetros n1, n2 y n3, devuelve
una lista entre n1 y n2 – 1, de forma que hay una diferencia entre cada elemento de n3. Así, la
función range(5) devuelve la lista [0, 1, 2, 3, 4], mientras que range(1, 3) devuelve la lista [1,
2], y range(1, 7, 2) devuelve la lista [1, 3, 5].
En el siguiente ejemplo se muestra como el bucle for opera sobre listas o textos:
for x in “hola”:
print(x, end=’ ‘)
La salida sería: h o l a. Mientras que para listas:

for x in [1, 2, 3]:
La salida sería: 1 2 3. Por tanto, la función range(i) no es obligatoria, sino tan solo
opcional, necesaria cuando no se está ya iterando sobre una lista. Así, los siguientes códigos
son iguales, mostrando el mismo resultado: 1 2 3, en pantalla. En el primero se itera
directamente sobre una lista.
l = [1, 2, 3]
for x in l:
En siguiente, en cambio, se utiliza la función range() para lograr el mismo objetivo.
l = [1, 2, 3]
for i in range(len(l)):
print(l[i], end=’ ‘)
Por supuesto, ahora que es conocida esta peculiaridad de for, es mucho más
recomendable el primero.
1 En Python 2, devolvía directamente una lista. Sin embargo, esto no era muy eficiente cuando se trataba de
grandes rangos, de manera que desde las primeras versiones de Python 3, en lugar de devolver una lista
directa, devuelve un mecanismo llamado generador que va creando los elementos de la misma a medida que
se van necesitando. Para convertir un generador a lista, solo es necesario utilizar list().
2.2 Empaquetando y desempaquetando listas

Es posible almacenar los diferentes valores de una lista en variables individuales, de la misma
forma que es posible crear una lista a partir de valores individuales. A esto se le llama
empaquetado y desempaquetado.
Por ejemplo, con el siguiente código se crea una lista con los valores de las variables
a, b, y c.
a = 1
b = 2
c = 3
l = [a, b, c]
print(l)
Mostraría [1, 2, 3] por pantalla, una lista creada a partir de los valores individuales de
las variables a, b, y c.
La contrapartida a esto consiste en poder tomar los valores individuales de una lista
para asignárselos al mismo número de variables que elementos tenga la lista.
Por ejemplo, en el siguiente código, las variables a, b, y c se crean a partir de los
valores almacenados en la lista l.
l = [1, 2, 3]
a, b, c = l
print(“Valor de a:”, a)
print(“Valor de b:”, b)
print(“Valor de c:”, c)
Mostraría la siguiente salida por pantalla.

Valor de a: 1
Valor de b: 2
Valor de c: 3
2.3 Lista de palabras a partir de un texto

La función str.split(t), acepta un texto que devuelve troceado en palabras, según los espacios
que encuentre en su interior. El soporte para estas palabras o trozos, resulta ser una lista.
Si bien esta función es muy útil, no se había visto hasta ahora debido que todavía no se
habían estudiado las listas.
# Trocea en palabras un texto dado
t = input(“Dame una frase: “)

print(str.split(t))
La salida es:
Dame una frase: Esto es una prueba
[“Esto”, “es”, “una”, “prueba”]
Una necesidad muy típica es la de contar palabras y caracteres en un texto dado, como
se puede ver en el siguiente programa.
# Datos cualitativos de un texto
t = input(“Dame una frase: “)

print(“Palabras:”, len(str.split(t)), “, caracteres:”, len(t), “.”)
La salida es:
Dame una frase: Esto es una prueba
Palabras: 4, caracteres 18.
Opcionalmente, str.split(t1, t2) acepta un segundo parámetro t2 con el delimitador a

utilizar para t1, en lugar del espacio.
# Trocea en valores usando la coma
t = input(“Dame valores separados por comas: “)
for x in str.split(t, ‘,’):

print(t, end=’ ‘)
print()
Salida
Dame una frase: 2, 4, 6, 8
2 4 6 8
Un ejemplo más práctico sería un programa que sumara y mostrara la media de varios
valores enteros separados por comas.
# Suma y calcula la media de valores separados por comas
t = input(“Dame valores enteros separados por comas: “)
valores = str.split(t, ‘,’)

suma_acumulada = 0
for x in valores:
suma_acumulada += int(x)
print(t, end=’ + ‘)
print(“0 =“, suma_acumulada)

print(“Media:”, suma_acumulada // len(valores))
Salida
Dame valores enteros separados por comas: 2, 4, 6, 8
2 + 4 + 6 + 8 + 0 = 20
Media: 5
2.4 Enumerando listas

En ocasiones, es interesante conocer no solo el valor dentro de una lista, sino también la
posición que ocupa dentro de ella. Esto se puede obtener mediante la función enumerate(l).
Esta función devuelve una lista de listas2, de tal manera que cada posición contiene una
sublista con dos elementos: la posición del elemento en la lista, y el valor en sí, como se
puede apreciar en el siguiente código:
print(list(enumerate("hola")))
Que produce la siguiente salida:

[(0, 'h'), (1, 'o'), (2, 'l'), (3, 'a')]
Así, esto se puede utilizar en un bucle for como se ve inmediatamente más abajo.
for i, x in enumerate(“hola”):
print(“En la posición”, i “se encuentra:”, x)
Que produce la siguiente salida:

En la posición 0 se encuentra: h
En la posición 1 se encuentra: o
En la posición 2 se encuentra: l
En la posición 3 se encuentra: a
2.5 Slicing
En un tema anterior se explicaba que se podía acceder a una posición de una cadena
utilizando índices entre corchetes, e incluso extraer una subcadena proporcionando índices de
comienzo, final y de avance. Este mecanismo se llama slicing, y está disponible tanto para
cadenas como para listas. El slicing es muy poderoso: se pueden obtener sublistas, indicando
el índice de comienzo y el de final (basados en 0), y el avance, separados por dos puntos,
entre corchetes. Nótese que siempre se crea una lista nueva, la lista original no se ve
modificada.
El acceder a una determinada posición n solo es un caso particular en la que el índice
superior es n + 1, y el paso es 1 (aunque ninguno se indique). Así, si l = [1, 2, 3], l[1] y
l[1:2:1] devuelven el mismo resultado: 2.
Sintaxis
vble_lista[<índice_inferior> : <índice_superior> : <paso>]
El mecanismo de slicing es muy flexible y potente, y de hecho se pueden omitir ambos

índices, así como el paso, de forma que l[::] devuelve l completa, mientras l[::-1] devuelve la
lista a la inversa.
2 En realidad se trata de una lista de tuplas, que se verán en un tema posterior. De forma básica, se pueden
entender las tuplas como listas que no se pueden modificar.
Tal y como pasa con la función range(i), en realidad la sublista devuelta nunca llega a
alcanzar el índice superior dado, sino al inmediatamente anterior.
El paso indica que los valores de la lista se pueden tomar de uno en uno (este es el
valor por defecto del paso), o de x (cualquier otro valor), en x.
l = [11, 21, 31, 41, 51, 61, 71, 81, 91, 101]
print(“’l’ es:“, l[::])
print(“’l’ inversa:”, l[::-1])
print(“’l’ de dos en dos:”, l[::2])
print(“’l’ desde la penúltima posición:”, l[-2::])
print(“’l’ de la penúlt. pos. paso: -1:”, l[-2::-1])
print(“’l’ de la segunda a la cuarta posición:”, l[1:4])
print(“’l’ de la segunda a la últ. posición, paso 2:”, l[1:-1:2])
La salida del anterior programa es:

‘l’ es: [11, 21, 31, 41, 51, 61, 71, 81, 91, 101]
‘l’ inversa: [101, 91, 81, 71, 61, 51, 41, 31, 21, 11]
‘l’ de dos en dos: [11, 31, 51, 71, 91]
‘l’ desde la penúltima posición: [91, 101]
‘l’ de la penúlt. pos. paso -1: [91, 81, 71, 61, 51, 41, 31, 21, 11]
’l’ de la segunda a la cuarta posición: [21, 31, 41]
’l’ de la segunda a la últ. posición, paso 2: [21, 41, 61, 81, 101]
2.6 Operadores disponibles para listas

Las listas soportan varios operadores que permiten extensa funcionalidad. Supóngase, para
poder comprender la siguiente tabla, dos listas l1, y l2 con valores [1, 2, 3] y [4, 5, 6],
respectivamente. Léase la tabla de arriba a abajo.
Operador Explicación Resultado
l1 += [4] Añade un nuevo elemento 4 a l1. l1 == [1, 2, 3, 4]
4 in l1 Comprueba si 4 está en l1. True
4 not in l1 Comprueba si 4 no está en l1. False
l1 + l2 Concatena l1 con l2, en una lista nueva. [1, 2, 3, 4, 4, 5, 6]

l1 += l2 Concatena l1 con l2, modificando l1. l1=[1, 2, 3, 4, 4, 5, 6]
l2 * 2, 2 * l2 Crea una lista con dos copias de l2. [4, 5, 6, 4, 5, 6]
l2[1] Obtiene el elemento 1, empezando en 0. 4
l2[1:2]
Obtiene una subsecuencia de la posición [5]
1 a la posición 2, exclusive.
Obtiene una subsecuencia de la posición

l1[0:-1:2] 0 a la penúltima posición, tomando los [1, 3, 4]
elementos de dos en dos.
del l1[0:2] Elimina una subsecuencia de l1. [3, 4, 4, 5, 6]
min(l2) Obtiene el elemento más pequeño de l2. 4

max(l2) Obtiene el elemento más grande de l2. 6
sum(l2) Suma los elementos en l2. 15
2.7 Comprensión de listas

Supongamos que se desea crear una nueva lista, escogiendo de una lista l aquellos elementos
que cumplan una condición (llamémosle cnd1), transformándola mediante la expresión expr1.
El código equivalente a esto, sería:
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
l2 = []
for x in l:
if cnd1(x):
l2 += [expr1(x)]
Por ejemplo, se podría querer obtener el doble de cada elemento impar: cnd1 sería x %
2 != 0, mientras que expr1 sería x * 2.
l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
l2 = []
for x in l:
if x % 2 != 0:
l2 += [x * 2]
print(l2)
Este código produciría la salida:

[2, 6, 10, 14, 18]
Pues bien: la comprensión de listas es capaz de abreviar un código como este. Se trata
de poder realizar transformaciones en los elementos de una lista, escogidos según una
condición. La sintaxis es parecida a un bucle for, y precisamente para distinguirlos se encierra
entre corchetes, dado a entender que el resultado será también una lista (insisto, una lista
creada a partir de la original, que no se modifica).
Sintaxis
[expr(<id>) for <id> in expr_lista<id>]
[expr(<id>) for <id> in expr_lista<id> if expr(<id>)]
En el siguiente ejemplo, se hace una transformación numérica.

l = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
print([x * 2 for x in l if x % 2 != 0])
print([x // 2 for x in l])
print(l)
La salida del código es la siguiente:

[2, 6, 10, 14, 18]
[0, 1, 1, 2, 2, 3, 3, 4, 4, 5]
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
Este ejemplo opera sobre listas de textos.
palabras = [“a”, “Pepe”, “Baltasar”, “”, “de”]
preposiciones = [“a”, “ante”, “bajo”, “contra”, “de”, “en”]
nombres = [“pepe”, “baltasar”, “miguel”, “pablo”]
lps = [x for x in palabras if len(x) > 0]
print([x for x in lps if x.lower() in preposiciones], end=’ ‘)
print([x for x in lps if x.lower() in nombres], end=’ ‘)
La salida es la siguiente:
a de
Baltasar Pepe
3 Diccionarios
Supongamos que se tienen dos listas, del mismo número de elementos, una que
denominaremos temperaturas, y otra que denominaremos ciudades. Se tratará de una
estructura de datos que guardará temperaturas asociadas a ciudades, de manera que la
posición i-ésima de ciudades guardará el nombre de la ciudad, mientras que la misma
posición en temperaturas guardará las temperaturas de dicha ciudad.
ciudades = [“Vigo”, “Ourense”, “Pontevedra”, “Coruña”, “Lugo”]
temperaturas = [20, 18, 17, 21, 26]
print(“En”, ciudades[1], “hay”, temperaturas[1], “º.”)
La salida de este código es la siguiente:

En Ourense hay 18º.
Esto sería equivalente a tener un diccionario. En el diccionario, existe una colección

de claves (como las ciudades en el ejemplo), y otra de valores (como las temperaturas en el
ejemplo), y se pueden obtener los valores mediante las claves.
Existen literales específicos para diccionarios. El diccionario vacío, se escribe como
{}, o bien se obtiene mediante la función dict(). Al igual que con una lista, los elementos de un
diccionario pueden ser de distinto tipo, es decir, no tienen por qué estar formados
homogéneamente solo por números, o solo por textos, etc. Cuando un diccionario tiene
elementos, estos son pares clave – valor, separados entre sí por dos puntos, cada elemento
separado por comas.
Sintaxis
dict()
{}
{1: “si”, 2: “no”, 3: “quizas”}
En el siguiente ejemplo, se utilizan diccionarios para versionar el código al comienzo

de esta sección.
temperaturas = {“Vigo”: 20, "Orense": 18, "Pontevedra": 17, “Coruña”:
21, “Lugo”: 26}
print(“Temperatura en Ourense”, temperaturas["Ourense"], “º”)
temperaturas["Ourense"] += 1
print(“Temperatura en Ourense”, temperaturas["Ourense"])
print(“Temperatura en Vigo”, temperaturas["Vigo"])
print(“Número de ciudades:”, len(temperaturas))
La salida del programa es la siguiente.

Temperatura en Ourense: 18º
Temperatura en Ourense: 19º
Temperatura en Vigo: 20º
Número de ciudades: 5
Así, cuando se aplica una clave entre corchetes a un diccionario, lo que devuelve
Python es el valor que se corresponde con dicha clave. Se puede utilizar como forma de
asignación, por otra parte. En el caso de que no se encuentre dicho valor, se provoca una
excepción3.
La existencia de dicho valor se puede comprobar previamente mediante in: valor in
diccionario devuelve True si el valor se encuentra entre las claves del diccionario, y False en
otro caso.
3.1 El bucle for para diccionarios

Efectivamente, se pueden recorrer los diccionarios mediante un bucle for(). Para ello, se
dispone de dict.keys(d), para recorrer las claves, dict.items(d), para recorrer pares formados
por clave y valor, y dict.values(d), para recorrer solamente los valores.
En este primer ejemplo se utiliza dict.keys(d) para recorrer claves y valores, utilizando
la posibilidad de búsqueda del diccionario.
temperaturas = {"Ourense": 5, "Vigo": 12, "Lugo": 7, "Coruña": 14}
for k in dict.keys(temperaturas):
print(str.format(“{0}: {1}º”, k, temperaturas[k]))
La salida del código anterior es la siguiente.

Ourense: 5º
Vigo: 12º
Lugo: 7º
Coruña: 14º
3 Las excepciones y el control de errores que permiten se discuten en un tema posterior.
En un segundo ejemplo, se utiliza dict.items(d), que devuelve pares clave – valor y

pueden ser utilizados para el recorrido, lo que es muy eficiente, y produce exactamente la
misma salida.
for k, v in dict.items(temperaturas):
print(“{0}: {1}º”.format(k, v))
Salida
Ourense: 5º
Vigo: 12º
Lugo: 7º
Coruña: 14º
El ejemplo siguiente muestra el uso de dict.values(d), para aquellos casos en los que se
desee recorrer solamente los valores, sin relacionarlos con sus claves correspondientes.
for v in dict.values(temperaturas):
print(“{0}º”.format(v))
Salida
5º
12º
7º
14º
3.2 Operadores y métodos disponibles para diccionarios

Los diccionarios soportan varios operadores y funciones miembro que permiten extensa
funcionalidad. Supóngase, para poder comprender la siguiente tabla, dos diccionarios d1, y d2
con valores {1: 'a', 2: 'b', 3: 'c'} y {4: 'd', 5: 'e', 6: 'f'}, respectivamente. Léase la tabla de arriba
a abajo.
Operador/método Explicación Resultado

d1 == {1: 'a', 2: 'b', 3:
d1[9]='i' Añade un nuevo par (9, 'i') a d1. 'c', 9: 'i'}
Devuelve el valor asociado a la

d1[9] clave 9 en d1. Provoca un error si 'i'
no existe la clave.
4 in l1
Comprueba si 4 está como clave False
en d1.
4 not in l1
Comprueba si 4 no está como True
clave en d1.
d1 == d2 Compara dos diccionarios. False
d1 != d2 Compara dos diccionarios. True
dict.clear(d2) Borra todos los elementos de d2. d2 == {}
del d1[1]
Elimina la clave 1 y su valor {2: 'b', 3: 'c', 9: 'i'}
asociado de d1.
min(d1)
Obtiene la clave más pequeña de 2
d1.
max(d1)
Obtiene la clave más grande de 9
d1.
4 Ejercicios resueltos
1. Muestra una lista con los valores impares del 1 al 30, inclusive.
# Mostrar valores impares del 1 al 30 inclusive.
print(list(range(1, 31, 2)))
2. Hacer el programa que para los números naturales menores que N (pedido por
teclado), calcule: a) la suma de los impares, b) la suma de los pares, y por último, la suma de
los múltiplos de tres.
# Suma de pares, impares y múltiplos de 3
valores_pares = []
valores_impares = []
valores_mult3 = []
n = int(input(“Dame un entero N: “))
for i in range(n):
if x % 2 == 0:
valores_pares += [i]
elif x % 3 == 0:
valores_mult3 += [i]
else:
valores_impares += [i]
print(“Suma de pares:”, sum(valores_pares))

print(“Suma de impares:”, sum(valores_impares))
print(“Suma de múltiplos de tres:”, sum(valores_mult3))
3. Escriba un programa que visualice una lista con los N primeros números de la
sucesión de Fibonacci. En la sucesión de Fibonacci, los dos primeros valores son 0 y 1. Los
valores subsiguientes se calculan sumando el último y el penúltimo.
# Sucesión de Fibonacci
n = int(input(“Dame max. de valores para suc. de Fibonacci: “))
valores_fibo = [0, 1]
n -= 2
for _ in range(n):
valores_fibo += [valores_fibo[-2] + valores_fibo[-1]]
print(“Primeros”, n, “valores de Fibonnaci:”, valores_fibo)
4. Escribe un programa que calcule la frecuencia con la que aparecen las palabras en
una cadena de texto leída desde el teclado.
# Frecuencias de palabras
texto = str.lower(str.strip(input(“Dame un texto: “)))

palabras = str.split(texto)
frecs = {}
for palabra in palabras:
if palabra not in frecs
frecs[palabra] = 1
else:
frecs[palabra] += 1
print(frecs)
La salida del programa podría ser la siguiente:

Dame un texto: Python el lenguaje de programación de el mundo.
{“python”: 1, “el”: 2, “lenguaje”: 1, “de”: 2, “programación”: 1,...
5. Escribe una función es_anagrama(s1, s2) que determine si son anagramas dos
cadenas pasadas como argumento. Dos cadenas son anagramas la una de la otra, si tienen las
mismas letras pero en distinto orden.
# Determina si p1 es anagrama de p2
p1 = str.strip(input(“Dame una palabra: “))

p2 = str.strip(input(“Dame una palabra: “))
s1 = str.lower(str.strip(s1))
s2 = str.lower(str.strip(s2))
letras1 = {}
letras2 = {}
longitud = len(s1)
if longitud == len(s2):
for i in range(longitud):
ltr1 = s1[i]
ltr2 = s2[i]
if ltr1 not in letras1:

letras1[ltr1] = 1
else:
letras1[ltr1] = 1
if ltr2 not in letras2:

letras2[ltr2] = 1
else:
letras2[ltr2] = 1
msg = “ anagramas”
if letras1 == letras2:
print(“Son“ + msg)
else:
print(“No son“ + msg)
5 Ejercicios propuestos
Los siguientes ejercicios son básicos y se pueden resolver conociendo listas, diccionarios y
los conceptos estudiados hasta ahora. Tras cada enunciado, se muestra un ejemplo de la
entrada y salida por pantalla del programa a escribir para que sirva de guía.
1. Muestra una lista con los números pares del 1 al 30 (ambos incluidos).
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30]
2. Crear un programa que guarde en una lista N números introducidos por teclado. El
valor de N también se introducirá por teclado. Al final se mostrará la lista de valores y su
suma.
Num. de valores: 2
Valor 1: 5
Valor 2: 6
Suma: [5, 6] == 11
3. Escribe un programa que calcule la media de N números introducidos por teclado.

Num. de valores: 2
Valor 1: 5
Valor 2: 6
Suma: [5, 6] == 5.50
4. Escriba un programa que visualice los N primeros números de la sucesión de

Tribonacci. En la sucesión de Tribonacci, los dos primeros valores son 0, 1 y 1. Los valores
subsiguientes se calculan sumando el último, el penúltimo y el antepenúltimo.
Valor N: 10
Tribonacci: 0, 1, 1, 2, 3, 5, 8, 13, 21, 34
5. Escribe un programa que visualice una lista con la descomposición de un número en

sus cifras de base 10 (el número de cifras de un entero se obtiene sumando 1 a la parte entera
de su logaritmo en base 10).
Dame un entero: 325
Cifras en base 10: [3, 2, 5]
6. Escribe un programa que muestre las monedas que es necesario dar para un cambio
determinado. Asume que el valor de las monedas se valorará en céntimos, al igual que el valor
del cambio.
Dame el valor del cambio a devolver: c25
Monedas disponibles: [100, 50, 20, 10, 5, 2, 1]
Monedas a devolver: [0, 0, 1, 0, 1, 0, 0]
7. Dado un texto introducido por teclado, crea y visualiza dos listas, una con las
vocales y otra con las consonantes.
Dame un texto: Hola, mundo
Vocales: [‘o’, ‘a’, ‘u’, ‘o’] (4)
Consonantes: [‘h’, ‘l’, ‘m’, ‘n’, ‘d’] (5)
8. Escriba un programa que visualice una lista con los 100 primeros números pares
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30,...]
9. Escriba un programa que visualice una lista con los primeros números pares por
debajo de 100.
[2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30,...]
10. Escribe un programa que visualice una lista con los 100 primeros números primos
[2, 3, 4, 5, 7, 11, 13,...]
11. Crea un programa que visualice una lista con los primeros números primos por
debajo de 100.
[2, 3, 4, 5, 7, 11, 13,...]
12. Escribe un programa que muestre las monedas que es necesario dar para un
cambio determinado. Asume que el valor de las monedas se valorará en céntimos, al igual que
el valor del cambio. Solo muestra aquellas monedas de las que se devolverá realmente alguna.
Dame el valor del cambio a devolver: 0.25
Monedas a devolver: {20: 1, 5: 1}
13. Un profesor imparte una asignatura en la que evalúa dos partes: la teórica, que
supone un x% de la nota, y la práctica, con un (100-x)%. Para aprobar, es necesario haber
obtenido al menos un cuatro en ambas partes. Escribe un programa que permita calcular la
nota para varios alumnos (guarda un diccionario de listas con las notas), mostrando el
desglose de su cálculo. El programa termina cuando la nota de teoría introducida sea menor
que cero, momento en el que visualizará la media de las notas de los aprobados, y la media de
los suspensos.
Dame el valor de la parte de teoria: %60
Dame el DNI del alumno: 11222333
Dame la nota de teoría: 6
Dame la nota de prácticas: 7
Dame el DNI del alumno: 12222333
Dame la nota de teoría: 5
Dame la nota de prácticas: 5
Dame la nota de teoría: -1
Nota final: 11222333: 6 60% + 7 40% = 6.40

Nota final: 12222333: 5 60% + 5 40% = 5.00
Medias: notas aprobados: 6.50 notas suspensos: 0.00
14. Escribe un programa que muestre una lista con los valores hasta n hasta superar x,
pedido por teclado, según la sucesión: y = 1 + 2 + 3 + 4 + 5 + 6 +… + n | y >= x.
Dame un valor x: 20
El valor de n es: 6 [1, 2, 3, 4, 5, 6]
15. Crea una función decodificadora de fechas. Aceptará fechas del estilo “12 Feb
2015”, y las convertirá al sistema ISO-8601, es decir, “2015-02-12” en el ejemplo.
Dame una fecha: 12 feb 2015
Fecha ISO 8601: 2015-02-12
16. Crea un programa que permita guardar y hacer búsquedas sobre pares de (nombre,
e.mail). El programa presentará un menú principal, con las opciones introducir, borrar, buscar
y listar. Al introducir datos, se pide un nombre y un e.mail, y se guardan. Para borrar, sólo se
pide el nombre, se busca y se borra. Para buscar, sólo se pide el nombre, se busca y se
muestra. Utiliza un diccionario para guardar los datos.
1. Inserta
2. Borra
3. Busca
4. Listar
0. Salir
Selecciona: 1
Dame un nombre: Baltasar

Dame un e.mail: jbgarcia@uvigo.es
1. Inserta
2. Borra
3. Busca
4. Listar
0. Salir
Selecciona: 4
Baltasar: jbgarcia@uvigo.es

Listas Diccionarios

Cargado por

Información del documento

Descripción original:

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Listas Diccionarios

Cargado por

Copyright:

Formatos disponibles

Introducción a la programación

El ejemplo anterior mostraría la siguiente salida:

La salida del ejemplo anterior sería:

valores_debajo20 = [[], []]

for i in range(1, 20):

print(“Valores pares por debajo de 20: ”, valores_debajo20[0])

El ejemplo anterior mostraría la siguiente salida:

2.1 El bucle for y la función range()

La salida sería: h o l a. Mientras que para listas:

En siguiente, en cambio, se utiliza la función range() para lograr el mismo objetivo.

2.2 Empaquetando y desempaquetando listas

Mostraría la siguiente salida por pantalla.

2.3 Lista de palabras a partir de un texto

t = input(“Dame una frase: “)

t = input(“Dame una frase: “)

Opcionalmente, str.split(t1, t2) acepta un segundo parámetro t2 con el delimitador a

t = input(“Dame valores separados por comas: “)

for x in str.split(t, ‘,’):

t = input(“Dame valores enteros separados por comas: “)

valores = str.split(t, ‘,’)

print(“0 =“, suma_acumulada)

2.4 Enumerando listas

Que produce la siguiente salida:

Que produce la siguiente salida:

El mecanismo de slicing es muy flexible y potente, y de hecho se pueden omitir ambos

La salida del anterior programa es:

2.6 Operadores disponibles para listas

Operador Explicación Resultado

l1 += [4] Añade un nuevo elemento 4 a l1. l1 == [1, 2, 3, 4]

4 in l1 Comprueba si 4 está en l1. True

4 not in l1 Comprueba si 4 no está en l1. False

l1 + l2 Concatena l1 con l2, en una lista nueva. [1, 2, 3, 4, 4, 5, 6]

l2 * 2, 2 * l2 Crea una lista con dos copias de l2. [4, 5, 6, 4, 5, 6]

l2[1] Obtiene el elemento 1, empezando en 0. 4

Obtiene una subsecuencia de la posición

min(l2) Obtiene el elemento más pequeño de l2. 4

sum(l2) Suma los elementos en l2. 15

2.7 Comprensión de listas

Este código produciría la salida:

En el siguiente ejemplo, se hace una transformación numérica.

La salida del código es la siguiente:

print(“En”, ciudades[1], “hay”, temperaturas[1], “º.”)

La salida de este código es la siguiente:

Esto sería equivalente a tener un diccionario. En el diccionario, existe una colección

En el siguiente ejemplo, se utilizan diccionarios para versionar el código al comienzo

La salida del programa es la siguiente.

3.1 El bucle for para diccionarios

La salida del código anterior es la siguiente.

3 Las excepciones y el control de errores que permiten se discuten en un tema posterior.

En un segundo ejemplo, se utiliza dict.items(d), que devuelve pares clave – valor y

3.2 Operadores y métodos disponibles para diccionarios

Operador/método Explicación Resultado

Devuelve el valor asociado a la

d1 != d2 Compara dos diccionarios. True

dict.clear(d2) Borra todos los elementos de d2. d2 == {}

print(list(range(1, 31, 2)))

print(“Suma de pares:”, sum(valores_pares))

n = int(input(“Dame max. de valores para suc. de Fibonacci: “))

print(“Primeros”, n, “valores de Fibonnaci:”, valores_fibo)

texto = str.lower(str.strip(input(“Dame un texto: “)))

La salida del programa podría ser la siguiente:

p1 = str.strip(input(“Dame una palabra: “))