Aprender Python Fácil PDF

Python para todos Explorando la información con Python 3 Charles R. Severance Créditos Soporte Editorial: Elliott Hauser, Sue Blumenberg Diseño de portada: Toby Koening, Aimee Andrion Contribuidores: Juan Carlos Perez Castellanos, Juan Dougnac, Daniel Merino Echeverría, Jaime Bermeo Ramírez y Fernando Tardío. Historial de impresión 02-Abr-2020 Traducción al Español completa de Python 3.0 05-Jul-2016 Primera versión completa de Python 3.0 20-Dic-2015 Borrador inicial de conversión a Python 3.0 Detalles de Copyright Copyright ~2009- Charles Severance. Este trabajo está registrado bajo una Licencia Creative Commons Attribution- NonCommercial-ShareAlike 3.0 Unported License. Este licencia está disponible en http://creativecommons.org/licenses/by-nc-sa/3.0/ Puedes ver lo que el autor considera usos comerciales y no-comerciales de este material, así como las exenciones de licencia en el Apéndice titulado “Detalles de Copyright”. iii Prólogo Remezclando un Libro Libre Se suele decir de los académicos deben “publicar o perecer” continuamente, de modo que es bastante normal que siempre quieran empezar algo desde cero, para que sea su propia y flamante creación. Este libro es un experimento, ya que no parte desde cero, sino que en vez de eso “remezcla” el libro titulado Think Python: How to Think Like a Computer Scientist (Piensa en Python: Cómo pensar como un científico de la computación), escrito por Allen B. Bowney, Jeff Elkner, y otros. En Diciembre de 2009, yo me estaba preparando para enseñar SI502 - Progra- mación en Red en la Universidad de Michigan por quinto semestre consecutivo, y decidí que ya era hora de escribir un libro de texto sobre Python que se centrase en la exploración de datos en lugar de en explicar algoritmos y abstracciones. Mi objetivo en SI502 es enseñar a la gente habilidades permanentes para el manejo de datos usando Python. Pocos de mis estudiantes pretenden llegar a ser progra- madores de computadoras profesionales. En vez de eso, quieren ser bibliotecarios, gerentes, abogados, biólogos, economistas, etc., que tal vez quieran aplicar el uso de la tecnología en sus respectivos campos. Parecía que no podría encontrar el libro perfecto para mi curso, que estuviera orientado al manejo de datos en Python, de modo que decidí empezar a escribirlo por mi mismo. Por suerte, en una reunión de profesores tres semanas antes de las vacaciones, que era la fecha en que tenía planeado empezar a escribir mi libro desde cero, el Dr. Atul Prakash me mostró el libro Think Python (Piensa en Python), que él había utilizado para impartir su curso de Python ese semestre. Se trata de un texto de Ciencias de la Computación bien escrito, con un enfoque breve, explicaciones directas y fácil de aprender. La estructura principal del libro se ha cambiado, para empezar a realizar problemas de análisis de datos lo antes posible, y para tener una serie de ejemplos funcionales y de ejercicios sobre el análisis de datos desde el principio. Los capítulos 2-10 son similares a los del libro Think Python, pero ha habido cambios importantes. Los ejemplos orientados a números y los ejercicios se han reemplazado por otros orientados a datos. Los temas se presentan en el orden necesario para ir creando soluciones de análisis de datos cuya complejidad aumente progresivamente. Algunos temas como try y except (manejo de excepciones) se han adelantado, y se presentan como parte del capítulo de los condicionales. Las funciones se tratan muy por encima hasta que son necesarias para manejar programas complejos, en lugar de introducirlas como abstracción en las primeras lecciones. Casi todas las funciones definidas por el usuario se han eliminado del código de los ejemplos y de los ejercicios excepto en el capítulo 4. La palabra “recursión”1 no aparece en todo el libro. Todo el contenido del capítulo 1 y del 11 al 16 es nuevo, centrado en aplicaciones para el mundo real y en ejemplos simples del uso de Python para el análisis de datos, incluyendo expresiones regulares para búsqueda y análisis, automatización de tareas en la computadora, descarga de datos a través de la red, escaneo de pági- nas web para recuperar datos, programación orientada a objetos, uso de servicios 1 Excepto, por supuesto, en esa línea. iv web, análisis de datos en formato XML y JSON, creación y uso de bases de datos usando el Lenguaje de Consultas Estructurado (SQL), y la visualización de datos. El objetivo final de todos estos cambios es variar la orientación, desde una dirigida a las Ciencias de la Computación hacia otra puramente informática, que trate sólo temas adecuados para una clase de tecnología para principiantes, que puedan resultarles útiles incluso si eligen no ser programadores profesionales. Los estudiantes que encuentren este libro interesante y quieran ir más allá, de- berían echar un vistazo al libro Think Python de Allen B. Downey’s. Como ambos libros comparten un montón de materia, los estudiantes adquirirán rápidamente habilidades en las áreas adicionales de la programación técnica y pensamiento al- gorítmico que se tratan en Think Python. Y dado que ambos libros comparten un estilo de escritura similar, deberían ser capaces de avanzar rápidamente a través del contenido de Think Python con un esfuerzo mínimo. Como propietario del copyright de Think Python, Allen me ha dado permiso para cambiar la licencia del contenido de su libro que se utiliza en éste, y que original- mente poseía una GNU Free Documentation License a otra más actual, Creative Commons Attribution — Share Alike license. Así se sigue una tendencia general en las licencias de documentación abierta, que están pasando desde la GFDL a la CC-BY-SA (por ejemplo, Wikipedia). El uso de la licencia CC-BY-SA mantiene la arraigada tradición copyleft del libro, a la vez que hacen más sencillo para los autores nuevos la reutilización de ese material a su conveniencia. Personalmente creo que este libro sirve como ejemplo de por qué los contenidos libres son tan importantes para el futuro de la educación, y quiero agradecer a Allen B. Downey y a la Cambridge University Press por su amplitud de miras a la hora de distribuir el libro bajo un copyright abierto. Espero que se sientan satisfechos con el resultado de mis esfuerzos y deseo que tú como lector también te sientas satisfecho de nuestros esfuerzos colectivos. Quiero agradecer a Allen B. Downey y Lauren Cowles su ayuda, paciencia y ori- entación a la hora de tratar y resolver los problemas de copyright referentes a este libro. Charles Severance www.dr-chuck.com Ann Arbor, MI, USA 9 de Septiembre, 2013 Charles Severance es Profesor Clínico Adjunto en la Escuela de Información (School of Information) de la Universidad de Michigan. Contents 1 ¿Por qué deberías aprender a escribir programas? 1 1.1 Creatividad y motivación....................... 2 1.2 Arquitectura hardware de las computadoras............. 3 1.3 Comprendiendo la programación................... 4 1.4 Palabras y frases............................ 5 1.5 Conversando con Python....................... 6 1.6 Terminología: intérprete y compilador................ 8 1.7 Escribiendo un programa....................... 10 1.8 ¿Qué es un programa?.......................... 11 1.9 Los bloques de construcción de los programas............ 12 1.10 ¿Qué es posible que vaya mal?.................... 13 1.11 Depurando los programas....................... 15 1.12 El camino del aprendizaje....................... 16 1.13 Glosario................................. 17 1.14 Ejercicios................................ 17 2 Variables, expresiones y sentencias 19 2.1 Valores y tipos............................. 19 2.2 Variables................................ 20 2.3 Nombres de variables y palabras claves................ 21 2.4 Sentencias................................ 22 2.5 Operadores y operandos........................ 22 2.6 Expresiones............................... 23 2.7 Orden de las operaciones....................... 24 2.8 Operador módulo........................... 24 2.9 Operaciones con cadenas....................... 25 v vi CONTENTS 2.10 Petición de información al usuario.................. 25 2.11 Comentarios.............................. 26 2.12 Elección de nombres de variables mnemónicos............ 27 2.13 Depuración............................... 29 2.14 Glosario................................. 29 2.15 Ejercicios................................. 31 3 Ejecución condicional 33 3.1 Expresiones booleanas......................... 33 3.2 Operadores lógicos........................... 34 3.3 Ejecución condicional......................... 34 3.4 Ejecución alternativa......................... 36 3.5 Condicionales encadenados...................... 36 3.6 Condicionales anidados........................ 37 3.7 Captura de excepciones usando try y except............ 38 3.8 Evaluación en cortocircuito de expresiones lógicas......... 40 3.9 Depuración................................ 41 3.10 Glosario................................. 42 3.11 Ejercicios................................ 43 4 Funciones 45 4.1 Llamadas a funciones......................... 45 4.2 Funciones internas........................... 45 4.3 Funciones de conversión de tipos................... 46 4.4 Funciones matemáticas........................ 47 4.5 Números aleatorios........................... 48 4.6 Añadiendo funciones nuevas...................... 49 4.7 Definición y usos............................ 50 4.8 Flujo de ejecución............................ 51 4.9 Parámetros y argumentos....................... 52 4.10 Funciones productivas y funciones estériles............. 53 4.11 ¿Por qué funciones?.......................... 54 4.12 Depuración............................... 55 4.13 Glosario................................. 55 4.14 Ejercicios................................ 57 CONTENTS vii 5 Iteración 59 5.1 Actualización de variables....................... 59 5.2 La sentencia while........................... 59 5.3 Bucles infinitos............................. 60 5.4 “Bucles infinitos” y break........................ 61 5.5 Finalizar iteraciones con continue.................. 62 5.6 Bucles definidos usando for...................... 62 5.7 Diseños de bucles........................... 63 5.7.1 Bucles de recuento y suma.................. 64 5.7.2 Bucles de máximos y mínimos................ 65 5.8 Depuración............................... 66 5.9 Glosario................................. 67 5.10 Ejercicios................................ 67 6 Cadenas 69 6.1 Una cadena es una secuencia..................... 69 6.2 Obtener el tamaño de una cadena usando len........... 70 6.3 Recorriendo una cadena mediante un bucle............. 70 6.4 Rebanado de una cadena........................ 71 6.5 Los cadenas son inmutables...................... 72 6.6 Iterando y contando.......................... 72 6.7 El operador in............................. 73 6.8 Comparación de cadenas....................... 73 6.9 Métodos de cadenas.......................... 73 6.10 Analizando cadenas.......................... 76 6.11 El operador de formato........................ 77 6.12 Depuración............................... 78 6.13 Glosario................................. 79 6.14 Ejercicios................................ 79 7 Archivos 81 7.1 Persistencia................................ 81 7.2 Abrir archivos............................. 82 7.3 Archivos de texto y líneas....................... 83 7.4 Lectura de archivos.......................... 84 viii CONTENTS 7.5 Búsqueda a través de un archivo................... 85 7.6 Permitiendo al usuario elegir el nombre de archivo......... 88 7.7 Utilizando try, except, y open................... 88 7.8 Escritura de archivos......................... 90 7.9 Depuración................................ 91 7.10 Glosario.................................. 91 7.11 Ejercicios................................ 92 8 Listas 95 8.1 Una lista es una secuencia....................... 95 8.2 Las listas son mutables........................ 96 8.3 Recorriendo una lista......................... 96 8.4 Operaciones de listas.......................... 97 8.5 Rebanado de listas........................... 98 8.6 Métodos de listas............................ 98 8.7 Eliminando elementos......................... 99 8.8 Listas y funciones........................... 100 8.9 Listas y cadenas............................. 101 8.10 Analizando líneas........................... 102 8.11 Objetos y valores............................ 103 8.12 Alias................................... 104 8.13 Listas como argumentos........................ 104 8.14 Depuración............................... 106 8.15 Glosario................................. 109 8.16 Ejercicios................................ 110 9 Diccionarios 113 9.1 Diccionario como un conjunto de contadores............ 115 9.2 Diccionarios y archivos........................ 116 9.3 Bucles y diccionarios.......................... 118 9.4 Análisis avanzado de texto...................... 119 9.5 Depuración................................ 121 9.6 Glosario.................................. 121 9.7 Ejercicios................................ 122 CONTENTS ix 10 Tuplas 125 10.1 Las Tuplas son inmutables...................... 125 10.2 Comparación de tuplas........................ 126 10.3 Asignación de tuplas.......................... 128 10.4 Diccionarios y tuplas.......................... 129 10.5 Asignación múltiple con diccionarios................. 130 10.6 Las palabras más comunes....................... 131 10.7 Uso de tuplas como claves en diccionarios.............. 132 10.8 Secuencias: cadenas, listas, y tuplas - ¡Dios mío!.......... 133 10.9 Depuración............................... 133 10.10 Glosario................................. 134 10.11 Ejercicios................................ 134 11 Expresiones regulares 137 11.1 Coincidencia de caracteres en expresiones regulares......... 138 11.2 Extrayendo datos usando expresiones regulares........... 139 11.3 Combinando búsqueda y extracción................. 142 11.4 Escapado de Caracteres........................ 146 11.5 Resumen................................ 146 11.6 Sección adicional para usuarios de Unix / Linux.......... 147 11.7 Depuración............................... 148 11.8 Glosario................................. 149 11.9 Ejercicios................................ 149 12 Programas en red 151 12.1 Protocolo de Transporte de Hipertexto - HTTP........... 151 12.2 El navegador web más sencillo del mundo.............. 152 12.3 Recepción de una imagen mediante HTTP............. 154 12.4 Recepción de páginas web con urllib................ 156 12.5 Leyendo archivos binarios con urllib................ 157 12.6 Análisis the HTML y rascado de la web............... 159 12.7 Análisis de HTML mediante expresiones regulares......... 159 12.8 Análisis de HTML mediante BeautifulSoup.............. 161 12.9 Sección extra para usuarios de Unix / Linux............ 164 12.10 Glosario................................. 164 12.11 Ejercicios................................ 165 x CONTENTS 13 Uso de Servicios Web 167 13.1 eXtensible Markup Language - XML................. 167 13.2 Análisis de XML............................ 168 13.3 Desplazamiento a través de los nodos................ 169 13.4 JavaScript Object Notation - JSON................. 170 13.5 Análisis de JSON............................ 171 13.6 Interfaces de programación de aplicaciones............. 172 13.7 Seguridad y uso de APIs....................... 174 13.8 Glossary................................. 174 13.9 Aplicación Nº 1: Servicio web de geocodificación de Google.... 175 13.10 Aplicación 2: Twitter......................... 178 14 Programación Orientada a Objetos 185 14.1 Manejando programas más grandes................. 185 14.2 Cómo empezar............................. 186 14.3 Usando objetos............................. 186 14.4 Comenzando con programas..................... 187 14.5 Subdividiendo un problema...................... 189 14.6 Nuestro primer objeto de Python................... 190 14.7 Clases como tipos........................... 192 14.8 Ciclo de vida de un objeto...................... 193 14.9 Múltiples instancias.......................... 194 14.10 Herencia................................ 195 14.11 Resumen................................ 196 14.12 Glosario................................. 197 15 Bases de datos y SQL 199 15.1 ¿Qué es una base de datos?...................... 199 15.2 Conceptos sobre bases de datos.................... 200 15.3 Navegador de bases de datos para SQLite.............. 200 15.4 Creación de una tabla en una base de datos.............. 201 15.5 Resumen de Lenguaje de Consultas Estructurado.......... 204 15.6 Rastreo en Twitter usando una base de datos............ 205 15.7 Modelado de datos básico........................ 211 15.8 Programación con múltiples tablas.................. 213 CONTENTS xi 15.8.1 Restricciones en tablas de bases de datos.......... 216 15.8.2 Recuperar y/o insertar un registro.............. 217 15.8.3 Almacenar las relaciones entre amigos............ 218 15.9 Tres tipos de claves.......................... 219 15.10 Uso de JOIN para recuperar datos.................. 219 15.11 Resumen................................ 222 15.12 Depuración............................... 223 15.13 Glosario................................. 223 16 Visualización de datos 225 16.1 Mapa de Google a partir de datos geocodificados.......... 225 16.2 Visualización de redes e interconexiones............... 228 16.3 Visualización de datos de correo................... 230 A Colaboraciones 237 A.1 Contributor List for Python para todos............... 237 A.2 Contributor List for Python for Everybody............. 237 A.3 Lista de colaboradores de “Python para Informáticos”....... 237 A.4 Prefacio para “Think Python”.................... 238 A.5 Lista de colaboradores de “Think Python”............. 239 B Detalles del Copyright 241 xii CONTENTS Chapter 1 ¿Por qué deberías aprender a escribir programas? Escribir programas (o programar) es una actividad muy creativa y gratificante. Puedes escribir programas por muchas razones, que pueden ir desde mantenerte activo resolviendo un problema de análisis de datos complejo hasta hacerlo por pura diversión ayudando a otros a resolver un enigma. Este libro asume que todo el mundo necesita saber programar, y que una vez que aprendas a programar ya encontrarás qué quieres hacer con esas habilidades recién adquiridas. En nuestra vida diaria estamos rodeados de computadoras, desde equipos portátiles (laptops) hasta teléfonos móviles (celulares). Podemos pensar en esas computado- ras como nuestros “asistentes personales”, que pueden ocuparse de muchas tareas por nosotros. El hardware en los equipos que usamos cada día está diseñado es- encialmente para hacernos la misma pregunta de forma constante, “¿Qué quieres que haga ahora?” ¿Qué hago a ¿Qué hago a continuación? continuación? ¿Qué hago a ¿Qué hago a continuación? continuación? Figure 1.1: Personal Digital Assistant Los programadores suelen añadir un sistema operativo y un conjunto de aplica- ciones al hardware y así nos proporcionan un Asistente Digital Personal que es bastante útil y capaz de ayudarnos a realizar una gran variedad de tareas. Nuestros equipos son rápidos y tienen grandes cantidades de memoria. Podrían resultarnos muy útiles si tan solo supiéramos qué idioma utilizar para explicarle a la computadora qué es lo que queremos que “haga ahora”. Si conociéramos ese idioma, podríamos pedirle al aparato que realizase en nuestro lugar, por ejemplo, tareas repetitivas. Precisamente el tipo de cosas que las computadoras saben hacer mejor suelen ser el tipo de cosas que las personas encontramos pesadas y aburridas. 1 2CHAPTER 1. ¿POR QUÉ DEBERÍAS APRENDER A ESCRIBIR PROGRAMAS? Por ejemplo, mira los primeros tres párrafos de este capítulos y dime cuál es la pal- abra que más se repite, y cuántas veces se ha utilizado. Aunque seas capaz de leer y comprender las palabras en pocos segundos, contarlas te resultará casi doloroso, porque la mente humana no fue diseñada para resolver ese tipo de problemas. Para una computadora es justo al revés, leer y comprender texto de un trozo de papel le sería difícil, pero contar las palabras y decirte cuántas veces se ha repetido la más utilizada le resulta muy sencillo: python words.py Enter file:words.txt to 16 Nuestro “asistente de análisis de información personal” nos dirá enseguida que la palabra “que” se usó nueve veces en los primeros tres párrafos de este capítulo. El hecho de que los computadores sean buenos en aquellas cosas en las que los humanos no lo son es el motivo por el que necesitas aprender a hablar el “idioma de las computadoras”. Una vez que aprendas este nuevo lenguaje, podrás delegar tareas mundanas a tu compañero (la computadora), lo que te dejará más tiempo para ocuparte de las cosas para las que sólo tú estás capacitado. Tú pondrás la creatividad, intuición y el ingenio en esa alianza. 1.1 Creatividad y motivación A pesar de que este libro no va dirigido a los programadores profesionales, la programación a nivel profesional puede ser un trabajo muy gratificante, tanto a nivel financiero como personal. Crear programas útiles, elegantes e inteligentes para que los usen otros, es una actividad muy creativa. Tu computadora o Asis- tente Digital Personal (PDA1 ), normalmente contiene muchos programas diferentes pertenecientes a distintos grupos de programadores, cada uno de ellos compitiendo por tu atención e interés. Todos ellos hacen su mejor esfuerzo por adaptarse a tus necesidades y proporcionarte una experiencia de usuario satisfactoria. En oca- siones, cuando elijes un software determinado, sus programadores son directamente recompensados gracias a tu elección. Si pensamos en los programas como el producto de la creatividad de los progra- madores, tal vez la figura siguiente sea una versión más acertada de nuestra PDA: ¡Elíge me! ¡Elíge me! ¡Elíge me! ¡Elíge me! Figure 1.2: Programadores Dirigiéndose a Ti Por ahora, nuestra principal motivación no es conseguir dinero ni complacer a los usuarios finales, sino simplemente conseguir ser más productivos a nivel personal 1 Personal Digital Assistant en inglés (N. del T.). 1.2. ARQUITECTURA HARDWARE DE LAS COMPUTADORAS 3 en el manejo de datos e información que encontremos en nuestras vidas. Cuando se empieza por primera vez, uno es a la vez programador y usuario final de sus propios programas. A medida que se gana habilidad como programador, y la programación se hace más creativa para uno mismo, se puede empezar a pensar en desarrollar programas para los demás. 1.2 Arquitectura hardware de las computadoras Antes de que empecemos a aprender el lenguaje que deberemos hablar para darle instrucciones a las computadoras para desarrollar software, tendremos que apren- der un poco acerca de cómo están construidos esas máquinas. Si desmontaras tu computadora o smartphone y mirases dentro con atención, encontrarías los sigu- ientes componentes: ¿Qué hago a Software continuación? Dispositivos Unidad Entrada Central Red Salida Procesamiento Memoria Memoria Principal Secundaria Figure 1.3: Arquitectura Hardware Las definiciones de alto nivel de esos componentes son las siguientes: La Unidad Central de Procesamiento (o CPU2 ) es el componente de la com- putadora diseñado para estar obsesionado con el “¿qué hago ahora?”. Si tu equipo está dentro de la clasificación de 3.0 Gigahercios, significa que la CPU preguntará “¿Qué hago ahora?” tres mil millones de veces por segundo. Vas a tener que aprender a hablar muy rápido para mantener el ritmo de la CPU. La Memoria Principal se usa para almacenar la información que la CPU necesita de forma inmediata. La memoria principal es casi tan rápida como la CPU. Pero la información almacenada en la memoria principal desaparece cuando se apaga el equipo. La Memoria Secundaria también se utiliza para almacenar información, pero es mucho más lenta que la memoria principal. La ventaja de la memoria secundaria es que puede almacenar la información incluso cuando el equipo está apagado. Algunos ejemplos de memoria secundaria serían las unidades de disco o las memorias flash (que suelen encontrarse en los pendrives USB y en los reproductores de música portátiles). 2 Central Processing Unit en inglés (N. del T.). 4CHAPTER 1. ¿POR QUÉ DEBERÍAS APRENDER A ESCRIBIR PROGRAMAS? Los Dispositivos de Entrada y Salida son simplemente la pantalla, teclado, ratón, micrófono, altavoz, touchpad, etc. Incluyen cualquier modo de inter- actuar con una computadora. Actualmente, casi todos los equipos tienen una Conexión de Red para recibir información dentro de una red. Podemos pensar en una red como en un lugar donde almacenar y recuperar datos de forma muy lenta, que puede no estar siempre “activo”. Así que, en cierto sentido, la red no es más que un tipo de Memoria Secundaria más lenta y a veces poco fiable. Aunque la mayoría de los detalles acerca de cómo funcionan estos componentes es mejor dejársela a los constructores de equipos, resulta útil disponer de cierta terminología para poder referirnos a ellos a la hora de escribir nuestros programas. Como programador, tu trabajo es usar y orquestar cada uno de esos recursos para resolver el problema del que tengas que ocuparte y analizar los datos de los que dispongas para encontrar la solución. Como programador estarás casi siempre “hablando” con la CPU y diciéndole qué es lo siguiente que debe hacer. A veces le tendrás que pedir a la CPU que use la memoria principal, la secundaria, la red, o los dispositivos de entrada/salida. ¿Qué hago a Software continuación? Dispositivos Unidad Entrada Central Red Salida Procesamiento Memoria Memoria Principal Secundaria Figure 1.4: ¿Dónde estás? Tú deberás ser la persona que responda a la pregunta “¿Qué hago ahora?” de la CPU. Pero sería muy incómodo encogerse uno mismo hasta los 5 mm. de altura e introducirse dentro de la computadora sólo para poder dar una orden tres mil millones de veces por segundo. Así que en vez de eso, tendrás que escribir las instrucciones por adelantado. Esas instrucciones almacenadas reciben el nombre de programa y el acto de escribirlas y encontrar cuáles son las instrucciones adecuadas, programar. 1.3 Comprendiendo la programación En el resto de este libro, intentaremos convertirte en una persona experta en el arte de programar. Al terminar, te habrás convertido en un programador - tal vez no uno profesional, pero al menos tendrás la capacidad de encarar un problema de análisis de datos/información y desarrollar un programa para resolverlo. En cierto modo, necesitas dos capacidades para ser programador: 1.4. PALABRAS Y FRASES 5 Primero, necesitas saber un lenguaje de programación (Python) - debes cono- cer su vocabulario y su gramática. Debes ser capaz de deletrear correcta- mente las palabras en ese nuevo lenguaje y saber construir “frases” bien formadas. Segundo, debes “contar una historia”. Al escribir un relato, combinas pal- abras y frases para comunicar una idea al lector. Hay una cierta técnica y arte en la construcción de un relato, y la habilidad para escribir relatos mejora escribiendo y recibiendo cierta respuesta. En programación, nuestro programa es el “relato” y el problema que estás tratando de resolver es la “idea”. Una vez que aprendas un lenguaje de programación como Python, encontrarás mucho más fácil aprender un segundo lenguaje como JavaScript o C++. Cada nuevo lenguaje tiene un vocabulario y gramática muy diferentes, pero la técnica de resolución de problemas será la misma en todos ellos. Aprenderás el “vocabulario” y “frases” de Python bastante rápido. Te llevará más tiempo el ser capaz de escribir un programa coherente para resolver un problema totalmente nuevo. Se enseña programación de forma muy similar a como se enseña a escribir. Se empieza leyendo y explicando programas, luego se escriben progra- mas sencillos, y a continuación se van escribiendo programas progresivamente más complejos con el tiempo. En algún momento “encuentras tu musa”, empiezas a descubrir los patrones por ti mismo y empiezas a ver casi de forma instintiva cómo abordar un problema y escribir un programa para resolverlo. Y una vez alcanzado ese punto, la programación se convierte en un proceso muy placentero y creativo. Comenzaremos con el vocabulario y la estructura de los programas en Python. Ten paciencia si la simplicidad de los ejemplos te recuerda a cuando aprendiste a leer. 1.4 Palabras y frases A diferencia de los lenguajes humanos, el vocabulario de Python es en realidad bastante reducido. Llamamos a este “vocabulario” las “palabras reservadas”. Se trata de palabras que tienen un significado muy especial para Python. Cuando Python se encuentra estas palabras en un programa, sabe que sólo tienen un único significado para él. Más adelante, cuando escribas programas, podrás usar tus propias palabras con significado, que reciben el nombre de variables. Tendrás gran libertad a la hora de elegir los nombres para tus variables, pero no podrás utilizar ninguna de las palabras reservadas de Python como nombre de una variable. Cuando se entrena a un perro, se utilizan palabras especiales como “siéntate”, “quieto” y “tráelo”. Cuando te diriges a un perro y no usas ninguna de las palabras reservadas, lo único que consigues es que se te quede mirando con cara extrañada, hasta que le dices una de las palabras que reconoce. Por ejemplo, si dices, “Me gustaría que más gente saliera a caminar para mejorar su salud general”, lo que la mayoría de los perros oirían es: “bla bla bla caminar bla bla bla bla.”. Eso se debe a que “caminar” es una palabra reservada en el lenguaje del perro. Seguramente habrá quien apunte que el lenguaje entre humanos y gatos no dispone de palabras reservadas3. 3 http://xkcd.com/231/ 6CHAPTER 1. ¿POR QUÉ DEBERÍAS APRENDER A ESCRIBIR PROGRAMAS? Las palabras reservadas en el lenguaje que utilizan los humanos para hablar con Python son, entre otras, las siguientes: and del global not with as elif if or yield assert else import pass break except in raise class finally is return continue for lambda try def from nonlocal while Es decir, a diferencia de un perro, Python ya está completamente entrenado. Cada vez le digas “inténtalo”, Python lo intentará una vez tras otra sin desfallecer4. Aprenderemos cuáles son las palabras reservadas y cómo utilizarlas en su momento, pero por ahora nos centraremos en el equivalente en Python de “habla” (en el lenguaje humano-perro). Lo bueno de pedirle a Python que hable es que podemos incluso indicarle lo que debe decir, pasándole un mensaje entre comillas: print('¡Hola, mundo!') Y ya acabamos de escribir nuestra primera oración sintácticamente correcta en Python. La frase comienza con la función print seguida de la cadena de texto que hayamos elegido dentro de comillas simples. Las comillas simples y dobles cumplen la misma función; la mayoría de las personas usan las comillas simples, excepto cuando la cadena de texto contiene también una comilla simple (que puede ser un apóstrofo). 1.5 Conversando con Python Ahora que ya conocemos una palabra y sabemos cómo crear una frase sencilla en Python, necesitamos aprender a iniciar una conversación con él para comprobar nuestras nuevas capacidades con el lenguaje. Antes de que puedas conversar con Python, deberás instalar el software necesario en tu computadora y aprender a iniciar Python en ella. En este capítulo no entraremos en detalles sobre cómo hacerlo, pero te sugiero que consultes https://es.py4e.com/ , donde encontrarás instrucciones detalladas y capturas sobre cómo configurar e iniciar Python en sistemas Macintosh y Windows. Si sigues los pasos, llegará un momento en que te encuentres ante una ventana de comandos o terminal. Si escribes entonces python, el intérprete de Python empezará a ejecutarse en modo interactivo, y aparecerá algo como esto: Python 3.5.1 (v3.5.1:37a07cee5969, Dec 6 2015, 01:54:25) [MSC v.1900 64 bit (AMD64)] on win32 Type "help", "copyright", "credits" or "license" for more information. >>> 4 En inglés "inténtalo" es "try", que es también una palabra reservada dentro del lenguaje Python (N. del T.). 1.5. CONVERSANDO CON PYTHON 7 El indicador >>> es el modo que tiene el intérprete de Python de preguntarte, “¿Qué quieres que haga ahora?”. Python está ya preparado para mantener una conversación contigo. Todo lo que tienes que saber es cómo hablar en su idioma. Supongamos por ejemplo que aún no conoces ni las palabras ni frases más sencillas de Python. Puede que quieras utilizar el método clásico de los astronautas cuando aterrizan en un planeta lejano e intentan hablar con los habitantes de ese mundo: >>> Vengo en son de paz, por favor llévame ante tu líder File "", line 1 Vengo en son de paz, por favor llévame ante tu líder ^ SyntaxError: invalid syntax >>> Esto no se ve bien. A menos que pienses en algo rápidamente, los habitantes del planeta sacarán sus lanzas, te ensartarán, te asarán sobre el fuego y al final les servirás de cena. Por suerte compraste una copia de este libro durante tus viajes, así que lo abres precisamente por esta página y pruebas de nuevo: >>> print('¡Hola, mundo!') ¡Hola, mundo! Esto tiene mejor aspecto, de modo que intentas comunicarte un poco más: >>> print('Usted debe ser el dios legendario que viene del cielo') Usted debe ser el dios legendario que viene del cielo >>> print('Hemos estado esperándole durante mucho tiempo') Hemos estado esperándole durante mucho tiempo >>> print('La leyenda dice que debe estar usted muy rico con mostaza') La leyenda dice que debe estar usted muy rico con mostaza >>> print 'Tendremos un festín esta noche a menos que diga File "", line 1 print 'Tendremos un festín esta noche a menos que diga ^ SyntaxError: Missing parentheses in call to 'print' >>> La conversación fue bien durante un rato, pero en cuanto cometiste el más mínimo fallo al utilizar el lenguaje Python, Python volvió a sacar las lanzas. En este momento, te habrás dado cuenta que a pesar de que Python es tremen- damente complejo y poderoso, y muy estricto en cuanto a la sintaxis que debes usar para comunicarte con él, Python no es inteligente. En realidad estás sola- mente manteniendo una conversación contigo mismo; eso sí, usando una sintaxis adecuada. En cierto modo, cuando utilizas un programa escrito por otra persona, la conver- sación se mantiene entre tú y el programador, con Python actuando meramente de 8CHAPTER 1. ¿POR QUÉ DEBERÍAS APRENDER A ESCRIBIR PROGRAMAS? intermediario. Python es una herramienta que permite a los creadores de progra- mas expresar el modo en que la conversación supuestamente debe fluir. Y dentro de unos pocos capítulos más, serás uno de esos programadores que utilizan Python para hablar con los usuarios de tu programa. Antes de que abandonemos nuestra primera conversación con el intérprete de Python, deberías aprender cual es el modo correcto de decir “adiós” al interac- tuar con los habitantes del Planeta Python: >>> adiós Traceback (most recent call last): File "", line 1, in NameError: name 'adiós' is not defined >>> if you don't mind, I need to leave File "", line 1 if you don't mind, I need to leave ^ SyntaxError: invalid syntax >>> quit() Te habrás fijado en que el error es diferente en cada uno de los dos primeros intentos. El segundo error es diferente porque if es una palabra reservada, y cuando Python la ve, cree que estamos intentando decirle algo, pero encuentra la sintaxis de la frase incorrecta. La forma correcta de decirle “adiós” a Python es introducir quit() en el símbolo indicador del sistema >>>. Seguramente te hubiera llevado un buen rato adivinarlo, así que tener este libro a mano probablemente te haya resultado útil. 1.6 Terminología: intérprete y compilador Python es un lenguaje de alto nivel, pensado para ser relativamente sencillo de leer y escribir para las personas, y fácil de leer y procesar para las máquinas. Otros lenguajes de alto nivel son Java, C++, PHP, Ruby, Basic, Perl, JavaScript, y mu- chos más. El hardware real que está dentro de la Unidad Central de Procesamiento (CPU), no entiende ninguno de esos lenguajes de alto nivel. La CPU entiende únicamente un lenguaje llamado lenguaje de máquina o código máquina. El código máquina es muy simple y francamente muy pesado de escribir, ya que está representado en su totalidad por solamente ceros y unos: 001010001110100100101010000001111 11100110000011101010010101101101... El código máquina parece bastante sencillo a simple vista, dado que sólo contiene ceros y unos, pero su sintaxis es incluso más compleja y mucho más enrevesada que la de Python, razón por la cual muy pocos programadores escriben en código máquina. En vez de eso, se han creado varios programas traductores para permitir a los programadores escribir en lenguajes de alto nivel como Python o Javascript, 1.6. TERMINOLOGÍA: INTÉRPRETE Y COMPILADOR 9 y son esos traductores quienes convierten los programas a código máquina, que es lo que ejecuta en realidad la CPU. Dado que el código máquina está ligado al hardware de la máquina que lo ejecuta, ese código no es portable (trasladable) entre equipos de diferente tipo. Los pro- gramas escritos en lenguajes de alto nivel pueden ser trasladados entre distintas máquinas usando un intérprete diferente en cada una de ellas, o recompilando el código para crear una versión diferente del código máquina del programa para cada uno de los tipos de equipo. Esos traductores de lenguajes de programación forman dos categorías generales: (1) intérpretes y (2) compiladores. Un intérprete lee el código fuente de los programas tal y como ha sido escrito por el programador, lo analiza, e interpreta sus instrucciones sobre la marcha. Python es un intérprete y cuando lo estamos ejecutando de forma interactiva, podemos escribir una línea de Python (una frase), y este la procesa de forma inmediata, quedando listo para que podamos escribir otra línea. Algunas de esas líneas le indican a Python que tú quieres que recuerde cierto valor para utilizarlo más tarde. Tenemos que escoger un nombre para que ese valor sea recordado y usaremos ese nombre simbólico para recuperar el valor más tarde. Utilizamos el término variable para denominar las etiquetas que usamos para referirnos a esos datos almacenados. >>> x = 6 >>> print(x) 6 >>> y = x * 7 >>> print(y) 42 >>> En este ejemplo, le pedimos a Python que recuerde el valor seis y use la etiqueta x para que podamos recuperar el valor más tarde. Comprobamos que Python ha guardado de verdad el valor usando print. Luego le pedimos a Python que recupere x, lo multiplique por siete y guarde el valor calculado en y. Finalmente, le pedimos a Python que escriba el valor actual de y. A pesar de que estamos escribiendo estos comandos en Python línea a línea, Python los está tratando como una secuencia ordenada de sentencias, en la cual las últimas frases son capaces de obtener datos creados en las anteriores. Estamos, por tanto, escribiendo nuestro primer párrafo sencillo con cuatro frases en un orden lógico y útil. La esencia de un intérprete consiste en ser capaz de mantener una conversación interactiva como la mostrada más arriba. Un compilador necesita que le entreguen el programa completo en un fichero, y luego ejecuta un proceso para traducir el código fuente de alto nivel a código máquina, tras lo cual coloca ese código máquina resultante dentro de otro fichero para su ejecución posterior. En sistemas Windows, a menudo esos ejecutables en código máquina tienen un sufijo o extensión como “.exe” o “.dll”, que significan “ejecutable” y “librería de 10CHAPTER 1. ¿POR QUÉ DEBERÍAS APRENDER A ESCRIBIR PROGRAMAS? enlace dinámico” (dynamic link library) respectivamente. En Linux y Macintosh, no existe un sufijo que identifique de manera exclusiva a un fichero como ejecutable. Si abrieras un fichero ejecutable con un editor de texto, verías algo complemente disparatado e ilegible: ^?ELF^A^A^A^@^@^@^@^@^@^@^@^@^B^@^C^@^A^@^@^@\xa0\x82 ^D^H4^@^@^@\x90^]^@^@^@^@^@^@4^@ ^@^G^@(^@$^@!^@^F^@ ^@^@4^@^@^@4\x80^D^H4\x80^D^H\xe0^@^@^@\xe0^@^@^@^E ^@^@^@^D^@^@^@^C^@^@^@^T^A^@^@^T\x81^D^H^T\x81^D^H^S ^@^@^@^S^@^@^@^D^@^@^@^A^@^@^@^A\^D^HQVhT\x83^D^H\xe8.... No resulta fácil leer o escribir código máquina, pero afortunadamente disponemos de intérpretes y compiladores que nos permiten escribir en lenguajes de alto nivel, como Python o C. Llegados a este punto en la explicación acerca de los compiladores e intérpretes, seguramente te estarás preguntando algunas cosas acerca del propio intérprete de Python. ¿En qué lenguaje está escrito? ¿Está escrito en un lenguaje compilado? Cuando escribimos “python”, ¿qué ocurre exactamente? El intérprete de Python está escrito en un lenguaje de alto nivel llamado “C”. En realidad, puedes ver el código fuente del intérprete de Python acudiendo a www.python.org e incluso modificarlo a tu gusto. Quedamos, pues, en que Python es en sí mismo un programa y que está compilado en código máquina. Cuando instalaste Python en tu computadora (o el vendedor lo instaló), colocaste una copia del código máquina del programa Python traducido para tu sistema. En Windows, el código máquina ejecutable para el intérprete de Python es probablemente un fichero con un nombre como: C:\Python35\python.exe En realidad, eso ya es más de lo que necesitas saber para ser un programador en Python, pero algunas veces vale la pena contestar estas pequeñas dudas recurrentes justo al principio. 1.7 Escribiendo un programa Escribir comandos en el intérprete de Python es un buen modo de experimentar con las capacidades de Python, pero no es lo más recomendado a la hora de resolver problemas más complejos. Cuando queremos escribir un programa, usamos un editor de texto para escribir las instrucciones de Python en un fichero, que recibe el nombre de script. Por convención, los scripts de Python tienen nombres que terminan en.py. Para ejecutar el script, hay que indicarle al intérprete de Python el nombre del fichero. En una ventana de comandos de Unix o Windows, escribirías python hola.py, de este modo: 1.8. ¿QUÉ ES UN PROGRAMA? 11 csev$ cat hola.py print('¡Hola, mundo!') csev$ python hola.py ¡Hola, mundo! csev$ “csev$” es el indicador (prompt) del sistema operativo, y el comando “cat hola.py” nos muestra que el archivo “hola.py” contiene un programa con una única línea de código que imprime en pantalla una cadena de texto. Llamamos al intérprete de Python y le pedimos que lea el código fuente desde el archivo “hola.py”, en vez de esperar a que vayamos introduciendo líneas de código Python de forma interactiva. Habrás notado que cuando trabajamos con un fichero no necesitamos incluir el comando quit() al final del programa Python. Cuando Python va leyendo tu código fuente desde un archivo, sabe que debe parar cuando llega al final del fichero. 1.8 ¿Qué es un programa? Podemos definir un programa, en su forma más básica, como una secuencia de declaraciones o sentencias que han sido diseñadas para hacer algo. Incluso nuestro sencillo script “hola.py” es un programa. Es un programa de una sola línea y no resulta particularmente útil, pero si nos ajustamos estrictamente a la definición, se trata de un programa en Python. Tal vez resulte más fácil comprender qué es un programa pensando en un problema que pudiera ser resuelto a través de un programa, y luego estudiando cómo sería el programa que solucionaría ese problema. Supongamos que estás haciendo una investigación de computación o informática so- cial en mensajes de Facebook, y te interesa conocer cual es la palabra más utilizada en un conjunto de mensajes. Podrías imprimir el flujo de mensajes de Facebook y revisar con atención el texto, buscando la palabra más común, pero sería un pro- ceso largo y muy propenso a errores. Sería más inteligente escribir un programa en Python para encargarse de la tarea con rapidez y precisión, y así poder emplear el fin de semana en hacer otras cosas más divertidas. Por ejemplo, fíjate en el siguiente texto, que trata de un payaso y un coche. Estú- dialo y trata de averiguar cual es la palabra más común y cuántas veces se repite. el payaso corrió tras el coche y el coche se metió dentro de la tienda y la tienda cayó sobre el payaso y el coche Ahora imagina que haces lo mismo pero buscando a través de millones de líneas de texto. Francamente, tardarías menos aprendiendo Python y escribiendo un programa en ese lenguaje para contar las palabras que si tuvieras que ir revisando todas ellas una a una. Pero hay una noticia aún mejor, y es que se me ha ocurrido un programa sencillo para encontrar cuál es la palabra más común dentro de un fichero de texto. Ya lo escribí, lo probé, y ahora te lo regalo para que lo puedas utilizar y ahorrarte mucho tiempo. 12CHAPTER 1. ¿POR QUÉ DEBERÍAS APRENDER A ESCRIBIR PROGRAMAS? name = input('Enter file:') handle = open(name, 'r') counts = dict() for line in handle: words = line.split() for word in words: counts[word] = counts.get(word, 0) + 1 bigcount = None bigword = None for word, count in list(counts.items()): if bigcount is None or count > bigcount: bigword = word bigcount = count print(bigword, bigcount) # Código: https://es.py4e.com/code3/words.py No necesitas ni siquiera saber Python para usar este programa. Tendrás que llegar hasta el capítulo 10 de este libro para entender por completo las impresionantes técnicas de Python que se han utilizado para crearlo. Ahora eres el usuario final, sólo tienes que usar el programa y sorprenderte de sus habilidades y de cómo te permite ahorrar un montón de esfuerzo. Tan sólo tienes que escribir el código dentro de un fichero llamado words.py y ejecutarlo, o puedes descargar el código fuente directamente desde https://es.py4e.com/code3/ y ejecutarlo. Este es un buen ejemplo de cómo Python y el lenguaje Python actúan como un intermediario entre tú (el usuario final) y yo (el programador). Python es un medio para que intercambiemos secuencias de instrucciones útiles (es decir, programas) en un lenguaje común que puede ser usado por cualquiera que instale Python en su computadora. Así que ninguno de nosotros está hablando con Python, sino que estamos comunicándonos uno con el otro a través de Python. 1.9 Los bloques de construcción de los programas En los próximos capítulos, aprenderemos más sobre el vocabulario, la estructura de las frases y de los párrafos y la estructura de los relatos en Python. Aprenderemos cuáles son las poderosas capacidades de Python y cómo combinar esas capacidades entre sí para crear programas útiles. Hay ciertos patrones conceptuales de bajo nivel que se usan para estructurar los programas. Esas estructuras no son exclusivas de Python, sino que forman parte de cualquier lenguaje de programación, desde el código máquina hasta los lenguajes de alto nivel. entrada Obtener datos del “mundo exterior”. Puede consistir en leer datos desde un fichero, o incluso desde algún tipo de sensor, como un micrófono o un GPS. 1.10. ¿QUÉ ES POSIBLE QUE VAYA MAL? 13 En nuestros primeros programas, las entradas van a provenir del usuario, que introducirá los datos a través del teclado. salida Mostrar los resultados del programa en una pantalla, almacenarlos en un fichero o incluso es posible enviarlos a un dispositivo como un altavoz para reproducir música o leer un texto. ejecución secuencial Ejecutar una sentencia tras otra en el mismo orden en que se van encontrando en el script. ejecución condicional Comprobar ciertas condiciones y luego ejecutar u omitir una secuencia de sentencias. ejecución repetida Ejecutar un conjunto de sentencias varias veces, normal- mente con algún tipo de variación. reutilización Escribir un conjunto de instrucciones una vez, darles un nombre y así poder reutilizarlas luego cuando se necesiten en cualquier punto de tu programa. Parece demasiado simple para ser cierto, y por supuesto nunca es tan sencillo. Es como si dijéramos que andar es simplemente “poner un pie delante del otro”. El “arte” de escribir un programa es componer y entrelazar juntos esos elementos básicos muchas veces hasta conseguir al final algo que resulte útil para sus usuarios. El programa para contar palabras que vimos antes utiliza al mismo tiempo todos esos patrones excepto uno. 1.10 ¿Qué es posible que vaya mal? Como vimos en nuestra anterior conversación con Python, debemos comunicarnos con mucha precisión cuando escribimos código Python. El menor error provocará que Python se niegue a hacer funcionar tu programa. Los programadores novatos a menudo se toman el hecho de que Python no permita cometer errores como la prueba definitiva de que es perverso, odioso y cruel. A pesar de que a Python parece gustarle todos los demás, es capaz de identificar a los novatos en concreto, y les guarda un gran rencor. Debido a ello, toma sus pro- gramas perfectamente escritos, y los rechaza, considerándolos como “inservibles”, sólo para atormentarlos. >>> primt '¡Hola, mundo!' File "", line 1 primt '¡Hola, mundo!' ^ SyntaxError: invalid syntax >>> primt ('Hola, mundo') Traceback (most recent call last): File "", line 1, in NameError: name 'primt' is not defined >>> ¡Te odio, Python! File "", line 1 ¡Te odio, Python! ^ 14CHAPTER 1. ¿POR QUÉ DEBERÍAS APRENDER A ESCRIBIR PROGRAMAS? SyntaxError: invalid syntax >>> si sales fuera, te daré una lección File "", line 1 si sales fuera, te daré una lección ^ SyntaxError: invalid syntax >>> No es mucho lo que se gana discutiendo con Python. Solo es una herramienta. No tiene emociones, es feliz y está preparado para servirte en el momento que lo necesites. Sus mensajes de error parecen crueles, pero simplemente se trata de una petición de ayuda del propio Python. Ha examinado lo que has tecleado, y sencillamente no es capaz de entender lo que has escrito. Python se parece mucho a un perro, te quiere incondicionalmente, entiende algunas pocas palabras clave, te mira con una mirada dulce en su cara(>>>), y espera que le digas algo que él pueda comprender. Cuando Python dice “SyntaxError: invalid syntax” (Error de sintaxis: sintaxis inválida), tan solo está agitando su cola y diciendo: “Creo que has dicho algo, pero no te entiendo; de todos modos, por favor, sigue hablando conmigo (>>>).” A medida que tus programas vayan aumentando su complejidad, te encontrarás con tres tipos de errores generales: Errores de sintaxis (Syntax errors) Estos son los primeros errores que come- terás y también los más fáciles de solucionar. Un error de sintaxis significa que has violado las reglas “gramaticales” de Python. Python hace todo lo que puede para señalar el punto exacto, la línea y el carácter donde ha de- tectado el fallo. Lo único complicado de los errores de sintaxis es que a veces el error que debe corregirse está en realidad en una línea anterior a la cual Python detectó ese fallo. De modo que la línea y el carácter que Python indica en un error de sintaxis pueden ser tan sólo un punto de partida para tu investigación. Errores lógicos Se produce un error lógico cuando un programa tiene una sin- taxis correcta, pero existe un error en el orden de las sentencias o en la forma en que están relacionadas unas con otras. Un buen ejemplo de un error lógico sería: “toma un trago de tu botella de agua, ponla en tu mochila, camina hasta la biblioteca y luego vuelve a enroscar la tapa en la botella.” Errores semánticos Un error semántico ocurre cuando la descripción que has brindado de los pasos a seguir es sintácticamente perfecta y está en el orden correcto, pero sencillamente hay un error en el programa. El programa es correcto, pero no hace lo que tú pretendías que hiciera. Un ejemplo podría ser cuando le das indicaciones a alguien sobre cómo llegar a un restaurante, y le dices “... cuando llegues a la intersección con la gasolinera, gira a la izquierda, continúa durante otro kilómetro y el restaurante es el edificio rojo que encontrarás a tu izquierda.”. Tu amigo se retrasa y te llama para decirte que está en una granja dando vueltas alrededor de un granero, sin rastro alguno de un restaurante. Entonces le preguntas “¿giraste a la izquierda o la derecha?”, y te responde “Seguí tus indicaciones al pie de la letra, di- jiste que girara a la izquierda y continuar un kilómetro desde la gasolinera.”, entonces le respondes “Lo siento mucho, porque a pesar de que mis indica- 1.11. DEPURANDO LOS PROGRAMAS 15 ciones fueron sintácticamente correctas, tristemente contenían un pequeño pero indetectado error semántico.”. Insisto en que, ante cualquiera de estos tres tipos de errores, Python únicamente hace lo que está a su alcance por seguir al pie de la letra lo que tú le has pedido que haga. 1.11 Depurando los programas Cuando Python muestra un error, u obtiene un resultado diferente al que esperabas, empieza una intensa búsqueda de la causa del error. Depurar es el proceso de encontrar la causa o el origen de ese error en tu código. Cuando depuras un programa, y especialmente cuando tratas con un bug algo difícil de solucionar, existen cuatro cosas por hacer: leer Revisar tu código, leerlo de nuevo, y asegurarte de que ahí está expresado de forma correcta lo que quieres decir. ejecutar Prueba haciendo cambios y ejecutando diferentes versiones. Con frecuen- cia, si muestras en tu programa lo correcto en el lugar indicado, el problema se vuelve obvio, pero en ocasiones debes invertir algo de tiempo hasta con- seguirlo. pensar detenidamente ¡Toma tu tiempo para pensar!, ¿A qué tipo de error corresponde: sintaxis, en tiempo de ejecución, semántico?, ¿Qué información puedes obtener de los mensajes de error, o de la salida del programa?, ¿Qué tipo de errores podría generar el problema que estás abordando?, ¿Cuál fue el último cambio que hiciste, antes de que se presentara el problema? retroceder En algún momento, lo mejor que podrás hacer es dar marcha atrás, deshacer los cambios recientes hasta obtener de nuevo un programa que fun- cione y puedas entender. Llegado a ese punto, podrás continuar con tu trabajo. Algunas veces, los programadores novatos se quedan estancados en una de estas actividades y olvidan las otras. Encontrar un bug requiere leer, ejecutar, pen- sar detenidamente y algunas veces retroceder. Si te bloqueas en alguna de estas actividades, prueba las otras. Cada actividad tiene su procedimiento de análisis. Por ejemplo, leer tu código podría ayudar si el problema es un error tipográfico, pero no si es uno conceptual. Si no comprendes lo que hace tu programa, puedes leerlo 100 veces y no encontrarás el error, puesto que dicho error está en tu mente. Experimentar puede ayudar, especialmente si ejecutas pequeñas pruebas. Pero si experimentas sin pensar o leer tu código, podrías caer en un patrón que llamo “programación de paseo aleatorio”, que es el proceso de realizar cambios al azar hasta que el programa logre hacer lo que debería. No hace falta mencionar que este tipo de programación puede tomar mucho tiempo. Debes tomar el tiempo suficiente para pensar. Depurar es como una ciencia exper- imental. Debes plantear al menos una hipótesis sobre qué podría ser el problema. Si hay dos o más posibilidades, piensa en alguna prueba que pueda ayudarte a descartar una de ellas. 16CHAPTER 1. ¿POR QUÉ DEBERÍAS APRENDER A ESCRIBIR PROGRAMAS? Descansar y conversar ayuda a estimular el pensamiento. Si le explicas el problema a alguien más (o incluso a tí mismo), a veces encontrarás la respuesta antes de terminar la pregunta. Pero incluso las mejores técnicas de depuración fallarán si hay demasiados errores, o si el código que intentas mejorar es demasiado extenso y complicado. Algunas veces la mejor opción es retroceder, y simplificar el programa hasta que obtengas algo que funcione y puedas entender. Por lo general, los programadores novatos son reacios a retroceder porque no so- portan tener que borrar una línea de código (incluso si está mal). Si te hace sentir mejor, prueba a copiar tu programa en otro archivo antes de empezar a modifi- carlo. De esa manera, puedes recuperar poco a poco pequeñas piezas de código que necesites. 1.12 El camino del aprendizaje Según vayas avanzando por el resto del libro, no te asustes si los conceptos no parecen encajar bien unos con otros al principio. Cuando estabas aprendiendo a hablar, no supuso un problema que durante los primeros años solo pudieras emitir lindos balbuceos. Y también fue normal que te llevara seis meses pasar de un vocabulario simple a frases simples, y que te llevara 5-6 años más pasar de frases a párrafos, y que todavía tuvieran que transcurrir unos cuantos años más hasta que fuiste capaz de escribir tu propia historia corta interesante. Pretendemos que aprendas Python rápidamente, por lo que te enseñaremos todo al mismo tiempo durante los próximos capítulos. Aún así, ten en cuenta que el proceso es similar a aprender un idioma nuevo, que lleva un tiempo absorber y comprender antes de que te resulte familiar. Eso produce cierta confusión, puesto que revisaremos en distintas ocasiones determinados temas, y trataremos que de esa manera puedas visualizar los pequeños fragmentos que componen esta obra completa. A pesar de que el libro está escrito de forma lineal, no dudes en ser no lineal en la forma en que abordes las materias. Avanza y retrocede, y lee a veces por encima. Al ojear material más avanzado sin comprender del todo los detalles, tendrás una mejor comprensión del “¿por qué?” de la programación. Al revisar el material anterior e incluso al realizar nuevamente los ejercicios previos, te darás cuenta que ya has aprendido un montón de cosas, incluso si el tema que estás examinando en ese momento parece un poco difícil de abordar. Normalmente, cuando uno aprende su primer lenguaje de programación, hay unos pocos momentos “¡A-já!” estupendos, en los cuales puedes levantar la vista de la roca que estás machacando con martillo y cincel, separarte unos pasos y comprobar que lo que estás intentando construir es una maravillosa escultura. Si algo parece particularmente difícil, generalmente no vale la pena quedarse mirán- dolo toda la noche. Respira, toma una siesta, come algo, explícale a alguien (quizás a tu perro) con qué estás teniendo problemas, y después vuelve a observarlo con un perspectiva diferente. Te aseguro que una vez que aprendas los conceptos de la programación en el libro, volverás atrás y verás que en realidad todo era fácil, elegante y que simplemente te ha llevado un poco de tiempo llegar a absorberlo. 1.13. GLOSARIO 17 1.13 Glosario bug Un error en un programa. código fuente Un programa en un lenguaje de alto nivel. código máquina El lenguaje de más bajo nivel para el software, es decir, el lenguaje que es directamente ejecutado por la unidad central de procesamiento (CPU). compilar Traducir un programa completo escrito en un lenguaje de alto nivel a un lenguaje de bajo nivel, para dejarlo listo para una ejecución posterior. error semántico Un error dentro de un programa que provoca que haga algo diferente de lo que pretendía el programador. función print Una instrucción que hace que el intérprete de Python muestre un valor en la pantalla. indicador de línea de comandos (prompt) Cuando un programa muestra un mensaje y se detiene para que el usuario teclee algún tipo de dato. interpretar Ejecutar un programa escrito en un lenguaje de alto nivel traducién- dolo línea a línea. lenguaje de alto nivel Un lenguaje de programación como Python, que ha sido diseñado para que sea fácil de leer y escribir por las personas. lenguaje de bajo nivel Un lenguaje de programación que está diseñado para ser fácil de ejecutar para una computadora; también recibe el nombre de “código máquina”, “lenguaje máquina” o “lenguaje ensamblador”. memoria principal Almacena los programas y datos. La memoria principal pierde su información cuando se desconecta la alimentación. memoria secundaria Almacena los programas y datos y mantiene su informa- ción incluso cuando se interrumpe la alimentación. Es generalmente más lenta que la memoria principal. Algunos ejemplos de memoria secundaria son las unidades de disco y memorias flash que se encuentran dentro de los dispositivos USB. modo interactivo Un modo de usar el intérprete de Python, escribiendo coman- dos y expresiones directamente en el indicador de la línea de comandos. parsear Examinar un programa y analizar la estructura sintáctica. portabilidad Es la propiedad que poseen los programas que pueden funcionar en más de un tipo de computadora. programa Un conjunto de instrucciones que indican cómo realizar algún tipo de cálculo. resolución de un problema El proceso de formular un problema, encontrar una solución, y mostrar esa solución. semántica El significado de un programa. unidad central de procesamiento El corazón de cualquier computadora. Es lo que ejecuta el software que escribimos. También recibe el nombre de “CPU” por sus siglas en inglés (Central Processsing Unit), o simplemente, “el procesador”. 1.14 Ejercicios Ejercicio 1: ¿Cuál es la función de la memoria secundaria en una computadora? a) Ejecutar todos los cálculos y la lógica del programa 18CHAPTER 1. ¿POR QUÉ DEBERÍAS APRENDER A ESCRIBIR PROGRAMAS? b) Descargar páginas web de Internet c) Almacenar información durante mucho tiempo, incluso después de ciclos de apagado y encendido d) Recolectar la entrada del usuario Ejercicio 2: ¿Qué es un programa? Ejercicio 3: ¿Cuál es la diferencia entre un compilador y un intérprete? Ejercicio 4: ¿Cuál de los siguientes contiene “código máquina”? a) El intérprete de Python b) El teclado c) El código fuente de Python d) Un documento de un procesador de texto Ejercicio 5: ¿Qué está mal en el siguiente código?: >>> primt '¡Hola, mundo!' File "", line 1 primt '¡Hola, mundo!' ^ SyntaxError: invalid syntax >>> Ejercicio 6: ¿En qué lugar del computador queda almacenada una variable, como en este caso “X”, después de ejecutar la siguiente línea de Python?: x = 123 a) Unidad central de procesamiento b) Memoria Principal c) Memoria Secundaria d) Dispositivos de Entrada e) Dispositivos de Salida Ejercicio 7: ¿Qué mostrará en pantalla el siguiente programa?: x = 43 x = x + 1 print(x) a) 43 b) 44 c) x + 1 d) Error, porque x = x + 1 no es posible matemáticamente. Ejercicio 8: Explica cada uno de los siguientes conceptos usando un ejemplo de una capacidad humana: (1) Unidad central de procesamiento, (2) Memoria prin- cipal, (3) Memoria secundaria, (4) Dispositivos de entrada, y (5) Dispositivos de salida. Por ejemplo, “¿Cuál sería el equivalente humano de la Unidad central de procesamiento?”. Ejercicio 9: ¿Cómo puedes corregir un “Error de sintaxis”?. Chapter 2 Variables, expresiones y sentencias 2.1 Valores y tipos Un valor es una de las cosas básicas que utiliza un programa, como una letra o un número. Los valores que hemos visto hasta ahora han sido 1, 2, y “¡Hola, mundo!” Esos valores pertenecen a tipos diferentes: 2 es un entero (int), y “¡Hola, mundo!” es una cadena (string), que recibe ese nombre porque contiene una “cadena” de letras. Tú (y el intérprete) podéis identificar las cadenas porque van encerradas entre comillas. La sentencia print también funciona con enteros. Vamos a usar el comando python para iniciar el intérprete. python >>> print(4) 4 Si no estás seguro de qué tipo de valor estás manejando, el intérprete te lo puede decir. >>> type(''¡Hola, mundo!) >>> type(17) Not surprisingly, strings belong to the type str and integers belong to the type int. Less obviously, numbers with a decimal point belong to a type called float, because these numbers are represented in a format called floating point. >>> type(3.2) 19 20 CHAPTER 2. VARIABLES, EXPRESIONES Y SENTENCIAS ¿Qué ocurre con valores como “17” y “3.2”? Parecen números, pero van entre comillas como las cadenas. >>> type('17') >>> type('3.2') Son cadenas. Cuando escribes un entero grande, puede que te sientas tentado a usar comas o puntos para separarlo en grupos de tres dígitos, como en 1,000,000 1. Eso no es un entero válido en Python, pero en cambio sí que resulta válido algo como: >>> print(1,000,000) 1 0 0 Bien, ha funcionado. ¡Pero eso no era lo que esperábamos!. Python interpreta 1,000,000 como una secuencia de enteros separados por comas, así que lo imprime con espacios en medio. Éste es el primer ejemplo que hemos visto de un error semántico: el código funciona sin producir ningún mensaje de error, pero no hace su trabajo “correctamente”. 2.2 Variables Una de las características más potentes de un lenguaje de programación es la capacidad de manipular variables. Una variable es un nombre que se refiere a un valor. Una sentencia de asignación crea variables nuevas y las da valores: >>> mensaje = 'Y ahora algo completamente diferente' >>> n = 17 >>> pi = 3.1415926535897931 Este ejemplo hace tres asignaciones. La primera asigna una cadena a una variable nueva llamada mensaje; la segunda asigna el entero 17 a n; la tercera asigna el valor (aproximado) de π a pi. Para mostrar el valor de una variable, se puede usar la sentencia print: >>> print(n) 17 >>> print(pi) 3.141592653589793 El tipo de una variable es el tipo del valor al que se refiere. 1 En el mundo anglosajón el “separador de millares” es la coma, y no el punto (Nota del trad.) 2.3. NOMBRES DE VARIABLES Y PALABRAS CLAVES 21 >>> type(mensaje) >>> type(n) >>> type(pi) 2.3 Nombres de variables y palabras claves Los programadores generalmente eligen nombres para sus variables que tengan sentido y documenten para qué se usa esa variable. Los nombres de las variables pueden ser arbitrariamente largos. Pueden contener tanto letras como números, pero no pueden comenzar con un número. Se pueden usar letras mayúsculas, pero es buena idea comenzar los nombres de las variables con una letras minúscula (veremos por qué más adelante). El carácter guión-bajo (_) puede utilizarse en un nombre. A menudo se utiliza en nombres con múltiples palabras, como en mi_nombre o velocidad_de_golondrina_sin_carga. Los nombres de las variables pueden comenzar con un carácter guión-bajo, pero generalmente se evita usarlo así a menos que se esté escribiendo código para librerías que luego utilizarán otros. Si se le da a una variable un nombre no permitido, se obtiene un error de sintaxis: >>> 76trombones = 'gran desfile' SyntaxError: invalid syntax >>> more@ = 1000000 SyntaxError: invalid syntax >>> class = 'Teorema avanzado de Zymurgy' SyntaxError: invalid syntax 76trombones es incorrecto porque comienza por un número. more@ es incorrecto porque contiene un carácter no premitido, @. Pero, ¿qué es lo que está mal en class? Pues resulta que class es una de las palabras clave de Python. El intérprete usa palabras clave para reconocer la estructura del programa, y esas palabras no pueden ser utilizadas como nombres de variables. Python reserva 33 palabras claves para su propio uso: and del from None True as elif global nonlocal try assert else if not while break except import or with class False in pass yield continue finally is raise def for lambda return Puede que quieras tener esta lista a mano. Si el intérprete se queja por el nombre de una de tus variables y no sabes por qué, comprueba si ese nombre está en esta lista. 22 CHAPTER 2. VARIABLES, EXPRESIONES Y SENTENCIAS 2.4 Sentencias Una sentencia es una unidad de código que el intérprete de Python puede ejecutar. Hemos visto hasta ahora dos tipos de sentencia: print y las asignaciones. Cuando escribes una sentencia en modo interactivo, el intérprete la ejecuta y mues- tra el resultado, si es que lo hay. Un script normalmente contiene una secuencia de sentencias. Si hay más de una sentencia, los resultados aparecen de uno en uno según se van ejecutando las sen- tencias. Por ejemplo, el script print(1) x = 2 print(x) produce la salida 1 2 La sentencia de asignación no produce ninguna salida. 2.5 Operadores y operandos Los operadores son símbolos especiales que representan cálculos, como la suma o la multiplicación. Los valores a los cuales se aplican esos operadores reciben el nombre de operandos. Los operadores +, -, , /, y \* realizan sumas, restas, multiplicaciones, divisiones y exponenciación (elevar un número a una potencia), como se muestra en los ejemplos siguientes: 20+32 hour-1 hour*60+minute minute/60 5**2 (5+9)*(15-7) Ha habido un cambio en el operador de división entre Python 2.x y Python 3.x. En Python 3.x, el resultado de esta división es un resultado de punto flotante: >>> minute = 59 >>> minute/60 0.9833333333333333 2.6. EXPRESIONES 23 El operador de división en Python 2.0 dividiría dos enteros y truncar el resultado a un entero: >>> minute = 59 >>> minute/60 0 Para obtener la misma respuesta en Python 3.0 use división dividida (// integer). >>> minute = 59 >>> minute//60 0 En Python 3, la división de enteros funciona mucho más como cabría esperar. Si ingresaste la expresión en una calculadora. 2.6 Expresiones Una expresión es una combinación de valores, variables y operadores. Un valor por si mismo se considera una expresión, y también lo es una variable, así que las siguientes expresiones son todas válidas (asumiendo que la variable x tenga un valor asignado): 17 x x + 17 Si escribes una expresión en modo interactivo, el intérprete la evalúa y muestra el resultado: >>> 1 + 1 2 Sin embargo, en un script, ¡una expresión por si misma no hace nada! Esto a menudo puede producir confusión entre los principiantes. Ejercicio 1: Escribe las siguientes sentencias en el intérprete de Python para comprobar qué hacen: 5 x = 5 x + 1 24 CHAPTER 2. VARIABLES, EXPRESIONES Y SENTENCIAS 2.7 Orden de las operaciones Cuando en una expresión aparece más de un operador, el orden de evaluación de- pende de las reglas de precedencia. Para los operadores matemáticos, Python sigue las convenciones matemáticas. El acrónimo PEMDSR resulta útil para recordar esas reglas: Los Paréntesis tienen el nivel superior de precedencia, y pueden usarse para forzar a que una expresión sea evaluada en el orden que se quiera. Dado que las expresiones entre paréntesis son evaluadas primero, 2 * (3-1) es 4, y (1+1)**(5-2) es 8. Se pueden usar también paréntesis para hacer una expresión más sencilla de leer, incluso si el resultado de la misma no varía por ello, como en (minuto * 100) / 60. La Exponenciación (elevar un número a una potencia) tiene el siguiente nivel más alto de precedencia, de modo que 2**1+1 es 3, no 4, y 3*1**3 es 3, no 27. La M ultiplicación y la División tienen la misma precedencia, que es superior a la de la Suma y la Resta, que también tienen entre si el mismo nivel de precedencia. Así que 2*3-1 es 5, no 4, y 6+4/2 es 8, no 5. Los operadores con igual precedencia son evaluados de izquierda a derecha. Así que la expresión 5-3-1 es 1 y no 3, ya que 5-3 se evalúa antes, y después se resta 1 de 2. En caso de duda, añade siempre paréntesis a tus expresiones para asegurarte de que las operaciones se realizan en el orden que tú quieres. 2.8 Operador módulo El operador módulo trabaja con enteros y obtiene el resto de la operación consis- tente en dividir el primer operando por el segundo. En Python, el operador módulo es un signo de porcentaje (%). La sintaxis es la misma que se usa para los demás operadores: >>> quotient = 7 // 3 >>> print(quotient) 2 >>> remainder = 7 % 3 >>> print(remainder) 1 Así que 7 dividido por 3 es 2 y nos sobra 1. El operador módulo resulta ser sorprendentemente útil. Por ejemplo, puedes com- probar si un número es divisible por otro—si x % y es cero, entonces x es divisible por y. También se puede extraer el dígito más a la derecha de los que componen un número. Por ejemplo, x % 10 obtiene el dígito que está más a la derecha de x (en base 10). De forma similar, x % 100 obtiene los dos últimos dígitos. 2.9. OPERACIONES CON CADENAS 25 2.9 Operaciones con cadenas El operador + funciona con las cadenas, pero no realiza una suma en el sentido matemático. En vez de eso, realiza una concatenación, que quiere decir que une ambas cadenas, enlazando el final de la primera con el principio de la segunda. Por ejemplo: >>> primero = 10 >>> segundo = 15 >>> print(primero+segundo) 25 >>> primero = '100' >>> segundo = '150' >>> print(primero + segundo) 100150 La salida de este programa es 100150. El operador * también trabaja con cadenas multiplicando el contenido de una cadena por un entero. Por ejemplo: >>> primero = 'Test ' >>> second = 3 >>> print(primero * second) Test Test Test 2.10 Petición de información al usuario A veces necesitaremos que sea el usuario quien nos proporcione el valor para una variable, a través del teclado. Python proporciona una función interna llamada input que recibe la entrada desde el teclado. Cuando se llama a esa función, el programa se detiene y espera a que el usuario escriba algo. Cuando el usuario pulsa Retorno o Intro, el programa continúa y input devuelve como una cadena aquello que el usuario escribió. >>> entrada = input() Cualquier cosa ridícula >>> print(entrada) Cualquier cosa ridícula Antes de recibir cualquier dato desde el usuario, es buena idea escribir un mensaje explicándole qué debe introducir. Se puede pasar una cadena a input, que será mostrada al usuario antes de que el programa se detenga para recibir su entrada: >>> nombre = input('¿Cómo te llamas?\n') ¿Cómo te llamas? Chuck >>> print(nombre) Chuck 26 CHAPTER 2. VARIABLES, EXPRESIONES Y SENTENCIAS La secuencia \n al final del mensaje representa un newline, que es un carácter especial que provoca un salto de línea. Por eso la entrada del usuario aparece debajo de nuestro mensaje. Si esperas que el usuario escriba un entero, puedes intentar convertir el valor de retorno a int usando la función int(): >>> prompt = '¿Cual es la velocidad de vuelo de una golondrina sin carga?\n' >>> velocidad = input(prompt) ¿Cual es la velocidad de vuelo de una golondrina sin carga? 17 >>> int(velocidad) 17 >>> int(velocidad) + 5 22 Pero si el usuario escribe algo que no sea una cadena de dígitos, obtendrás un error: >>> velocidad = input(prompt) ¿Cual.... es la velocidad de vuelo de una golondrina sin carga? ¿Te refieres a una golondrina africana o a una europea? >>> int(velocidad) ValueError: invalid literal for int() Veremos cómo controlar este tipo de errores más adelante. 2.11 Comentarios A medida que los programas se van volviendo más grandes y complicados, se vuel- ven más difíciles de leer. Los lenguajes formales son densos, y a menudo es com- plicado mirar un trozo de código e imaginarse qué es lo que hace, o por qué. Por eso es buena idea añadir notas a tus programas, para explicar en un lenguaje normal qué es lo que el programa está haciendo. Estas notas reciben el nombre de comentarios, y en Python comienzan con el símbolo #: # calcula el porcentaje de hora transcurrido porcentaje = (minuto * 100) / 60 En este caso, el comentario aparece como una línea completa. Pero también puedes poner comentarios al final de una línea porcentaje = (minuto * 100) / 60 # porcentaje de una hora Todo lo que va desde # hasta el final de la línea es ignorado—no afecta para nada al programa. Las comentarios son más útiles cuando documentan características del código que no resultan obvias. Es razonable asumir que el lector puede descifrar qué es lo que el código hace; es mucho más útil explicarle por qué. Este comentario es redundante con el código e inútil: 2.12. ELECCIÓN DE NOMBRES DE VARIABLES MNEMÓNICOS 27 v = 5 # asigna 5 a v Este comentario contiene información útil que no está en el código: v = 5 # velocidad en metros/segundo. Elegir nombres adecuados para las variables puede reducir la necesidad de co- mentarios, pero los nombres largos también pueden ocasionar que las expresiones complejas sean difíciles de leer, así que hay que conseguir una solución de compro- miso. 2.12 Elección de nombres de variables mnemóni- cos Mientras sigas las sencillas reglas de nombrado de variables y evites las palabras reservadas, dispondrás de una gran variedad de opciones para poner nombres a tus variables. Al principio, esa diversidad puede llegar a resultarte confusa, tanto al leer un programa como al escribir el tuyo propio. Por ejemplo, los tres programas siguientes son idénticos en cuanto a la función que realizan, pero muy diferentes cuando los lees e intentas entenderlos. a = 35.0 b = 12.50 c = a * b print(c) horas = 35.0 tarifa = 12.50 salario = horas * tarifa print(salario) x1q3z9ahd = 35.0 x1q3z9afd = 12.50 x1q3p9afd = x1q3z9ahd * x1q3z9afd print(x1q3p9afd) El intérprete de Python ve los tres programas como exactamente idénticos, pero los humanos ven y asimilan estos programas de forma bastante diferente. Los humanos entenderán más rápidamente el objetivo del segundo programa, ya que el programador ha elegido nombres de variables que reflejan lo que pretendía de acuerdo al contenido que iba almacenar en cada variable. Esa sabia elección de nombres de variables se denomina utilizar “nombres de vari- ables mnemónicos”. La palabra mnemónico2 significa “que ayuda a memorizar”. 2 Consulta https://es.wikipedia.org/wiki/Mnemonico para obtener una descripción detallada de la palabra “mnemónico”. 28 CHAPTER 2. VARIABLES, EXPRESIONES Y SENTENCIAS Elegimos nombres de variables mnemónicos para ayudarnos a recordar por qué creamos las variables al principio. A pesar de que todo esto parezca estupendo, y de que sea una idea muy buena usar nombres de variables mnemónicos, ese tipo de nombres pueden interponerse en el camino de los programadores novatos a la hora de analizar y comprender el código. Esto se debe a que los programadores principiantes no han memorizado aún las palabras reservadas (sólo hay 33), y a veces variables con nombres que son demasi- ado descriptivos pueden llegar a parecerles parte del lenguaje y no simplemente nombres de variable bien elegidos3. Echa un vistazo rápido al siguiente código de ejemplo en Python, que se mueve en bucle a través de un conjunto de datos. Trataremos los bucles pronto, pero por ahora tan sólo trata de entender su significado: for word in words: print(word) ¿Qué ocurre aquí? ¿Cuáles de las piezas (for, word, in, etc.) son palabras reser- vadas y cuáles son simplemente nombres de variables? ¿Acaso Python comprende de un modo básico la noción de palabras (words)? Los programadores novatos tienen problemas separando qué parte del código debe mantenerse tal como está en este ejemplo y qué partes son simplemente elección del programador. El código siguiente es equivalente al de arriba: for slice in pizza: print(slice) Para los principiantes es más fácil estudiar este código y saber qué partes son palabras reservadas definidas por Python y qué partes son simplemente nombres de variables elegidas por el programador. Está bastante claro que Python no entiende nada de pizza ni de porciones, ni del hecho de que una pizza consiste en un conjunto de una o más porciones. Pero si nuestro programa lo que realmente va a hacer es leer datos y buscar palabras en ellos, pizza y porción son nombres muy poco mnemónicos. Elegirlos como nombres de variables distrae del propósito real del programa. Dentro de muy poco tiempo, conocerás las palabras reservadas más comunes, y empezarás a ver cómo esas palabras reservadas resaltan sobre las demás: Las partes del código que están definidas por Python (for, in, print, y :) están en negrita, mientras que las variables elegidas por el programador (word y words) no lo están. Muchos editores de texto son conscientes de la sintaxis de Python y colorearán las palabras reservadas de forma diferente para darte pistas que te permitan mantener tus variables y las palabras reservadas separados. Dentro de poco empezarás a leer Python y podrás determinar rápidamente qué es una variable y qué es una palabra reservada. 3 El párrafo anterior se refiere más bien a quienes eligen nombres de variables en inglés, ya que todas las palabras reservadas de Python coinciden con palabras propias de ese idioma (Nota del trad.) 2.13. DEPURACIÓN 29 2.13 Depuración En este punto, el error de sintaxis que es más probable que cometas será intentar utilizar nombres de variables no válidos, como class y yield, que son palabras clave, o odd~job y US$, que contienen caracteres no válidos. Si pones un espacio en un nombre de variable, Python cree que se trata de dos operandos sin ningún operador: >>> bad name = 5 SyntaxError: invalid syntax >>> month = 09 File "", line 1 month = 09 ^ SyntaxError: invalid token Para la mayoría de errores de sintaxis, los mensajes de error no ayudan mucho. Los mensajes más comunes son SyntaxError: invalid syntax y SyntaxError: invalid token, ninguno de los cuales resulta muy informativo. El runtime error (error en tiempo de ejecución) que es más probable que obtengas es un “use before def” (uso antes de definir); que significa que estás intentando usar una variable antes de que le hayas asignado un valor. Eso puede ocurrir si escribes mal el nombre de la variable: >>> principal = 327.68 >>> interest = principle * rate NameError: name 'principle' is not defined Los nombres de las variables son sensibles a mayúsculas, así que LaTeX no es lo mismo que latex. En este punto, la causa más probable de un error semántico es el orden de las operaciones. Por ejemplo, para evaluar 2π 1 , puedes sentirte tentado a escribir >>> 1.0 / 2.0 * pi Pero la división se evalúa antes, ¡así que obtendrás π/2, que no es lo mismo! No hay forma de que Python sepa qué es lo que querías escribir exactamente, así que en este caso no obtienes un mensaje de error; simplemente obtienes una respuesta incorrecta. 2.14 Glosario asignación Una sentencia que asigna un valor a una variable. 30 CHAPTER 2. VARIABLES, EXPRESIONES Y SENTENCIAS cadena Un tipo que representa secuencias de caracteres. concatenar Unir dos operandos, uno a continuación del otro. comentario Información en un programa que se pone para otros programadores (o para cualquiera que lea el código fuente), y no tiene efecto alguno en la ejecución del programa. división entera La operación que divide dos números y trunca la parte frac- cionaria. entero Un tipo que representa números enteros. evaluar Simplificar una expresión realizando las operaciones en orden para obtener un único valor. expresión Una combinación de variables, operadores y valores que representan un único valor resultante. mnemónico Una ayuda para memorizar. A menudo damos nombres mnemónicos a las variables para ayudarnos a recordar qué está almacenado en ellas. palabra clave Una palabra reservada que es usada por el compilador para analizar un programa; no se pueden usar palabres clave como if, def, y while como nombres de variables. punto flotante Un tipo que representa números con parte decimal. operador Un símbolo especial que representa un cálculo simple, como suma, mul- tiplicación o concatenación de cadenas. operador módulo Un operador, representado por un signo de porcentaje (%), que funciona con enteros y obtiene el resto cuando un número es dividido por otro. operando Uno de los valores con los cuales un operador opera. 2.15. EJERCICIOS 31 reglas de precedencia El conjunto de reglas que gobierna el orden en el cual son evaluadas las expresiones que involucran a múltiples operadores. sentencia Una sección del código que representa un comando o acción. Hasta ahora, las únicas sentencias que hemos visto son asignaciones y sentencias print. tipo Una categoría de valores. Los tipos que hemos visto hasta ahora son enteros (tipo int), números en punto flotante (tipo float), y cadenas (tipo str). valor Una de las unidades básicas de datos, como un número o una cadena, que un programa manipula. variable Un nombre que hace referencia a un valor. 2.15 Ejercicios Ejercicio 2: Escribe un programa que use input para pedirle al usuario su nombre y luego darle la bienvenida. Introduzca tu nombre: Chuck Hola, Chuck Ejercicio 3: Escribe un programa para pedirle al usuario el número de horas y la tarifa por hora para calcular el salario bruto. Introduzca Horas: 35 Introduzca Tarifa: 2.75 Salario: 96.25 Por ahora no es necesario preocuparse de que nuestro salario tenga exactamente dos dígitos después del punto decimal. Si quieres, puedes probar la función interna de Python round para redondear de forma adecuada el salario resultante a dos dígitos decimales. Ejercicio 4: Asume que ejecutamos las siguientes sentencias de asig- nación: ancho = 17 alto = 12.0 Para cada una de las expresiones siguientes, escribe el valor de la expresión y el tipo (del valor de la expresión). 32 CHAPTER 2. VARIABLES, EXPRESIONES Y SENTENCIAS 1. ancho/2 2. ancho/2.0 3. alto/3 4. 1 + 2 * 5 Usa el intérprete de Python para comprobar tus respuestas. Ejercicio 5: Escribe un programa que le pida al usuario una temper- atura en grados Celsius, la convierta a grados Fahrenheit e imprima por pantalla la temperatura convertida. Chapter 3 Ejecución condicional 3.1 Expresiones booleanas Una expresión booleana es aquella que puede ser verdadera (True) o falsa (False). Los ejemplos siguientes usan el operador ==, que compara dos operandos y devuelve True si son iguales y False en caso contrario: >>> 5 == 5 True >>> 5 == 6 False True y False son valores especiales que pertenecen al tipo bool (booleano); no son cadenas: >>> type(True) >>> type(False) El operador == es uno de los operadores de comparación; los demás son: x != y # x es distinto de y x > y # x es mayor que y x < y # x es menor que y x >= y # x es mayor o igual que y x. 33 34 CHAPTER 3. EJECUCIÓN CONDICIONAL 3.2 Operadores lógicos Existen tres operadores lógicos: and (y), or (o), y not (no). El significado semántico de estas operaciones es similar a su significado en inglés. Por ejemplo, x > 0 and x < 10 es verdadero sólo cuando x es mayor que 0 y menor que 10. n%2 == 0 or n%3 == 0 es verdadero si cualquiera de las condiciones es verdadera, es decir, si el número es divisible por 2 o por 3. Finalmente, el operador not niega una expresión booleana, de modo que not (x > y) es verdadero si x > y es falso; es decir, si x es menor o igual que y. Estrictamente hablando, los operandos de los operadores lógicos deberían ser ex- presiones booleanas, pero Python no es muy estricto. Cualquier número distinto de cero se interpreta como “verdadero.” >>> 17 and True True Esta flexibilidad puede ser útil, pero existen ciertas sutilezas en ese tipo de uso que pueden resultar confusas. Es posible que prefieras evitar usarlo de este modo hasta que estés bien seguro de lo que estás haciendo. 3.3 Ejecución condicional Para poder escribir programas útiles, casi siempre vamos a necesitar la capacidad de comprobar condiciones y cambiar el comportamiento del programa de acuerdo a ellas. Las sentencias condicionales nos proporcionan esa capacidad. La forma más sencilla es la sentencia if: if x > 0 : print('x es positivo') La expresión booleana después de la sentencia if recibe el nombre de condición. La sentencia if se finaliza con un carácter de dos-puntos (:) y la(s) línea(s) que van detrás de la sentencia if van indentadas1 (es decir, llevan una tabulación o varios espacios en blanco al principio). Si la condición lógica es verdadera, la sentencia indentada será ejecutada. Si la condición es falsa, la sentencia indentada será omitida. La sentencia if tiene la misma estructura que la definición de funciones o los bucles for2. La sentencia consiste en una línea de encabezado que termina con el carácter dos-puntos (:) seguido por un bloque indentado. Las sentencias de este tipo reciben el nombre de sentencias compuestas, porque se extienden a lo largo de varias líneas. 1 el término correcto en español sería “sangradas”, pero en el mundillo de la programación se suele decir que las líneas van “indentadas” (Nota del trad.) 2 Estudiaremos las funciones en el capítulo 4 y los bucles en el capítulo 5. 3.3. EJECUCIÓN CONDICIONAL 35 sí x>0 print(‘x es positivo’) Figure 3.1: If Logic No hay límite en el número de sentencias que pueden aparecer en el cuerpo, pero debe haber al menos una. Ocasionalmente, puede resultar útil tener un cuerpo sin sentencias (normalmente como emplazamiento reservado para código que no se ha escrito aún). En ese caso, se puede usar la sentencia pass, que no hace nada. if x < 0 : pass # ¡necesito gestionar los valores negativos! Si introduces una sentencia if en el intérprete de Python, el prompt cambiará su aspecto habitual por puntos suspensivos, para indicar que estás en medio de un bloque de sentencias, como se muestra a continuación: >>> x = 3 >>> if x < 10:... print('Pequeño')... Pequeño >>> Al usar el intérprete de Python, debe dejar una línea en blanco al final de un bloque, de lo contrario Python devolverá un error: >>> x = 3 >>> if x < 10:... print('Pequeño')... print('Hecho') File "", line 3 print('Hecho') ^ SyntaxError: invalid syntax No es necesaria una línea en blanco al final de un bloque de instrucciones al escribir y ejecutar un script, pero puede mejorar la legibilidad de su código. 36 CHAPTER 3. EJECUCIÓN CONDICIONAL 3.4 Ejecución alternativa La segunda forma de la sentencia if es la ejecución alternativa, en la cual existen dos posibilidades y la condición determina cual de ellas será ejecutada. La sintaxis es similar a ésta: if x%2 == 0 : print('x es par') else : print('x es impar') Si al dividir x por 2 obtenemos como resto 0, entonces sabemos que x es par, y el programa muestra un mensaje a tal efecto. Si esa condición es falsa, se ejecuta el segundo conjunto de sentencias. no sí x%2 == 0 print(‘x es impar’) print(‘x es par’) Figure 3.2: If-Then-Else Logic Dado que la condición debe ser obligatoriamente verdadera o falsa, solamente una de las alternativas será ejecutada. Las alternativas reciben

Aprender Python Fácil PDF

Document Details

Tags

Related

Summary

Full Transcript

Upgrade to continue