Python 3 los fundamentos del lenguaje.pdf

Universidad de LasAmóricas
Biblioteca Concepción
Recursosinformáticos
Python 3
Los fundamentos
del lenguaje
2‘edición
Sébastien CHAZALLET
Archivos complementarios
para descarga

¡A C A D A UNO LO SUYO!
► Libros impresos y online
► Manuales personalizables para formación
n®
www.Facebook.com/EdicionesENI
www.Twitter.com/EdicionesENI

cceda de inmediato
ia versión digital online
comprando en www.edicioneS-eni.com

Recursosinformáticos
Python 3
Los fundamentos
del lenguaje
2‘edición

Todas las marcas citadas han sido registradas por su respectivo editor.
Reservados todos los derechos. El contenido de esta obra está protegido por la ley, que
establece penas de prisión y/o multas, además de las correspondientes indemnizaciones
por daños y perjuicios, para quienes reprodujeren, plagiaren, distribuyeren o comunica
ren públicamente, en todo o en parte, una obra literaria, artística o científica, o su trans
formación, interpretación o ejecución artística fijada en cualquier tipo de soporte o
comunicada a través de cualquier medio, sin la preceptiva autorización.
Copyright - Editions ENI - Diciembre 2016
ISBN: 978-2-409-00614-2
Edición original: 978-2-7460-00159-8
Ediciones ENI es una marca comercial registrada de Ediciones Software.
Ediciones ENI
P° Ferrocarriles Catalanes, 97-117, 2a pl. of. 18
08940 - Cornelia de Llobregat (Barcelona)
Tel: 934 246 401
Fax: 934 231 576
e-mail: info@ediciones-eni.com
http://www.ediciones-eni.com
Autor: Sébastien CHAZALLET
Edición española: Francisco Javier PIQUERES JUAN
Colección Recursos Informáticos dirigida por Joélle MUSSET

Contenido___________ _______________________________1
Podrá descargar algunos elementos de este libro en la página web
de Ediciones ENI: http://www.ediciones-eni.com.
Escriba la referencia ENI del libro RIT23PYT en la zona de búsqueda
y valide. Haga clic en el título y después en el botón de descarga.
Prólogo
1. Contenido del libro............................................................................................ 31
2. Progresión del libro............................................................................................ 32
3. Destinado a profesores y alumnos...................................................................33
4. Destinado a investigadores y doctores.............................................................34
5. Destinado a aquellos que vienen de otro lenguaje..........................................35
Parte 1: Las bazas de Python
Capítulo 1.1
Python en el paisaje informático
1. Breve historia de los lenguajes informáticos....................................................37
1.1 Informática teórica..................................................................................... 37
1.2 Cronología de la informática.....................................................................37
1.2.1 Evolución de las problemáticas vinculadas a la informática... 37
1.2.2 Cronología de los lenguajes informáticos..................................... 39
1.3 Historia de Python.....................................................................................43
1.3.1 Génesis............................................................................................. 43
1.3.2 Extensión del perímetro funcional................................................44
1.3.3 Evolución de la licencia.................................................................. 44
1.3.4 Porvenir........................................................................................... 45
2. Tipología de los lenguajes de programación..................................................45
2.1 Paradigmas................................................................................................ 45
2.1.1 Definición.........................................................................................45
2.1.2 Paradigma imperativo y derivados............................................... 47
2.1.3 Paradigma orientado a objetos y derivados.................................47
2.1.4 Programación orientada a aspectos............................................... 47
2.1.5 Paradigma funcional...................................................................... 48
2.1.6 Paradigma lógico............................................................................ 48

2.1.7 Programación concurrente............................................................. 48
2.1.8 Síntesis.............................................................................................49
2.2 Interoperabilidad........................................................................................ 50
2.3 Niveles de programación..........................................................................51
2.3.1 Máquina...........................................................................................51
2.3.2 Bajo nivel.........................................................................................51
2.3.3 Alto nivel.........................................................................................52
2.4 Tipado.........................................................................................................53
2.4.1 Débil vs. fuerte............................................................................... 53
2.4.2 Estático vs dinámico......................................................................53
2.5 Gramática...................................................................................................54
2.5.1 Lenguajes formales.......................................................................... 54
2.5.2 Sintaxis.............................................................................................54
3. Python y el resto del mundo............................................................................. 55
3.1 Posición estratégica del lenguaje Python................................................55
3.1.1 Segmentos de mercado..................................................................55
3.1.2 Nivel de complejidad......................................................................55
3.1.3 Fortalezas del lenguaje....................................................................55
3.1.4 Puntos débiles.................................................................................. 56
3.2 Integración con otros lenguajes................................................................56
3.2.1 Extensiones C.................................................................................. 56
3.2.2 Integración de programas escritos en C .......................................57
3.2.3 Integración de programasPython en C ....................................... 57
3.2.4 Integración de programas escritos en Java...................................57
3.2.5 Integración de programasPython en Java....................................57
3.2.6 Otras integraciones........................................................................57
Capítulo 1.2
Presentación de Python
1. Filosofía............................................................................................................. 59
1.1 Python en pocas líneas.............................................................................. 59
1.1.1 ¿De dónde proviene el nombre «Python»?.................................. 59
1.1.2 Presentación técnica........................................................................59
1.1.3 Presentación conceptual................................................................60
1.2 Comparación con otros lenguajes............................................................60
1.2.1 Shell...................................................................................................60
1.2.2 Perl...................................................................................................61
2 ________________________ Python 3
Los fundamentos del lenguaje

1.2.3 C , C + + ............................................................................................... 61
1.2.4 Java........................................................................................................62
1.2.5 PHP........................................................................................................64
1.3 Grandes principios........................................................................................65
1.3.1 El zen de Python................................................................................65
1.3.2 El desarrollador no es estúpido........................................................66
1.3.3 Documentación.................................................................................. 66
1.3.4 Python viene con todo incluido......................................................66
1.3.5 Duck Typing...................................................................................... 67
1.3.6 Noción de código pythónico............................................................ 67
2. Gobierno................................................................................................................... 67
2.1 Desarrollo........................................................................................................67
2.1.1 Ramas....................................................................................................67
2.1.2 Comunidad.........................................................................................68
2.2 Modo de gobierno...........................................................................................69
2.2.1 Creador del lenguaje..........................................................................69
2.2.2 PEP........................................................................................................69
2.2.3 Toma de decisiones............................................................................69
3. ¿Qué contiene Python?...........................................................................................70
3.1 Una gramática y una sintaxis..................................................................... 70
3.2 Varias implementaciones..............................................................................70
3.3 Una librería estándar.................................................................................... 70
3.4 Librerías de terceros.......................................................................................71
3.5 Frameworks......................................................................................................71
4. Fases de ejecución de un programa Python........................................................71
4.1 Carga de la máquina virtual.........................................................................71
4.2 Compilación................................................................................................... 71
4.3 Interpretación................................................................................................. 72
Capítulo 1.3
Por qué escoger Python
1. Cualidades del lenguaje........................................................................................73
1.1 Puerta de entrada...........................................................................................73
1.2 Cualidades intrínsecas..................................................................................74
1.3 Cobertura funcional...................................................................................... 75
1.4 Dominios de excelencia................................................................................76
Contenido----------------------------------------------------- 3

