Unidad 2 Diccionarios Paquetes Modulos PDF

UNIDAD II
Diccionarios Paquetes - Mdulos
MBA. Ing. Juan M. Barreto

UTN - FRBA. Secretara de Cultura y Extensin Universitaria
Medrano 951 2do piso (1179) // Tel. +54 11 xxxx xxxxx
Email: cursosprogramados@gmail.com
p. 2
Indice
ndice de contenido
Presentacin:.....................................................................4
Objetivos:............................................................................5
Bloques temticos:............................................................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. Mdulo y paquete.........................................................11
2.1. Preparando y creando distribucin 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 distribucin........................................................12
.................................................................................................................................14
2.1.4. Paso 4 Instalamos la distribucin dentro de nuestra distribucin local
de Python................................................................................................................14
MBA. Ing. Juan M. Barreto

Medrano 951 2do piso (1179) // Tel. +54 11 xxxx xxxxx
Email: cursosprogramados@gmail.com
p. 3
2.1.5. Paso 5 Ejecutamos mdulo......................................................................16

2.1.5.1. Ejecutamos desde distribucin.........................................................................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 distribucin en PyPI................................................18
2.2. Optimizando el cdigo.........................................................................18

2.3. Optimizando an ms el cdigo.........................................................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. Ms 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 Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

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
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
Bibliografa.......................................................................36
Presentacin:
En esta unidad veremos como llevar nuestros cdigos a un nivel optimo de organizacin
mediante la implementacin de mdulos y paquetes, los cuales permitirn que nuestros
scripts sean reusables. Un mdulo en concreto se corresponde con un script, y cada
mdulo puede importar otros mediante el uso de import o from.
Tambin veremos una forma ms eficiente de guardar informacin que utilizando listas, al
incorporar el uso de diccionarios.
Finalmente profundizaremos un poco en los conceptos de funciones, bucles y estructuras.

p. 5
Objetivos:
Que los participantes:
Aprendan a crear mdulos y paquetes, as como a usar diccionarios para guardar y
manipular informacin.
Profundicen en la comprensin de los conceptos de funciones, estructuras de control y
bucles

p. 6
Bloques temticos:
1.- Diccionarios.
2.- Mdulos y paquetes.
3.- Uso de __main__
4.- Ejemplo Diccionario
5.- Tuplas
6. Ms sobre bucles y estructuras

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 coleccin ordenada de objetos, se puede pensar en los diccionarios como
colecciones desordenadas, que poseen como principal distincin el hecho de que los
elementos se almacenan por clave, en lugar de por su posicin. Mientras que las listas se
pueden considerar como los arrays de otros lenguajes, los diccionarios toman el lugar de
los registros, tablas de bsqueda, y cualquier otro tipo de registro, en donde los nombres
de los elementos son ms significativos que sus posiciones.
La siguiente tabla recoge un resumen de las operaciones ms utilizadas.
Operacin
Interpretacin
D={}
Diccionario vaco
D = { 'nombre: 'Juan', 'edad' = 39}
Dos items del diccionario
E = {'identificacin': {'nombre': 'Juan',
Anidamiento
'apellido': 'Barreto'}
D = dict('nombre: 'Juan', 'edad' = 39)
Estructura alternativa
D = dict([('nombre', 'Juan'),('edad', 39)])
Pares clave/valor
D = dict(zip(['clave1','clave2'],['valor1', 'valor2']))
Crear lista con zip
D['identificacin']['nombre']
Indexado por identificacin y nombre
'edad' in D
Chequear si un campo se encuentra en el diccionario
D.keys()
Todas las claves
D.values()
todos los valores
D.items()
Tuplas de todas las (clave, valor)
D.copy()
copiar
D.clear()
remueve todos los items
D.update(D2)
Agrego D2 a D
D.get(clave)
Obtiene el valor de una clave
D.pop(key)
Borra un elemento por su clave y retorna el valor
list(D.keys())
Crea una lista que contiene las claves del diccionario
list(D.values())
Crea una lista que contiene los valores del diccionario
list(D.items())
Crea una lista que contiene las claves y los valores del diccionario
len(D)
Longitud
D[clave] = 42
Agrega una nueva clave con su valor
Comprensin
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()])

p. 8
1.1. Crear diccionario.

diccionario1_crear.py
# ######################################
# Crear diccionario
# ######################################
F = {'clave1': 'valor1', 'clave2':'valor2', 'claven':'valorn'}
print(F['clave1'])
# ######################################
# Crear por asigancin
# ######################################
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

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',
{'primero': 'Juan', 'segundo': 'Marcelo'}}
'pintor'],
'nombre':

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',
'Marcelo'}]
'ingeniero'],
{'primero':
'Juan',
'segundo':
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'}

p. 11
2. Mdulo y paquete
2.1. Preparando y creando distribucin de paquete.
Podemos crear paquetes para:
A.- Agregarlos a nuestra distribucin de Python
B.- Compartir con otros a travs de PyPI
A continuacin 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 cdigo 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

p. 12
El contenido de setup.py es el siguiente:

from distutils.core import setup
setup(
name
version
py_modules
autor
autor_email
url
description
= 'prueba1',
= '1.0.0',
= ['prueba1'],
= 'hfpython',
= 'juanbarretor@gmail.com',
= 'fascinaweb.com',
= 'Es una prueba de uso',
)
Son los nombres de los argumentos de la funcin setup
Nota: Con py_modules asociamos los metadatos del mdulo con los argumentos
de la funcin setup
2.1.3. Paso 3 Construimos la distribucin

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)
'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

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

