Algoritmos Programacion Python

Algoritmos y Programacin ICon lenguaje Python

9 de marzo de 2011

Contenidos

1. Conceptos bsicos 71.1. Computadoras y programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71.2. El mito de la mquina todopoderosa . . . . . . . . . . . . . . . . . . . . . . . . . . 81.3. Cmo darle instrucciones a la mquina usando Python . . . . . . . . . . . . . . . 91.4. Devolver un resultado . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 131.5. Una instruccin un poco ms compleja: el ciclo definido . . . . . . . . . . . . . . . 13

1.5.1. Ayuda desde el intrprete . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.6. Construir programas y mdulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 151.7. La forma de un programa Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171.8. Estado y computacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 181.9. Depuracin de programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191.10. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20

2. Programas sencillos 212.1. Construccin de programas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 212.2. Realizando un programa sencillo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222.3. Piezas de un programa Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24

2.3.1. Nombres . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 242.3.2. Expresiones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 25

2.4. No slo de nmeros viven los programas . . . . . . . . . . . . . . . . . . . . . . . 262.5. Instrucciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.6. Ciclos definidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 272.7. Una gua para el diseo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 282.8. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

3. Funciones 303.1. Documentacin de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 303.2. Imprimir versus Devolver . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 313.3. Cmo usar una funcin en un programa . . . . . . . . . . . . . . . . . . . . . . . . 323.4. Ms sobre los resultados de las funciones . . . . . . . . . . . . . . . . . . . . . . . 343.5. Un ejemplo completo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 353.6. Devolver mltiples resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383.7. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 39

4. Decisiones 414.1. Expresiones booleanas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41

4.1.1. Expresiones de comparacin . . . . . . . . . . . . . . . . . . . . . . . . . . 424.1.2. Operadores lgicos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42

2

CONTENIDOS 3

4.2. Comparaciones simples . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 434.3. Mltiples decisiones consecutivas . . . . . . . . . . . . . . . . . . . . . . . . . . . 464.4. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 484.5. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 48

5. Ms sobre ciclos 505.1. Ciclos indefinidos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515.2. Ciclo interactivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 515.3. Ciclo con centinela . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 535.4. Cmo romper un ciclo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 545.5. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 565.6. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 57

6. Cadenas de caracteres 586.1. Operaciones con cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58

6.1.1. Obtener el largo de una cadena . . . . . . . . . . . . . . . . . . . . . . . . . 586.1.2. Recorrer una cadena . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 596.1.3. Acceder a una posicin de la cadena . . . . . . . . . . . . . . . . . . . . . . 59

6.2. Segmentos de cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 606.3. Las cadenas son inmutables . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 616.4. Procesamiento sencillo de cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . 626.5. Nuestro primer juego . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 656.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 716.7. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 71

7. Tuplas y listas 727.1. Tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 72

7.1.1. Elementos y segmentos de tuplas . . . . . . . . . . . . . . . . . . . . . . . . 727.1.2. Las tuplas son inmutables . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737.1.3. Longitud de tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 737.1.4. Empaquetado y desempaquetado de tuplas . . . . . . . . . . . . . . . . . . 747.1.5. Ejercicios con tuplas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75

7.2. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 757.2.1. Longitud de la lista. Elementos y segmentos de listas . . . . . . . . . . . . 767.2.2. Cmo mutar listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 767.2.3. Cmo buscar dentro de las listas . . . . . . . . . . . . . . . . . . . . . . . . 77

7.3. Ordenar listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 837.4. Listas y cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83

7.4.1. Ejercicios con listas y cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . 847.5. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84

8. Algoritmos de bsqueda 878.1. El problema de la bsqueda . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 878.2. Cmo programar la bsqueda lineal a mano . . . . . . . . . . . . . . . . . . . . . 888.3. Bsqueda lineal . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 888.4. Buscar sobre una lista ordenada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908.5. Bsqueda binaria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 908.6. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 94

4 CONTENIDOS

9. Diccionarios 959.1. Qu es un diccionario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 959.2. Utilizando diccionarios en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . 969.3. Algunos usos de diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 979.4. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 98

10. Contratos y Mutabilidad 9910.1. Pre y Postcondiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 99

10.1.1. Precondiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9910.1.2. Postcondiciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9910.1.3. Aseveraciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10010.1.4. Ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 100

10.2. Invariantes de ciclo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10110.2.1. Comprobacin de invariantes desde el cdigo . . . . . . . . . . . . . . . . 102

10.3. Mutabilidad e Inmutabilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10210.3.1. Parmetros mutables e inmutables . . . . . . . . . . . . . . . . . . . . . . . 103

10.4. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10410.5. Apndice - Acertijo MU . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 105

11. Manejo de archivos 10711.1. Cerrar un archivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10711.2. Ejemplo de procesamiento de archivos . . . . . . . . . . . . . . . . . . . . . . . . . 10811.3. Modo de apertura de los archivos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10911.4. Escribir en un archivo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10911.5. Agregar informacin a un archivo . . . . . . . . . . . . . . . . . . . . . . . . . . . 11011.6. Manipular un archivo en forma binaria . . . . . . . . . . . . . . . . . . . . . . . . 11211.7. Persistencia de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 113

11.7.1. Persistencia en archivos CSV . . . . . . . . . . . . . . . . . . . . . . . . . . 11511.7.2. Persistencia en archivos binarios . . . . . . . . . . . . . . . . . . . . . . . . 117

11.8. Directorios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11811.9. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11811.10.Apndice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 121

12. Manejo de errores y excepciones 12412.1. Errores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12412.2. Excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 124

12.2.1. Manejo de excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12512.2.2. Procesamiento y propagacin de excepciones . . . . . . . . . . . . . . . . . 12712.2.3. Acceso a informacin de contexto . . . . . . . . . . . . . . . . . . . . . . . 128

12.3. Validaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12812.3.1. Comprobaciones por contenido . . . . . . . . . . . . . . . . . . . . . . . . . 12912.3.2. Entrada del usuario . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12912.3.3. Comprobaciones por tipo . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13012.3.4. Comprobaciones por caractersticas . . . . . . . . . . . . . . . . . . . . . . 132

12.4. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13212.5. Apndice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 134

CONTENIDOS 5

13. Procesamiento de archivos 13513.1. Corte de control . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13513.2. Apareo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13713.3. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 138

14. Objetos 13914.1. Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13914.2. Qu es un objeto . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14014.3. Definiendo nuevos tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 141

14.3.1. Nuestra primera clase: Punto . . . . . . . . . . . . . . . . . . . . . . . . . . 14114.3.2. Agregando validaciones al constructor . . . . . . . . . . . . . . . . . . . . 14214.3.3. Agregando operaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 143

14.4. Mtodos especiales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14514.4.1. Un mtodo para mostrar objetos . . . . . . . . . . . . . . . . . . . . . . . . 14514.4.2. Mtodos para operar matemticamente . . . . . . . . . . . . . . . . . . . . 145

14.5. Creando clases ms complejas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14614.5.1. Mtodos para comparar objetos . . . . . . . . . . . . . . . . . . . . . . . . . 14814.5.2. Ordenar de menor a mayor listas de hoteles . . . . . . . . . . . . . . . . . 14914.5.3. Otras formas de comparacin . . . . . . . . . . . . . . . . . . . . . . . . . . 15014.5.4. Comparacin slo por igualdad o desigualdad . . . . . . . . . . . . . . . . 151

14.6. Ejercicios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15214.7. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 152

15. Polimorfismo, Herencia y Delegacin 15415.1. Polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 154

15.1.1. Interfaz . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15415.1.2. Redefinicin de mtodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15515.1.3. Un ejemplo de polimorfismo . . . . . . . . . . . . . . . . . . . . . . . . . . 155

15.2. Herencia . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15715.3. Delegacin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15915.4. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162

16. Listas enlazadas 16316.1. Una clase sencilla de vagones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 163

16.1.1. Caminos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16416.1.2. Referenciando el principio de la lista . . . . . . . . . . . . . . . . . . . . . . 165

16.2. Tipos abstractos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16516.3. La clase ListaEnlazada . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166

16.3.1. Construccin de la lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16716.3.2. Eliminar un elemento de una posicin . . . . . . . . . . . . . . . . . . . . . 16816.3.3. Eliminar un elemento por su valor . . . . . . . . . . . . . . . . . . . . . . . 16916.3.4. Insertar nodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 171

16.4. Invariantes de objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17516.5. Otras listas enlazadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17516.6. Iteradores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17616.7. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 178

6 CONTENIDOS

17. Pilas y colas 17917.1. Pilas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 179

17.1.1. Pilas representadas por listas . . . . . . . . . . . . . . . . . . . . . . . . . . 17917.1.2. Uso de pila: calculadora cientfica . . . . . . . . . . . . . . . . . . . . . . . 18117.1.3. Cunto cuestan los mtodos? . . . . . . . . . . . . . . . . . . . . . . . . . 186

17.2. Colas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18617.2.1. Colas implementadas sobre listas . . . . . . . . . . . . . . . . . . . . . . . . 18617.2.2. Colas y listas enlazadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 188

17.3. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19017.4. Apndice . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 191

18. Modelo de ejecucin de funciones y recursividad 19418.1. La pila de ejecucin de las funciones . . . . . . . . . . . . . . . . . . . . . . . . . . 19418.2. Pasaje de parmetros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19618.3. Devolucin de resultados . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19818.4. La recursin y cmo puede ser que funcione . . . . . . . . . . . . . . . . . . . . . 19918.5. Una funcin recursiva matemtica . . . . . . . . . . . . . . . . . . . . . . . . . . . 19918.6. Algoritmos recursivos y algoritmos iterativos . . . . . . . . . . . . . . . . . . . . . 20218.7. Un ejemplo de recursividad elegante . . . . . . . . . . . . . . . . . . . . . . . . . . 20318.8. Un ejemplo de recursividad poco eficiente . . . . . . . . . . . . . . . . . . . . . . . 20518.9. Limitaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20618.10.Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 207

19. Ordenar listas 20819.1. Ordenamiento por seleccin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208

19.1.1. Invariante en el ordenamiento por seleccin . . . . . . . . . . . . . . . . . 20919.1.2. Cunto cuesta ordenar por seleccin? . . . . . . . . . . . . . . . . . . . . . 211