1.5 Garantías....................................................................................................77
2. Difusión............................................................................................................... 78
2.1 Empresas.....................................................................................................78
2.2 El mundo de la investigación....................................................................79
2.3 El mundo de la educación..........................................................................80
2.4 Comunidad.................................................................................................81
3. Referencias ............................................................................................................82
3.1 Pesos pesados en la industria informática.............................................. 82
3.1.1 Google...............................................................................................82
3.1.2 Mozilla.............................................................................................83
3.1.3 Microsoft.........................................................................................83
3.1.4 Canonical.........................................................................................83
3.1.5 Cisco.................................................................................................84
3.2 Empresas de innovación............................................................................ 84
3.2.1 Servicios de almacenamiento en línea.........................................84
3.2.2 Cloud computing............................................................................ 84
3.2.3 Plataforma colaborativa(Forge).................................................... 84
3.2.4 Redes sociales.................................................................................. 85
3.3 Editores de contenidos.............................................................................. 85
3.3.1 Disney Animation Studio.............................................................85
3.3.2 YouTube...........................................................................................85
3.3.3 Box ADSL.........................................................................................85
3.3.4 Spotify.............................................................................................85
3.4 Fabricantes de software............................................................................ 85
4. Experiencia........................................................................................................... 86
4.1 Internet de las cosas...................................................................................86
4.2 Sistemas y desarrollo web.......................................................................... 87
4.3 Enseñanza................................................................................................... 88
4.4 Informática embebida................................................................................ 88
4.5 Desarrollo w eb ...........................................................................................89
4.6 ERP............................................................................................................... 90
4 _____________________ Python 3

Capítulo 1.4
Instalar el entorno de trabajo
1. Introducción.............................................................................................................91
2. Instalar Python........................................................................................................91
2.1 Para Windows................................................................................................91
2.2 Para M ac.......................................................................................................... 94
2.3 Para GNU/Linux et B S D ..............................................................................94
2.4 Mediante compilación.................................................................................. 95
2.5 Para un smartphone.......................................................................................96
3. Instalar una librería externa.................................................................................. 96
3.1 A partir de Python 3 .4 .................................................................................. 96
3.2 Para una versión inferior a Python 3 .4 ......................................................98
3.3 Para Linux........................................................................................................ 98
4. Crear un entorno virtual.........................................................................................99
4.1 ¿Para qué sirve un entorno virtual?.............................................................99
4.2 Para Python 3.3 o versiones superiores......................................................99
4.3 Para cualquier versión de Python...............................................................100
4.4 Para Linux...................................................................................................... 101
5. Instalar Anaconda..................................................................................................102
5.1 Para Windows................................................................................................102
5.2 Para Linux...................................................................................................... 105
5.3 Para M ac........................................................................................................ 105
5.4 Actualizar Anaconda...................................................................................106
5.5 Instalar una librería externa........................................................................106
5.6 Entornos virtuales.........................................................................................106
6. La consola Python..................................................................................................106
6.1 Arrancar la consola Python........................................................................106
6.2 BPython.......................................................................................................... 107
6.3 IPython.......................................................................................................... 108
6.4 IPython Notebook.......................................................................................108
7. Instalar un ID E ......................................................................................................109
7.1 lista de IDE....................................................................................................109
7.2 Presentación de PyCharm..........................................................................109
7.3 Configuración de PyCharm....................................................................... 110
Contenido----------------------------------------------------- 5

Parte 2: Guiar Python
Capítulo 2.1
Primeros pasos
1. Antes de comenzar.............................................................................................115
1.1 Algunas nociones importantes...............................................................115
1.1.1 ¿Gomo funciona un ordenador?................................................. 115
1.1.2 ¿Qué es un programa informático?............................................. 116
1.1.3 ¿Qué es el código fuente..............................................................116
1.2 Algunas convenciones utilizadas en este libro.....................................116
1.2.1 Código Python...............................................................................116
1.2.2 Terminal.........................................................................................117
1.2.3 Formato.........................................................................................117
1.3 ¿Cuál es el mejor método para aprender?............................................. 118
2. Primer programa...............................................................................................118
2.1 Helio world!...............................................................................................118
2.2 Asignación................................................................................................. 120
2.3 Valor booleano.........................................................................................121
2.4 Tipo........................................................................................................... 122
2.5 Excepciones............................................................................................... 123
2.6 Bloque condicional...................................................................................126
2.7 Condiciones avanzadas.............................................................................127
2.8 Bloque iterativo......................................................................................... 128
3. Primer juego: Adivine el número.................................................................... 130
3.1 Descripción del juego...............................................................................130
3.2 Pistas..........................................................................................................130
3.2.1 Gestión del azar.............................................................................130
3.2.2 Etapas del desarrollo.................................................................... 130
3.3 Para ir más allá...........................................................................................131
6____________________________ Python 3

Capítulo 2.2
Funciones y módulos
1. Las funciones...........................................................................................................133
1.1 ¿Por qué utilizar funciones?........................................................................133
1.2 Introducción a las funciones......................................................................135
1.2.1 Cómo declarar una función.............................................................135
1.2.2 Gestión de un parámetro................................................................. 136
1.2.3 Cómo hacer la función más genérica..........................................138
1.2.4 Parámetros por defecto....................................................................140
1.3 Problemáticas de acoplamiento y duplicación de código......................141
1.3.1 Nivel de sus funciones......................................................................141
1.3.2 Noción de complejidad................................................................... 143
1.3.3 Buenas prácticas.................................................................................145
2. Los módulos.............................................................................................................146
2.1 Introducción..................................................................................................146
2.1.1 ¿Qué es un módulo?........................................................................146
2.1.2 ¿Cómo crear un módulo en Python?............................................147
2.1.3 Organizar el código..........................................................................147
2.2 Gestionar el código de los módulos...........................................................147
2.2.1 Ejecutar un módulo, importar un módulo...................................147
2.2.2 Gestionar un árbol de módulos...................................................... 148
3. Terminar el juego....................................................................................................149
3.1 Crear niveles..................................................................................................149
3.2 Determinar un número máximo de intentos......................................... 150
3.3 Registrar las mejores puntuaciones...........................................................150
3.4 Inteligencia artificial.....................................................................................150
Capítulo 2.3
Los principales tipos
1. Cadenas de caracteres.......................................................................................... 151
1.1 Sintaxis.......................................................................................................... 151
1.2 Formato de una cadena..............................................................................152
1.3 Noción de tamaño de letra..........................................................................153
1.4 Noción de longitud.......................................................................................153
1.5 Pertenencia....................................................................................................154
1.6 Noción de ocurrencia.................................................................................. 154
Contenido____________________________________________ 7

