Curso de Python

-----------------------------------------------------------------------------------------------------------------------------------

Tipos de Secuencias y Mutabilidad

Sirve para describir un objeto como un agrupamiento de datos de distintos tipos.
Una tupla es una secuencia inmutable. Se puede comportar como una lista pero no puede ser
modificada en el momento.
Lo primero que distingue una lista de una tupla es la sintaxis empleada para crearlas. Las tuplas
utilizan paréntesis, mientras que las listas usan corchetes, aunque también es posible crear una
tupla tan solo separando los valores por comas.
Ejemplos:
Una fecha se puede colocar como:
fecha= (20, “Noviembre”,2020)
print(fecha)

Un punto del Plano cartesiano:

punto=(2.5, 6)
print(punto)

Datos de un producto:
producto = (“prod001”,” galletas día”,0.80,100)
print(producto)

Podemos tener tuplas anidadas

Por ejemplo:
alumno=(12345678, “Cordova”, “Martin”, (10,”Agosto”,1964))
print(alumno)

tupla =2,4,10
print(tupla)

Si deseamos una tupla vacia colocaremos

t=()
Si se desea crear una tupla de un solo elemento, se debe de considerar el hecho de que, debido a
la sintaxis (una tupla debe de poder distinguirse de un valor entero ordinario), se debe de colocar
una coma al final:
tuplaUnElemento1 = (1, )
tuplaUnElemento2 = 1.,
print(tuplaUnElemento1)
print(tuplaUnElemento2)
Elementos y rodajas de tuplas
Las tuplas son secuencias igual que las listas y se puede utilizar la misma notación de índices que
las listas para obtener cada uno de sus elementos
miTupla = (1, 10, 100, 1000)
Elemento miTupla[0] es 1, miTupla[1] es 2, miTupla[2] es 3, miTupla[3] es 4.
Puedo escribir
miTupla = (1, 10, 100, 1000)
for i in range(4):
print(miTupla[i])

Docente: Ing. Marcelino Torres Villanueva Pag. 1

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

print(miTupla[-1]) # Muestra el ultimo elemento

print(miTupla[1:]) #Muestra (10,100,1000)
print(miTupla[:-2]) #Muestra (1,10)
También se podria imprimir los elementos de la tupla de la siguiente manera:
for elem in miTupla:
print(elem)

Las tuplas no se pueden modificar. Si intentamos ejecutar el siguiente codigo, nos saldra error:
miTupla = (1, 10, 100, 1000)
miTupla.append(10000)
del miTupla[0]
miTupla[1] = -10

Longitud de tuplas
A las tuplas también se les puede aplicar la función len() para calcular su longitud. El valor de esta
función aplicada a una tupla nos indica cuántas componentes tiene esa tupla.
tupla = 1,5,9
Print(len(tupla))

Operaciones con tuplas

• El operador + puede unir tuplas (ya se ha mostrado esto antes).
• El operador * puede multiplicar las tuplas, así como las listas.
• Los operadores in y not in funcionan de la misma manera que en las listas

miTupla = (1, 10, 100)

t1 = miTupla + (1000, 10000)
t2 = miTupla * 3
print(t1)
print(t2)
print(len(t2))
print(10 in miTupla)
print(-10 not in miTupla)
Resultado:
(1, 10, 100, 1000, 10000)
(1, 10, 100, 1, 10, 100, 1, 10, 100)
9
True
True

Una de las propiedades de las tuplas mas útiles es que pueden aparecer en el lado izquierdo del
operador de asignación. Este fenómeno ya se vio con anterioridad, cuando fue necesario
encontrar una manera de intercambiar los valores entre dos variables
var = 123
t1 = (1, )
t2 = (2, )
t3 = (3, var)
t1, t2, t3 = t2, t3, t1
print(t1, t2, t3)

Docente: Ing. Marcelino Torres Villanueva Pag. 2

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

El resultado es:
(2,) (3, 123) (1,)
Muestra tres tuplas interactuando en efecto, los valores almacenados en ellas "circulan" entre
ellas. t1 se convierte en t2, t2 se convierte en t3, y t3 se convierte en t1.
El ejemplo presenta un importante hecho mas: los elementos de una tupla pueden ser variables,
no solo literales. Además, pueden ser expresiones si se encuentran en el lado derecho del
operador de asignacion.

Empaquetado y desempaquetado de tuplas

Si a una variable se le asigna una secuencia de valores separados por comas, el valor de esa
variable será la tupla formada por todos los valores asignados. A esta operación se la denomina
empaquetado de tuplas.
codigo='12345'
apellidos='Zegarra Alvarado'
nombres='Luis'
edad=50
persona=codigo,apellidos,nombres,edad
print(persona)
Si se tiene una tupla de longitud k, se puede asignar la tupla a k variables distintas y en cada
variable quedará una de las componentes de la tupla. A esta operación se la denomina
desempaquetado de tuplas.
tupla=3,5,12,8
x,y,z,w=tupla
print(x,y,z,w)