19.2. Ordenamiento por insercin . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21119.2.1. Invariante del ordenamiento por insercin . . . . . . . . . . . . . . . . . . 21419.2.2. Cunto cuesta ordenar por insercin? . . . . . . . . . . . . . . . . . . . . . 21419.2.3. Insercin en una lista ordenada . . . . . . . . . . . . . . . . . . . . . . . . . 214

19.3. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214

20. Algunos ordenamientos recursivos 21620.1. Ordenamiento por mezcla, o Merge sort . . . . . . . . . . . . . . . . . . . . . . . . 21620.2. Cunto cuesta el Merge sort? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21720.3. Ordenamiento rpido o Quick sort . . . . . . . . . . . . . . . . . . . . . . . . . . . 21920.4. Cunto cuesta el Quick sort? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22020.5. Una versin mejorada de Quick sort . . . . . . . . . . . . . . . . . . . . . . . . . . . 22220.6. Resumen . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 222

A. Licencia y Copyright 224

Unidad 1

Algunos conceptos bsicos

En esta unidad hablaremos de lo que es un programa de computadora e introduciremosunos cuantos conceptos referidos a la programacin y a la ejecucin de programas. Utilizare-mos en todo momento el lenguaje de programacin Python para ilustrar esos conceptos.

1.1. Computadoras y programas

En la actualidad, la mayora de nosotros utilizamos computadoras permanentemente: paramandar correos electrnicos, navegar por Internet, chatear, jugar, escribir textos.

Las computadoras se usan para actividades tan dismiles como predecir las condicionesmeteorolgicas de la prxima semana, guardar historias clnicas, disear aviones, llevar la con-tabilidad de las empresas o controlar una fbrica. Y lo interesante aqu (y lo que hace apasio-nante a esta carrera) es que el mismo aparato sirve para realizar todas estas actividades: unono cambia de computadora cuando se cansa de chatear y quiere jugar al solitario.

Muchos definen una computadora moderna como una mquina que almacena y manipulainformacin bajo el control de un programa que puede cambiar. Aparecen ac dos conceptosque son claves: por un lado se habla de una mquina que almacena informacin, y por el otrolado, esta mquina est controlada por un programa que puede cambiar.

Una calculadora sencilla, de esas que slo tienen 10 teclas para los dgitos, una tecla paracada una de las 4 operaciones, un signo igual, encendido y CLEAR, tambin es una mquinaque almacena informacin y que est controlada por un programa. Pero lo que diferencia a estacalculadora de una computadora es que en la calculadora el programa no puede cambiar.

Un programa de computadora es un conjunto de instrucciones paso a paso que le indican a unacomputadora cmo realizar una tarea dada, y en cada momento uno puede elegir ejecutar unprograma de acuerdo a la tarea que quiere realizar.

Las instrucciones se deben escribir en un lenguaje que nuestra computadora entienda. Loslenguajes de programacin son lenguajes diseados especialmente para dar rdenes a unacomputadora, de manera exacta y no ambigua. Sera muy agradable poder darle las rdenesa la computadora en castellano, pero el problema del castellano, y de las lenguas habladas engeneral, es su ambigedad:

Si alguien nos dice Compr el collar sin monedas, no sabremos si nos pide que compremosel collar que no tiene monedas, o que compremos un collar y que no usemos monedas para lacompra. Habr que preguntarle a quien nos da la orden cul es la interpretacin correcta. Perotales dudas no pueden aparecer cuando se le dan rdenes a una computadora.

Este curso va a tratar precisamente de cmo se escriben programas para hacer que una

7

8 Unidad 1. Conceptos bsicos

computadora realice una determinada tarea. Vamos a usar un lenguaje especfico (Python) por-que es sencillo y elegante, pero ste no ser un curso de Python sino un curso de programacin.

Sabas que . . .Existen una gran cantidad de programas desarrollados en Python, desde herramientas para servi-dores, como mailman, hasta programas amigables para usuarios finales, como emesene, pasandopor aplicaciones empresariales, openerp, tryton; herramientas de desarrollo, meld, mercurial, ba-zaar, trac; plataformas web, django, turbogears, zope; clientes de bittorrent, bittorrent, bittornado,deluge; montones de juegos de todo tipo, y muchsimas aplicaciones ms.Todas estas aplicaciones son software libre, por lo que se puede obtener y estudiar el cdigo con elque estn hechas

1.2. El mito de la mquina todopoderosa

Muchas veces la gente se imagina que con la computadora se puede hacer cualquier cosa,que no hay tareas imposibles de realizar. Ms an, se imaginan que si bien hubo cosas que eranimposibles de realizar hace 50 aos, ya no lo son ms, o no lo sern dentro de algunos aos,cuando las computadoras crezcan en poder (memoria, velocidad), y la computadora se vuelvauna mquina todopoderosa.

Sin embargo eso no es as: existen algunos problemas, llamados no computables que nuncapodrn ser resueltos por una computadora digital, por ms poderosa que sta sea. La compu-tabilidad es la rama de la computacin que se ocupa de estudiar qu tareas son computables yqu tareas no lo son.

De la mano del mito anterior, viene el mito del lenguaje todopoderoso: hay problemas queson no computables porque en realidad se utiliza algn lenguaje que no es el apropiado.

En realidad todas las computadoras pueden resolver los mismos problemas, y eso es inde-pendiente del lenguaje de programacin que se use. Las soluciones a los problemas compu-tables se pueden escribir en cualquier lenguaje de programacin. Eso no significa que no hayalenguajes ms adecuados que otros para la resolucin de determinados problemas, pero laadecuacin est relacionada con temas tales como la elegancia, la velocidad, la facilidad paradescribir un problema de manera simple, etc., nunca con la capacidad de resolucin.

Los problemas no computables no son los nicos escollos que se le presentan a la compu-tacin. Hay otros problemas que si bien son computables demandan para su resolucin unesfuerzo enorme en tiempo y en memoria. Estos problemas se llaman intratables. El anlisis dealgoritmos se ocupa de separar los problemas tratables de los intratables, encontrar la solu-cin ms barata para resolver un problema dado, y en el caso de los intratables, resolverlos demanera aproximada: no encontramos la verdadera solucin porque no nos alcanzan los recur-sos para eso, pero encontramos una solucin bastante buena y que nos insume muchos menosrecursos (el orden de las respuestas de Google a una bsqueda es un buen ejemplo de unasolucin aproximada pero no necesariamente ptima).

En este curso trabajaremos con problemas no slo computables sino tambin tratables. Yaprenderemos a medir los recursos que nos demanda una solucin, y empezaremos a buscar lasolucin menos demandante en cada caso particular.

Algunos ejemplos de los problemas que encararemos y de sus soluciones:

Problema 1.1. Dado un nmero N se quiere calcular N33.

1.3. Cmo darle instrucciones a la mquina usando Python 9

Una solucin posible, por supuesto, es hacer el producto N N . . . N , que involucra32 multiplicaciones.

Otra solucin, mucho ms eficiente es:

Calcular N N .Al resultado anterior mutiplicarlo por s mismo con lo cual ya disponemos de N4.

Al resultado anterior mutiplicarlo por s mismo con lo cual ya disponemos de N8.



Al resultado anterior mutiplicarlo por N con lo cual conseguimos el resultado deseadocon slo 6 multiplicaciones.

Cada una de estas soluciones representa un algoritmo, es decir un mtodo de clculo, dife-rente. Para un mismo problema puede haber algoritmos diferentes que lo resuelven, cada unocon un costo distinto en trminos de recursos computacionales involucrados.

Sabas que . . .La palabra algoritmo no es una variacin de logaritmo, sino que proviene de algorismo. En la an-tigedad, los algoristas eran los que calculaban usando la numeracin arbiga y mientras que losabacistas eran los que calculaban usando bacos. Con el tiempo el algorismo se deform en algoritmo,influenciado por el trmino aritmtica.A su vez el uso de la palabra algorismo proviene del nombre de un matemtico persa famoso, en supoca y para los estudiosos de esa poca, Abu Abdallah Muhammad ibn Ms al-Jwrizm, queliteralmente significa: Padre de Jafar Mohammed, hijo de Moises, nativo de Jiva. Al-Juarismi,como se lo llama usualmente, escribi en el ao 825 el libro Al-Kitb al-mukhtasar f hsb al-gabrwal-muqbala (Compendio del clculo por el mtodo de completado y balanceado), del cualsurgi tambin la palabra lgebra.Hasta hace no mucho tiempo se utilizaba el trmino algoritmo para referirse nicamente a formasde realizar ciertos clculos, pero con el surgimiento de la computacin, el trmino algoritmo pasa abarcar cualquier mtodo para obtener un resultado.

Problema 1.2. Tenemos que permitir la actualizacin y consulta de una gua telefnica.

Para este problema no hay una solucin nica: hay muchas y cada una est relacionadacon un contexto de uso. De qu gua estamos hablando: la gua de una pequea oficina, unpequeo pueblo, una gran ciudad, la gua de la Argentina? Y en cada caso de qu tipo deconsulta estamos hablando: hay que imprimir un listado una vez por mes con la gua comple-ta, se trata de una consulta en lnea, etc.? Para cada contexto hay una solucin diferente, conlos datos guardados en una estructura de datos apropiada, y con diferentes algoritmos para laactualizacin y la consulta.

1.3. Cmo darle instrucciones a la mquina usando Python

El lenguaje Python nos provee de un intrprete, es decir un programa que interpreta las r-denes que le damos a medida que las escribimos. Para orientarnos, el intrprete presenta una


Sabas que . . .Python fue creado a finales de los aos 80, por un programador holands llamado Guido vanRossum, quien sigue siendo an hoy el lder del desarrollo del lenguaje.La versin 2.0, lanzada en 2000, fue un paso muy importante para el lenguaje ya que era muchoms madura, incluyendo un recolector de basura. La versin 2.2, lanzada en diciembre de 2001, fuetambin un hito importante ya que mejor la orientacin a objetos. La ltima versin de esta lneaes la 2.7 que fue lanzada en noviembre de 2010 y an est vigente.En diciembre de 2008, se lanz la versin 3.0, cuya versin actual es la 3.2, de febrero de 2011.Sin embargo, debido a que estas versiones introducen importantes cambios y no son totalmentecompatibles con las versiones anteriores, todava no se la utiliza extensamente.