1.7 Reemplazo.....................................................................................................155
1.8 Noción de carácter......................................................................................155
1.9 Tipología de los caracteres.........................................................................156
1.10 Secuenciar una cadena de caracteres........................................................157
2. Listas........................................................................................................................ 158
2.1 Sintaxis......................................................................................................... 158
2.2 índices ............................................................................................................158
2.3 Valores............................................................................................................159
2.4 Azar................................................................................................................160
2.5 Técnicas de iteración....................................................................................161
2.6 Ordenación...................................................................................................163
3. Diccionarios............................................................................................................165
3.1 Presentación de los diccionarios............................................................... 165
3.2 Recorrer un diccionario................................................................................166
3.3 Ejemplo..........................................................................................................166
Capítulo 2.4
Las clases
1. Sintaxis.................................................................................................................... 169
2. Noción de instancia en curso..............................................................................170
3. Operadores..............................................................................................................173
4. Herencia.................................................................................................................. 174
4.1 Especialización.............................................................................................175
4.2 Programación por composición................................................................ 175
Parte 3: Los fundamentos del lenguaje
Capítulo 3.1
Algoritmos básicos
1. Delimitadores............................................................... 179
1.1 Instrucción.....................................................................................................179
1.2 Una línea de código = una instrucción................................................... 179
1.3 Comentario...................................................................................................180
1.4 Una instrucción en varias líneas..............................................................180
1.5 Palabras clave.................................................................................................181
8---------------------------------- Python 3

Contenido 9
1.6 Palabras reservadas.......................................................................................181
1.7 Indentación.................................................................................................... 182
1.8 Símbolos........................................................................................................ 183
1.9 Operadores....................................................................................................187
1.10 Uso del carácter de subrayado................................................................... 189
1.11 PEP-8...............................................................................................................190
1.12 PEP-7...............................................................................................................191
1.13 PEP-257 ......................................................................................................... 191
2. Instrucciones........................................................................................................191
2.1 Definiciones..................................................................................................191
2.1.1 Variable................................................................................................191
2.1.2 Función................................................................................................193
2.1.3 Funciones lambda............................................................................ 194
2.1.4 Clase.................................................................................................... 195
2.1.5 Instrucción vacía.............................................................................. 195
2.1.6 Borrado................................................................................................196
2.1.7 Devolver el resultado de la función..............................................196
2.2 Instrucciones condicionales........................................................................198
2.2.1 Definición........................................................................................... 198
2.2.2 Condición........................................................................................... 198
2.2.3 Instrucción i f .....................................................................................198
2.2.4 Instrucción elif...................................................................................199
2.2.5 Instrucción else................................................................................ 199
2.2.6 Instrucción switch............................................................................201
2.2.7 Interrupciones.................................................................................. 201
2.2.8 Profundizando en las condiciones..................................................201
2.2.9 Rendimiento.................................................................................... 202
2.3 Iteraciones......................................................................................................203
2.3.1 Instrucción for..................................................................................203
2.3.2 Instrucción while..............................................................................204
2.3.3 ¿Cuál es la diferencia entre for y while?.......................................204
2.3.4 Instrucción break..............................................................................204
2.3.5 Instrucción retum ........................................................................... 206
2.3.6 Instrucción continué.......................................................................206
2.3.7 Instrucción else................................................................................206
2.3.8 Generadores......................................................................................207

2.4 Construcciones funcionales.......................................................................210
2.4.1 Construcción condicional..............................................................210
2.4.2 Generadores......................................................................................210
2.4.3 Recorrido de listas...........................................................................211
2.4.4 Recorrido de conjuntos.................................................................. 211
2.4.5 Recorrido de diccionarios................................................................211
2.5 Gestión de excepciones............................................................................... 211
2.5.1 Breve presentación de las excepciones........................................ 211
2.5.2 Elevar una excepción.......................................................................212
2.5.3 ¿Por qué elevar una excepción?..................................................... 212
2.5.4 Aserciones..........................................................................................213
2.5.5 Capturar una excepción.................................................................. 214
2.5.6 Manejar una excepción.................................................................. 215
2.5.7 Gestionar la salida del bloque de captura....................................217
2.5.8 Gestionar que no se produzcan excepciones............................. 217
2.5.9 Uso y liberación de recursos..........................................................219
2.5.10 Programación asincrona.................................................................. 220
2.6 O tros............................................................................................................. 221
2.6.1 Gestionar im ports...........................................................................221
2.6.2 Compartir espacios de nombres................................................... 222
2.6.3 Funciones print, help, eval y exec.................................................224
Capítulo 3.2
Declaraciones
1. Variable..................................................................................................................227
1.1 ¿Qué es una variable?................................................................................. 227
1.1.1 Contenido..........................................................................................227
1.1.2 Continente........................................................................................227
1.1.3 Formas de modificar una variable.................................................229
1.2 Tipado dinámico..........................................................................................232
1.2.1 Asignación: recordatorio................................................................ 232
1.2.2 Primitiva type y naturaleza del tipo.............................................232
1.2.3 Características del tipado Python.................................................233
1.3 Visibilidad.....................................................................................................235
1.3.1 Espacio global................................................................................... 235
1.3.2 Noción de bloque.............................................................................236
____________________________ Python 3

