Post on 06-Jul-2018
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
1/36
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
2/36
p. 2
Indice
Índice de contenido
Presentación:.....................................................................4
Objetivos:............................................................................5
Bloques temáticos:............................................................6
1. Diccionarios....................................................................7
1.1. Crear diccionario...................................................................................8
1.2. Encadenamiento y agregar elementos.................................................9
1.3. Pasar a lista..........................................................................................10
1.4. Iterar......................................................................................................10
2. Módulo y paquete.........................................................11
2.1. Preparando y creando distribución de paquete.................................11
..................................................................................................................................11
2.1.1. Paso 1 – Creamos el o los archivos a incluir en el paquete (directorio) 11
2.1.2. Paso 2 – Le agrego un archivo denominado setup.py.............................11
2.1.3. Paso 3 – Construimos la distribución........................................................12
.................................................................................................................................14
2.1.4. Paso 4 – Instalamos la distribución dentro de nuestra distribución local
de Python................................................................................................................14
MBA. Ing. Juan M. BarretoUTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 xxxx xxxxxEmail: cursosprogramados@gmail.com
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
3/36
p. 3
2.1.5. Paso 5 –Ejecutamos módulo......................................................................16
2.1.5.1. Ejecutamos desde distribución.........................................................................16
5.1.5.2. Ejecutamos desde paquete................................................................................17
.................................................................................................................................17
2.1.6. Paso 6 –Modificaciones posteriores..........................................................17
2.1.7. Paso 7 – Registro de distribución en PyPI................................................18
2.2. Optimizando el código.........................................................................18
2.3. Optimizando aún más el código.........................................................20
3. Uso de __main__..........................................................21
Ejercicio............................................................................23
4. Base de Datos: Uso de Shelves..................................26
4.1. Crear archivo de bytes de base de datos...........................................27
4.2. Leer desde “persona” - leerDesdePersona.py..................................27
4.3. Actualizar datos - actualizarDatos.py.................................................28
4.4. Borrar datos - borrarDatos.py.............................................................28
5. Tuplas............................................................................29
6. Más sobre bucles y......................................................30
6.1. Estructura for.......................................................................................30
6.2. Estructura for aplicada a Strings........................................................31
6.3. Estructura for aplicada a Tuplas y objetos con tuplas......................31
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
4/36
p. 4
6.4. Estructura for aplicada a Objetos.......................................................32
6.5. Estructura for aplicada a objetos asociados.....................................32
6.6. Estructura while...................................................................................33
6.6. Estructura while - continue.................................................................34
6.6. Estructura while – breack – while/else...............................................35
Bibliografía.......................................................................36
Presentación:
En esta unidad veremos como llevar nuestros códigos a un nivel optimo de organización
mediante la implementación de módulos y paquetes, los cuales permitirán que nuestros
scripts sean reusables. Un módulo en concreto se corresponde con un script, y cada
módulo puede importar otros mediante el uso de “import” o “from”.
También veremos una forma más eficiente de guardar información que utilizando listas, al
incorporar el uso de diccionarios.
Finalmente profundizaremos un poco en los conceptos de funciones, bucles y estructuras.
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
5/36
p. 5
Objetivos:
Que los participantes:
Aprendan a crear módulos y paquetes, así como a usar diccionarios para guardar y
manipular información.
Profundicen en la comprensión de los conceptos de funciones, estructuras de control y
bucles
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
6/36
p. 6
Bloques temáticos:
1.- Diccionarios.
2.- Módulos y paquetes.
3.- Uso de __main__
4.- Ejemplo Diccionario
5.- Tuplas
6. Más sobre bucles y estructuras
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
7/36
p. 7
1. Diccionarios
Junto con las listas, los diccionarios son uno de los tipos de objetos incorporados por
python, que presentan una gran flexibilidad. Mientras que podemos pensar las listas como
una colección ordenada de objetos, se puede pensar en los diccionarios como
colecciones desordenadas, que poseen como principal distinción el hecho de que los
elementos se almacenan por clave, en lugar de por su posición. Mientras que las listas se
pueden considerar como los arrays de otros lenguajes, los diccionarios toman el lugar de
los registros, tablas de búsqueda, y cualquier otro tipo de registro, en donde los nombres
de los elementos son más significativos que sus posiciones.
La siguiente tabla recoge un resumen de las operaciones más utilizadas.
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
Operación InterpretaciónD = { } Diccionario vacíoD = { 'nombre: 'Juan', 'edad' = 39} Dos items de diccionario! = {'identi"icación': {'nombre': 'Juan', #nidamiento
'apeido': '$arreto'}D = dict%'nombre: 'Juan', 'edad' = 39& !structura aternativaD = dict%%'nombre', 'Juan'&,%'edad', 39&(& )ares cave*vaorD = dict%+ip%'cave','cave-'(,'vaor', 'vaor-'(&& .rear ista con +ipD'identi"icación'('nombre'( Inde/ado por identi"icación 0 nombre
'edad' in D .1e2uear si un campo se encuentra en e diccionarioD4e0s%& 5odas as cavesDvaues%& todos os vaoresDitems%& 5upas de todas as %cave, vaor&Dcop0%& copiarDcear%& remueve todos os itemsDupdate%D-& #6re6o D- a DD6et%cave& Obtiene e vaor de una caveDpop%4e0& $orra un eemento por su cave 0 retorna e vaorist%D4e0s%&& .rea una ista 2ue contiene as caves de diccionarioist%Dvaues%&& .rea una ista 2ue contiene os vaores de diccionarioist%Ditems%&& .rea una ista 2ue contiene as caves 0 os vaores de diccionarioen%D& 7on6itudDcave( = 8- #6re6a una nueva cave con su vaor
.omprensiónprint%cave "or %cave, vaor& in dbitems%&(&print%vaor "or %cave, vaor& in Juanitems%& i" cave == 'identi"icacion'(&print%cave "or cave in db4e0s%&(&
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
8/36
p. 8
1.1. Crear diccionario.
diccionario1_crear.py
# ######################################
# Crear diccionario
# ######################################
F = {'clave1': 'valor1', 'clave2':'valor2', 'claven':'valorn'}
print(F['clave1'])
# ######################################
# Crear por asiganción
# ######################################
J = {}
J['clave1'] = 'valor1'
J['clave2'] = 'valor2'
print(F['clave1'])
# ######################################
# Crear mediante dict()
# ######################################
S = dict(clave1 = 'valor1', clave2 = 'valor2')
print(S['clave1'])
# ######################################
# Crear mediante dict() y zip
# ######################################
P = dict(zip(['clave1', 'clave2'], ['valor1', 'valor2']))
print(P['clave1'])
input()
valor1
valor1
valor1
valor1
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
9/36
p. 9
1.2. Encadenamiento y agregar elementos
diccionarios2_anidar.py
# ######################################
# Encadenamiento
# ######################################
F = {'nombre': {'primero':'Juan', 'segundo':'Marcelo'},
'trabajo':['profesor','ingeniero']
}
print(F)print('nombre')
print(F['nombre']['primero'])
# ######################################
# Agregar elementos
# ######################################
F['trabajo'].append('pintor')
print(F)
input()
{'trabajo': ['profesor', 'ingeniero'], 'nombre': {'primero':'Juan', 'segundo': 'Marcelo'}}
nombre
Juan
{'trabajo': ['profesor', 'ingeniero', 'pintor'], 'nombre':
{'primero': 'Juan', 'segundo': 'Marcelo'}}
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
10/36
p. 10
1.3. Pasar a lista.
diccionarios3_pasar_a_lista.py
# ######################################
# Pasar a lista
# ######################################
F = {'nombre': {'primero': 'Juan', 'segundo': 'Marcelo'},
'trabajo': ['profesor', 'ingeniero']
}
P = list(F.keys())
print(P)
S = list(F.values())
print(S)
input()
['trabajo', 'nombre']
[['profesor', 'ingeniero'], {'primero': 'Juan', 'segundo':
'Marcelo'}]
1.4. Iterar.
diccionarios4_iterar.py
# ######################################
# Iterar
# ######################################
F = {'nombre': {'primero': 'Juan', 'segundo': 'Marcelo'},
'trabajo': ['profesor', 'ingeniero']
}
for key in F:
print(key, '=>', F[key])
input()
trabajo => ['profesor', 'ingeniero']
nombre => {'segundo': 'Marcelo', 'primero': 'Juan'}
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
11/36
p. 11
2. Módulo y paquete
2.1. Preparando y creando distribución de paquete.
Podemos crear paquetes para:
A.- Agregarlos a nuestra distribución de Python
B.- Compartir con otros a través de PyPI
A continuación crearemos un paquete paso a paso:
2.1.1. Paso 1 – Creamos el o los archivos a incluir en el paquete (directorio)
Supongamos que creo el archivo prueba1.py y lo guardo dentro del paquete prueba1.
(Tomo el código del script dado en el ejercicio 11.3 de la Unidad1)
prueba1
prueba1.py
2.1.2. Paso 2 – Le agrego un archivo denominado setup.py
prueba1
prueba1.py
setup.py
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
12/36
p. 12
El contenido de setup.py es el siguiente:
from distutils.core import setup
setup(
name = 'prueba1',
version = '1.0.0',
py_modules = ['prueba1'],
autor = 'hfpython',
autor_email = 'juanbarretor@gmail.com',
url = 'fascinaweb.com',
description = 'Es una prueba de uso',)
Son los nombres de los argumentos de la función setup
Nota: Con py_modules asociamos los metadatos del módulo con los argumentos
de la función setup
2.1.3. Paso 3 – Construimos la distribución
Entramos al directorio del paquete desde el cmd (en mi caso lo tengo en el escritorio) y
escribimos:
C:/Users/Marcelo/Desktop/prueba1>python setup.py sdist
Sale:
C:\Users\Marcelo\Desktop\prueba1>python setup.py sdist
C:\Python34\lib\distutils\dist.py:260: UserWarning: Unknown
distribution option:
'autor_email'
warnings.warn(msg)
C:\Python34\lib\distutils\dist.py:260: UserWarning: Unknowndistribution option:
'autor'
warnings.warn(msg)
running sdist
running check
warning: check: missing meta-data: either (author and
author_email) or (maintain
er and maintainer_email) must be supplied
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
13/36
p. 13
warning: sdist: manifest template 'MANIFEST.in' does not exist(using default fi
le list)
warning: sdist: standard file not found: should have one of
README, README.txt
writing manifest file 'MANIFEST'
creating prueba1-1.0.0
making hard links in prueba1-1.0.0...
hard linking prueba1.py -> prueba1-1.0.0
hard linking setup.py -> prueba1-1.0.0
creating dist
creating 'dist\prueba1-1.0.0.zip' and adding 'prueba1-1.0.0' to
adding 'prueba1-1.0.0\PKG-INFO'
adding 'prueba1-1.0.0\prueba1.py'
adding 'prueba1-1.0.0\setup.py'
removing 'prueba1-1.0.0' (and everything under it)
Ahora la estructura quedo de la siguiente forma:
prueba1
dist
prueba1-1.0.0.zip
PKG-INFO
prueba1.py
setup.py
MANIFEST
prueba1.py
setup.py
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
14/36
p. 14
dist dentro tiene un archivo .zip con nombre igual al paquete y al cual se le ha agregado la
versión
El contenido de PKG-INFO es:
Metadata-Version: 1.0
Name: prueba1
Version: 1.0.0
Summary: Es una prueba de uso
Home-page: fascinaweb.com
Author: UNKNOWN
Author-email: UNKNOWNLicense: UNKNOWN
Description: UNKNOWN
Platform: UNKNOWN
El contenido de MANIFEST es un listado de los archivos en el paquete:
# file GENERATED by distutils, do NOT edit
prueba1.py
setup.py
2.1.4. Paso 4 – Instalamos la distribución dentro de nuestra distribución local
de Python.
Escribimos en el cmd:
C:\Users\Marcelo\Desktop\prueba1>python setup.py install
Nos sale:
C:\Python34\lib\distutils\dist.py:260: UserWarning: Unknown
distribution option:
'autor'
warnings.warn(msg)
C:\Python34\lib\distutils\dist.py:260: UserWarning: Unknown
distribution option:
'autor_email'
warnings.warn(msg)
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
15/36
p. 15
running install
running buildrunning build_py
creating build
creating build\lib
copying prueba1.py -> build\lib
running install_lib
copying build\lib\prueba1.py -> C:\Python34\Lib\site-packages
byte-compiling C:\Python34\Lib\site-packages\prueba1.py to
prueba1.cpython-34.py
c
running install_egg_info
Writing C:\Python34\Lib\site-packages\prueba1-1.0.0-py3.4.egg-info
Ahora la estructura quedo de la siguiente forma:
prueba1
build
libprueba1.py
dist
prueba1-1.0.0.zip
PKG-INFO
prueba1.py
setup.py
MANIFEST
prueba1.py
setup.py
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
16/36
p. 16
2.1.5. Paso 5 –Ejecutamos módulo.
Nuestro módulo ahora se puede ejecutar desde el paquete creado que se encuentra en el
directorio python1 ó desde la copia que se creo en la distribución de python que tenemos
en nuestra máquina en el archivo:
C:\Python34\Lib\site-packages
Aquí se crearon los archivos:
prueba1.py
prueba1-1.0.0-py3.4.egg-info
prueba1-1.0.0-py3.4.egg-info tiene el mismo contenido que PKG-INFO
ademas dentro de:
C:\Python34\Lib\site-packages\__pycache__
Se creo el binario de nuestro módulo.
2.1.5.1. Ejecutamos desde distribución
Si el módulo lo ejecutamos desde la distribución de python en nuestra máquina el código
sería:
02-Paquete-y-Modulo/01-CrearPaquete/prueba2.py
import prueba1
lista = ["elemento1n1", "elemento2n1", "elemento3n1",
["elemento1n2", "elemento2n2", "elemento3n2",
["elemento1n3", "elemento2n3", "elemento3n3"]]]
prueba1.recorrerLista(lista)
+eval(input())
elemento1n1
elemento2n1
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
17/36
p. 17
elemento3n1
elemento1n2elemento2n2
elemento3n2
elemento1n3
elemento2n3
elemento3n3
5.1.5.2. Ejecutamos desde paquete
En este caso el paquete prueba1 esta en el mismo directorio que prueba3.py
02-Paquete-y-Modulo/01-CrearPaquete/DesdePaquete/prueba3.py
import prueba1.prueba1
lista = ["elemento1n1", "elemento2n1", "elemento3n1",
["elemento1n2", "elemento2n2", "elemento3n2",
["elemento1n3", "elemento2n3", "elemento3n3"]]]
prueba1.prueba1.recorrerLista(lista)
+eval(input())
2.1.6. Paso 6 –Modificaciones posteriores.
Si realizáramos una modificación en el código, para que esta se grave tendríamos queejecutar el comando:
C:\Users\Marcelo\Desktop\prueba1>python setup.py sdist upload
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
18/36
p. 18
2.1.7. Paso 7 – Registro de distribución en PyPI
Para poder compartir nuestro código a través de PyPI, necesitamos seguir los siguientes
pasos:
Paso 1. Acceder al sitio web http://pypi.python.org/
Paso 2. Registrarnos y aceptar las normas.
Paso 3. Ingresar por línea de comandos:
C:\Users\Marcelo\Desktop\prueba1>python setup.py register
Aquí se nos pedira nuestro usuario y password.
Paso 4. De necesitar realizar una actualización del código se debe ejecutar:
C:\Users\Marcelo\Desktop\prueba1>python setup.py sdist upload
2.2. Optimizando el código
Podemos optimizar nuestro código si ahora agregamos un segundo parámetro al módulo
prueba1.py que imprima una separación extra por cada nivel de la lista
02-MayorControl-agregamosNivel/prueba1/prueba1.py
def recorrerLista(item, nivel): # Agrego segundo parámetro for x in item:
if isinstance(x, list):
recorrerLista(x, nivel + 1)
else:
for y in range(nivel):
print((''))
print(x)
Ahora puedo crear un script que llame a este paquete mediante import de la siguiente
forma:
02-MayorControl-agregamosNivel/pruebaConNivel.py
import prueba1.prueba1
lista = ["elemento1n1", "elemento2n1", "elemento3n1",
["elemento1n2", "elemento2n2", "elemento3n2",
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
19/36
p. 19
["elemento1n3", "elemento2n3", "elemento3n3"]]]
# Agrego segundo parámetroprueba1.prueba1.recorrerLista(lista, 0)
+eval(input())
elemento1n1
elemento2n1
elemento3n1
elemento1n2
elemento2n2
elemento3n2
elemento1n3
elemento2n3
elemento3n3
Lo que hemos logrado es que se agregue por cada nivel un salto de línea extra.
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
20/36
p. 20
2.3. Optimizando aún más el código
Podría darse el caso en el cual una persona se olvide de agregar el parámetro
que indica el nivel, en cullo caso el programa daría un error. Para evitar esto
le pasamos un valor por defecto al parámetro nivel, y si la persona se olvida de
indicarlos al llamar a la función, el programa se seguiría ejecutando.
03-MayorContro-agregamosNivel-valorPorDefecto/prueba1/prueba1.py
def recorrerLista(item, nivel=0): # Agrego valor por defecto
for x in item:
if isinstance(x, list):
recorrerLista(x, nivel + 1)
else:
for y in range(nivel):
print("\t", end="") # Agrego indentación en lugar de saltos de línea
print(x)
elemento1n1
elemento2n1
elemento3n1
elemento1n2
elemento2n2elemento3n2
elemento1n3
elemento2n3
elemento3n3
Notar que aquí se ha agregado una indentación en lugar del salto de línea con lo cual la
salida queda más legible.
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
21/36
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
22/36
p. 22
elemento2n1
elemento3n1elemento1n2
elemento2n2
elemento3n2
elemento1n3
elemento2n3
elemento3n3
--NIVEL 1------------------------------------
elemento1n1
elemento2n1elemento3n1
['elemento1n2', 'elemento2n2', 'elemento3n2', ['elemento1n3', 'elemento2n3',
'elemento3n3']]
--NIVEL 2------------------------------------
elemento1n2
elemento2n2
elemento3n2
['elemento1n3', 'elemento2n3', 'elemento3n3']
--NIVEL 3------------------------------------
elemento1n3
elemento2n3
elemento3n3
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
23/36
p. 23
Ejercicio
Una de las ventajas que incorpora Python con el uso de __main__ es poder llamar un
módulo
001-definir-diccionario.py
import pprint
# #################################################
# Definir diccionarios
# #################################################
Juan = {'identificacion': {'nombre': 'Juan', 'apellido':'Garcia'},
'edad': 24,
'sueldo': 5000,
'profesión': 'Pintor'}
Susana = {'identificacion': {'nombre': 'Susana', 'apellido':
'Gomez'},
'edad':25,
'sueldo': 6000,
'profesión': 'Empleada'}
print(Juan)
print(Susana)
print('------------------------------')
# #################################################
# Lista de diccionarios
# #################################################
personas = [Juan, Susana]
for x in personas:
print(x['identificacion']['nombre'], end='!\n')
print('------------------------------')
# #################################################
# Diccionario de diccionarios
# #################################################
db= {}
db['Juan']= Juan
db['Susana']= Susana
print(db['Juan']['identificacion']['nombre'])
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
24/36
p. 24
print(db['Juan']['edad'])
print('------------------------------')print(db)
print('------------------------------')
# #################################################
# Aumentar legibilidad con módulo pprint
# #################################################
pprint.pprint(db)
print('------------------------------')
# #################################################
# Chequear presencia de un elemento
# #################################################
print('identificacion' in Juan)
print('nombre' in Juan)
print('nombre' in db)
print('------------------------------')
# #################################################
# Recorrer diccionario (comprension)
# #################################################
print([clave for (clave, valor) in db.items()])
print([valor for (clave, valor) in Juan.items() if clave =='identificacion'])
print([clave for clave in db.keys()])
+eval(input())
{'edad': 24, 'sueldo': 5000, 'profesión': 'Pintor',
'identificacion': {'apellido': 'Garcia', 'nombre': 'Juan'}}
{'edad': 25, 'sueldo': 6000, 'profesión': 'Empleada',
'identificacion': {'apellido': 'Gomez', 'nombre': 'Susana'}}
------------------------------
Juan!
Susana!
------------------------------
Juan
24
------------------------------
{'Susana': {'edad': 25, 'sueldo': 6000, 'profesión': 'Empleada',
'identificacion': {'apellido': 'Gomez', 'nombre': 'Susana'}},
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
25/36
p. 25
'Juan': {'edad': 24, 'sueldo': 5000, 'profesión': 'Pintor',
'identificacion': {'apellido': 'Garcia', 'nombre': 'Juan'}}}------------------------------
{'Juan': {'edad': 24,
'identificacion': {'apellido': 'Garcia', 'nombre':
'Juan'},
'profesión': 'Pintor',
'sueldo': 5000},
'Susana': {'edad': 25,
'identificacion': {'apellido': 'Gomez', 'nombre':
'Susana'},
'profesión': 'Empleada',
'sueldo': 6000}}
------------------------------
True
False
False
------------------------------
['Susana', 'Juan']
[{'apellido': 'Garcia', 'nombre': 'Juan'}]
['Susana', 'Juan']
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
26/36
p. 26
4. Base de Datos: Uso de Shelves.
El módulo shelves nos da una forma de acceso al almacenamiento de datos mediante
clave valor que nos permite persistir datos y acceder en forma individual a cada uno para
realizar acciones como la actualización de los mismos. Su funcionamiento es similar a
Pickle (otro módulo que nos permite persistir datos), pero mucho más simple, de hecho es
idéntico al uso de diccionario, pero con las llamadas extras de apertura y cierre.
Partamos del siguiente registro de datos:
04-bd-shelves/datosInicioP/datosInicioM.py
# #################################################
# Datos
# #################################################
Juan = {'identificacion': {'nombre': 'Juan', 'apellido':
'Garcia'},
'edad': 24,
'sueldo': 5000,
'profesión': 'Pintor'}
Susana = {'identificacion': {'nombre': 'Susana', 'apellido':
'Gomez'},
'edad': 25,
'sueldo': 6000,
'profesión': 'Empleada'}
# #################################################
# Base de datos
# #################################################
db = {}
db['Juan'] = Juan
db['Susana'] = Susana
# #################################################
# Evaluar solo al correr script
# #################################################
if __name__ == '__main__':
for clave in db:
print(clave, '=>\n', db[clave])
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
27/36
p. 27
4.1. Crear archivo de bytes de base de datos.
A continuación vamos utilizar el módulo :
04-bd-shelves/crearDb.py
if __name__ == '__main__':
from datosInicioP.datosInicioM import Juan, Susana
import shelve
db = shelve.open('persona')
db['Juan'] = Juan
db['Susana'] = Susana
db.close()
print('-----------------------')
F
Nota1: Se crean en el directorio, tres archivos a ser utilizados como bd en donde la
información se reparte entre los tres:
1.- persona.bak
2.- persona.dir
3.- pesona
Nota 2: El método open() lo utilizamos para abrir un archivo en la ruta especificada,
si el archivo no existe este se crea.
INDB =
4.2. Leer desde “persona” - leerDesdePersona.py
04-bd-shelves/leerDesdePersona.py
import shelve
db = shelve.open('persona')
for key in db:
print(key, '=>\n ', db[key])
print(db['Juan']['edad'])
db.close()
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
28/36
p. 28
4.3. Actualizar datos - actualizarDatos.py
04-bd-shelves/actualizarDatos.py
from datosInicioP.datosInicioM import Tom
import shelve
db = shelve.open('persona')
Juan = db['Juan'] # obtener Juan
Juan['edad'] = 33
db['Juan'] = Juan # actualizar Juan
db['Tom'] = Tomdb.close()
4.4. Borrar datos - borrarDatos.py
04-bd-shelves/borrarDatos.py
import shelve
db = shelve.open('persona')
del db['Susana']
db.close()
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
29/36
p. 29
5. Tuplas
Las tuplas son secuencias como las listas pero son INMUTABLES como los strings
Se utilizan para representar colecciones fijas de items. Por ejemplo los componentes
de un calendario específico.
Se crean utilizando parentesis, de forma muy similar a las listas, salvo que las listas son
MUTABLES.
05-Tuplas/tupla1.py
# ####################################### Crear tupla
# ######################################
F = (1, 2, 3, 4, 5, 3)
print(len(F))
# ######################################
# Extender
# ######################################
F + (6, 7)
print(F)# ######################################
# Determinar un elemento
# ######################################
print(F[0])
# ######################################
# Posición de un elemento
# ######################################
print(F.index(3))
# ######################################
# n° de veces que aparece un elemento
# ######################################
print(F.count(3))
input()
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
30/36
p. 30
6. Más sobre bucles y estructuras
6.1. Estructura for aplicado a secuencia de objetos.
Ya hemos visto en la unidad anterior la estructura básica for, y la hemos aplicado a varios
ejercicios, a continuación profundizaremos en esta estructura para poder lograr una mayor
fluidez en la escritura de código.
Para comenzar, veamos algunos ejemplos de repaso, aplicando la estructura for a
recorrer una lista de objetos:
06-for/01-SecuenciaDeObjetos.py
for x in ["peras", "manzanas", "naranjas"]:
print(x, end=' ')
Ahora hagamos algo un poquito más complejo que solo recorrer una lista, y vemos como
podemos realizar la suma de valores numéricos:
suma = 0
for x in [1, 2, 3, 4]:
suma = suma + x
print(suma)
Como podemos ver el ejercicio anterior declara una variable “suma” y en cada vuelta del
for recorre una lista de cuatro números y los va sumando. Esto parece demasiado
abstracto y sin aplicación, pero bastaría poder tomar los valores de la lista desde un
campo input de una página web, o esde un input de una plataforma gráfica como las que
veremos más adelante, y hacer una calculadora online o de escritorio.
Ejercicio: Realizar un script que en lugar de sumar multiplique. Ver resultado en el
script 01-SecuenciaDeObjetos.
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
31/36
p. 31
6.2. Estructura for aplicada a Strings
La estructura for puede ser utilizada para recorrer y recoger los elmentos de un string, de
la siguiente manera:
06-for/02-String.py
A = "Manzana"
for x in A: print(x, end=' ')
Nota: En el ejemplo anterior el print() puede ir en la misma línea que el for, pero si loponemos en una nueva línea debemos recordar aplicarle la indentación correspondiente.
6.3. Estructura for aplicada a Tuplas y objetos con tuplas
Como podemos deducir a estas alturas, recorrer una tupla no difiere mucho de como
recorremos un string o una lista, veamos un ejemplo:
06-for/03-Tuplas.py
A = ("Hay", "manzanas", "rojas")
for x in A: print(x, end=' ')
Es posible dar un pasito más y crear listas cuyos elementos sean tuplas y luego
recorrerlos, veamos un par de ejemplos:
Ejemplo 1
06-for/04-ListasConTuplas.py
A = [(1,2), (3,4), (5,6)]
for x in A: print(x, end=' ')
print('',end='\n################\n' )
Ejemplo 2
A = [(1,2), (3,4), (5,6)]
for (x,y) in A: print(x, '=>', y)
input()
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
32/36
p. 32
En el primer ejemplo solo recorremos y obtenemos los elementos de la lista, en el
segundo obtenemos los elementos de la lista y los formateamos.
6.4. Estructura for aplicada a Objetos
De forma análoga, podemos recorrer un diccionario y formatearlo, veamos un ejemplo:
06-for/05-Diccionarios.py
A = {'a':1, 'b':2, 'c':3}for clave in A: print(clave,'=>', A[clave])
6.5. Estructura for aplicada a objetos asociados
Supongamos que tenemos dos objetos y queremos saber si los elementos de un objeto
se encuentran en el otro, por ejemplo si tubieramos dos listas de elementos (las listas
podrían ser passwords, roles de usuarios, etc), en este caso podríamos hacer uso de la
estructura for combinada con una estructura if/else y tomar decisiones (en este caso
imprimir una frase con su valor correspondiente) según exista coincidencia o no.
06-for/06-AsociarDatosSecuenciaObjetos.py
A = ["Hay", 2323 , (1,2)]
B = [(1,2) , 545]
for b in B:
if b in A:
print("Se encontro coincidencia", b)
else:
print("No se encontro coincidencia", b)
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
33/36
p. 33
6.6. Estructura while
La estructura while es un bucle muy utilizado en programación, por ejemplo si
estuviéramos presentando noticias en una página web traídas desde un base de datos,
podríamos utilizar un bucle while para que mientras que la condición se cumpla se
impriman en pantalla los datos.
Un par de ejemplos ilustrativos nos van a ayudar a comprender su sintaxis y
funcionamiento:
06-while/06-estructura.py
# ################################### Ejemplo 1
# ##################################
a = 'Curso'
while a:
print(a, end=' ')
a = a[1:]
# ##################################
# Ejemplo 2
# ##################################a = 1; b= 7
while a < b:
print(a, end=' ')
a += 1
Notemos como en el primer caso partimos de un string “a”, en donde la primera vez que
entramos al while imprimimos la palabra “Curso”, pero la segunda vez le quitamos una
letra, y en cada vuelta siguiente le seguimos sacando de a una letra hasta que ya no hay
que imprimir. El resultado se vería así:
Curso urso rso so o
El segundo ejemplo es similar, pero en cada vuelta de a sumamos 1 hasta que a deja de
ser menor que b, dando un resultado como sigue:
1 2 3 4 5 6
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
34/36
p. 34
6.6. Estructura while - continue
La palabra continue se puede utilizar para que una condición se saltee un segmento de
código se la utilizamos, por ejemplo en el siguiente caso si el resto de dividir por 2 es
distinto de cero (distinto se expresa como !=) se saltea la impresión y sino imprime el
valor:
06-while/02-breack-continue.py
# ##################################
# Ejemplo 1
# continue: no imprime los números# que al dividir por 2 dan resto cero
# ##################################
print('',end='\n################\n' )
x = 10
while x:
x = x - 1
if x % 2 != 0: continue
print(x, end=' ')
El resultado sería:
8 6 4 2 0
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
35/36
p. 35
6.6. Estructura while – breack – while/else
Otra palabra utilizada a menudo es “breack”, la cual si una determinada condición se
cumple el programa finaliza su ejecución. En el siguiente ejemplo el valor de 5 es
alcanzado antes que el de 7 (logicamente) y por lo tanto cuando cuando es leida la quinta
línea de código la ejecución se corta y núnca se llega al else asociado al while.
Nota 1: Veamos de paso que a diferencia de otros lenguajes podemos utilizar el
else junto al while.
a = 1; b= 7
while a < b:
print(a, end=' ')
a += 1
if a > 5: break
if a > 2: continue
print(a, end=' ')
else:
print("hola")
La salida da:
1 2 2 3 4 5
Nota: el segundo print es salteado a partír del 2 ya que estamos utilizando
“continue”.
Centro de Formación, Investigación y Desarrollo de Soluciones de e-Learning.UTN - FRBA. Secretaría de Cultura y Extensión Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 4867 7589 / Fax +54 11 4032 0148 // e-learning@sceu.frba.utn.edu.ar
www.sceu.frba.utn.edu.ar/e-learning
8/16/2019 Unidad 2 Diccionarios Paquetes Modulos
36/36
p. 36
Bibliografía
Libros
Programming Python 5th Edition – Mark Lutz – O'Reilly 2013
Programming Python 4th Edition – Mark Lutz – O'Reilly 2011
Head First Python – Paul Barry – O'Reilly 2011
Manual online
https://docs.python.org/3.4/library/intro.html