lnea de comandos (los comandos son las rdenes) que identifica al comienzo con los smbolos>>>, y que llamaremos prompt. En esta lnea, a continuacin del prompt podemos escribir dife-rentes rdenes.

Algunas rdenes sencillas, por ejemplo, permiten utilizar la lnea de comandos como unacalculadora simple con nmeros enteros. Para esto escribimos la expresin que queremos re-solver en el prompt y presionamos la tecla . El intrprete de Python responde elresultado de la operacin en la lnea siguiente, sin prompt, y luego nos presenta nuevamente elcursor para escribir la siguiente orden.

>>> 2+35>>>

Python permite utilizar las operaciones +, -, *, / (divisin entera), y ** (potencia-cin). La sintaxis es la convencional (valores intercalados con operaciones), y se pueden usarparntesis para modificar el orden de asociacin natural de las operaciones (potenciacin, pro-ducto/divisin, suma/resta).

>>> 5*735>>> 2+3*723>>> (2+3)*735>>> 10/52>>> 5**225>>>

Otra orden sencilla de Python permite indicarle al intrprete que escriba o imprima porpantalla una palabra o frase, que llamaremos cadena de texto.

>>> print HolaHola>>> print Como estan?Como estan?>>> print "Bienvenidos y bienvenidas a este curso!"Bienvenidos y bienvenidas a este curso!

1.3. Cmo darle instrucciones a la mquina usando Python 11

>>>

print es una instruccin de Python: aqulla que le indica a la mquina que debe imprimirun texto en pantalla, que deber ser ingresado entre comillas simples o dobles " indistinta-mente. Ya veremos con qu otras instrucciones viene equipado Python.

Pero ya dijimos que como programadores debamos ser capaces de escribir nuevas instruc-ciones para la computadora. Los programas de correo electrnico, navegacin por Internet,chat, juegos, escritura de textos o prediccin de las condiciones meteorolgicas de los prxi-mos das no son ms que grandes instrucciones que se le dan a la mquina, escritas por uno omuchos programadores.

Llamaremos funcin a una instruccin escrita por un programador.Si queremos escribir una funcin (que llamaremos holaMar) que escribe en una lnea el

texto Hola Marta! y en la lnea siguiente el texto Estoy programando en Python., lo quedebemos hacer es ingresar el siguiente conjunto de lneas en Python:

Cdigo 1.1 holaMar: Saluda a Marta

>>> def holaMar():print "Hola Marta!"print "Estoy programando en Python."

>>>

def holaMar(): le indica a Python que estamos escribiendo una instruccin cuyo nom-bre es holaMar. Por qu se ponen esos dos parntesis? Lo veremos dentro de unos p-rrafos. La sangra con la que se escriben las dos instrucciones print le indican a Pyt-hon que estamos escribiendo el cuerpo (es decir las instrucciones que la componen) de lafuncin en cuestin. Las dos teclas que tecleamos despus de ingresar el texto"Estoy programando en Python." le indican a Python que se acab el cuerpo de la fun-cin (y por eso aparece nuevamente el cursor).

Si ahora queremos que la mquina ejecute la instruccin holaMar, debemos escribirholaMar() a continuacin del cursor de Python:

>>> holaMar()Hola Marta!Estoy programando en Python.>>>

Se dice que estamos invocando a la funcin holaMar. Al invocar una funcin, se ejecutanlas instrucciones que habamos escrito en su cuerpo, una a continuacin de la otra.

Nuestro amigo Pablo seguramente se pondr celoso porque escribimos una funcin que lasaluda a Marta, y nos pedir que escribamos una funcin que lo salude a l. Y as procederemosentonces:

Cdigo 1.2 holaPab: Saluda a Pablo

>>> def holaPab():print "Hola Pablo!"print "Estoy programando en Python."


Pero, si para cada amigo que quiere que lo saludemos debemos que escribir una funcindistinta, parecera que la computadora no es una gran solucin. A continuacin veremos, sinembargo, que podemos llegar a escribir una nica funcin que se personalice en cada invoca-cin, para saludar a quien querramos. Para eso estn precisamente los parntesis.

Las funciones tienen partes variables, llamadas parmetros, que se ponen dentro de los pa-rntesis. Escribimos por ejemplo una funcin hola general que nos sirva para saludar a cual-quiera, de la siguiente manera:

Cdigo 1.3 hola: Saluda a quien sea necesario

>>> def hola(alguien):print "Hola", alguien,"!"print "Estoy programando en Python."

En este caso, alguien es un parmetro cuyo valor ser reemplazado por un texto (nombreen este caso) en cada invocacin. Por ejemplo, podemos invocarla dos veces, para saludar aAna y a Juan:

>>> hola("Ana")Hola Ana !Estoy programando en Python.>>> hola("Juan")Hola Juan !Estoy programando en Python.>>>

Problema 1.3.1. Escribir un programa que calcule el cuadrado de un nmero dado.

Solucin. Para resolver este problema, se combinan los recursos utilizados hasta ahora.

Cdigo 1.4 cuad1: Eleva un nmero al cuadrado y lo imprime

def cuad1(num):print num*num

Para invocarlo, deberemos hacer:

1 >>> cuad1(5)2 253 >>>

Problema 1.3.2. Permitir que el usuario ingrese el valor a elevar al cuadrado.

Solucin. Para esto utilizaremos una nueva funcin input que permite leer valores ingresadospor el usuario.

La ejecucin del programa ser la siguiente:

>>> cuad2()Ingrese un numero: 525>>>

1.4. Devolver un resultado 13

Cdigo 1.5 cuad2: Pide un nmero al usuario e imprime su cuadrado

def cuad2():n = input("Ingrese un nmero: ")cuad1(n)

1.4. Devolver un resultado

Las funciones que vimos hasta ahora muestran mensajes, pero no hemos visto funcionesque se comporten como las funciones que conocemos, las de la matemtica, que se usan paracalcular resultados.

Queremos tambin poder hacer cosas del estilo y = f(x) en nuestros programas. Para ellointroduciremos la instruccin return que indica cul es el valor que tiene quedevolver nuestra funcin.

En este ejemplo escribimos una funcin que eleva al cuadrado un nmero.

Cdigo 1.6 cuadrado: Eleva un nmero al cuadrado y lo devuelve

>>> def cuadrado (x):... cua = x * x... return cua...>>> y = cuadrado (5)>>> y25>>>

1.5. Una instruccin un poco ms compleja: el ciclo definido

Problema 1.5.1. Ahora que sabemos construir una funcin que calcula el cuadrado de un n-mero, nos piden que imprimamos los cuadrados de los nmeros del 2 al 8.

Solucin. Por supuesto que podemos hacer:

>>> def cuad3():print cuadrado(2)print cuadrado(3)print cuadrado(4)print cuadrado(5)print cuadrado(6)print cuadrado(7)print cuadrado(8)

>>> cuad3()


491625364964>>>

Se puede hacer algo mejor que esto? Con lo que sabemos de Python hasta el momento, no.Para resolver este tipo de problema (repetir un clculo para los valores contenidos en un

intervalo dado) de manera eficiente, introducimos el concepto de ciclo definido, que tiene lasiguiente forma:

for x in range(n1, n2):

Esta instruccin se lee como:

Generar la secuencia de valores enteros del intervalo [n1, n2), y

Para cada uno de los valores enteros que toma x en el intervalo generado, se debe hacerlo indicado por .

Vemos cmo, usando esta construccin, el problema anterior se puede resolver de manerams compacta:

Solucin. En nuestro caso lo que hay que hacer es invocar a la instruccin print cuadrado(x)que usa la funcin definida en 1.6 para calcular el cuadrado de x, y luego imprime el resultado,cuando x toma los valores 2, 3, . . . , 8.

La instruccin que describe qu tipo de repeticiones se deben realizar es el encabezado delciclo, y las instrucciones que describen la accin que se repite se llaman cuerpo del ciclo.

No nos olvidemos que en nuestro ejemplo el ciclo debe recorrer todos los valores enterosentre 2 y 8, por lo tanto:

for x in range(2, 9): ser el encabezado del ciclo y

print cuadrado(x) ser el cuerpo del ciclo.

Vemos entonces cmo resulta el ciclo completo (con su ejecucin):

AtencinTodas las instrucciones que describen el cuerpo del ciclo deben tener una sangra mayor que elencabezado del ciclo.Esta sangra puede ingresarse mediante espacios o tabuladores, pero es importante que sea la mis-ma para todas las instrucciones del ciclo.

1.6. Construir programas y mdulos 15

Cdigo 1.7 cuadrados: Imprime los cuadrados del 2 al 8

>>> for x in range(2, 9):print cuadrado(x)

491625364964>>>

1.5.1. Ayuda desde el intrprete

El intrprete de python nos provee una ayuda en lnea, es decir, nos puede dar la docu-mentacin de una funcin, intruccin, etc, para obtenerla llamamos a help(). Por ejemplopodemos pedir help(input) y nos dara la documentacin de esa funcin.

Para obtener la documentacin de las instrucciones las debemos poner entre comillas, esdecir help(return), de la misma forma se puede pedir ayuda sobre variables o valores.

Otra forma de obtener ayuda es mediante dir(variable), que nos va a listar todas lasfunciones que tiene asociadas esa variable. Por ejemplo, mostramos las funciones asociadas auna cadena.

>>> dir("hola")[__add__, __class__, __contains__, __delattr__, __doc__, __eq__,__ge__, __getattribute__, __getitem__, __getnewargs__, __getslice__,__gt__, __hash__, __init__, __le__, __len__, __lt__, __mod__,__mul__, __ne__, __new__, __reduce__, __reduce_ex__, __repr__,__rmod__, __rmul__, __setattr__, __str__, capitalize, center,count, decode, encode, endswith, expandtabs, find, index,isalnum, isalpha, isdigit, islower, isspace, istitle, isupper,join, ljust, lower, lstrip, partition, replace, rfind, rindex,rjust, rpartition, rsplit, rstrip, split, splitlines,startswith, strip, swapcase, title, translate, upper, zfill]