Contenido 11
2. Función..................................................................................................................... 240
2.1 Declaración....................................................................................................240
2.2 Parámetros......................................................................................................241
2.2.1 Firma de una función..................................................................... 241
2.2.2 Noción de argumento o de parámetro.........................................241
2.2.3 Valor por defecto.............................................................................. 242
2.2.4 Valor por defecto mutable...............................................................243
2.2.5 Parámetros nombrados................................................................... 244
2.2.6 Declaración de parámetros extensibles.......................................245
2.2.7 Paso de parámetros con asterisco..................................................246
2.2.8 Firma universal................................................................................ 247
2.2.9 Obligar a un parámetro a ser nombrado (keyword-only). . . . 247
2.2.10 Anotaciones.......................................................................................249
2.2.11 Tipos hints.........................................................................................253
3. Clase......................................................................................................................... 253
3.1 Declaración....................................................................................................253
3.1.1 Firma....................................................................................................253
3.1.2 Atributo............................................................................................. 254
3.1.3 Método............................................................................................... 254
3.1.4 Bloque local.......................................................................................255
3.2 Instanciación..................................................................................................255
3.2.1 Sintaxis............................................................................................... 255
3.2.2 Relación entre la instancia y la clase...........................................256
4. Módulo.....................................................................................................................256
4.1 ¿Para qué sirve un módulo?....................................................................... 256
4.2 Declaración....................................................................................................257
4.3 Instrucciones específicas............................................................................257
4.4 ¿Cómo conocer el contenido de un módulo?.........................................258
4.5 Compilación de los módulos.....................................................................259
Capítulo 3.3
Modelo de objetos
1. Todo es un objeto................................................................................................261
1.1 Principios.......................................................................................................261
1.1.1 Qué sentido dar a «objeto»............................................................ 261
1.1.2 Adaptación de la teoría de objetos en Python..........................262

1.1.3 Generalidades.................................................................................. 263
1.2 Clases.............................................................................................................264
1.2.1 Introducdón......................................................................................264
1.2.2 Declaradón imperativa de una dase.............................................264
1.2.3 Instanda............................................................................................265
1.2.4 Objeto en curso............................................................................... 266
1.2.5 Declaración por prototipo de una clase...................................... 266
1.2.6 Tupias con nombre.........................................................................269
1.3 Métodos.........................................................................................................269
1.3.1 Declaración........................................................................................269
1.3.2 Invocar al método...........................................................................271
1.3.3 Métodos y atributos especiales..................................................... 274
1.3.4 Constructor e inicializador............................................................277
1.3.5 Gestión automática de atributos................................................... 278
1.3.6 Interés del paradigma orientado a objetos..................................278
1.3.7 Relación entre objetos.................................................................... 279
1.4 Herencia......................................................................................................... 279
1.4.1 Polimorfismo por subtipado..........................................................279
1.4.2 Sobrecarga de métodos.................................................................. 281
1.4.3 Sobrecarga de operadores................................................................ 283
1.4.4 Polimorfismo paramétrico.............................................................. 283
1.4.5 Herencia múltiple............................................................................. 285
2. Otras herramientas de la programación orientada a objetos.....................287
2.1 Principios....................................................................................................... 287
2.2 Interfaces.......................................................................................................287
2.3 Atributos....................................................................................................... 290
2.4 Propiedades...................................................................................................292
2.5 Ubicaciones...................................................................................................295
2.6 Metaclases.....................................................................................................296
2.7 Clases abstractas..........................................................................................298
2.8 Zope Component Architecture................................................................ 301
2.8.1 Presentación............................................. 301
2.8.2 Instalación........................................................................................301
2.8.3 Definir una interfaz y un componente........................................302
2.8.4 Otras funcionalidades.................................................................... 303
2.8.5 Ventajas de la Z C A .........................................................................303
12_____________________________ Python 3

Contenido 13
3. Funciones principales y primitivas asociadas............................................... 303
3.1 Personalización............................................................................................. 303
3.1.1 Clases..................................................................................................303
3.1.2 Instancias...........................................................................................305
3.1.3 Comparación.....................................................................................306
3.1.4 Evaluación booleana........................................................................307
3.1.5 Relaciones de herencia o de clase a instancia.............................. 307
3.2 Clases particulares.......................................................................................308
3.2.1 Iterador............................................................................................... 308
3.2.2 Contenedores.....................................................................................310
3.2.3 Instancias similares a funciones....................................................310
3.2.4 Recursos que hay que proteger......................................................311
3.2.5 Tipos....................................................................................................312
Capítulo 3.4
Tipos de datos y algoritmos aplicados
1. Números................................................................................................................. 313
1.1 Tipos...............................................................................................................313
1.1.1 Enteros............................................................................................... 313
1.1.2 Reales..................................................................................................314
1.1.3 Cosas en común entre números enteros y reales........................315
1.1.4 Métodos dedicados a los números enteros.................................. 316
1.1.5 Métodos dedicados a los números reales.....................................317
1.1.6 Complejos.........................................................................................317
1.2 La consola Python, la calculadora por excelencia.................................. 318
1.2.1 Operadores matemáticos binarios............................................... 318
1.2.2 Operadores binarios particulares..................................................319
1.2.3 Operadores matemáticos unarios................................................. 320
1.2.4 Redondeo...........................................................................................321
1.2.5 Operadores de comparación.......................................................... 324
1.2.6 Operaciones matemáticas n-arias................................................. 325
1.2.7 Funciones matemáticas usuales....................................................326
1.3 Representaciones de un número.............................................................. 331
1.3.1 Representación decimal...................................................................331
1.3.2 Representación por un exponente............................................... 331
1.3.3 Representación por una fracción................................................. 331
1.3.4 Representación hexadecimal..........................................................332

1.3.5 Representación octal......................................................................... 334
1.3.6 Representación binaria.....................................................................334
1.3.7 Operaciones binarias......................................................................... 334
1.3.8 Longitud de la representación en memoria de un en tero-----336
1.4 Conversiones .................................................................................................. 338
1.4.1 Conversión entre enteros y reales................................................... 338
1.4.2 Conversión entre reales y complejos...............................................338
1.4.3 Conversión en un booleano.............................................................. 339
1.5 Trabajar con variables.....................................................................................340
1.5.1 Un número es inmutable...................................................................340
1.5.2 Modificar el valor de una variable.................................................340
1.5.3 Operadores increméntales.................................................................341
1.6 Estadísticas.......................................................................................................342
2. Secuencias...................................................................................................................343
2.1 Presentación de los distintos tipos de secuencias................................... 343
2.1.1 Generalidades....................................................................................... 343
2.1.2 Las listas................................................................................................344
2.1.3 Lasn-tuplas......................................................................................... 345
2.1.4 Conversión entre listas y n-tuplas.................................................347
2.1.5 Cosas en común entre una lista y una n -tu p la.......................... 347
2.1.6 Noción de iterador.............................................................................. 348
2.2 Uso de índices y tram os.................................................................................350
2.2.1 Definición de índice de un objeto y sus ocurrencias................. 350
2.2.2 Utilizar el índice para recorrer la secuencia.................................351
2.2.3 Encontrar las ocurrencias de un objeto y sus índices................. 352
2.2.4 Tamaño de una lista, contar ocurrencias..................................... 353
2.2.5 Utilizar el índice para modificar o eliminar.................................354
2.2.6 Iteración sim ple...................................................................................356
2.2.7 Presentación de la noción de tramos (slices)...............................360
2.2.8 Caso particular de la rama 2.x de Python..................................... 369
2.2.9 Uso básico de tramos......................................................................... 370
2.2.10 Uso avanzado de tram os........................ 371
2.3 Uso de operadores........................................................................................... 373
2.3.1 Operador + ............................................................................................373
2.3.2 Operador * ............................................................................................374
2.3.3 Operador + = .......................................................................................377
2.3.4 Operador * = ......................................................................................... 378
14______________________________ Python 3

