PDF de programación - Inmersión en Python

Table of Contents

Inmersión en Python........................................................................................................................................................1

Capítulo 1. Instalación de Python...................................................................................................................................2
1.1. ¿Qué Python es adecuado para usted?...........................................................................................................2
1.2. Python en Windows.......................................................................................................................................2
1.3. Python en Mac OS X.....................................................................................................................................3
1.4. Python en Mac OS 9......................................................................................................................................5
1.5. Python en RedHat Linux................................................................................................................................5
1.6. Python en Debian GNU/Linux.......................................................................................................................6
1.7. Instalación de Python desde el Código Fuente..............................................................................................7
1.8. El intérprete interactivo..................................................................................................................................7
1.9. Resumen.........................................................................................................................................................8

Capítulo 2. Su primer programa en Python..................................................................................................................9
2.1. Inmersión.......................................................................................................................................................9
2.2. Declaración de funciones.............................................................................................................................10
2.3. Documentación de funciones.......................................................................................................................11
2.4. Todo es un objeto.........................................................................................................................................11
2.5. Sangrado (indentado) de código..................................................................................................................13
2.6. Prueba de módulos.......................................................................................................................................14

Capítulo 3. Tipos de dato nativos.................................................................................................................................16
3.1. Presentación de los diccionarios..................................................................................................................16
3.2. Presentación de las listas..............................................................................................................................18
3.3. Presentación de las tuplas............................................................................................................................23
3.4. Declaración de variables..............................................................................................................................24
3.5. Formato de cadenas......................................................................................................................................26
3.6. Inyección de listas (mapping)......................................................................................................................28
3.7. Unir listas y dividir cadenas.........................................................................................................................29
3.8. Resumen.......................................................................................................................................................31

Capítulo 4. El poder de la introspección......................................................................................................................33
4.1. Inmersión.....................................................................................................................................................33
4.2. Argumentos opcionales y con nombre.........................................................................................................34
4.3. Uso de type, str, dir y otras funciones incorporadas....................................................................................35
4.4. Obtención de referencias a objetos con getattr............................................................................................38
4.5. Filtrado de listas...........................................................................................................................................40
4.6. La peculiar naturaleza de and y or...............................................................................................................42
4.7. Utilización de las funciones lambda............................................................................................................44
4.8. Todo junto....................................................................................................................................................46
4.9. Resumen.......................................................................................................................................................48

Capítulo 5. Objetos y orientación a objetos.................................................................................................................49
5.1. Inmersión.....................................................................................................................................................49
5.2. Importar módulos usando from módulo import...........................................................................................51
5.3. Definición de clases.....................................................................................................................................52
5.4. Instanciación de clases.................................................................................................................................55
5.5. Exploración de UserDict: Una clase cápsula...............................................................................................56
5.6. Métodos de clase especiales.........................................................................................................................59
5.7. Métodos especiales avanzados.....................................................................................................................61

Inmersión en Python

i

Table of Contents

Capítulo 5. Objetos y orientación a objetos

5.8. Presentación de los atributos de clase..........................................................................................................63
5.9. Funciones privadas.......................................................................................................................................64
5.10. Resumen.....................................................................................................................................................65

Capítulo 6. Excepciones y gestión de ficheros.............................................................................................................66
6.1. Gestión de excepciones................................................................................................................................66
6.2. Trabajo con objetos de fichero.....................................................................................................................68
6.3. Iteración con bucles for................................................................................................................................72
6.4. Uso de sys.modules......................................................................................................................................74
6.5. Trabajo con directorios................................................................................................................................76
6.6. Todo junto....................................................................................................................................................80
6.7. Resumen.......................................................................................................................................................81

Capítulo 7. Expresiones regulares................................................................................................................................83
7.1. Inmersión.....................................................................................................................................................83
7.2. Caso de estudio: direcciones de calles.........................................................................................................83
7.3. Caso de estudio: números romanos..............................................................................................................85
7.4. Uso de la sintaxis {n,m}..............................................................................................................................88
7.5. Expresiones regulares prolijas.....................................................................................................................90
7.6. Caso de estudio: análisis de números de teléfono..................................