Como se puede ver son muchas las funciones asociadas a las cadenas, pero no necesitamosconocerlas todas, a medida que avancemos veremos algunas.

1.6. Construir programas y mdulos

El interprete es muy til para probar cosas, acceder a la ayuda, inspeccionar el lenguaje, etc,pero si escribimos nuestras funciones frente al cursor de Python como hasta ahora, perdemostodas las definiciones cuando salimos de Python. Para conservar los programas que vamosescribiendo, debemos usar algn editor de texto, y guardar el archivo con la extensin .py.

Por convencin, la primer lnea del archivo deber contener:

#!/usr/bin/env python


Estas dos convenciones indican que se trata de un mdulo o programa Python, es decir unarchivo separado que deber ser ejecutado por Python.

Sabas que . . .Python es un lenguaje multiplataforma, esto quiere decir, que est pensado para que pueda utili-zarse en una gran variedad de sistemas operativos (Windows, Mac, Linux, etc).Las dos convenciones mencionadas le permiten a distintos sistemas darse cuenta que este archi-vo en particular lo tiene que procesar con Python. En particular, Windows, tradicionalmente, slose fija en la extensin del archivo para saber cmo procesarlo (por eso el .py), mientras que todoslos sistemas derivados de Unix (OS X, Linux, Solaris, etc) analizan los permisos del archivo (enparticular, el permiso de ejecucin) y los primeros caracteres, para saber como procesarlos (por elloes necesario incluir esa primera lnea mgica).

Problema 1.6.1. Escribir en Python un programa que haga lo siguiente:

Muestra un mensaje de bienvenida por pantalla.

Le pide al usuario que introduzca dos nmeros enteros n1 y n2.

Imprime el cuadrado de todos los nmeros enteros del intervalo [n1, n2).

Muestra un mensaje de despedida por pantalla.

Solucin. Para la resolucin del problema, escribiremos nuestro primer mdulo de Python, queguardaremos en el archivo cuad.py, el cdigo de este programa se encuentra en el Cdigo 1.8.

Cdigo 1.8 cuad.py: Imprime los cuadrados solicitados

1 #!/usr/bin/env python2 """ Un programa sencillo, para calcular cuadrados de nmeros """3

4 def main():5 print "Se calcularn cuadrados de nmeros"6

7 n1 = input("Ingrese un nmero entero: ")8 n2 = input("Ingrese otro nmero entero: ")9

10 for x in range(n1, n2):11 print x*x12

13 print "Es todo por ahora"14

15 main()

Para ejecutar este mdulo, podemos iniciar Python y luego importarlo. Lo ejecutaremos convalores 5 y 8 de la siguiente manera:

1.7. La forma de un programa Python 17

>>> import cuadSe calcularn cuadrados de nmerosIngrese un nmero entero: 5Ingrese otro nmero entero: 8253649Es todo por ahora>>>

La orden import cuad le indica a Python que debe traer a la memoria el mdulocuad.py, tal como lo habamos guardado, y ejecutar su contenido. Al hacer esto, sucendenlas siguientes operaciones:

Se carga en memoria la funcin main del mdulo cuad (a la que se le asigna el nombrecuad.main), segn la definicin que est en el archivo, y

se inicia su ejecucin inmediatamente, dado que luego de la definicin se encuentra lainvocacin main().

Una vez importado el mdulo, cuad.main queda en memoria, y se puede volver a invocarsin necesidad de importar nuevamente:

>>> cuad.main()Se calcularn cuadrados de nmerosIngrese un nmero entero: 3Ingrese otro nmero entero: 5916Es todo por ahora>>>

Por otro lado, habiendo cumplido con las convenciones nombradas anteriormente, es posible eje-cutar el archivo como un programa normal, y el sistema se encargar de llamar a Python y darlenuestro archivo para que lo procese y ejecute.

1.7. La forma de un programa Python

La primera instruccin de cuad.main es

5 print "Se calcularn cuadrados de nmeros"

que lo que hace es mostrar un mensaje por pantalla.Las instrucciones segunda y tercera

7 n1 = input("Ingrese un nmero entero: ")8 n2 = input("Ingrese otro nmero entero: ")


Sabas que . . .En los programas Python que escribimos, podemos operar con cadenas de texto o con nmeros.Las representaciones dentro de la computadora de un nmero y una cadena son muy distintas, elnmero 12345678 se almacena en forma binaria y utiliza unos pocos bytes, mientras que la cadena"12345678", es una sucesin de caracteres, en la que cada nmero es un caracter que ocupa unbyte.La funcin input toma valores numricos, y si se desea ingresar una cadena, debe hacrselo entrecomillas: "hola". Existe, por otro lado, la funcin raw_input, para la cual los valores ingresadosson siempre cadenas de caracteres.

son instrucciones de entrada: se despliega el texto que est entre comillas y se espera que elusuario ingrese un valor numrico y oprima la tecla .

Cmo hacer para que los valores que provee el usuario se recuerden a lo largo de todo elprograma? Al valor ingresado se le dar un nombre, de la misma manera que a otros valorescalculados durante la ejecucin. Aparece el concepto de variables de un programa: una variablese usa para darle un nombre a un valor dado y poder de esa manera referirnos al mismo a lolargo del programa.

En estas dos instrucciones, n1 y n2 son los nombres con los que se mencionarn el primery el segundo entero tipeados por el usuario.

En el ejemplo de la ltima corrida, se asociar el valor 3 con la variable n1 y el valor 5 conla variable n2.

Luego de leer esos valores, se procede a ejecutar el ciclo

10 for x in range(n1, n2):11 print x*x

Si el valor asociado con n1 es 3, y el valor asociado con n2 es 5, se asociar a x sucesivamentecon los valores 3 y 4, y en cada caso se ejecutar el cuerpo del ciclo indicado (mostrar enpantalla los valores de los cuadrados de 3 y 4).

Finalmente, cuando se terminan las repeticiones indicadas en el ciclo, se ejecuta la instruc-cin

13 print "Es todo por ahora"

que, como ya se ha visto, muestra el mensaje Es todo por ahora por pantalla.

1.8. Estado y computacin

A lo largo de la ejecucin de un programa las variables pueden cambiar el valor con el queestn asociadas. En un momento dado uno puede detenerse a observar a qu valor se refierecada una de las variables del programa. Esa foto que indica en un momento dado a qu valorhace referencia cada una de las variables se denomina estado. Tambin hablaremos del estado deuna variable para indicar a qu valor est asociada esa variable, y usaremos la notacin n 13para describir el estado de la variable n (e indicar que est asociada al nmero 13).

A medida que las variables cambian de valores a los que se refieren, el programa va cam-biando de estado. La sucesin de todos los estados por los que pasa el programa en una ejecu-cin dada se denomina computacin.

Para ejemplificar estos conceptos veamos qu sucede cuando se ejecuta el programa cuad:

1.9. Depuracin de programas 19

Instruccin Qu sucede Estadoprint "Se calcularncuadrados de nmeros"

Se despliega el texto Se calcularn cua-drados de nmeros en la pantalla.

n1 = input("Ingreseun nmero entero: ")

Se despliega el texto Ingrese un nmeroentero: en la pantalla y el programa sequeda esperando que el usuario ingreseun nmero.Supondremos que el usuario ingresa elnmero 3 y luego oprime la tecla .Se asocia el nmero 3 con la variable n1.

n1 3

n2 = input("Ingreseotro nmero entero: ")

Se despliega el texto Ingrese otro nme-ro entero: en la pantalla y el programase queda esperando que el usuario ingre-se un nmero.

n1 3

Supondremos que el usuario ingresa elnmero 5 y luego oprime la tecla .Se asocia el nmero 5 con la variable n2.

n1 3n2 5

for x in range(n1, n2): Se asocia el primer nmero de [n1,n2)con la variable x y se ejecuta el cuerpo delciclo.

n1 3n2 5x 3

print x*x Se imprime por pantalla el valor de x * x(9)

n1 3n2 5x 3

for x in range(n1, n2): Se asocia el segundo nmero de [n1,n2)con la variable x y se ejecuta el cuerpo delciclo.

n1 3n2 5x 4

print x*x Se imprime por pantalla el valor de x * x(16)

n1 3n2 5x 4

for x in range(n1, n2): Como no quedan ms valores por trataren [n1,n2), se sale del ciclo.

n1 3n2 5x 4

print "Es todo por ahora" Se despliega por pantalla el mensaje Estodo por ahora

n1 3n2 5x 4

1.9. Depuracin de programas

Una manera de seguir la evolucin del estado es insertar instrucciones de impresin ensitios crticos del programa. Esto nos ser de utilidad para detectar errores y tambin paracomprender cmo funcionan determinadas instrucciones.


1.10. Ejercicios

Ejercicio 1.1. Correr tres veces el programa cuad con valores de entrada (3,5), (3,3) y (5,3)respectivamente. Qu sucede en cada caso?

Ejercicio 1.2. Insertar instrucciones de depuracin que permitan ver el valor asociado con lavariable x en el cuerpo del ciclo for y despus que se sale de tal ciclo. Volver a correr tres vecesel programa cuad con valores de entrada (3,5), (3,3) y (5,3) respectivamente, y explicar lo quesucede.

Ejercicio 1.3. La salida del programa cuad es poco informativa. Escribir un programanom_cuad que ponga el nmero junto a su cuadrado. Ejecutar el programa nuevo.

Ejercicio 1.4. Si la salida sigue siendo poco informativa seguir mejorndola hasta que sea losuficientemente clara.

Unidad 2

Programas sencillos

En esta unidad empezaremos a resolver problemas sencillos, y a programarlos en Python.

2.1. Construccin de programas

Cuando nos piden que hagamos un programa debemos seguir una cierta cantidad de pasospara asegurarnos de que tendremos xito en la tarea. La accin irreflexiva (me piden algo, mesiento frente a la computadora y escribo rpidamente y sin pensarlo lo que me parece que es lasolucin) no constituye una actitud profesional (e ingenieril) de resolucin de problemas. Todaconstruccin tiene que seguir una metodologa, un protocolo de desarrollo, dado.