p. 14
dist dentro tiene un archivo .zip con nombre igual al paquete y al cual se le ha agregado la
versin
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: UNKNOWN
License: 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 distribucin dentro de nuestra distribucin local

de Python.
Escribimos en el cmd:
C:\Users\Marcelo\Desktop\prueba1>python setup.py install
Nos sale:
'autor'
warnings.warn(msg)
'autor_email'
warnings.warn(msg)

p. 15
running install
running build
running 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
lib
prueba1.py
dist
prueba1-1.0.0.zip
PKG-INFO
prueba1.py
setup.py
MANIFEST
prueba1.py
setup.py

p. 16
2.1.5. Paso 5 Ejecutamos mdulo.

Nuestro mdulo ahora se puede ejecutar desde el paquete creado que se encuentra en el
directorio python1 desde la copia que se creo en la distribucin de python que tenemos
en nuestra mquina 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 mdulo.
2.1.5.1. Ejecutamos desde distribucin
Si el mdulo lo ejecutamos desde la distribucin de python en nuestra mquina el cdigo

sera:
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

p. 17
elemento3n1
elemento1n2
elemento2n2
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
prueba1.prueba1.recorrerLista(lista)
+eval(input())
2.1.6. Paso 6 Modificaciones posteriores.

Si realizramos una modificacin en el cdigo, para que esta se grave tendramos que
ejecutar el comando:
C:\Users\Marcelo\Desktop\prueba1>python setup.py sdist upload

p. 18
2.1.7. Paso 7 Registro de distribucin en PyPI

Para poder compartir nuestro cdigo a travs 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 lnea 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 actualizacin del cdigo se debe ejecutar:
C:\Users\Marcelo\Desktop\prueba1>python setup.py sdist upload
2.2. Optimizando el cdigo

Podemos optimizar nuestro cdigo si ahora agregamos un segundo parmetro al mdulo
prueba1.py que imprima una separacin extra por cada nivel de la lista
02-MayorControl-agregamosNivel/prueba1/prueba1.py
def recorrerLista(item, nivel):
# Agrego segundo parmetro
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

p. 19

# Agrego segundo parmetro
prueba1.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 lnea extra.

p. 20
2.3. Optimizando an ms el cdigo

Podra darse el caso en el cual una persona se olvide de agregar el parmetro
que indica el nivel, en cullo caso el programa dara un error. Para evitar esto
le pasamos un valor por defecto al parmetro nivel, y si la persona se olvida de
indicarlos al llamar a la funcin, el programa se seguira ejecutando.
03-MayorContro-agregamosNivel-valorPorDefecto/prueba1/prueba1.py
def recorrerLista(item, nivel=0):
# Agrego valor por defecto
for x in item:
else:
print("\t", end="")
# Agrego indentacin en lugar de saltos de lnea
print(x)
elemento1n1
elemento2n1
elemento3n1
elemento1n2
elemento2n2
elemento3n2
elemento1n3
elemento2n3
elemento3n3
Notar que aqu se ha agregado una indentacin en lugar del salto de lnea con lo cual la
salida queda ms legible.

p. 21
3. Uso de __main__
Una de las ventajas que incorpora Python con el uso de __main__ es poder llamar un
mdulo directamente, con un cdigo de prueba que es ledo y ejecutado unicamente
cuando este se invoca. Esto permite testear nuestro script y dejar en el mismo el cdigo
de prueba.
03-Uso-de-main/prueba1/prueba1.py
def recorrerLista(item, nivel=0):
for x in item:
else:
print("\t", end="")
print(x)
if __name__ == '__main__':
recorrerLista(lista)
print('--NIVEL 1------------------------------------')
print(lista[0])
print(lista[1])
print(lista[2])
print(lista[3])
print('--NIVEL 2------------------------------------')
print(lista[3][0])
print(lista[3][1])
print(lista[3][2])
print(lista[3][3])
print('--NIVEL 3------------------------------------')
print(lista[3][3][0])
input()
elemento1n1

