Introducción a la programación con Python 3

408 Pages·2014·9.01 MB·Spanish

by  Andrés Marzal Varó

Introducción
a la programación
con Python 3
Andrés Marzal Varó
Isabel Gracia Luengo
Pedro García Sevilla
Departament De LLenguatges i sistemes
informàtics
Codis d’assignatures EI1003 i mt1003
Andrés Marzal / Isabel Gracia / Pedro García - ISBN: 978-84-697-1178-1 Introducción a la programación con Python 3 - UJI - DOI: http://dx.doi.org/10.6035/Sapientia93
Edita: Publicacions de la Universitat Jaume I. Servei de Comunicació i Publicacions
Campus del Riu Sec. Edifici Rectorat i Serveis Centrals. 12071 Castelló de la Plana
http://www.tenda.uji.es e-mail: [email protected]
Col·lecció Sapientia 93
www.sapientia.uji.es
Primera edició, 2014
ISBN: 978-84-697-1178-1
Publicacions de la Universitat Jaume I és una editorial membre de l’une,
cosa que en garanteix la difusió de les obres en els àmbits nacional i inter-
nacional. www.une.es
Reconeixement-CompartirIgual
CC BY-SA
Aquest text està subjecte a una llicència Reconeixement-CompartirIgual de Creative Com-
mons, que permet copiar, distribuir i comunicar públicament l’obra sempre que s’especifique
l’autor i el nom de la publicació fins i tot amb objectius comercials i també permet crear obres
derivades, sempre que siguen distribuïdes amb aquesta mateixa llicència.
http://creativecommons.org/licenses/by-sa/3.0/legalcode
Andrés Marzal / Isabel Gracia / Pedro García - ISBN: 978-84-697-1178-1 Introducción a la programación con Python 3 - UJI - DOI: http://dx.doi.org/10.6035/Sapientia93
Índice general
Prefacio 7
1. Introducción 11
1.1. Computadores . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 11
1.2. Codificación de la información . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
1.3. Programas y lenguajes de programación . . . . . . . . . . . . . . . . . . . . . . . . . 16
1.3.1. Código de máquina. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
1.3.2. Lenguaje ensamblador . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
1.3.3. ¿Un programa diferente para cada ordenador? . . . . . . . . . . . . . . . . . 20
1.3.4. Lenguajes de programación de alto nivel . . . . . . . . . . . . . . . . . . . . 21
1.3.5. Compiladores e intérpretes . . . . . . . . . . . . . . . . . . . . . . . . . . . . 22
1.3.6. Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
1.3.7. Java . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 26
1.4. Más allá de los programas: algoritmos . . . . . . . . . . . . . . . . . . . . . . . . . . 26
2. Una calculadora avanzada 31
2.1. Sesiones interactivas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
2.1.1. Los operadores aritméticos . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
2.1.2. Errores de tecleo y excepciones . . . . . . . . . . . . . . . . . . . . . . . . . 39
2.2. Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40
2.2.1. Tipos entero y flotante. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 41
2.2.2. El tipo de datos booleano (y sus operadores) . . . . . . . . . . . . . . . . . 42
2.3. Literales de entero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 46
2.4. Variables y asignaciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 47
2.4.1. Asignaciones con operador . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.4.2. Variables no inicializadas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
2.5. El tipo de datos cadena . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 52
2.6. Funciones predefinidas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
2.6.1. Algunas funciones sobre valores numéricos . . . . . . . . . . . . . . . . . . 54
2.6.2. Dos funciones básicas para cadenas: ord y chr . . . . . . . . . . . . . . . . 57
2.7. Módulos e importación de funciones y variables . . . . . . . . . . . . . . . . . . . . 58
2.7.1. El módulo math . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 58
2.7.2. Otros módulos de interés . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
2.8. Métodos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 61
2.8.1. Unos métodos sencillos para manipular cadenas... . . . . . . . . . . . . . . 61
2.8.2. ... y uno mucho más complejo: format . . . . . . . . . . . . . . . . . . . . . 62
3. Programas 67
3.1. Tu primer programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 67
3.1.1. Instalar y preparar Eclipse para el trabajo con la extensión Pydev . . . . 67
3.1.2. Nuestro primer programa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 75
3.2. Ejecución de programas desde la línea de órdenes . . . . . . . . . . . . . . . . . . 77
3.3. Entrada/salida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 77
3.3.1. Lectura de datos de teclado. . . . . . . . . . . . . . . . . . . . . . . . . . . . 78
3.3.2. Más sobre la función print . . . . . . . . . . . . . . . . . . . . . . . . . . . . 80
Andrés Marzal / Isabel Gracia / Pedro García - ISBN: 978-84-697-1178-1 Introducción a la programación con Python 3 - UJI - DOI: http://dx.doi.org/10.6035/Sapientia93
3.4. Sobre la legibilidad de los programas . . . . . . . . . . . . . . . . . . . . . . . . . . 81
3.4.1. Algunos convenios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
3.4.2. Comentarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 83
3.5. Gráficos de tortuga . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 84
4. Estructuras de control 95
4.1. Sentencias condicionales . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 95
4.1.1. Un programa ilustrativo: resolución de ecuaciones de primer grado . . . . 95
4.1.2. La sentencia condicional if . . . . . . . . . . . . . . . . . . . . . . . . . . . . 97
4.1.3. Sentencias condicionales anidadas . . . . . . . . . . . . . . . . . . . . . . . 100
4.1.4. Otro ejemplo: resolución de ecuaciones de segundo grado . . . . . . . . . 103
4.1.5. En caso contrario (else) . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 104
4.1.6. Una estrategia de diseño: refinamientos sucesivos . . . . . . . . . . . . . . 106
4.1.7. Un nuevo refinamiento del programa de ejemplo . . . . . . . . . . . . . . . 108
4.1.8. Otro ejemplo: máximo de una serie de números . . . . . . . . . . . . . . . . 110
4.1.9. Evaluación con cortocircuitos . . . . . . . . . . . . . . . . . . . . . . . . . . . 115
4.1.10. Un último problema: menús de usuario . . . . . . . . . . . . . . . . . . . . . 116
4.1.11. Una forma compacta para estructuras condicionales múltiples (elif) . . . . 118
4.2. Sentencias iterativas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 119
4.2.1. La sentencia while . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 120
4.2.2. Un problema de ejemplo: cálculo de sumatorios . . . . . . . . . . . . . . . . 125
4.2.3. Otro programa de ejemplo: requisitos en la entrada . . . . . . . . . . . . . 127
4.2.4. Mejorando el programa de los menús . . . . . . . . . . . . . . . . . . . . . . 129
4.2.5. El bucle for in . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 132
4.2.6. for in como forma compacta de ciertos while . . . . . . . . . . . . . . . . . 135
4.2.7. Números primos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 136
4.2.8. Rotura de bucles: break . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 142
4.2.9. Anidamiento de estructuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . 144
4.3. Captura y tratamiento de excepciones . . . . . . . . . . . . . . . . . . . . . . . . . . 146
4.4. Algunos ejemplos gráficos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
4.4.1. Un graficador de funciones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 148
4.4.2. Una animación: simulación gravitacional . . . . . . . . . . . . . . . . . . . . 152
4.5. Una reflexión final . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 159
5. Tipos estructurados: secuencias 161
5.1. Cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
5.1.1. Lo que ya sabemos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 161
5.1.2. Escapes . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 162
5.1.3. Longitud de una cadena . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 165
5.1.4. Indexación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 166
5.1.5. Recorrido de cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 167
5.1.6. Un ejemplo: un contador de palabras . . . . . . . . . . . . . . . . . . . . . . 169
5.1.7. Otro ejemplo: un programa de conversión de binario a decimal. . . . . . . 173
5.1.8. A vueltas con las cadenas: inversión de una cadena . . . . . . . . . . . . . 175
5.1.9. Subcadenas: el operador de corte . . . . . . . . . . . . . . . . . . . . . . . . 176
5.1.10. Una aplicación: correo electrónico personalizado . . . . . . . . . . . . . . 178
5.1.11. Referencias a cadenas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 180
5.2. Listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 185
5.2.1. Cosas que, sin darnos cuenta, ya sabemos sobre las listas . . . . . . . . . 186
5.2.2. Comparación de listas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 189
5.2.3. El operador is. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 190
5.2.4. Modificación de elementos de listas. . . . . . . . . . . . . . . . . . . . . . . 191
5.2.5. Mutabilidad, inmutabilidad y representación de la información en
memoria . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 192
5.2.6. Adición de elementos a una lista . . . . . . . . . . . . . . . . . . . . . . . . 194
5.2.7. Lectura de listas por teclado . . . . . . . . . . . . . . . . . . . . . . . . . . . 197
5.2.8. Borrado de elementos de una lista . . . . . . . . . . . . . . . . . . . . . . . 199
Andrés Marzal / Isabel Gracia / Pedro García - ISBN: 978-84-697-1178-1 Introducción a la programación con Python 3 - UJI - DOI: http://dx.doi.org/10.6035/Sapientia93
5.2.9. Pertenencia de un elemento a una lista . . . . . . . . . . . . . . . . . . . . 202
5.2.10. Ordenación de una lista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 203
5.3. De cadenas a listas y viceversa . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 208
5.4. Matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 210
5.4.1. Sobre la creación de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . 211
5.4.2. Lectura de matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 214
5.4.3. ¿Qué dimensión tiene una matriz? . . . . . . . . . . . . . . . . . . . . . . . . 214
5.4.4. Operaciones con matrices . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 215
5.4.5. El juego de la vida . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 219
6. Funciones 231
6.1. Uso de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 231
6.2. Definición de funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 232
6.2.1. Definición y uso de funciones con un solo parámetro . . . . . . . . . . . . 232
6.2.2. Definición y uso de funciones con varios parámetros . . . . . . . . . . . . . 242
6.2.3. Definición y uso de funciones sin parámetros . . . . . . . . . . . . . . . . . 244
6.2.4. Procedimientos: funciones sin devolución de valor . . . . . . . . . . . . . . 248
6.2.5. Funciones que devuelven varios valores mediante una lista . . . . . . . . . 253
6.3. Variables locales y variables globales . . . . . . . . . . . . . . . . . . . . . . . . . . 255
6.4. El mecanismo de las llamadas a función . . . . . . . . . . . . . . . . . . . . . . . . . 264
6.4.1. La pila de llamadas a función y el paso de parámetros . . . . . . . . . . . 264
6.4.2. Paso del resultado de expresiones como argumentos . . . . . . . . . . . . . 269
6.4.3. Más sobre el paso de parámetros . . . . . . . . . . . . . . . . . . . . . . . . 270
6.4.4. Acceso a variables globales desde funciones. . . . . . . . . . . . . . . . . . 278
6.5. Un ejemplo: Memorión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 283
6.6. Ejemplos. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
6.6.1. Integración numérica . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 293
6.6.2. Aproximación de la exponencial de un número real . . . . . . . . . . . . . . 295
6.6.3. Cálculo de números combinatorios . . . . . . . . . . . . . . . . . . . . . . . . 300
6.6.4. El método de la bisección. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 301
6.7. Diseño de programas con funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . 303
6.7.1. Ahorro de tecleo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 304
6.7.2. Mejora de la legibilidad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
6.7.3. Algunosconsejosparadecidirquédeberíadefinirsecomofunción:análisis
descendente y ascendente . . . . . . . . . . . . . . . . . . . . . . . . . . . . 305
6.8. Recursión . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 306
6.8.1. Cálculo recursivo del factorial . . . . . . . . . . . . . . . . . . . . . . . . . . 307
6.8.2. Cálculorecursivodelnúmerodebitsnecesariospararepresentarunnúmero310
6.8.3. Los números de Fibonacci. . . . . . . . . . . . . . . . . . . . . . . . . . . . . 311
6.8.4. El algoritmo de Euclides . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 314
6.8.5. Las torres de Hanoi . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 316
6.8.6. Recursión indirecta . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 319
6.8.7. Gráficos fractales: copos de nieve de Von Koch . . . . . . . . . . . . . . . . 320
6.9. Módulos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 326
6.9.1. Un módulo muy sencillo: mínimo y máximo . . . . . . . . . . . . . . . . . . 326
6.9.2. Un módulo más interesante: gravedad . . . . . . . . . . . . . . . . . . . . . 327
6.10. Documentación del código . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 330
6.10.1. Otro módulo: cálculo vectorial . . . . . . . . . . . . . . . . . . . . . . . . . . 331
6.10.2. Un módulo para trabajar con polinomios . . . . . . . . . . . . . . . . . . . . 334
6.10.3. Un módulo con utilidades estadísticas . . . . . . . . . . . . . . . . . . . . . 337
6.10.4. Un módulo para cálculo matricial . . . . . . . . . . . . . . . . . . . . . . . . 338
Andrés Marzal / Isabel Gracia / Pedro García - ISBN: 978-84-697-1178-1 Introducción a la programación con Python 3 - UJI - DOI: http://dx.doi.org/10.6035/Sapientia93
7. Tipos estructurados: clases y diccionarios 341
7.1. Tipos de datos «a medida» . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
7.1.1. Lo que sabemos hacer . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 341
7.1.2. ... pero sabemos hacerlo mejor . . . . . . . . . . . . . . . . . . . . . . . . . 342
7.1.3. Lo que haremos: usar tipos de datos «a medida» . . . . . . . . . . . . . . . 344
7.2. Definición de clases en Python . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 346
7.2.1. Referencias y objetos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 349
7.2.2. Un ejemplo: gestión de calificaciones de estudiantes . . . . . . . . . . . . . 351
7.3. Algunas clases de uso común . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 354
7.3.1. La clase fecha . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 355
7.3.2. Colas y pilas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 358
7.3.3. Colas de prioridad . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 360
7.3.4. Conjuntos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 361
7.4. Un ejemplo completo: gestión de un videoclub . . . . . . . . . . . . . . . . . . . . . 363
7.4.1. Videoclub básico . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 364
7.4.2. Un videoclub más realista . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 370
7.4.3. Listado completo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 372
7.4.4. Extensiones propuestas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
7.4.5. Algunas reflexiones. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 378
7.5. Diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
7.5.1. Creación de diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
7.5.2. Consulta en diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 379
7.5.3. Recorrido de diccionarios . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 380
7.5.4. Borrado de elementos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 381
7.5.5. Una aplicación: un listín telefónico . . . . . . . . . . . . . . . . . . . . . . . 381
7.5.6. Un contador de palabras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 383
7.5.7. Rediseño del programa del videoclub con diccionarios . . . . . . . . . . . . 384
8. Ficheros 387
8.1. Generalidades sobre ficheros . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 387
8.1.1. Sistemas de ficheros: directorios y ficheros . . . . . . . . . . . . . . . . . . 387
8.1.2. Rutas . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 388
8.1.3. Montaje de unidades. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 389
8.2. Ficheros de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 390
8.2.1. El protocolo de trabajo con ficheros: abrir, leer/escribir, cerrar . . . . . . . 390
8.2.2. Lectura de ficheros de texto línea a línea . . . . . . . . . . . . . . . . . . . 390
8.2.3. Lectura carácter a carácter . . . . . . . . . . . . . . . . . . . . . . . . . . . . 395
8.2.4. Otra forma de leer línea a línea . . . . . . . . . . . . . . . . . . . . . . . . . 397
8.2.5. Escritura de ficheros de texto. . . . . . . . . . . . . . . . . . . . . . . . . . . 398
8.2.6. Añadir texto a un fichero . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 400
8.2.7. Cosas que no se pueden hacer con ficheros de texto . . . . . . . . . . . . . 402
8.2.8. Un par de ficheros especiales: el teclado y la pantalla . . . . . . . . . . . 402
8.3. Una aplicación . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 403
8.4. Texto con formato . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 407
Andrés Marzal / Isabel Gracia / Pedro García - ISBN: 978-84-697-1178-1 Introducción a la programación con Python 3 - UJI - DOI: http://dx.doi.org/10.6035/Sapientia93
Prefacio
«Introducción a la programación con Python 3» desarrolla el temario de la asignatura «Pro-
gramación I» que se imparte durante el primer semestre de primer curso en los grados en
Ingeniería Informática y en Matemática Computacional de la Universitat Jaume I. En ella se
pretende enseñar a programar y se utiliza Python como primer lenguaje de programación.
¿Por qué Python? Python es un lenguaje de muy alto nivel que permite expresar algoritmos
deformacasidirecta(hallegadoaconsiderarse«pseudocódigoejecutable»)yhemoscomprobado
que se trata de un lenguaje particularmente adecuado para la enseñanza de la programación.
Esta impresión se ve corroborada por la adopción de Python como lenguaje introductorio en
otras universidades. Otros lenguajes, como Java, C o C#, exigen una gran atención a multitud
de detalles que dificultan la implementación de algoritmos a un estudiante que se enfrenta
por primera vez al desarrollo de programas. No obstante, son lenguajes de programación de
referencia y deberían formar parte del currículum de todo informático. Aprender Python como
primer lenguaje permite estudiar las estructuras de control y de datos básicas con un alto
nivel de abstracción y, así, entender mejor qué supone exactamente la mayor complejidad de
la programación en otros lenguajes y hasta qué punto es mayor el grado de control que nos
otorgan. Por ejemplo, una vez se han estudiado listas en Python, su implementación en otros
lenguajes permite al estudiante no perder de vista el objetivo último: construir una entidad con
ciertoniveldeabstracciónusandolasherramientasconcretasproporcionadasporellenguaje.De
algún modo, pues, Python ayuda al aprendizaje posterior de otros lenguajes, lo que proporciona
al estudiante una visión más rica y completa de la programación. Las similitudes y diferencias
entre los distintos lenguajes permiten al estudiante inferir más fácilmente qué es fundamental y
qué accesorio o accidental al diseñar programas en un lenguaje de programación cualquiera.
¿Y por qué otro libro de texto introductorio a la programación? Ciertamente hay muchos
libros que enseñan a programar desde cero. Creemos que este texto se diferencia de ellos en la
formaenqueseexponenydesarrollanloscontenidos.Hemosprocuradoadoptarsiempreelpunto
de vista del estudiante y presentar los conceptos y estrategias para diseñar programas básicos
paso a paso, incrementalmente. La experiencia docente nos ha ido mostrando toda una serie
de líneas de razonamiento inapropiadas, errores y vicios en los que caen muchos estudiantes.
El texto intenta exponer, con mayor o menor fortuna, esos razonamientos, errores y vicios para
que el estudiante los tenga presentes y procure evitarlos. Así, en el desarrollo de algunos
programas llegamos a ofrecer versiones erróneas para, acto seguido, estudiar sus defectos y
mostrar una versión corregida. El libro está repleto de cuadros que pretenden profundizar en
aspectos marginales, llamar la atención sobre algún extremo, ofrecer algunas pinceladas de
historia o, sencillamente, desviarse de lo sustancial con alguna digresión que podría resultar
motivadora para el estudiante.
Queremos aprovechar para dar un consejo al estudiantado que no nos cansamos de repetir:
es imposible aprender a programar limitándose a leer un texto o a seguir pasivamente una
explicación en clase (especialmente si el período de estudio se concentra en una o dos semanas
antes del examen). Programar al nivel propio de un curso introductorio no es particularmente
difícil, pero constituye una actividad intelectual radicalmente nueva para muchos estudiantes.
Es necesario darse una oportunidad para ir asentando los conocimientos y las estrategias de
diseñodeprogramas(yasí,superarelcurso).Esaoportunidadrequieretiempoparamadurar... y
trabajo, mucho trabajo; por eso el texto ofrece más de cuatrocientos ejercicios. Solo tras haberse
enfrentado a buena parte de ellos se estará preparado para demostrar que se ha aprendido lo
necesario.
Andrés Marzal / Isabel Gracia / Pedro García - ISBN: 978-84-697-1178-1 Introducción a la programación con Python 3 - UJI - DOI: http://dx.doi.org/10.6035/Sapientia93
EstetextoesunaactualizaciónyrevisióndellibroIntroducciónalaprogramaciónconPython
publicadodentrodelacolecciónSapientiadelaUniversitatJaumeI.Lasprincipalesdiferencias
con respecto a la versión anterior son:
Sehaactualizadolaversióndellenguajeempleado.Laversiónanteriordellibroseescribió
para Python 2 (en concreto, para la versión 2.3). Desde entonces, el lenguaje ha seguido
dosramasdedesarrollodiferentes:Python2yPython3.EstenuevotextoutilizaPython3,
lo que, además de modificar contenidos, ha supuesto reescribir «todos» los programas de
ejemplo. Aunque en el momento de escribir estas líneas ya se ha publicado la versión 3.4
dePython,todoslosprogramasdeejemploincluidosenestelibrodeberíanfuncionarpara
cualquier versión a partir de la 3.1.
También hemos cambiado el entorno de desarrollo y la librería gráfica empleada. La
versión anterior del libro usaba un entorno de desarrollo propio (PythonG) que, a su
vez, incorporaba una sencilla librería gráfica. Ahora se utiliza un entorno de desarrollo
estándar y muy potente, Eclipse, que podrá seguir siendo usado por los estudiantes en
otras asignaturas y con otros lenguajes de programación. En cuanto a la parte gráfica,
ahora se utiliza el módulo turtle, incorporado al propio lenguaje desde la versión 3.1.
Elcapítulo7dellibroanteriorresultabauntantoartificialalsimular,medianteunalibrería
propia, el concepto de «registro» como una versión simplificada del concepto de clase.
Aunque la programación orientada a objetos se estudia en detalle en otras asignaturas
delosgrados,hemosconsideradomásacertadoreescribirestecapítuloparaintroducirlos
conceptos básicos de clase y objeto. Además, se ha incluido también un breve apartado
dedicado al estudio de diccionarios.
Por supuesto, hemos corregido erratas (¡y también errores importantes!), hemos añadido nuevos
ejemplos y modificado otros, hemos incorporado nuevos ejercicios y reubicado otros en lugares
que hemos juzgado más apropiados, etc.
Convenios tipográficos
Hemos tratado de seguir una serie de convenios tipográficos a lo largo del texto. Los pro-
gramas, por ejemplo, se muestran con fondo gris, así:
1
print
Por regla general, las líneas del programa aparecen numeradas a mano izquierda. Esta nu-
meración tiene por objeto facilitar la referencia a puntos concretos del programa y no debe
reproducirse en el fichero de texto si se copia el programa.
Cuando se quiere destacar el nombre del fichero en el que reside un programa, se indica en
una barra encima del código:
1
print
Cuandoun programa contienealgún errorgrave, apareceun rayorojo ala izquierdadel nombre
E
del programa:
1
rint
Algunos programas no están completos y, por ello, presentan alguna deficiencia. No obstante,
hemos optado por no marcarlos como erróneos cuando estos evolucionan en el curso de la
exposición.
La información que aparece en pantalla se muestra con un tipo de letra monoespaciado. Así,
el resultado de ejecutar la versión correcta del programa hola_mundo py se mostrará como:
Andrés Marzal / Isabel Gracia / Pedro García - ISBN: 978-84-697-1178-1 Introducción a la programación con Python 3 - UJI - DOI: http://dx.doi.org/10.6035/Sapientia93
Las sesiones interactivas del intérprete de Python también se muestran con un tipo de letra
monoespaciado. El prompt primario del intérprete Python se muestra con los caracteres « »
y el secundario con « ».
Las expresiones y sentencias que debe teclear el usuario, tanto en el intérprete de Python
como durante la ejecución de un programa, se destacan en color azul y el retorno de carro se
representa explícitamente con el símbolo :
Agradecimientos
Este texto es fruto de la experiencia docente de todo el profesorado de las asignaturas
«Metodología y tecnología de la programación» (de las antiguas titulaciones de Ingeniería In-
formática e Ingeniería Técnica en Informática de Gestión) y «Programación I» (de los actuales
grados en Ingeniería Informática y en Matemática Computacional) de la Universitat Jaume I y
se ha enriquecido con las aportaciones, comentarios y correcciones de muchos profesores del
Departamento de Lenguajes y Sistemas Informáticos: Juan Pablo Aibar Ausina, Rafael Berlanga
Llavori, Antonio Castellanos López, Víctor Manuel Jiménez Pelayo, María Dolores Llidó Escrivá,
DavidLlorensPiñana,JoséLuisLlopisBorrás,RamónMollinedaCárdenas,FedericoPratVillar
y Juan Miguel Vilar Torres. Para todos ellos, nuestro más sincero agradecimiento. Finalmen-
te, también agradecemos la colaboración de cuantos nos han hecho llegar sugerencias o han
detectado erratas.
Castellón de la Plana, 28 de julio de 2014
Andrés Marzal Varó, Isabel Gracia Luengo y Pedro García Sevilla
Andrés Marzal / Isabel Gracia / Pedro García - ISBN: 978-84-697-1178-1 Introducción a la programación con Python 3 - UJI - DOI: http://dx.doi.org/10.6035/Sapientia93