Diccionarios
Qué es un diccionario?
El diccionario es otro tipo de estructura de datos de Python. No es una secuencia (pero puede
adaptarse fácilmente a un procesamiento secuencial) y además es mutable.
Para explicar lo que es un diccionario en Python, es importante comprender de manera literal lo
que es un diccionario.
Un diccionario en Python funciona de la misma manera que un diccionario bilingüe. Por ejemplo,
se tiene la palabra en español "gato" y se necesita su equivalente en francés. Lo que se haría es
buscar en el diccionario para encontrar la palabra "gato". Eventualmente la encontrarás, y sabrás
que la palabra equivalente en francés es "chat".

En el mundo de Python, la palabra que se esta buscando se denomina clave(key). La palabra que
se obtiene del diccionario es denominada valor.

Esto significa que un diccionario es un conjunto de pares de claves y valores. Nota:

• Cada clave debe de ser única. No es posible tener una clave duplicada.
• Una clave puede ser un tipo de dato de cualquier tipo: puede ser un número (entero o flotante),
o incluso una cadena.
• Un diccionario no es una lista. Una lista contiene un conjunto de valores numerados, mientras
que un diccionario almacena pares de valores.
• La función len() aplica también para los diccionarios, regresa la cantidad de pares (clave-valor) en
el diccionario.

Docente: Ing. Marcelino Torres Villanueva Pag. 3

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

• Un diccionario es una herramienta de un solo sentido. Si fuese un diccionario español-francés,

podríamos buscar en español para encontrar su contraparte en francés mas no viceversa.

¿Cómo crear un diccionario?

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}
numerosTelefono = {'jefe' : 5551234567, 'Suzy' : 22657854310}
diccionarioVacio = {}
print(dict)
print(numerosTelefono)
print(diccionarioVacio)
Resultado:
{'gato': 'chat', 'perro': 'chien', 'caballo': 'cheval'}
{'jefe': 5551234567, 'Suzy': 22657854310}
{}

En este primer ejemplo, el diccionario emplea claves y valores las cuales ambas son cadenas. En el
segundo, las claves con cadenas pero los valores son enteros. El orden inverso (claves → números,
valores → cadenas) también es posible, así como la combinación número a número.
La lista de todos los pares es encerrada con llaves, mientras que los pares son separados por
comas, y las claves y valores por dos puntos.

¿Cómo utilizar un diccionario?

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}
numerosTelefono = {'jefe' : 5551234567, 'Suzy' : 22657854310}
diccionarioVacio = {}
print(dict['gato'])
print(numerosTelefono['Suzy'])
Resultado:
chat
22657854310

El obtener el valor de un diccionario es semejante a la indexación, gracias a los corchetes

alrededor del valor de la clave.
• Si una clave es una cadena, se tiene que especificar como una cadena.
• Las claves son sensibles a las mayúsculas y minúsculas: 'Suzy' sería diferente a 'suzy'.

El siguiente código busca de manera segura palabras en francés:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

words = ['gato', 'leon', 'caballo']

for word in words:

if word in dict:
print(word, "->", dict[word])
else:
print(word, "no está en el diccionario")

Resultado:

Docente: Ing. Marcelino Torres Villanueva Pag. 4

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

gato -> chat

leon no está en el diccionario
caballo -> cheval

¿Cómo utilizar un diccionario? El método keys()

¿Pueden los diccionarios ser examinados utilizando el bucle for, como las listas o tuplas?
No y si.
No, porque un diccionario no es un tipo de dato secuencial - el bucle for no es útil aquí.
Si, porque hay herramientas simples y muy efectivas que pueden adaptar cualquier diccionario a
los requerimientos del bucle for (en otras palabras, se construye un enlace intermedio entre el
diccionario y una entidad secuencial temporal).
El primero de ellos es un método denominado keys(), el cual es parte de todo diccionario. El
método retorna o regresa una lista de todas las claves dentro del diccionario. Al tener una lista de
claves se puede acceder a todo el diccionario de una manera fácil y útil.
A continuación se muestra un ejemplo:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

for key in dict.keys():
print(key, "->", dict[key])
Resultado:
gato -> chat
perro -> chien
caballo -> cheval

La función sorted()
¿Deseas que la salida este ordenada? Solo hay que agregar al bucle for lo siguiente:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

for key in sorted(dict.keys()):
print(key, "->", dict[key])caballo -> cheval
Resultado:
gato -> chat
perro -> chien

¿Cómo utilizar un diccionario? Los métodos item() y values()

Otra manera de hacerlo es utilizar el método items(). Este método regresa una lista de tuplas (este
es el primer ejemplo en el que las tuplas son mas que un ejemplo de si mismas) donde cada tupla
es un par de cada clave con su valor.

Así es como funciona:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

for spanish, french in dict.items():
print(spanish, "->", french)
Resultado:
gato -> chat
perro -> chien
caballo -> cheval

Docente: Ing. Marcelino Torres Villanueva Pag. 5

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

También existe un método denominado values(), funciona de manera muy similar al de keys(),
pero regresa una lista de valores.
Este es un ejemplo sencillo:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