p. 22
elemento2n1
elemento3n1
elemento1n2
elemento2n2
elemento3n2
elemento1n3
elemento2n3
elemento3n3
--NIVEL 1-----------------------------------elemento1n1
elemento2n1
elemento3n1
['elemento1n2', 'elemento2n2', 'elemento3n2', ['elemento1n3', 'elemento2n3',
'elemento3n3']]
--NIVEL 2-----------------------------------elemento1n2
elemento2n2
elemento3n2
['elemento1n3', 'elemento2n3', 'elemento3n3']
--NIVEL 3-----------------------------------elemento1n3
elemento2n3
elemento3n3

p. 23
Ejercicio
Una de las ventajas que incorpora Python con el uso de __main__ es poder llamar un
mdulo
001-definir-diccionario.py
import pprint
# #################################################
# Definir diccionarios
# #################################################
Juan = {'identificacion': {'nombre': 'Juan', 'apellido':
'Garcia'},
'edad': 24,
'sueldo': 5000,
'profesin': 'Pintor'}
Susana = {'identificacion': {'nombre': 'Susana', 'apellido':
'Gomez'},
'edad':25,
'sueldo': 6000,
'profesin': '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'])

p. 24
print(db['Juan']['edad'])
print('------------------------------')
print(db)
print('------------------------------')
# #################################################
# Aumentar legibilidad con mdulo 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, 'profesin': 'Pintor',
'identificacion': {'apellido': 'Garcia', 'nombre': 'Juan'}}
{'edad': 25, 'sueldo': 6000, 'profesin': 'Empleada',
'identificacion': {'apellido': 'Gomez', 'nombre': 'Susana'}}
-----------------------------Juan!
Susana!
-----------------------------Juan
24
-----------------------------{'Susana': {'edad': 25, 'sueldo': 6000, 'profesin': 'Empleada',
'identificacion': {'apellido': 'Gomez', 'nombre': 'Susana'}},

p. 25
'Juan': {'edad': 24, 'sueldo': 5000, 'profesin': 'Pintor',

'identificacion': {'apellido': 'Garcia', 'nombre': 'Juan'}}}
-----------------------------{'Juan': {'edad': 24,
'identificacion': {'apellido': 'Garcia', 'nombre':
'Juan'},
'profesin': 'Pintor',
'sueldo': 5000},
'Susana': {'edad': 25,
'identificacion': {'apellido': 'Gomez', 'nombre':
'Susana'},
'profesin': 'Empleada',
'sueldo': 6000}}
-----------------------------True
False
False
-----------------------------['Susana', 'Juan']
[{'apellido': 'Garcia', 'nombre': 'Juan'}]
['Susana', 'Juan']

p. 26
4. Base de Datos: Uso de Shelves.

El mdulo 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 actualizacin de los mismos. Su funcionamiento es similar a
Pickle (otro mdulo que nos permite persistir datos), pero mucho ms simple, de hecho es
idntico 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,
'profesin': 'Pintor'}
Susana = {'identificacion': {'nombre': 'Susana', 'apellido':
'Gomez'},
'edad': 25,
'sueldo': 6000,
'profesin': '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])

p. 27
4.1. Crear archivo de bytes de base de datos.

A continuacin vamos utilizar el mdulo :
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
informacin se reparte entre los tres:
1.- persona.bak
2.- persona.dir
3.- pesona
Nota 2: El mtodo 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
for key in db:
print(key, '=>\n ', db[key])
print(db['Juan']['edad'])
db.close()

p. 28
4.3. Actualizar datos - actualizarDatos.py

04-bd-shelves/actualizarDatos.py
from datosInicioP.datosInicioM import Tom
import shelve
Juan = db['Juan'] # obtener Juan
Juan['edad'] = 33
db['Juan'] = Juan # actualizar Juan
db['Tom'] = Tom
db.close()
4.4. Borrar datos - borrarDatos.py

04-bd-shelves/borrarDatos.py
import shelve
del db['Susana']
db.close()

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 especfico.
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])
# ######################################
# Posicin de un elemento
# ######################################
print(F.index(3))
# ######################################
# n de veces que aparece un elemento
# ######################################
print(F.count(3))
input()

p. 30
6. Ms sobre bucles y estructuras