2.3.5 Operador i n .......................................................................................379
2.3.6 Operadores de comparación.......................................................... 380
2.4 Métodos de modificación............................................................................381
2.4.1 Agregar elementos a una lista y a una n-tupla............................381
2.4.2 Eliminar un objeto de una lista y de una n-tupla..................... 383
2.4.3 Soluciones alternativas para la modificación de n-tuplas . . . . 387
2.4.4 Invertir una lista o una tupia........................................................ 388
2.4.5 Ordenar una lista..............................................................................389
2.5 Uso avanzado de listas ..............................................................................392
2.5.1 Operaciones de conjunto.................................................................392
2.5.2 Pivotar una secuencia..................................................................... 393
2.5.3 Iterar correctamente....................................................................... 394
2.5.4 Programación funcional.................................................................395
2.5.5 Recorrido de listas............................................................................397
2.5.6 Iteraciones avanzadas..................................................................... 399
2.5.7 Combinatoria.....................................................................................403
2.6 Adaptar las listas a necesidades específicas............................................. 405
2.6.1 Lista de enteros................................................................................405
2.6.2 Presentación del tipo array.............................................................407
2.6.3 Utilizar una lista como una pila....................................................409
2.6.4 Utilizar una lista como una fila de espera.................................. 409
2.6.5 Contenedor con mejor rendimiento............................................. 410
2.6.6 Utilizar las listas para representar matrices................................ 411
2.6.7 Lista sin duplicados......................................................................... 412
2.7 Otros tipos de datos.................................................................................... 415
3. Conjuntos............................................................................................................417
3.1 Presentación ..................................................................................................417
3.1.1 Definición de un conjunto............................................................ 417
3.1.2 Diferencias entre set y frozenset................................................. 418
3.1.3 Uso para eliminar valores duplicados de las listas..................... 419
3.1.4 Agregar una relación de orden........................................................419
3.2 Operaciones sobre conjuntos.....................................................................420
3.2.1 Operadores para un conjunto a partir de otros dos...................420
3.2.2 Operadores para modificar un conjunto a partir de otro . . . . 421
3.2.3 Métodos equivalentes a la creación
o modificación de conjuntos..........................................................422
3.2.4 Métodos de comparación de conjuntos.......................................422
Contenido____________________________________________ 15

3.2.5 Ejemplos de uso poco clásicos.....................................................423
3.3 Métodos de modificación de un conjunto..............................................427
3.3.1 Agregar un elemento...................................................................... 427
3.3.2 Eliminar un elemento.................................................................... 427
3.3.3 Vaciar un conjunto.........................................................................428
3.3.4 Duplicar un elemento.................................................................... 428
3.3.5 Sacar un valor de un conjunto..................................................... 429
3.3.6 Utilizar un conjunto como un almacén de objetos...................430
3.3.7 Algorítmica avanzada: resolución del problema
de las n reinas................................................................................... 432
4. Cadenas de caracteres......................................................................................... 434
4.1 Presentación...................................................................................................434
4.1.1 Definición..........................................................................................434
4.1.2 Vocabulario........................................................................................435
4.1.3 Especificidades de la rama 2.x........................................................436
4.1.4 Cambios aportados por la rama 3 .x .............................................437
4.1.5 Cadena de caracteres como secuencia de caracteres................ 439
4.1.6 Caracteres..........................................................................................442
4.1.7 Operadores de comparación..........................................................443
4.2 Dar formato a cadenas de caracteres........................................................445
4.2.1 Operador módulo............................................................................. 445
4.2.2 Métodos para dar formato al conjunto de la cadena................ 450
4.2.3 Nuevo método para dar formato a variables en una cadena.. 453
4.3 Operaciones de conjunto...........................................................................456
4.3.1 Secuenciación de cadenas..............................................................456
4.3.2 Operaciones sobre mayúsculas y minúsculas............................. 458
4.3.3 Búsqueda en una cadena de caracteres........................................ 460
4.3.4 Información sobre los caracteres...................................................460
4.4 Problemáticas relativas a la codificación.................................................462
4.4.1 Codificación por defecto................................................................ 462
4.4.2 Codificación del sistema................................................................462
4.4.3 Unicode, referencia absoluta......................................................... 462
4.4.4 Otras codificaciones.........................................................................463
4.4.5 Puntos entre el Unicode y el resto del mundo...........................464
4.4.6 Volver a Unicode.............................................................................466
16_____________________________Python 3

4.5 Manipulaciones de bajo nivel avanzadas............................................... 466
4.5.1 Operaciones para contar.................................................................466
4.5.2 Una cadena de caracteres vista como una lista..........................467
4.5.3 Una cadena de caracteres vista como un conjunto
de caracteres.......................................................................................468
4.6 Representación en memoria........................................................................468
4.6.1 Presentación del tipo bytes.............................................................468
4.6.2 Vínculo con las cadenas de caracteres.........................................469
4.6.3 Presentación del tipo bytearray....................................................470
4.6.4 Gestión de un juego de caracteres..................................................473
5. Diccionarios...........................................................................................................478
5.1 Presentación..................................................................................................478
5.1.1 Definición...........................................................................................478
5.1.2 Evolución y diferencias entre las ramas 2.x y 3 .x ..................... 479
5.1.3 Vistas de diccionarios..................................................................... 480
5.1.4 Instanciación.................................................................................... 482
5.1.5 Recorrer un diccionario...................................................................483
5.2 Manipular un diccionario............................................................................483
5.2.1 Recuperar un valor de un diccionario...........................................483
5.2.2 Modificar los valores de un diccionario.......................................484
5.2.3 Eliminar una entrada de un diccionario.......................................485
5.2.4 Duplicar un diccionario...................................................................485
5.2.5 Utilizar un diccionario como un agregador de datos.................486
5.2.6 Métodos de iteración....................................................................... 487
5.3 Uso avanzado de diccionarios...................................................................487
5.3.1 Agregar una relación de orden........................................................487
5.3.2 Algorítmicas clásicas....................................................................... 491
5.3.3 Adaptar los diccionarios a necesidades específicas...................493
5.3.4 Representación universal de datos............................................... 495
6. Booleanos...............................................................................................................496
6.1 El tipo booleano............................................................................................496
6.1.1 Clase bool...........................................................................................496
6.1.2 Los dos objetos True y False..........................................................497
6.1.3 Diferencia entre el operador de igualdad y de identidad.........497
6.2 Evaluación booleana....................................................................................497
6.2.1 Método genérico............................................................................. 497
6.2.2 Objetos clásicos................................................................................498
Contenido____________________________________________ 17

