PDF de programación - Guía de aprendizaje de Python

GUÍA DE APRENDIZAJE DE

PYTHON

Alan Ignacio Sepulveda Rodriguez
[email protected]

Índice de contenido

Resumen:..................................................................................................................4
1. Abriendo el apetito..........................................................................................................4
........................................................................................................................................5
1.1 Por dónde seguir...........................................................................................................6
Notas al pie............................................................................................................6
2. Utilización del intérprete Python........................................................................................7
2.1 Llamar al intérprete......................................................................................................7
2.1.1 Traspaso de argumentos........................................................................................8
2.1.2 Modo interactivo....................................................................................................8
2.2 El intérprete y su entorno..............................................................................................8
2.2.1 Gestión de errores.................................................................................................8
2.2.2 Guiones Python ejecutables....................................................................................9
2.2.3 El fichero de arranque interactivo............................................................................9
Notas al pie............................................................................................................9
3. Introducción informal a Python........................................................................................10
3.1 Python como calculadora.............................................................................................10
3.1.1 Números.............................................................................................................10
3.1.2 Cadenas.............................................................................................................12
3.1.3 Listas.................................................................................................................15
3.2 Primeros pasos programando.......................................................................................16
Notas al pie..........................................................................................................17
4. Más herramientas de control de flujo...............................................................................18
4.1 Construcciones if........................................................................................................18
4.2 Sentencias for............................................................................................................18
4.3 La función range()......................................................................................................19
4.4 Construcciones con break, continue y else en bucles.......................................................19
4.5 Construcciones con pass..............................................................................................20
4.6 Definición de funciones................................................................................................20
4.7 Más sobre la definición de funciones..............................................................................22
4.7.1 Valores por omisión en los argumentos...................................................................22
4.7.2 Argumentos por clave...........................................................................................23
4.7.3 Listas de argumentos arbitrarias............................................................................24
4.7.4 Formas lambda....................................................................................................24
4.7.5 Cadenas de documentación...................................................................................25
Notas al pie..........................................................................................................25
5. Estructuras de datos......................................................................................................26
5.1 Más sobre las listas.....................................................................................................26
5.1.1 Herramientas de programación funcional................................................................27
5.2 La sentencia del.........................................................................................................28
5.3 Tuplas y secuencias....................................................................................................28
5.4 Diccionarios...............................................................................................................29
5.5 Más sobre las condiciones............................................................................................30
5.6 Comparación entre secuencias y otros tipos...................................................................31
Notas al pie..........................................................................................................32
6. Módulos.......................................................................................................................33
6.1 Más sobre los módulos................................................................................................34
6.1.1 El camino de búsqueda de módulos........................................................................34
6.1.2 Ficheros Python ``Compilados''..............................................................................35
6.2 Módulos estándar.......................................................................................................35
6.3 La función dir()..........................................................................................................36
6.4 Paquetes...................................................................................................................37
6.4.1 Importar * de un paquete.....................................................................................38
6.4.2 Referencias internas al paquete..............................................................................39

Notas al pie..........................................................................................................40
7. Entrada y salida............................................................................................................41
7.1 Formato de salida mejorado.........................................................................................41
7.2 Lectura y escritura de ficheros......................................................................................43
7.2.1 Métodos de los objetos fichero...............................................................................44
7.2.2 El módulo pickle...................................................................................................45
Notas al pie..........................................................................................................46
8. Errores y excepciones....................................................................................................47
8.1 Errores de sintaxis......................................................................................................47
8.2 Excepciones...............................................................................................................47
8.3 Gestión de excepciones...............................................................................................48
8.4 Hacer saltar excepciones.............................................................................................49
8.5 Excepciones definidas por el usuario.............................................................................50
8.6 Definir acciones de limpieza.........................................................................................50
9. Clases..........................................................................................................................51
9.1 Unas palabras sobre la terminología..............................................................................51
9.2 Ámbitos y espacios nominales en Python.......................................................................52
9.3 Un primer vistazo a las clases......................................................................................53
9.3.1 Sintaxis de definición de clases..............................................................................53
9.3.2 Objetos clase.......................................................................................................54
9.3.3 Objetos instancia.................................................................................................55
9.3.4 Objetos método...................................................................................................55
9.4 Cajón de sastre..........................................................................................................56
9.5 Herencia....................................................................................................................58
9.5.1 Herencia múltiple.................................................................................................59
9.6 Variables privadas......................................................................................................59
9.7 Remates..........................................................