Existen muchas metodologas para construir programas, pero en este curso aplicaremosuna metodologa sencilla, que es adecuada para la construccin de programas pequeos, y quese puede resumir en los siguientes pasos:

1. Analizar el problema. Entender profundamente cul es el problema que se trata de resol-ver, incluyendo el contexto en el cual se usar.

Una vez analizado el problema, asentar el anlisis por escrito.

2. Especificar la solucin. ste es el punto en el cual se describe qu debe hacer el programa,sin importar el cmo. En el caso de los problemas sencillos que abordaremos, deberemosdecidir cules son los datos de entrada que se nos proveen, cules son las salidas quedebemos producir, y cul es la relacin entre todos ellos.

Al especificar el problema a resolver, documentar la especificacin por escrito.

3. Disear la solucin. ste es el punto en el cul atacamos el cmo vamos a resolver elproblema, cules son los algoritmos y las estructuras de datos que usaremos. Analiza-mos posibles variantes, y las decisiones las tomamos usando como dato de la realidad elcontexto en el que se aplicar la solucin, y los costos asociados a cada diseo.

Luego de disear la solucin, asentar por escrito el diseo, asegurndonos de que est completo.

4. Implementar el diseo. Traducir a un lenguaje de programacin (en nuestro caso, y porel momento, Python) el diseo que elegimos en el punto anterior.

21

22 Unidad 2. Programas sencillos

La implementacin tambin se debe documentar, con comentarios dentro y fuera del cdigo, alrespecto de qu hace el programa, cmo lo hace y por qu lo hace de esa forma.

5. Probar el programa. Disear un conjunto de pruebas para probar cada una de sus partespor separado, y tambin la correcta integracin entre ellas. Utilizar el depurador comoinstrumento para descubir dnde se producen ciertos errores.

Al ejecutar las pruebas, documentar los resultados obtenidos.

6. Mantener el programa. Realizar los cambios en respuesta a nuevas demandas.

Cuando se realicen cambios, es necesario documentar el anlisis, la especificacin, el diseo, laimplementacin y las pruebas que surjan para llevar estos cambios a cabo.

2.2. Realizando un programa sencillo

Al leer un artculo en una revista norteamericana que contiene informacin de longitudesexpresadas en millas, pies y pulgadas, queremos poder convertir esas distancias de modo quesean fciles de entender. Para ello, decidimos escribir un programa que convierta las longitudesdel sistema ingls al sistema mtrico decimal.

Antes de comenzar a programar, utilizamos la gua de la seccin anterior, para analizar,especificar, disear, implementar y probar el problema.

1. Anlisis del problema. En este caso el problema es sencillo: nos dan un valor expresadoen millas, pies y pulgadas y queremos transformarlo en un valor en el sistema mtricodecimal. Sin embargo hay varias respuestas posibles, porque no hemos fijado en qu uni-dad queremos el resultado. Supongamos que decidimos que queremos expresar todo enmetros.

2. Especificacin. Debemos establecer la relacin entre los datos de entrada y los datos desalida. Ante todo debemos averiguar los valores para la conversin de las unidades bsi-cas. Buscando en Internet encontramos la siguiente tabla:

1 milla = 1.609344 km

1 pie = 30.48 cm

1 pulgada = 2.54 cm

AtencinA lo largo de todo el curso usaremos punto decimal, en lugar de coma decimal, para representarvalores no enteros, dado que esa es la notacin que utiliza Python.

La tabla obtenida no traduce las longitudes a metros. La manipulamos para llevar todo ametros:

1 milla = 1609.344 m

1 pie = 0.3048 m

2.2. Realizando un programa sencillo 23

1 pulgada = 0.0254 m

Si una longitud se expresa como L millas, F pies y P pulgadas, su conversin a metros secalcular como M = 1609,344 L+ 0,3048 F + 0,0254 P.Hemos especificado el problema. Pasamos entonces a la prxima etapa.

3. Diseo. La estructura de este programa es sencilla: leer los datos de entrada, calcular lasolucin, mostrar el resultado, o Entrada-Clculo-Salida.

Antes de escribir el programa, escribiremos en pseudocdigo (un castellano preciso que seusa para describir lo que hace un programa) una descripcin del mismo:

Leer cuntas millas tiene la longitud dada(y referenciarlo con la variable millas)

Leer cuntos pies tiene la longitud dada(y referenciarlo con la variable pies)

Leer cuntas pulgadas tiene la longitud dada(y referenciarlo con la variable pulgadas)

Calcular metros = 1609.344 * millas +0.3048 * pies + 0.0254 * pulgadas

Mostrar por pantalla la variable metros

4. Implementacin. Ahora estamos en condiciones de traducir este pseudocdigo a un pro-grama en lenguaje Python:

Cdigo 2.1 ametrico.py: Convierte medidas inglesas a sistema metrico

1 def main():2 print "Convierte medidas inglesas a sistema metrico"3 millas = input("Cuntas millas?: ")4 pies = input("Y cuntos pies?: ")5 pulgadas = input("Y cuntas pulgadas?: ")6

7 metros = 1609.344 * millas + 0.3048 * pies + 0.0254 * pulgadas8 print "La longitud es de ", metros, " metros"9 main()

5. Prueba. Probaremos el programa para valores para los que conocemos la solucin:

1 milla, 0 pies, 0 pulgadas.0 millas, 1 pie, 0 pulgada.0 millas, 0 pies, 1 pulgada.

La prueba la documentaremos con la sesin de Python correspondiente a las tres invoca-ciones a ametrico.py.


En la seccin anterior hicimos hincapi en la necesidad de documentar todo el proceso dedesarrollo. En este ejemplo la documentacin completa del proceso lo constituye todo lo escritoen esta seccin.

AtencinAl entregar un ejercicio, se deber presentar el desarrollo completo con todas las etapas, desde elanlisis hasta las pruebas (y el mantenimiento, si hubo cambios).

2.3. Piezas de un programa Python

Para poder empezar a programar en Python es necesario que conocer los elementos queconstituyen un programa en dicho lenguaje y las reglas para construirlos.

Cuando empezamos a hablar en un idioma extranjero es posible que nos entiendan pese a quecometamos errores. No sucede lo mismo con los lenguajes de programacin: la computadora nonos entender si nos desviamos un poco de alguna de las reglas.

2.3.1. Nombres

Ya hemos visto que se usan nombres para denominar a los programas (ametrico) y paradenominar a las funciones dentro de un mdulo (main). Cuando queremos dar nombres avalores usamos variables (millas, pies, pulgadas, metros). Todos esos nombres se llamanidentificadores y Python tiene reglas sobre qu es un identificador vlido y qu no lo es.

Un identificador comienza con una letra o con guin bajo (_) y luego sigue con una se-cuencia de letras, nmeros y guiones bajos. Los espacios no estn permitidos dentro de losidentificadores.

Los siguientes son todos identificadores vlidos de Python:

hola

hola12t

_hola

Hola

Python distingue maysculas de minsculas, as que Hola es un identificador y hola esotro identificador.

Por convencin, no usaremos identificadores que empiezan con mayscula.

Los siguientes son todos identificadores invlidos de Python:

hola a12t

8hola

hola\%

Hola*9

2.3. Piezas de un programa Python 25

Python reserva 31 palabras para describir la estructura del programa, y no permite que seusen como identificadores. Cuando en un programa nos encontramos con que un nombre no esadmitido pese a que su formato es vlido, seguramente se trata de una de las palabras de estalista, a la que llamaremos de palabras reservadas. La lista completa de las palabras reservadas dePython aparecen en el cuadro 2.1.

and del from not whileas elif global or withassert else if pass yieldbreak except import printclass exec in raisecontinue finally is returndef for lambda try

Cuadro 2.1: Las palabras reservadas de Python. Estas palabras no pueden ser usadas comoidentificadores.

2.3.2. Expresiones

Una expresin es una porcin de cdigo Python que produce o calcula un valor (resultado).

Un valor es una expresin (de hecho es la expresin ms sencilla). Por ejemplo el resulta-do de la expresin 111 es precisamente el nmero 111.

Una variable es una expresin, y el valor que produce es el que tiene asociado en el estado(si x 5 en el estado, entonces el resultado de la expresin x es el nmero 5).

Usamos operaciones para combinar expresiones y construir expresiones ms complejas:

Si x es como antes, x + 1 es una expresin cuyo resultado es 6. Si en el estado millas 1, pies 0 y pulgadas 0, entonces1609.344 * millas + 0.3048 * pies + 0.0254 * pulgadas es una ex-presin cuyo resultado es 1609.344.

La exponenciacin se representa con el smbolo **. Por ejemplo, x**3 significa x3. Se pueden usar parntesis para indicar un orden de evaluacin: ((b * b) - (4 * a * c)) / (2 * a). Igual que en la matemtica, si no hay parntesis en la expresin primero se agrupan

las exponenciaciones, luego los productos y cocientes, y luego las sumas y restas.

Sin embargo, hay que tener cuidado con lo que sucede con los cocientes, porque si xe y son nmeros enteros, entonces x / y se calcula como la divisin entera entre x ey:Si x se refiere al valor 12 e y se refiere al valor 9 entonces x / y se refiere al valor 1.

Si x e y son nmeros enteros, entonces x % y se calcula como el resto de la divisinentera entre x e y:Si x se refiere al valor 12 e y se refiere al valor 9 entonces x % y se refiere al valor 3.


Los nmeros pueden ser tanto enteros (111, -24), como reales (12.5, 12.0, -12.5). Dentro de lacomputadora se representan de manera diferente, y se comportan de manera diferente frente a lasoperaciones.

Conocemos tambin dos expresiones muy particulares:

input, que devuelve el valor ingresado por teclado tal como se lo digita (en parti-cular sirve para ingresar valores numricos).

raw_input, que devuelve lo ingresado por teclado como si fuera un texto.

Ejercicio 2.1. Aplicando las reglas matemticas de asociatividad, decidir cules de las siguien-tes expresiones son iguales entre s:

a) ((b * b) - (4 * a * c)) / (2 * a),

b) (b * b - 4 * a * c) / (2 * a),

c) b * b - 4 * a * c / 2 * a,

d) (b * b) - (4 * a * c / 2 * a)

e) 1 / 2 * b

f) b / 2.

