unidad 2 diccionarios paquetes modulos

8/16/2019 Unidad 2 Diccionarios Paquetes Modulos

1/36


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: [email protected]


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 // [email protected]

www.sceu.frba.utn.edu.ar/e-learning


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.





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





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





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.




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/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





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





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





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





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 = '[email protected]',

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





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





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:



'autor'

warnings.warn(msg)



'autor_email'

warnings.warn(msg)





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





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





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




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





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







19/36

p. 19


# 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.





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


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.





21/36


22/36

p. 22

elemento2n1


elemento2n2

elemento3n2

elemento1n3

elemento2n3

elemento3n3

--NIVEL 1------------------------------------

elemento1n1


['elemento1n2', 'elemento2n2', 'elemento3n2', ['elemento1n3', 'elemento2n3',

'elemento3n3']]

--NIVEL 2------------------------------------

elemento1n2

elemento2n2

elemento3n2

['elemento1n3', 'elemento2n3', 'elemento3n3']

--NIVEL 3------------------------------------

elemento1n3

elemento2n3

elemento3n3





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





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'}},





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





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





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


for key in db:

print(key, '=>\n ', db[key])

print(db['Juan']['edad'])

db.close()





28/36

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'] = Tomdb.close()

4.4. Borrar datos - borrarDatos.py

04-bd-shelves/borrarDatos.py

import shelve


del db['Susana']

db.close()





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





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.





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


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


print('',end='\n################\n' )

Ejemplo 2

A = [(1,2), (3,4), (5,6)]

for (x,y) in A: print(x, '=>', y)

input()





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)





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





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





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”.





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

unidad 2 diccionarios paquetes modulos

Documents