7. Datos temporales................................................................................................. 498
7.1 Gestionar una fecha del calendario........................................................ 498
7.1.1 Noción de fecha del calendario..................................................... 498
7.1.2 Trabajar con una fecha.................................................................. 499
7.1.3 Consideraciones astronómicas..................................................... 500
7.1.4 Consideraciones históricas............................................................500
7.1.5 Consideraciones técnicas............................................................... 500
7.1.6 Representación textual.................................................................. 501
7.2 Gestionar un horario o un momento de la jornada.............................. 503
7.2.1 Noción de instante...........................................................................503
7.2.2 Noción de huso horario.................................................................. 504
7.3 Gestionar un instante absoluto................................................................ 505
7.3.1 Noción de instante absoluto..........................................................505
7.3.2 Relación con las nociones anteriores.............................................506
7.3.4 Gestión de los husos horarios....................................................... 508
7.3.5 Crear una fecha a partir de una representación textual.........508
7.4 Gestionar una diferencia entre dos fechas o instantes........................509
7.4.1 Noción de diferencia y de resolución...........................................509
7.4.2 Consideraciones técnicas................................................................510
7.4.3 Uso con fechas del calendario........................................................511
7.4.4 Uso con horarios............................................................................. 511
7.4.5 Uso con fechas absolutas................................................................ 511
7.4.6 El segundo como unidad básica..................................................... 512
7.5 Especificidades de los husoshorarios.........................................................512
7.6 Problemáticas de bajo nivel.......................................................................513
7.6.1 Timestamp y struct_time..............................................................513
7.6.2 Medidas de rendimiento................................................................ 514
7.7 Uso del calendario........................................................................................516
7.7.1 Presentación del módulo calendar.................................................516
7.7.2 Funciones esenciales del calendario.............................................521
18________________________ ____Python 3

Capítulo 3.5
Patrones de diseño
1. Definición.................................................................................................................523
1.1 Situación respecto a la noción de objeto..................................................523
1.2 Organización del capítulo..........................................................................524
1.3 Situación respecto a otros conceptos........................................................ 524
2. Patrones de creación............................................................................................. 525
2.1 Singleton........................................................................................................ 525
2.2 Fábrica.............................................................................................................525
2.3 Fábrica abstracta...........................................................................................528
2.4 Constructor....................................................................................................529
2.5 Prototipo........................................................................................................ 531
3. Patrones deestructuración...................................................................................534
3.1 Adaptador......................................................................................................534
3.2 Puente.............................................................................................................537
3.3 Composite......................................................................................................540
3.4 Decorador......................................................................................................542
3.5 Fachada.......................................................................................................... 544
3.6 Peso m osca....................................................................................................546
3.7 Proxy...............................................................................................................548
4. Patrones de comportamiento..............................................................................550
4.1 Cadena de responsabilidad..........................................................................550
4.2 Solicitud.......................................................................................................... 551
4.3 Iterador.......................................................................................................... 553
4.4 Memento........................................................................................................555
4.5 Visitante........................................................................................................557
4.6 Observador....................................................................................................558
4.7 Estrategia........................................................................................................559
4.8 Función de callback.......................................................................................560
5. Z C A .........................................................................................................................561
5.1 Consideraciones...........................................................................................561
5.2 Adaptador..................................................................................................... 561
5.3 Utilidad..........................................................................................................563
5.4 Fábrica............................................................................................................564
5.5 Para ir más allá.............................................................................................565
Contenido____________________________________________ 19

Parte 4: Las funcionalidades
Capítulo 4.1
Manipulación de datos
1. Bases de datos.........................................................................................................567
1.1 Presentación.................................................................................................. 567
1.2 Acceso á una base de datos relacional..................................................... 567
1.2.1 Punto de entrada............................................................................. 567
1.2.2 MySQL.............................................................................................. 568
1.2.3 PostgreSQL......................................................................... 573
1.2.4 SQ lite................................................................................................ 575
1.2.5 Oracle................................................................................................ 575
1.3 Uso de un O R M ..........................................................................................576
1.3.1 ¿Qué es un O RM ?...........................................................................576
1.3.2 ORM propuestos por Python....................................................... 576
1.3.3 SQLAlchemy....................................................................................577
1.4 Otras bases de datos................................................................................... 583
1.4.1 CSV.....................................................................................................583
1.4.2 NoSQL.............................................................................................. 590
1.4.3 Base de datos orientada a objetos: Z O D B ..................................590
1.4.4 Base de datos de tipo clave-valor: Redis...................................... 595
1.4.5 Bases de datos orientadas a documentos:
CouchDB y MongoDB.................................................................... 597
1.4.6 Bases de datos nativas XML: BaseX, eXist..................................597
1.4.7 Cassandra..........................................................................................598
1.4.8 Bases de datos orientadas a columnas: HBase...........................599
1.4.9 Big Data: el ecosistema Hadoop...................................................500
2. LDAP........................................................................................................................ 603
2.1 Presentación...................................................................................................603
2.1.1 Protocolo............................................................................................ 603
2.1.2 Servidores..........................................................................................603
2.1.3 Terminología....................................................................................603
2.2 Instalación.............................. 604
2.3 Abrir una conexión a un servidor..............................................................604
2.4 Realizar una búsqueda............................................................................... 606
2.5 Síncrono vs asincrono................................................................................. 607
---------------------------------- Python 3