Ejercicio 2.2. En Python hagan lo siguiente: Denle a a, b y c los valores 10, 100 y 1000 respec-tivamente y evalen las expresiones del ejercicio anterior.

Ejercicio 2.3. En Python hagan lo siguiente: Denle a a, b y c los valores 10.0, 100.0 y 1000.0respectivamente y evalen las expresiones del punto anterior.

2.4. No slo de nmeros viven los programas

No slo tendremos expresiones numricas en un programa Python. Recuerden el programaque se us para saludar a muchos amigos:

def hola(alguien):print "Hola", alguien, "!"print "Estoy programando en Python."

Para invocar a ese programa y hacer que saludara a Ana haba que escribir hola("Ana").La variable alguien en dicha invocacin queda ligada a un valor que es una cadena de

caracteres (letras, dgitos, smbolos, etc.), en este caso, "Ana".Python usa tambin una notacin con comillas simples para referirse a las cadenas de ca-

racteres, y habla de Ana.Como en la seccin anterior, veremos las reglas de qu constituyen expresiones con carac-

teres:

Un valor tambin ac es una expresin. Por ejemplo el resultado de la expresin Anaes precisamente Ana.

Una variable es una expresin, y el valor que produce es el que tiene asociado en el estado(si amiga Ana en el estado, entonces el resultado de la expresin amiga es la cadenaAna).

2.5. Instrucciones 27

Usamos operaciones para combinar expresiones y construir expresiones ms complejas,pero atencin con qu operaciones estn permitidas sobre cadenas:

El signo + no representa la suma sino la concatenacin de cadenas: Si amiga es comoantes, amiga + Laura es una expresin cuyo valor es AnaLaura.

AtencinNo se pueden sumar cadenas ms nmeros.

>>> amiga="Ana">>> amiga+LauraAnaLaura>>> amiga+3Traceback (most recent call last):

File "", line 1, in TypeError: cannot concatenate str and int objects>>>

El signo * se usa para indicar cuntas veces se repite una cadena: amiga * 3 es unaexpresin cuyo valor es AnaAnaAna.

AtencinNo se pueden multiplicar cadenas entre s

>>> amiga * 3AnaAnaAna>>> amiga * amigaTraceback (most recent call last):

File "", line 1, in TypeError: cant multiply sequence by non-int of type str

2.5. Instrucciones

Las instrucciones son las rdenes que entiende Python. Ya hemos usado varias instrucciones:

hemos mostrado valores por pantalla mediante la instruccin print,

hemos retornado valores de una funcin mediante la instruccin return,

hemos asociado valores con variables y

hemos usado un ciclo para repetir un clculo.

2.6. Ciclos definidos

Hemos ya usado la instruccin for en el programa que calcula cuadrados de enteros en unrango.


for x in range(n1, n2):print x*x

Este ciclo se llama definido porque de entrada, y una vez ledos n1 y n2, se sabe exacta-mente cuntas veces se ejecutar el cuerpo y qu valores tomar x.

Un ciclo definido es de la forma

for in :

En nuestro ejemplo la secuencia de valores es el intervalo de enteros [n1, n1+1, ..., n2-1]y la variable es x.

La secuencia de valores se puede indicar como:

range(n). Establece como secuencia de valores a [0, 1, ..., n-1].

range(n1, n2). Establece como secuencia de valores a [n1, n1+1, ..., n2-1].

Se puede definir a mano una secuencia entre corchetes. Por ejemplo,

for x in [1, 3, 9, 27]:print x*x

imprimir los cuadrados de los nmeros 1, 3, 9 y 27.

2.7. Una gua para el diseo

En su artculo How to program it, Simon Thompson plantea algunas preguntas a susalumnos que son muy tiles para la etapa de diseo:

Han visto este problema antes, aunque sea de manera ligeramente diferente?

Conocen un problema relacionado? Conocen un programa que puede ser til?

Fjense en la especificacin. Traten de encontrar un problema que les resulte familiar yque tenga la misma especificacin o una parecida.

Ac hay un problema relacionado con el que ustedes tienen y que ya fue resuelto. Lopueden usar? Pueden usar sus resultados? Pueden usar sus mtodos? Pueden agre-garle alguna parte auxiliar a ese programa del que ya disponen?

Si no pueden resolver el problema propuesto, traten de resolver uno relacionado. Pue-den imaginarse uno relacionado que sea ms fcil de resolver? Uno ms general? Unoms especfico? Un problema anlogo?

Pueden resolver una parte del problema? Pueden sacar algo til de los datos de entra-da? Pueden pensar qu informacin es til para calcular las salidas? De qu manera sepueden manipular las entradas y las salidas de modo tal que estn ms cerca unas delas otras?

Usaron todos los datos de entrada? Usaron las condiciones especiales sobre los datosde entrada que aparecen en el enunciado? Han tenido en cuenta todos los requisitos quese enuncian en la especificacin?

2.8. Ejercicios 29

2.8. Ejercicios

Ejercicio 2.4. Escribir un ciclo definido para imprimir por pantalla todos los nmeros entre 10y 20.

Ejercicio 2.5. Escribir un ciclo definido que salude por pantalla a sus cinco mejores amigos/as.

Ejercicio 2.6. Escribir un programa que use un ciclo definido con rango numrico, que preguntelos nombres de sus cinco mejores amigos/as, y los salude.

Ejercicio 2.7. Escribir un programa que use un ciclo definido con rango numrico, que preguntelos nombres de sus seis mejores amigos/as, y los salude.

Ejercicio 2.8. Escribir un programa que use un ciclo definido con rango numrico, que averiguea cuntos amigos quieren saludar, les pregunte los nombres de esos amigos/as, y los salude.

Unidad 3

Funciones

En la primera unidad vimos que el programador puede definir nuevas instrucciones, quellamamos funciones. En particular lo aplicamos a la construccin de una funcin llamada holaque salude a todos a quienes queramos saludar:

def hola(alguien):print "Hola ", alguien,"!"print "Estoy programando en Python."

Dijimos en esa ocasin que las funciones tienen partes variables, llamadas parmetros, quese asocian a un valor distinto en cada invocacin. El valor con el que se asocia un parmetro sellama argumento. En nuestro caso la invocamos dos veces, para saludar a Ana y a Juan, haciendoque alguien se asocie al valor "Ana" en la primera llamada y al valor "Juan" en la segunda:

>>> hola("Ana")Hola Ana !Estoy programando en Python.>>> hola("Juan")Hola Juan !Estoy programando en Python.>>>

Una funcin puede tener ninguno, uno o ms parmetros. La funcin hola tiene un par-metro. Ya vimos tambin ejemplos de funciones sin parmetros:

def holaPab():print "Hola Pablo!"print "Estoy programando en Python."

En el caso de tener ms de un parmetro, stos se separan entre s por comas, y en la invo-cacin tambin se separan por comas los argumentos.

3.1. Documentacin de funciones

Cada funcin escrita por un programador realiza una tarea especfica. Cuando la cantidadde funciones disponibles para ser utilizadas es grande, puede ser difcil saber exactamente quhace una funcin. Es por eso que es extremadamente importante documentar en cada funcincul es la tarea que realiza, cules son los parmetros que recibe y qu es lo que devuelve, paraque a la hora de utilizarla sea lo pueda hacer correctamente.

30

3.2. Imprimir versus Devolver 31

La documentacin de una funcin se coloca luego del encabezado de la funcin, en unprrafo encerrado entre """. As, para la funcin vista en el ejemplo anterior:

def hola(alguien):""" Imprime por pantalla un saludo, dirigido a la persona que