6.1. Estructura for aplicado a secuencia de objetos.
Ya hemos visto en la unidad anterior la estructura bsica for, y la hemos aplicado a varios
ejercicios, a continuacin profundizaremos en esta estructura para poder lograr una mayor
fluidez en la escritura de cdigo.
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 ms complejo que solo recorrer una lista, y vemos como
podemos realizar la suma de valores numricos:
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 nmeros y los va sumando. Esto parece demasiado
abstracto y sin aplicacin, pero bastara poder tomar los valores de la lista desde un
campo input de una pgina web, o esde un input de una plataforma grfica como las que
veremos ms 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.

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 lnea que el for, pero si lo
ponemos en una nueva lnea debemos recordar aplicarle la indentacin 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")
Es posible dar un pasito ms 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)]
print('',end='\n################\n' )
Ejemplo 2
A = [(1,2), (3,4), (5,6)]
for (x,y) in A: print(x, '=>', y)
input()

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 anloga, 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
podran ser passwords, roles de usuarios, etc), en este caso podramos 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) segn 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)

p. 33
6.6. Estructura while

La estructura while es un bucle muy utilizado en programacin, por ejemplo si
estuviramos presentando noticias en una pgina web tradas desde un base de datos,
podramos utilizar un bucle while para que mientras que la condicin 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 vera 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:
123456

p. 34
6.6. Estructura while - continue

La palabra continue se puede utilizar para que una condicin se saltee un segmento de
cdigo 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 impresin y sino imprime el
valor:
06-while/02-breack-continue.py
# ##################################
# Ejemplo 1
# continue: no imprime los nmeros
# 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 sera:
86420

p. 35
6.6. Estructura while breack while/else

Otra palabra utilizada a menudo es breack, la cual si una determinada condicin se
cumple el programa finaliza su ejecucin. 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
lnea de cdigo la ejecucin se corta y nnca 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:
122345
Nota: el segundo print es salteado a partr del 2 ya que estamos utilizando
continue.

p. 36
Bibliografa
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


Unidad 2 Diccionarios Paquetes Modulos PDF

Cargado por

Información del documento

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

Unidad 2 Diccionarios Paquetes Modulos PDF

Cargado por

Copyright:

Formatos disponibles

UNIDAD II

Diccionarios Paquetes - Mdulos

MBA. Ing. Juan M. Barreto

MBA. Ing. Juan M. Barreto

2.1.5. Paso 5 Ejecutamos mdulo......................................................................16

2.2. Optimizando el cdigo.........................................................................18

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

6.4. Estructura for aplicada a Objetos.......................................................32

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

1.1. Crear diccionario.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

1.2. Encadenamiento y agregar elementos

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

1.3. Pasar a lista.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

A continuacin crearemos un paquete paso a paso:

2.1.1. Paso 1 Creamos el o los archivos a incluir en el paquete (directorio)

2.1.2. Paso 2 Le agrego un archivo denominado setup.py

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

El contenido de setup.py es el siguiente:

2.1.3. Paso 3 Construimos la distribucin

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

warning: sdist: manifest template 'MANIFEST.in' does not exist

Ahora la estructura quedo de la siguiente forma:

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

El contenido de MANIFEST es un listado de los archivos en el paquete:

2.1.4. Paso 4 Instalamos la distribucin dentro de nuestra distribucin local

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Ahora la estructura quedo de la siguiente forma:

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

2.1.5. Paso 5 Ejecutamos mdulo.

tiene el mismo contenido que PKG-INFO

ademas dentro de:

Si el mdulo lo ejecutamos desde la distribucin de python en nuestra mquina el cdigo

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

5.1.5.2. Ejecutamos desde paquete

En este caso el paquete prueba1 esta en el mismo directorio que prueba3.py

2.1.6. Paso 6 Modificaciones posteriores.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

2.1.7. Paso 7 Registro de distribucin en PyPI

2.2. Optimizando el cdigo

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

["elemento1n3", "elemento2n3", "elemento3n3"]]]

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

2.3. Optimizando an ms el cdigo

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

'Juan': {'edad': 24, 'sueldo': 5000, 'profesin': 'Pintor',

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

4. Base de Datos: Uso de Shelves.

Partamos del siguiente registro de datos:

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

4.1. Crear archivo de bytes de base de datos.

Nota 2: El mtodo open() lo utilizamos para abrir un archivo en la ruta especificada,

4.2. Leer desde persona - leerDesdePersona.py

Centro de Formacin, Investigacin y Desarrollo de Soluciones de e-Learning.

4.3. Actualizar datos - actualizarDatos.py