2.6 Conexiones seguras......................................................................................607
3. XM L..........................................................................................................................608
3.1 XML y las tecnologías relacionadas......................................................... 608
3.1.1 Definición de XML, terminología asociada................................ 608
3.1.2 Noción de esquema..........................................................................609
3.1.3 Ventajas e inconvenientes de X M L ..............................................610
3.1.4 Distintas maneras de recorrer un archivo XML..........................611
3.1.5 Módulos Python dedicados a XML................................................611
3.2 Validar un documento X M L ......................................................................612
3.2.1 Documento XML.............................................................................. 612
3.2.2 Esquema D T D .................................................................................. 613
3.2.3 Esquema X S D .................................................................................. 613
3.2.4 Esquema RNG (RelaxNG)...............................................................614
3.2.5 Schematron.......................................................................................615
3.3 D O M ...............................................................................................................615
3.3.1 Lectura................................................................................................615
3.3.2 Escritura............................................................................................. 616
3.4 SA X .................................................................................................................617
3.4.1 Soporte de SAX en lx m l.................................................................617
3.4.2 API SAX ligera.................................................................................. 618
3.5 XPath...............................................................................................................619
3.6 X SL T ...............................................................................................................622
3.7 El caso concreto de los archivos H TM L..................................................623
3.7.1 Problemática.......................................................................................623
3.7.2 Parsear un archivo HTML según D O M .......................................623
3.7.3 Parsear un archivo HTML según SA X.........................................625
4. Herramientas de manipulación de datos.......................................................... 626
4.1 Encriptar un d ato.........................................................................................626
4.1.1 Funciones de hash............................................................................626
4.1.2 Código de autenticación del mensaje...........................................628
4.1.3 Esteganografía.................................................................................. 629
4.2 Generar números aleatorios....................................................................... 632
4.3 Expresiones regulares..................................................................................633
5. Trabajar con imágenes.........................................................................................637
5.1 Representación informática de una imagen...........................................637
5.2 Presentación de Pillow................................................................................638
Contenido____________________________________________ 21

5.3 Formatos de imágenes matriciales............................................................639
5.4 Recuperar la información de una imagen...............................................641
5.5 Operaciones de conjunto sobre una imagen...........................................642
5.6 Trabajar con capas o con píxeles..............................................................644
Capítulo 4.2
Generación de contenido
1. PDF.........................................................................................................................647
1.1 Presentación...................................................................................................647
1.1.1 Formato P D F....................................................................................647
1.1.2 Ventajas............................................................................................ 647
1.1.3 Inconvenientes..................................................................................648
1.1.4 Presentación de la librería libre..................................................... 648
1.2 Bajo nivel.......................................................................................................648
1.2.1 Librería de datos............................................................................... 648
1.2.2 Canvas.............................................................................................. 650
1.3 Alto nivel.......................................................................................................651
1.3.1 Estilos.................................................................................................651
1.3.2 Flujo de datos....................................................................................653
1.3.3 Creación de un elemento visual................................................... 655
1.3.4 Plantilla de página...........................................................................656
1.3.5 Página que contiene varias zonas.................................................657
2. OpenDocument....................................................................................................659
2.1 Presentación...................................................................................................659
2.2 ezodf2..............................................................................................................659
2.2.1 Instalación........................................................................................659
2.2.2 OpenDocument T e x to .................................................................. 660
2.2.3 OpenDocument Hoja de cálculo................................................... 660
2.2.4 Ir más allá.......................................................................................... 660
2.3 Alternativas...................................................................................................660
2.3.1 lpod.....................................................................................................660
2.3.2 Generación a partir de plantillas...................................................661
22 ________ _______________Python 3
Losfundamentos del lenguaje

Contenido 23
Capítulo 4.3
Programación paralela
1. Terminología...........................................................................................................663
1.1 Proceso.............................................................................................................663
1.2 Tarea...............................................................................................................664
2. Uso de una tarea....................................................................................................664
2.1 Gestión de una tarea.....................................................................................664
2.1.1 Presentación.......................................................................................664
2.1.2 Creación..............................................................................................664
2.2 Gestión de varias tareas.............................................................................. 668
2.2.1 Arranque y control..........................................................................668
2.2.2 Oportunidad de utilizar una tarea................................................669
2.3 Resolución de problemáticas asociadas....................................................671
2.3.1 Sincronización.................................................................................. 671
2.3.2 Sincronización condicional.............................................................673
2.3.3 Semáforo........................................................................................... 676
3. Uso de procesos......................................................................................................677
3.1 Gestión de un proceso................................................................................ 677
3.1.1 Presentación.......................................................................................677
3.1.2 Creación............................................................................................. 678
3.2 Gestión de varios procesos..........................................................................680
3.2.1 Sincronización.................................................................................. 680
3.2.2 Paralelizar un trabajo........................................................................681
3.3 Resolución de problemáticas asociadas....................................................683
3.3.1 Comunicación interproceso...........................................................683
3.3.2 Compartir datos entre procesos....................................................684
3.4 Oportunidad de utilizar los procesos........................................................685
3.5 Demonio........................................................................................................685
4. Ejecución asincrona............................................................................................... 687
4.1 Introducción................................................................................................. 687
4.2 Presentación................................................................................................. 688

Capítulo 4.4
Programación de sistema y de red
1. Presentación..........................................................................................................695
1.1 Definición.....................................................................................................695
1.2 Objetivos del capítulo................................................................................. 696
2. Escribir Scripts de sistema...................................................................................696
2.1 Conozca su sistema operativo.................................................................. 696
2.1.1 Advertencia........................................................................................696
2.1.2 Sistema operativo............................................................................. 696
2.1.3 Procesos en curso............................................................................. 697
2.1.4 Usuarios y grupos............................................................................. 698
2.1.5 Constantes para el sistema de archivos...................................... 700
2.1.6 Gestionar las rutas...........................................................................700
2.2 Gestión de archivos......................................................................................701
2.2.1 Abrir un archivo............................................................................... 701
2.2.2 Leer un archivo..................................................................................702
2.2.3 Escribir un archivo........................................................................... 703
2.2.4 Cambiar los permisos de un archivo.............................................704
2.2.5 Cambiar de propietario o de grupo...............................................706
2.2.6 Recuperar información relativa al archivo..................................706
2.2.7 Eliminar un archivo.........................................................................707
2.3 Alternativas sencillas a los comandos bash habituales......................... 707
2.3.1 Carpetas.............................................................................................707
2.3.2 Archivos............................................................................................ 710
2.3.3 Módulo de alto nivel.......................................................................711
2.3.4 Buscar un archivo............................................................................. 713
2.4 Ejecutar comandos externos.......................................................................713
2.4.1 Ejecutar y mostrar el resultado..................................................... 713
2.4.2 Ejecutar y recuperar el resultado...................................................714
2.4.3 Para Python 3 .5 ............................................................................... 715
2.5 Herramientas.................................................................................................715
2.5.1 Comparar dos archivos.................................................................. 715
2.5.2 Herramienta de salvaguarda..........................................................717
2.5.3 Leer un archivo de configuración.................................................718
2.5.4 Pickle...................................................................................................719
24-------------------------- --------Python 3