se indica por parmetro. """print "Hola ", alguien,"!"print "Estoy programando en Python."

Cuando una funcin definida est correctamente documentada, es posible acceder a su do-cumentacin mediante la funcin help provista por Python:

>>> help(hola)Help on function hola in module __main__:

hola(alguien)Imprime por pantalla un saludo, dirigido a la persona quese indica por parmetro.

De esta forma no es necesario mirar el cdigo de una funcin para saber lo que hace, sim-plemente llamando a help es posible obtener esta informacin.

3.2. Imprimir versus Devolver

A continuacin se define una funcin print_asegundos (horas, minutos, segundos)con tres parmetros (horas, minutos y segundos) que imprime por pantalla la transforma-cin a segundos de una medida de tiempo expresada en horas, minutos y segundos:

1 def print_asegundos (horas, minutos, segundos):2 """ Transforma en segundos una medida de tiempo expresada en3 horas, minutos y segundos """4 segsal = 3600 * horas + 60 * minutos + segundos # regla de transformacin5 print "Son", segsal, "segundos"

Para ver si realmente funciona, podemos ejecutar la funcin de la siguiente forma:

>>> print_asegundos (1, 10, 10)Son 4210 segundos

Contar con funciones es de gran utilidad, ya que nos permite ir armando una biblioteca deinstrucciones con problemas que vamos resolviendo, y que se pueden reutilizar en la resolu-cin de nuevos problemas (como partes de un problema ms grande, por ejemplo) tal como losugiere Thompson en How to program it.

Sin embargo, ms til que tener una biblioteca donde los resultados se imprimen por pan-talla, es contar con una biblioteca donde los resultados se devuelven, para que la gente que usaesas funciones manipule esos resultados a voluntad: los imprima, los use para realizar clculosms complejos, etc.

1 def calc_asegundos (horas, minutos, segundos):2 """ Transforma en segundos una medida de tiempo expresada en3 horas, minutos y segundos """4 segsal = 3600 * horas + 60 * minutos + segundos # regla de transformacion5 return segsal

32 Unidad 3. Funciones

De esta forma, es posible realizar distintas operaciones con el valor obtenido luego de hacerla cuenta:

>>> print calc_asegundos (1, 10, 10)4210>>> print "Son", calc_asegundos (1, 10, 10), "segundos"Son 4210 segundos>>> y = calc_asegundos(1, 10, 10)>>> z = calc_asegundos(2, 20, 20)>>> y+z12630

Ejercicio 3.1. Escribir una funcin repite_hola que reciba como parmetro un nmero en-tero n y escriba por pantalla el mensaje "Hola" n veces. Invocarla con distintos valores den.

Ejercicio 3.2. Escribir otra funcin repite_hola que reciba como parmetro un nmero en-tero n y retorne la cadena formada por n concatenaciones de "Hola". Invocarla con distintosvalores de n.

Ejercicio 3.3. Escribir una funcin repite_saludo que reciba como parmetro un nmeroentero n y una cadena saludo y escriba por pantalla el valor de saludo n veces. Invocarlacon distintos valores de n y de saludo.

Ejercicio 3.4. Escribir otra funcin repite_saludo que reciba como parmetro un nmeroentero n y una cadena saludo retorne el valor de n concatenaciones de saludo. Invocarla condistintos valores de n y de saludo.

3.3. Cmo usar una funcin en un programa

Una funcin es til porque nos permite repetir la misma instruccin (puede que con argu-mentos distintos) todas las veces que las necesitemos en un programa.

Para utilizar las funciones definidas anteriormente, escribiremos un programa que pida tresduraciones, y en los tres casos las transforme a segundos y las muestra por pantalla.

1. Anlisis: El programa debe pedir tres duraciones expresadas en horas, minutos y segun-dos, y las tiene que mostrar en pantalla expresadas en segundos.

2. Especificacin:

Entradas: Tres duraciones ledas de teclado y expresadas en horas, minutos y se-gundos.

Salidas: Mostrar por pantalla cada una de las duraciones ingresadas, convertidas asegundos. Para cada juego de datos de entrada (h, m, s) se obtiene entonces 3600 * h+ 60 * m + s, y se muestra ese resultado por pantalla.

3. Diseo:

Se tienen que leer tres conjuntos de datos y para cada conjunto hacer lo mismo, setrata entonces de un programa con estructura de ciclo definido de tres pasos:

3.3. Cmo usar una funcin en un programa 33

repetir 3 veces:

El cuerpo del ciclo ( ) tiene la estructura Entrada-Clculo-Salida. Enpseudocdigo:

Leer cuntas horas tiene el tiempo dado(y referenciarlo con la variable hs)

Leer cuntos minutos tiene tiene el tiempo dado(y referenciarlo con la variable min)

Leer cuntos segundos tiene el tiempo dado(y referenciarlo con la variable seg)

Mostrar por pantalla 3600 * hs + 60 * min + seg

Pero convertir y mostrar por pantalla es exactamente lo que hace nuestra funcinprint_asegundos, por lo que podemos hacer que el cuerpo del ciclo se diseecomo:

Leer cuntas horas tiene la duracin dada(y referenciarlo con la variable hs)

Leer cuntos minutos tiene tiene la duracin dada(y referenciarlo con la variable min)

Leer cuntas segundos tiene la duracin dada(y referenciarlo con la variable seg)

Invocar la funcin print_asegundos(hs, min, seg)

El pseudocdigo final queda:

repetir 3 veces:Leer cuntas horas tiene la duracin dada(y referenciarlo con la variable hs)

Leer cuntos minutos tiene la duracin dada(y referenciarlo con la variable min)

Leer cuntos segundos tiene la duracin dada(y referenciarlo con la variable seg)

Invocar la funcin print_asegundos(hs, min, seg)

4. Implementacin: A partir del diseo, se escribe el programa Python que se muestra en elCdigo 3.1, que se guardar en el archivo tres_tiempos.py.

5. Prueba: Probamos el programa con las ternas (1,0,0), (0,1,0) y (0,0,1):


Cdigo 3.1 tres_tiempos.py: Lee tres tiempos y los imprime en segundos

1 def print_asegundos (horas, minutos, segundos):2 """ Transforma en segundos una medida de tiempo expresada en3 horas, minutos y segundos """4 segsal = 3600 * horas + 60 * minutos + segundos5 print "Son",segsal, "segundos"6

7 def main():8 """ Lee tres tiempos expresados en hs, min y seg, y usa9 print_asegundos para mostrar en pantalla la conversin a