for french in dict.values():

print(french)
Resultado:
cheval
chien
chat

¿Cómo utilizar un diccionario? Modificar, agregar y eliminar valores?

El asignar un nuevo valor a una clave existente es sencillo, debido a que los diccionarios son
completamente mutables, no existen obstáculos para modificarlos.
Se va a reemplazar el valor "chat" por "minou", lo cual no es muy adecuado, pero funcionará con
nuestro ejemplo.
Observa:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

dict['gato'] = 'minou'
print(dict)

La salida es:
{'gato': 'minou','perro': 'chien', 'caballo': 'cheval' }

Agregando nuevas claves

El agregar una nueva clave con su valor a un diccionario es tan simple como cambiar un valor. Solo
se tiene que asignar un valor a una nueva clave que no haya existido antes.
Nota: este es un comportamiento muy diferente comparado a las listas, las cuales no permiten
asignar valores a índices no existentes.
A continuación se agrega un par nuevo al diccionario, un poco extraño pero valido:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

dict['cisne'] = 'cygne'
print(dict)

El ejemplo muestra como salida:

{'gato': 'chat', 'perro': 'chien', 'caballo': 'cheval', 'cisne': 'cygne'}
También es posible insertar un elemento al diccionario utilizando el método update(), por
ejemplo:
dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

Docente: Ing. Marcelino Torres Villanueva Pag. 6

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

dict.update({"pato" : "canard"})
print(dict)
Resultado:
{'gato': 'chat', 'perro': 'chien', 'caballo': 'cheval', 'pato': 'canard'}

Este metodo tambien permite actualizar una clave por ejemplo:

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}

dict.update({"gato" : "minou"})
print(dict)
Resultado
{'gato': 'minou', 'perro': 'chien', 'caballo': 'cheval'}

Eliminado claves
¿Puedes deducir como eliminar una clave de un diccionario?
Nota: al eliminar la clave también se removerá el valor asociado. Los valores no pueden existir sin
sus claves.
Esto se logra con la instrucción del.
A continuación un ejemplo:
dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}
del dict['perro']
print(dict)
Resultado:
{'gato': 'chat', 'caballo': 'cheval'}

Para eliminar el ultimo elemento de la lista, se puede emplear el método popitem():

dict = {"gato" : "chat", "perro" : "chien", "caballo" : "cheval"}
dict.popitem()
print(dict) # outputs: {'gato' : 'chat', 'perro' : 'chien'}

Las tuplas y los diccionarios pueden trabajar juntos

Se ha preparado un ejemplo sencillo, mostrando como las tuplas y los diccionarios pueden trabajar
juntos.
Imaginemos el siguiente problema:
• Necesitas un programa para calcular los promedios de tus alumnos.
• El programa pide el nombre del alumno seguido de su calificación.
• Los nombres son ingresados en cualquier orden.
• El ingresar la palabra exit da por terminado el ingreso de nombres.
• Una lista con todos los nombre y el promedio de cada alumno debe ser mostrada al final.
grupo = {}
while True:
nombre = input("Ingresa el nombre del estudiante (o exit para detenerse): ")
if nombre == 'exit':
break
calif = int(input("Ingresa la calificación del alumno (0-10): "))
if nombre in grupo:
grupo[nombre] += (calif,)
else:

Docente: Ing. Marcelino Torres Villanueva Pag. 7

Curso de Python
-----------------------------------------------------------------------------------------------------------------------------------

grupo[nombre] = (calif,)

for nombre in sorted(grupo.keys()):

sum = 0
contador = 0
for calif in grupo[nombre]:
sum += calif
contador += 1
print(nombre, ":", sum / contador)

Ahora se analizará línea por línea:

• Línea 1: crea un diccionario vacío para ingresar los datos: el nombre del alumno es empleado
como clave, mientras que todas las calificaciones asociadas son almacenadas en una tupla (la tupla
puede ser el valor de un diccionario, esto no es un problema).
• Línea 3: se ingresa a un bucle "infinito" (no te preocupes, saldrémos de el en el momento
indicado).
• Línea 4: se lee el nombre del alumno.
• Línea 5-6: si el nombre es exit, nos salimos del bucle.
• Línea 8: se pide la calificación del alumno (un valor entero en el rango del 1-10).
• Línea 10-11: si el nombre del estudiante ya se encuentra en el diccionario, se alarga la tupla
asociada con la nueva calificación (observa el operador +=).
• Línea 12-13: si el estudiante es nuevo (desconocido para el diccionario), se crea una entrada
nueva, su valor es una tupla de un solo elemento la cual contiene la calificación ingresada.
• Línea 15: se itera a través de los nombres ordenados de los estudiantes.
• Línea 16-17: inicializa los datos necesarios para calcular el promedio (sumador y contador).
• Línea 18-20: Se itera a través de la tupla, tomado todas las calificaciones subsecuentes y
actualizando la suma junto con el contador.
• Línea 21: se calcula e imprime el promedio del alumno junto con su nombre.

Docente: Ing. Marcelino Torres Villanueva Pag. 8