Contenido 25
2.6 Comprimir y descomprimir un archivo...................................................721
2.6.1 Tarfile..................................................................................................721
2.6.2 G zip....................................................................................................723
2.6.3 B z 2 ...................................................................................................... 724
2.6.4 Zipfile..................................................................................................724
2.6.5 Interfaz de alto nivel........................................................................726
3. Trabajar con argumentos.....................................................................................727
3.1 Presentación..................................................................................................727
3.2 Implementación........................................................................................... 728
4. Programación de red ..............................................................................................731
4.1 Escribir un servidor y un cliente...............................................................731
4.1.1 Uso de un socket TCP..................................................................... 731
4.1.2 Uso de un socket UDP......................................................................735
4.1.3 Creación de un servidor T C P .........................................................737
4.1.4 Creación de un servidor UDP.........................................................739
4.1.5 Un poco más allá.............................................................................. 740
4.2 Utilizar un protocolo estándar................................................................... 741
4.2.1 H TTP..................................................................................................741
4.2.2 Proxy....................................................................................................745
4.2.3 Cookies................................................................................................746
4.2.4 FTPySFTP.........................................................................................746
4.2.5 SSH...................................................................................................... 748
4.2.6 POP y POPS.......................................................................................750
4.2.7 IMAPelMAPS.................................................................................. 751
4.2.8 SMTP y SMTPS................................................................................ 753
4.2.9 NNTP..................................................................................................757
4.2.10 I RC. . . . . ...........................................................................................758
4.3 Servicios web..................................................................................................761
4.3.1 REST....................................................................................................761
4.3.2 SO AP................................................................................................. 762
4.3.3 Pyro......................................................................................................763
5. Uso de hardware....................................................................................................764
5.1 Wake-on-LAN...............................................................................................764
5.1.1 Requisitos previos............................................................................764
5.1.2 Implementación................................................................................765
5.2 Uso del puerto serie.................................................................................... 765

26-------------------------------Python 3
Capítulo 4.5
Programación asincrona
1. Utilidad de la programación asincrona............................................................... 767
2. Ejemplo de trabajo.................................................................................................. 768
3. Ejemplo modificado utilizando generadores.................................................... 770
4. Ejemplo modificado con programación asincrona para Python 3 .4 .............771
5. Ejemplo modificado con programación asincrona paraPython 3 .5 .............773
6. Para ir más lejos..................................................................................................... 774
Capítulo A.6
Programación científica
1. Cálculo científico.............................................................................................................. 777
1.1 Presentación.............................................................................................................. 777
1.2 Python, una alternativa libre y creíble............................................................778
1.3 Visión general de algunas librerías...................................................................778
2. Arrays multidimensionales...........................................................................................779
2.1 Creación......................................................................................................................779
2.2 Determinar la composición de un a rra y .......................................................780
2.3 Generador de array s..............................................................................................781
2.4 Operaciones b á sicas..............................................................................................782
2.5 Operador corchete.................................................................................................. 784
3. M atrices...............................................................................................................................787
4. Generación de gráficos.....................................................................................................788
4.1 Sintaxis M ATLAB.................................................................................................. 788
4.2 Sintaxis orientada a objetos...............................................................................789
4.3 Com posición............................................................................................................790
4.4 Gráficos ......................................................................................................................794

Capítulo 4.7
Buenas prácticas
1. Desarrollo guiado por pruebas............................................................................ 799
1.1 Pruebas unitarias........................................................................................... 799
1.1.1 Principios........................................................................................... 799
1.1.2 Interpretación...................................................................................800
1.1.3 Cobertura........................................................................................... 801
1.1.4 Herramientas.....................................................................................801
1.1.5 Otras herramientas..........................................................................803
1.2 Pruebas de regresión.....................................................................................803
1.2.1 Acciones de desarrollo......................................................................803
1.2.2 Gestión de las anomalías detectadas........................................... 804
1.3 Pruebas funcionales.....................................................................................805
1.4 Pruebas de rendimiento.............................................................................. 806
1.5 Integración continua...................................................................................808
2. Programación dirigida por la documentación..................................................809
2.1 Documentación interna.............................................................................. 809
2.1.1 Destinada a los desarrolladores...................................................... 809
2.1.2 Destinada a los usuarios.................................................................809
2.2 Documentación externa.............................................................................. 810
2.2.1 Presentación.......................................................................................810
2.2.2 Inicio rápido.......................................................................................810
2.2.3 Resultado........................................................................................... 812
3. Optimización.......................................................................................................... 813
3.1 Medir la calidad............................................................................................. 813
3.2 Herramientas de depuración..................................................................... 815
3.3 Herramientas de perfilado..........................................................................815
3.4 Reglas de optimización................................................................................ 817
3.4.1 ¿Por qué optimizar?..........................................................................817
3.4.2 Reglas generales................................................................................ 818
3.4.3 Optimizar un algoritmo.................................................................819
3.4.4 Optimizar el uso de la memoria....................................................828
Contenido----------------------------------------------------- 27

Parte S: Práctica
Capítulo 5.1
Crear una aplicación web en 30 minutos
1. Descripción de la aplicación que se va a construir...........................................831
2. Implementación......................................................................................................832
2.1 Aislar el entorno..........................................................................................832
2.2 Creación del proyecto..................................................................................833
2.3 Configuración............................................................................................... 833
2.4 Primeros ensayos...........................................................................................834
3. Realizar la aplicación............................................................................................. 835
3.1 Modelos..........................................................................................................835
3.2 Vistas.............................................................................................................. 838
3.3 Controladores............................................................................................... 839
4. Para ir más allá........................................................................................................844
Capítulo 5.2
Crear una aplicación de consola en 10 minutos
1. Objetivo...................................................................................................................845
2. Registrar el script....................................................................................................846
3. Creación de los datos............................................................................................. 846
4. Parser de argumentos.............................................................................................847
Capítulo 5.3
Crear una aplicación gráfica en 20 minutos
1. Objetivo...................................................................................................................849
1.1 Funcional........................................................................................................849
1.2 Técnica............................................................................................................ 849
2. Breve presentación de Gtk y algunos trucos................................................... 850
2.1 Presentación....................................................................................................850
2.2 Trucos.................................. ....................................................................... 850
3. Iniciar el programa................................................................................................. 851
4. Interfaz gráfica con Glade.................................................................................... 854
5. Crear el componente gráfico................................................................................856
28---------------------------------- Python 3

Python 3 los fundamentos del lenguaje.pdf

Python 3 los fundamentos del lenguaje.pdf

Recomendados

Recomendados

Más contenido relacionado

Similar a Python 3 los fundamentos del lenguaje.pdf

Similar a Python 3 los fundamentos del lenguaje.pdf (20)

Último

Último (20)

Python 3 los fundamentos del lenguaje.pdf