10 segundos """11 for x in range(3):12 hs = raw_input("Cuantas horas?: ")13 min = raw_input("Cuantos minutos?: ")14 seg = raw_input("Cuantos segundos?: ")15 print_asegundos(hs, min, seg)16

17 main()

>>> import tres_tiemposCuantas horas?: 1Cuantos minutos?: 0Cuantos segundos?: 0Son 3600 segundosCuantas horas?: 0Cuantos minutos?: 1Cuantos segundos?: 0Son 60 segundosCuantas horas?: 0Cuantos minutos?: 0Cuantos segundos?: 1Son 1 segundos>>>

Ejercicio 3.5. Resolver el problema anterior usando ahora la funcin calc_asegundos.

3.4. Ms sobre los resultados de las funciones

Ya hemos visto cmo hacer para que las funciones que se comporten como las funcionesque conocemos, las de la matemtica, que se usan para calcular resultados.

Veremos ahora varias cuestiones a tener en cuenta al escribir funciones. Para ello volvemosa escribir una funcin que eleva al cuadrado un nmero.

>>> def cuadrado (x):... cua = x * x... return cua

3.5. Un ejemplo completo 35

...>>> y = cuadrado (5)>>> y25>>>

Por qu no usamos dentro del programa el valor cua calculado dentro de la funcin?

>>> def cuadrado (x):... cua = x * x... return cua...>>> cuaTraceback (most recent call last):

File "", line 1, in NameError: name cua is not defined>>>

Las variables y los parmetros que se declaran dentro de una funcin no existen fuera de ella, no selos conoce. Fuera de la funcin se puede ver slo el valor que retorna y es por eso que es necesariointroducir la instruccin return.

Para qu hay que introducir un return en la funcin? No alcanza con el valor que secalcula dentro de la misma para que se considere que la funcin retorna un valor? En Pythonno alcanza (hay otros lenguajes en los que se considera que el ltimo valor calculado en unafuncin es el valor de retorno de la misma).

>>> def cuadrado (x):... cua = x * x...>>> y = cuadrado (5)>>> y>>>

Cuando se invoca la funcin cuadrado mediante la instruccin y = cuadrado (5) loque sucede es lo siguiente:

Se invoca a cuadrado con el argumento 5, y se ejecuta el cuerpo de la funcin.

El valor que devuelve la funcin se asocia con la variable y.

Es por eso que si la funcin no devuelve ningn valor, no queda ningn valor asociado a lavariable y.

3.5. Un ejemplo completo

Problema 3.1. Un usuario nos plantea su problema: necesita que se facture el uso de un tel-fono. Nos informar la tarifa por segundo, cuntas comunicaciones se realizaron, la duracinde cada comunicacin expresada en horas, minutos y segundos. Como resultado deberemosinformar la duracin en segundos de cada comunicacin y su costo.

Solucin. Aplicaremos los pasos aprendidos:


1. Anlisis:

Cuntas tarifas distintas se usan? Una sola (la llamaremos f).

Cuntas comunicaciones se realizaron? La cantidad de comunicaciones (a la quellamaremos n) se informa cuando se inicia el programa.

En qu formato vienen las duraciones de las comunicaciones? Vienen como ternas(h, m, s).

Qu se hace con esas ternas? Se convierten a segundos y se calcula el costo de cadacomunicacin multiplicando el tiempo por la tarifa.

2. Especificacin:

Entradas:

Una tarifa f expresada en pesos/segundo. Una cantidad n de llamadas telefnicas. n duraciones de llamadas ledas de teclado y expresadas en horas, minutos y

segundos.

Salidas: Mostrar por pantalla las n duraciones ingresadas, convertidas a segundos,y su costo. Para cada juego de datos de entrada (h, m, s) se imprime:

3600 h+ 60 m+ s, f (3600 h+ 60 m+ s).

3. Diseo:

Siguiendo a Thompson, buscamos un programa que haga algo anlogo, y vemos si selo puede modificar para resolver nuestro problema. El programa tres_tiempos quehicimos anteriormente, se parece bastante a lo que necesitamos. Veamos las diferenciasentre sus especificaciones.

tres_tiempos.py tarifador.py

repetir 3 veces:

leer el valor de fleer el valor de nrepetir n veces:

El cuerpo del ciclo:

Leer el valor de hsLeer el valor de minLeer el valor de segInvocar print_asegundos(hs, min, seg)

El cuerpo del ciclo:

Leer el valor de hsLeer el valor de minLeer el valor de segAsignar segcalc = asegundos(hs, min, seg)Calcular costo = segcalc * fMostrar por pantalla segcalc y costo

print_asegundos (hs, min, seg):segsal = 3600*hs+60*min+segprint segsal

asegundos (hs, min, seg):segsal = 3600*hs+60*min+segreturn segsal

3.5. Un ejemplo completo 37

En primer lugar se observa que el tarifador debe leer el valor de la tarifa (f) y queen tres_tiempos se conoce la cantidad de ternas (3), mientras que en tarifador lacantidad de ternas es un dato a ingresar.

Adems, se puede ver que en el cuerpo del ciclo de tres_tiempos, se lee una ternay se llama a print_asegundos que calcula, imprime y no devuelve ningn valor. Sihiciramos lo mismo en tarifador, no podramos calcular el costo de la comunicacin.Es por ello que en lugar de usar print_asegundos se utiliza la funcin asegundos,que calcula el valor transformado y lo devuelve en lugar de imprimirlo y en el cuerpoprincipal del programa se imprime el tiempo junto con el costo asociado.

4. Implementacin: El siguiente es el programa resultante:

Cdigo 3.2 tarifador.py: Factura el tiempo de uso de un telfono

1 def main():2 """ El usuario ingresa la tarifa por segundo, cuntas3 comunicaciones se realizaron, y la duracion de cada4 comunicacin expresada en horas, minutos y segundos. Como5 resultado se informa la duracin en segundos de cada6 comunicacin y su costo. """7

8 f = input("Cunto cuesta 1 segundo de comunicacion?: ")9 n = input("Cuntas comunicaciones hubo?: ")

10 for x in range(n):11 hs = input("Cuntas horas?: ")12 min = input("Cuntos minutos?: ")13 seg = input("Cuntos segundos?: ")14 segcalc = asegundos(hs, min, seg)15 costo = segcalc * f16 print "Duracion: ", segcalc, "segundos. Costo: ",costo, "$."17

18 def asegundos (horas, minutos, segundos):19 segsal = 3600 * horas + 60 * minutos + segundos20 return segsal21

22 main()

5. Prueba: Lo probamos con una tarifa de $ 0,40 el segundo y tres ternas de (1,0,0),(0,1,0) y (0,0,1). sta es la corrida:

>>> import tarifadorCuanto cuesta 1 segundo de comunicacion?: 0.40Cuantas comunicaciones hubo?: 3Cuantas horas?: 1Cuantos minutos?: 0Cuantos segundos?: 0Duracion: 3600 segundos. Costo: 1440.0 $.Cuantas horas?: 0


Cuantos minutos?: 1Cuantos segundos?: 0Duracion: 60 segundos. Costo: 24.0 $.Cuantas horas?: 0Cuantos minutos?: 0Cuantos segundos?: 1Duracion: 1 segundos. Costo: 0.4 $.>>>

6. Mantenimiento:

Ejercicio 3.6. Corregir el programa para que:

Imprima el costo en pesos y centavos, en lugar de un nmero decimal.

Informe adems cul fue el total facturado en la corrida.

3.6. Devolver mltiples resultados

Ahora nos piden que escribamos una funcin que dada una duracin en segundos sin frac-ciones (representada por un nmero entero) calcule la misma duracin en horas, minutos ysegundos.

La especificacin es sencilla:

La cantidad de horas es la duracin informada en segundos dividida por 3600 (divisinentera).

La cantidad de minutos es el resto de la divisin del paso 1, dividido por 60 (divisinentera).

La cantidad de segundos es el resto de la divisin del paso 2.

Es importante notar que si la duracin no se informa como un nmero entero, todas lasoperaciones que se indican ms arriba carecen de sentido.

Cmo hacemos para devolver ms de un valor? En realidad lo que se espera de esta fun-cin es que devuelva una terna de valores: si ya calculamos hs, min y seg, lo que debemosretornar es la terna (hs, min, seg):

1 def aHsMinSeg (x):2 """ Dada una duracin en segundos sin fracciones3 (la funcin debe invocarse con nmeros enteros)4 se la convierte a horas, minutos y segundos """5 hs = x / 36006 min = (x % 3600) / 607 seg = (x % 3600 ) % 608 return (hs, min, seg)

Esto es lo que sucede al invocar esta funcin:

3.7. Resumen 39

>>> (h, m, s) = aHsMinSeg(3661)>>> print "Son",h,"horas",m,"minutos",s,"segundos"Son 1 horas 1 minutos 1 segundos>>> (h, m, s) = aHsMinSeg(3661.0) # aca violamos la especificacion>>> print "Son",h,"horas",m,"minutos",s,"segundos" # y esto es lo que pasa:Son 1.0169444444444444 horas 1.0166666666666666 minutos 1.0 segundos>>>

Sabas que . . .Cuando la funcin debe retornar mltiples resultados se empaquetan todos juntos en una n-upladel tamao adecuado.Esta caracterstica est presente en Python, Haskell, y algunos otros pocos lenguajes. En los lengua-jes en los que esta caracterstica no est presente, como C, Pascal, Java o PHP, es necesario recurrira otras tcnicas ms complejas para poder obtener un comportamiento similar.

Respecto de la variable que har referencia al resultado de la invocacin, se podr usar tantouna n-upla de variables como en el ejemplo anterior, en cuyo caso podremos nombrar en formaseparada cada uno de los resultados, o bien se podr usar una sola variable, en cuyo caso seconsiderar que el resultado tiene un solo nombre y la forma de una n-upla:

>>> t=aHsMinSeg(3661)>>> print t(1, 1, 1)>>>

Si se usa una n-upla de variables para referirse a un resultado, la cantidad de variables tiene quecoincidir con la cantidad de valores que se retornan.

>>> (x,y)=aHsMinSeg(3661)Traceback (most recent call last):

File "", line 1, in ValueError: too many values to unpack>>> (x,y,w,z)=aHsMinSeg(3661)Traceback (most recent call last):

File "", line 1, in ValueError: need more than 3 values to unpack>>>

3.7. Resumen

Una funcin puede tener ninguno, uno o ms parmetros. En el caso de tener ms de uno,se separan por comas tanto en la declaracin de la funcin como en la invocacin.

Es altamente recomendable documentar cada funcin que se escribe, para poder saberqu parmetros recibe, qu devuelve y qu hace sin necesidad de leer el cdigo.

Las funciones pueden imprimir mensajes para comunicarlos al usuario, y/o devolvervalores. Cuando una funcin realice un clculo o una operacin con sus parmetros, es


recomendable que devuelva el resultado en lugar de imprimirlo, permitiendo realizarotras operaciones con l.

No es posible acceder a las variables definidas dentro de una funcin desde el programaprincipal, si se quiere utilizar algn valor calculado en la funcin, ser necesario devol-verlo.

Si una funcin no devuelve nada, por ms que se la asigne a una variable, no quedarningn valor asociado a esa variable.

Referencia del lenguaje Python

def funcion(param1, param2, param3):Permite definir funciones, que pueden tener ninguno, uno o ms parmetros. El cuerpo de lafuncin debe estar un nivel de indentacin ms adentro que la declaracin de la funcin.

def funcion(param1, param2, param3):# hacer algo con los parametros

Documentacin de funcionesSi en la primera lnea de la funcin se ingresa un comentario encerrado entre comillas, estecomentario pasa a ser la documentacin de la funcin, que puede ser accedida mendiante elcomando help(funcion).

def funcion():""" Esta es la documentacin de la funcin """# hacer algo

return valorDentro de una funcin se utiliza la instruccin return para indicar el valor que la funcindebe devolver.

Una vez que se ejecuta esta instruccin, se termina la ejecucin de la funcin, sin importar sies la ltima lnea o no.

Si la funcin no contiene esta instruccin, no devuelve nada.return (valor1, valor2, valor3)

Si se desea devolver ms de un valor, se los empaqueta en una tupla de valores. Esta tuplapuede o no ser desempaquetada al invocar la funcin:

def f(valor):# operarreturn (a1, a2, a3)

# desempaquetado:v1, v2, v3 = f(x)# empaquetadov = f(y)

Unidad 4

Decisiones

Nos plantean el siguiente problema:

Problema 4.1. Debemos leer un nmero y, si el nmero es positivo, debemos escribir en panta-lla el cartel Numero positivo.

Solucin. Especificamos nuestra solucin: se deber leer un nmero x. Si x > 0 se escribe elmensaje "Nmero positivo".

Diseamos nuestra solucin:

1. Solicitar al usuario un nmero, guardarlo en x.

2. Si x > 0, imprimir "Numero positivo"

Es claro que la primera lnea se puede traducir como

x = input("Ingrese un numero: ")

Sin embargo, con las instrucciones que vimos hasta ahora no podemos tomar el tipo dedecisiones que nos planteamos en la segunda lnea de este diseo.

Para resolver este problema introducimos una nueva instruccin que llamaremos condicio-nal que tiene la siguiente forma:

if :

Donde if es una palabra reservada.Qu es la condicin que aparece luego de la palabra reservada if? Antes de seguir ade-

lante con la construccin debemos introducir un nuevo tipo de expresin que nos indicar si seda una cierta situacin o no. Hasta ahora las expresiones con las que trabajamos fueron de tiponumrica y de tipo texto. Pero ahora la respuesta que buscamos es de tipo s o no.

4.1. Expresiones booleanas

Adems de los nmeros y los textos que vimos hasta ahora, Python introduce las constantesTrue y False para representar los valores de verdad verdadero y falso respectivamente.

Vimos que una expresin es un trozo de cdigo Python que produce o calcula un valor(resultado). Una expresin booleana o expresin lgica es una expresin que vale o bien True obien False.

41

42 Unidad 4. Decisiones

4.1.1. Expresiones de comparacin

En el ejemplo que queremos resolver, la condicin que queremos ver si se cumple o no esque x sea mayor que cero. Python provee las llamadas expresiones de comparacin que sirvenpara comparar valores entre s, y que por lo tanto permiten codificar ese tipo de pregunta. Enparticular la pregunta de si x es mayor que cero, se codifica en Python como x > 0.

De esta forma, 5 > 3 es una expresin booleana cuyo valor es True, y 5 < 3 tambin esuna expresin booleana, pero su valor es False.

>>> 5 > 3True>>> 3 > 5False>>>

Los expresiones booleanas de comparacin que provee Python son las siguientes:Expresin Significadoa == b a es igual a ba != b a es distinto de ba < b a es menor que ba b a es mayor que ba >= b a es mayor o igual que b

A continuacin, algunos ejemplos de uso de estos operadores:

>>> 6==6True>>> 6!=6False>>> 6>6False>>> 6>=6True>>> 6>4True>>> 6>> 6>> 4>>

4.1.2. Operadores lgicos

De la misma manera que se puede operar entre nmeros mediante las operaciones de suma,resta, etc., tambin existen tres operadores lgicos para combinar expresiones booleanas: and(y), or (o) y not (no).

El significado de estos operadores es igual al del castellano, pero vale la pena recordarlo:

4.2. Comparaciones simples 43

Expresin Significadoa and b El resultado es True solamente si a es True y b es True

de lo contrario el resultado es Falsea or b El resultado es True si a es True o b es True

de lo contrario el resultado es Falsenot a El resultado es True si a es False

de lo contrario el resultado es False

a > b and a > c es verdadero si a es simultneamente mayor que b y que c.

>>> 5>2 and 5>3True>>> 5>2 and 5>6False>>>

a > b or a > c es verdadero si a es mayor que b o a es mayor que c.

>>> 5>2 or 5>3True>>> 5>2 or 5>6True>>> 5>8 or 5>6False>>>

not (a > b) es verdadero si a > b es falso (o sea si a >> 5>8False>>> not (5>8)True>>> 5>2True>>> not (5>2)False>>>

4.2. Comparaciones simples

Volvemos al problema que nos plantearon: Debemos leer un nmero y, si el nmero espositivo, debemos escribir en pantalla el mensaje "Numero positivo".

Utilizando la instruccin if que acabamos de introducir y que sirve para tomar decisionessimples. Dijimos que su formato ms sencillo es:

if :

cuyo significado es el

Documents

Algoritmos Programacion Python