Se encuentra usted aquí

Python 3 - Los fundamentos del lenguaje

Páginas: 
860
ISBN: 
978-2-7460-9427-7
Año: 
2015
Precio: 
38.90€
Editorial: 
Descripción: 

Este libro acerca de los fundamentos del lenguaje Python 3 está dirigido a aquellos profesionales de la informática, ingenieros, estudiantes, profesores o incluso personas autodidactas que deseen conocer y dominar este lenguaje, muy extendido. Cubre un perímetro relativamente amplio, detalla todo el núcleo del lenguaje y del procesamiento de los datos y abre perspectivas importantes sobre todo lo que permite realizar Python 3 (desde la creación de sitios web hasta el desarrollo de juegos, pasando por el diseño de una interfaz gráfica con Gtk). El libro se centra en la rama 3 de Python; no obstante, como el lenguaje Python 2 todavía está muy presente, el autor presenta, cuando existen, las principales diferencias con la rama anterior de Python.

La primera parte del libro detalla las capacidades de Python 3 para responder a las necesidades de las empresas sea cual sea el dominio de la informática en que se trabaje.

La segunda parte describe los fundamentos del lenguaje: las distintas nociones se presentan de manera progresiva, con ejemplos de código que ilustran cada punto. El autor ha querido que el lector alcance una autonomía real en su aprendizaje, y cada noción se presenta con dos objetivos distintos: permitir a aquél que no conozca un concepto determinado aprenderlo correctamente, respetando su rol, y permitir a quien ya lo conozca encontrar ángulos de ataque originales para ir más allá en su posible explotación.

La tercera parte permite utilizar Python 3 para resolver problemáticas de negocio concretas y, por tanto, explica cómo utilizar todos los complementos de Python 3 (protocolos, servidores, imágenes,…). En esta parte, el hilo conductor es la funcionalidad y no el módulo en sí; cada capítulo se centra en la manera de explotar una funcionalidad utilizando uno o varios módulos y presenta una metodología, pero no se centra en una descripción anatómica de los módulos en sí. Los módulos abordados en esta sección son aquellos ya migrados a Python 3 así como las funcionalidades que, actualmente, están maduras en esta versión del lenguaje.

Por último, la última parte del libro es un vasto tutorial que permite poner en práctica, en un marco de trabajo profesional, todo lo que se ha visto anteriormente creando aplicaciones que cubren todos los dominios habituales en el desarrollo (datos, Web con Pyramid, interfaz gráfica con Gtk, scripts de sistema…) y presentar, de este modo, soluciones eficaces de desarrollo basadas en Python 3.

Contenidos: 
  • Prólogo
    • 1. Contenido del libro
    • 2. Progresión del libro
    • 3. Destinado a profesores y alumnos
    • 4. Destinado a investigadores y doctores
    • 5. Destinado a aquellos que vienen de otro lenguaje
  • Python en el paisaje informático
    • 1. Breve historia de los lenguajes informáticos
      • 1.1 Informática teórica
      • 1.2 Cronología de la informática
        • 1.2.1 Evolución de las problemáticas vinculadas a la informática
        • 1.2.2 Cronología de los lenguajes informáticos
      • 1.3 Historia de Python
        • 1.3.1 Génesis
        • 1.3.2 Extensión del perímetro funcional
        • 1.3.3 Evolución de la licencia
        • 1.3.4 Porvenir
    • 2. Tipología de los lenguajes de programación
      • 2.1 Paradigmas
        • 2.1.1 Definición
        • 2.1.2 Paradigma imperativo y derivados
        • 2.1.3 Paradigma orientado a objetos y derivados
        • 2.1.4 Programación orientada a aspectos
        • 2.1.5 Paradigma funcional
        • 2.1.6 Paradigma lógico
        • 2.1.7 Programación concurrente
        • 2.1.8 Síntesis
      • 2.2 Interoperabilidad
      • 2.3 Niveles de programación
        • 2.3.1 Máquina
        • 2.3.2 Bajo nivel
        • 2.3.3 Alto nivel
      • 2.4 Tipado
        • 2.4.1 Débil vs. fuerte
        • 2.4.2 Estático vs dinámico
      • 2.5 Gramática
        • 2.5.1 Lenguajes formales
        • 2.5.2 Sintaxis
    • 3. Ubicar Python en el paisaje informático
      • 3.1 Tipología de Python
        • 3.1.1 Gramática y sintaxis
        • 3.1.2 Tipado
        • 3.1.3 Nivel de programación
        • 3.1.4 Paradigmas soportados
      • 3.2 Posición estratégica del lenguaje Python
        • 3.2.1 Segmentos de mercado
        • 3.2.2 Nivel de complejidad
        • 3.2.3 Fortalezas del lenguaje
        • 3.2.4 Puntos débiles
      • 3.3 Integración con otros lenguajes
        • 3.3.1 Extensiones C
        • 3.3.2 Integración de programas escritos en C
        • 3.3.3 Integración de programas Python en C
        • 3.3.4 Integración de programas escritos en Java
        • 3.3.5 Integración de programas Python en Java
        • 3.3.6 Otras integraciones
  • Presentación de Python
    • 1. Filosofía
      • 1.1 Python en pocas líneas
        • 1.1.1 ¿ De dónde proviene el nombre «Python» ?
        • 1.1.2 Presentación técnica
        • 1.1.3 Presentación conceptual
      • 1.2 Comparación con otros lenguajes
        • 1.2.1 Shell
        • 1.2.2 Perl
        • 1.2.3 C, C++
        • 1.2.4 Java
        • 1.2.5 PHP
      • 1.3 Grandes principios
        • 1.3.1 El zen de Python
        • 1.3.2 El desarrollador no es estúpido
        • 1.3.3 Documentación
        • 1.3.4 Python viene con todo incluido
        • 1.3.5 Duck Typing
        • 1.3.6 Noción de código pythónico
    • 2. Gobierno
      • 2.1 Desarrollo
        • 2.1.1 Ramas
        • 2.1.2 Comunidad
      • 2.2 Modo de gobierno
        • 2.2.1 Creador del lenguaje
        • 2.2.2 PEP
        • 2.2.3 Toma de decisiones
    • 3. ¿ Qué contiene Python ?
      • 3.1 Una gramática y una sintaxis
      • 3.2 Varias implementaciones
      • 3.3 Una librería estándar
      • 3.4 Librerías de terceros
      • 3.5 Frameworks
    • 4. Fases de ejecución de un programa Python
      • 4.1 Carga de la máquina virtual
      • 4.2 Compilación
      • 4.3 Interpretación
  • Por qué escoger Python
    • 1. Cualidades del lenguaje
      • 1.1 Cobertura funcional
      • 1.2 Puerta de entrada
      • 1.3 Garantías
    • 2. Difusión
      • 2.1 Empresas
      • 2.2 El mundo de la investigación
      • 2.3 El mundo de la educación
      • 2.4 Comunidad
    • 3. Referencias
      • 3.1 Pesos pesados en la industria informática
        • 3.1.1 Google
        • 3.1.2 Mozilla
        • 3.1.3 Microsoft
        • 3.1.4 Canonical
        • 3.1.5 Cisco
      • 3.2 Empresas de innovación
        • 3.2.1 Servicios de almacenamiento en línea
        • 3.2.2 Cloud computing
        • 3.2.3 Plataforma colaborativa (Forge)
        • 3.2.4 Redes sociales
      • 3.3 Editores de contenidos
        • 3.3.1 Disney Animation Studio
        • 3.3.2 YouTube
        • 3.3.3 Box ADSL
        • 3.3.4 Spotify
      • 3.4 Fabricantes de software
    • 4. Experiencia
      • 4.1 Impresiones
      • 4.2 Desarrollo en un contexto heterogéneo
      • 4.3 Desarrollo rápido
      • 4.4 Venta de desarrollos en Python
      • 4.5 Navegar por lo desconocido
  • Instalar el entorno de desarrollo
    • 1. Instalar Python
      • 1.1 Windows
      • 1.2 Mac OS
      • 1.3 UNIX/Linux
      • 1.4 Compilación
      • 1.5 Compilación de Python 3.4
    • 2. Instalar librerías externas
      • 2.1 Instalador o administrador de paquetes
      • 2.2 PIP
      • 2.3 Entorno virtual
    • 3. Instalar un IDE
      • 3.1 Consola y herramientas asociadas
      • 3.2 Eclipse + PyDev
      • 3.3 Aptana
      • 3.4 Eric
      • 3.5 PyCharm
      • 3.6 Otras soluciones
      • 3.7 StacklessPython
      • 3.8 Entorno heterogéneo
    • 4. Uso de la consola
      • 4.1 Consola estándar
      • 4.2 iPython
    • 5. Distribuir sus propias aplicaciones
      • 5.1 Herramienta de distribución
      • 5.2 Creación de paquetes distribuibles
      • 5.3 Distribución binaria para Windows
      • 5.4 Distribución binaria para Mac
      • 5.5 Distribución binaria multiplataforma
      • 5.6 Distribución específica para un entorno
  • Algoritmos básicos
    • 1. Delimitadores
      • 1.1 Instrucción
      • 1.2 Una línea de código = una instrucción
      • 1.3 Comentario
      • 1.4 Una instrucción en varias líneas
      • 1.5 Palabras clave
      • 1.6 Palabras reservadas
      • 1.7 Indentación
      • 1.8 Símbolos
      • 1.9 Operadores
      • 1.10 Uso del carácter de subrayado
      • 1.11 PEP-8
      • 1.12 PEP-7
      • 1.13 PEP-257
    • 2. Instrucciones
      • 2.1 Definiciones
        • 2.1.1 Variable
        • 2.1.2 Función
        • 2.1.3 Funciones lambda
        • 2.1.4 Clase
        • 2.1.5 Instrucción vacía
        • 2.1.6 Borrado
        • 2.1.7 Devolver el resultado de la función
      • 2.2 Instrucciones condicionales
        • 2.2.1 Definición
        • 2.2.2 Condición
        • 2.2.3 Instrucción if
        • 2.2.4 Instrucción elif
        • 2.2.5 Instrucción else
        • 2.2.6 Instrucción switch
        • 2.2.7 Interrupciones
        • 2.2.8 Profundizando en las condiciones
        • 2.2.9 Rendimiento
      • 2.3 Iteraciones
        • 2.3.1 Instrucción for
        • 2.3.2 Instrucción while
        • 2.3.3 Diferencias entre for y while
        • 2.3.4 Instrucción break
        • 2.3.5 Instrucción return
        • 2.3.6 Instrucción continue
        • 2.3.7 Instrucción else
        • 2.3.8 Generadores
      • 2.4 Construcciones funcionales
        • 2.4.1 Generadores
        • 2.4.2 Recorrido de listas
        • 2.4.3 Recorrido de conjuntos
        • 2.4.4 Recorrido de diccionarios
      • 2.5 Gestión de excepciones
        • 2.5.1 Breve presentación de las excepciones
        • 2.5.2 Elevar una excepción
        • 2.5.3 ¿ Por qué elevar una excepción ?
        • 2.5.4 Aserciones
        • 2.5.5 Capturar una excepción
        • 2.5.6 Manejar una excepción
        • 2.5.7 Gestionar la salida del bloque de captura
        • 2.5.8 Gestionar que no se produzcan excepciones
        • 2.5.9 Uso y liberación de recursos
      • 2.6 Otros
        • 2.6.1 Gestionar imports
        • 2.6.2 Compartir espacios de nombres
        • 2.6.3 Funciones print, help, eval y exec
  • Declaraciones
    • 1. Variable
      • 1.1 ¿ Qué es una variable ?
        • 1.1.1 Contenido
        • 1.1.2 Continente
        • 1.1.3 Formas de modificar una variable
      • 1.2 Tipado dinámico
        • 1.2.1 Asignación: recordatorio
        • 1.2.2 Primitiva type y naturaleza del tipo
        • 1.2.3 Características del tipado Python
      • 1.3 Visibilidad
        • 1.3.1 Espacio global
        • 1.3.2 Noción de bloque
    • 2. Función
      • 2.1 Declaración
      • 2.2 Parámetros
        • 2.2.1 Firma de una función
        • 2.2.2 Noción de argumento o de parámetro
        • 2.2.3 Valor por defecto
        • 2.2.4 Parámetros nombrados
        • 2.2.5 Declaración de parámetros extensibles
        • 2.2.6 Paso de parámetros con asterisco
        • 2.2.7 Firma universal
        • 2.2.8 Obligar a un parámetro a ser nombrado (keyword-only)
        • 2.2.9 Anotaciones
    • 3. Clase
      • 3.1 Declaración
        • 3.1.1 Firma
        • 3.1.2 Atributo
        • 3.1.3 Método
        • 3.1.4 Bloque local
      • 3.2 Instanciación
        • 3.2.1 Sintaxis
        • 3.2.2 Relación entre la instancia y la clase
    • 4. Módulo
      • 4.1 Declaración
      • 4.2 Instrucciones específicas
      • 4.3 ¿ Cómo conocer el contenido de un módulo ?
  • Modelo de objetos
    • 1. Todo es un objeto
      • 1.1 Principios
        • 1.1.1 Qué sentido dar a «objeto»
        • 1.1.2 Adaptación de la teoría de objetos en Python
        • 1.1.3 Generalidades
      • 1.2 Clases
        • 1.2.1 Introducción
        • 1.2.2 Declaración imperativa de una clase
        • 1.2.3 Instancia
        • 1.2.4 Objeto en curso
        • 1.2.5 Declaración por prototipo de una clase
      • 1.3 Métodos
        • 1.3.1 Declaración
        • 1.3.2 Invocar al método
        • 1.3.3 Métodos y atributos especiales
        • 1.3.4 Constructor e inicializador
        • 1.3.5 Gestión automática de atributos
        • 1.3.6 Interés del paradigma orientado a objetos
        • 1.3.7 Relación entre objetos
      • 1.4 Herencia
        • 1.4.1 Polimorfismo por subtipado
        • 1.4.2 Sobrecarga de métodos
        • 1.4.3 Sobrecarga de operadores
        • 1.4.4 Polimorfismo paramétrico
        • 1.4.5 Herencia múltiple
    • 2. Otras herramientas de la programación orientada a objetos
      • 2.1 Principios
      • 2.2 Interfaces
      • 2.3 Atributos
      • 2.4 Propiedades
      • 2.5 Ubicaciones
      • 2.6 Metaclases
      • 2.7 Clases abstractas
      • 2.8 Zope Component Architecture
        • 2.8.1 Presentación
        • 2.8.2 Instalación
        • 2.8.3 Definir una interfaz y un componente
        • 2.8.4 Otras funcionalidades
        • 2.8.5 Ventajas de la ZCA
    • 3. Funciones principales y primitivas asociadas
      • 3.1 Personalización
        • 3.1.1 Clases
        • 3.1.2 Instancias
        • 3.1.3 Comparación
        • 3.1.4 Evaluación booleana
        • 3.1.5 Relaciones de herencia o de clase a instancia
      • 3.2 Clases particulares
        • 3.2.1 Iterador
        • 3.2.2 Contenedores
        • 3.2.3 Instancias similares a funciones
        • 3.2.4 Recursos que hay que proteger
        • 3.2.5 Tipos
  • Tipos de datos y algoritmos aplicados
    • 1. Números
      • 1.1 Tipos
        • 1.1.1 Enteros
        • 1.1.2 Reales
        • 1.1.3 Cosas en común entre números enteros y reales
        • 1.1.4 Métodos dedicados a los números enteros
        • 1.1.5 Métodos dedicados a los números reales
        • 1.1.6 Complejos
      • 1.2 La consola Python, la calculadora por excelencia
        • 1.2.1 Operadores matemáticos binarios
        • 1.2.2 Operadores binarios particulares
        • 1.2.3 Operadores matemáticos unarios
        • 1.2.4 Redondeo
        • 1.2.5 Operadores de comparación
        • 1.2.6 Operaciones matemáticas n-arias
        • 1.2.7 Funciones matemáticas usuales
      • 1.3 Representaciones de un número
        • 1.3.1 Representación decimal
        • 1.3.2 Representación por un exponente
        • 1.3.3 Representación por una fracción
        • 1.3.4 Representación hexadecimal
        • 1.3.5 Representación octal
        • 1.3.6 Representación binaria
        • 1.3.7 Operaciones binarias
        • 1.3.8 Longitud de la representación en memoria de un entero
      • 1.4 Conversiones
        • 1.4.1 Conversión entre enteros y reales
        • 1.4.2 Conversión entre reales y complejos
        • 1.4.3 Conversión en un booleano
      • 1.5 Trabajar con variables
        • 1.5.1 Un número es inmutable
        • 1.5.2 Modificar el valor de una variable
        • 1.5.3 Operadores incrementales
      • 1.6 Estadísticas
      • 1.7 Cálculo científico
        • 1.7.1 El cálculo científico ¿ para qué hacerlo ?
        • 1.7.2 Python, una alternativa libre y con credibilidad
        • 1.7.3 Algunas librerías
    • 2. Secuencias
      • 2.1 Presentación de los distintos tipos de secuencias
        • 2.1.1 Generalidades
        • 2.1.2 Las listas
        • 2.1.3 Las n-tuplas
        • 2.1.4 Conversión entre listas y n-tuplas
        • 2.1.5 Cosas en común entre una lista y una n-tupla
        • 2.1.6 Noción de iterador
      • 2.2 Uso de índices y tramos
        • 2.2.1 Definición de índice de un objeto y sus ocurrencias
        • 2.2.2 Utilizar el índice para recorrer la secuencia
        • 2.2.3 Encontrar las ocurrencias de un objeto y sus índices
        • 2.2.4 Tamaño de una lista, contar ocurrencias
        • 2.2.5 Utilizar el índice para modificar o eliminar
        • 2.2.6 Iteración simple
        • 2.2.7 Presentación de la noción de tramos (slices)
        • 2.2.8 Caso particular de la rama 2.x de Python
        • 2.2.9 Uso básico de tramos
        • 2.2.10 Uso avanzado de tramos
      • 2.3 Uso de operadores
        • 2.3.1 Operador +
        • 2.3.2 Operador *
        • 2.3.3 Operador +=
        • 2.3.4 Operador *=
        • 2.3.5 Operador in
        • 2.3.6 Operadores de comparación
      • 2.4 Métodos de modificación
        • 2.4.1 Agregar elementos a una lista y a una n-tupla
        • 2.4.2 Eliminar un objeto de una lista y de una n-tupla
        • 2.4.3 Soluciones alternativas para la modificación de n-tuplas
        • 2.4.4 Invertir una lista o una tupla
        • 2.4.5 Ordenar una lista
      • 2.5 Uso avanzado de listas
        • 2.5.1 Operaciones de conjunto
        • 2.5.2 Pivotar una secuencia
        • 2.5.3 Iterar correctamente
        • 2.5.4 Programación funcional
        • 2.5.5 Recorrido de listas
        • 2.5.6 Iteraciones avanzadas
        • 2.5.7 Combinatoria
      • 2.6 Adaptar las listas a necesidades específicas
        • 2.6.1 Lista de enteros
        • 2.6.2 Presentación del tipo array
        • 2.6.3 Utilizar una lista como una pila
        • 2.6.4 Utilizar una lista como una lista de espera
        • 2.6.5 Utilizar las listas para representar matrices
        • 2.6.6 Lista sin duplicados
      • 2.7 Otros tipos de datos
    • 3. Conjuntos
      • 3.1 Presentación
        • 3.1.1 Definición de un conjunto
        • 3.1.2 Diferencias entre set y frozenset
        • 3.1.3 Uso para eliminar valores duplicados de las listas
        • 3.1.4 Agregar una relación de orden
      • 3.2 Operaciones sobre conjuntos
        • 3.2.1 Operadores para un conjunto a partir de otros dos
        • 3.2.2 Operadores para modificar un conjunto a partir de otro
        • 3.2.3 Métodos equivalentes a la creación o modificación de conjuntos
        • 3.2.4 Métodos de comparación de conjuntos
        • 3.2.5 Ejemplos de uso poco clásicos
      • 3.3 Métodos de modificación de un conjunto
        • 3.3.1 Agregar un elemento
        • 3.3.2 Eliminar un elemento
        • 3.3.3 Vaciar un conjunto
        • 3.3.4 Duplicar un elemento
        • 3.3.5 Sacar un valor de un conjunto
        • 3.3.6 Utilizar un conjunto como un almacén de objetos
        • 3.3.7 Algorítmica avanzada: resolución del problema de las n reinas
    • 4. Cadenas de caracteres
      • 4.1 Presentación
        • 4.1.1 Definición
        • 4.1.2 Vocabulario
        • 4.1.3 Especificidades de la rama 2.x
        • 4.1.4 Cambios aportados por la rama 3.x
        • 4.1.5 Cadena de caracteres como secuencia de caracteres
        • 4.1.6 Caracteres
        • 4.1.7 Operadores de comparación
      • 4.2 Dar formato a cadenas de caracteres
        • 4.2.1 Operador módulo
        • 4.2.2 Métodos para dar formato al conjunto de la cadena
        • 4.2.3 Nuevo método para dar formato a variables en una cadena
      • 4.3 Operaciones de conjunto
        • 4.3.1 Secuenciación de cadenas
        • 4.3.2 Operaciones sobre mayúsculas y minúsculas
        • 4.3.3 Búsqueda en una cadena de caracteres
        • 4.3.4 Información sobre los caracteres
      • 4.4 Problemáticas relativas a la codificación
        • 4.4.1 Codificación por defecto
        • 4.4.2 Codificación del sistema
        • 4.4.3 Unicode, referencia absoluta
        • 4.4.4 Otras codificaciones
        • 4.4.5 Puntos entre el Unicode y el resto del mundo
        • 4.4.6 Volver a Unicode
      • 4.5 Manipulaciones de bajo nivel avanzadas
        • 4.5.1 Operaciones para contar
        • 4.5.2 Una cadena de caracteres vista como una lista
        • 4.5.3 Una cadena de caracteres vista como un conjunto de caracteres
      • 4.6 Representación en memoria
        • 4.6.1 Presentación del tipo bytes
        • 4.6.2 Vínculo con las cadenas de caracteres
        • 4.6.3 Presentación del tipo bytearray
        • 4.6.4 Gestión de un juego de caracteres
    • 5. Diccionarios
      • 5.1 Presentación
        • 5.1.1 Definición
        • 5.1.2 Evolución y diferencias entre las ramas 2.x y 3.x
        • 5.1.3 Vistas de diccionarios
        • 5.1.4 Instanciación
        • 5.1.5 Recorrer un diccionario
      • 5.2 Manipular un diccionario
        • 5.2.1 Recuperar un valor de un diccionario
        • 5.2.2 Modificar los valores de un diccionario
        • 5.2.3 Eliminar una entrada de un diccionario
        • 5.2.4 Duplicar un diccionario
        • 5.2.5 Utilizar un diccionario como un agregador de datos
        • 5.2.6 Métodos de iteración
      • 5.3 Uso avanzado de diccionarios
        • 5.3.1 Agregar una relación de orden
        • 5.3.2 Algorítmica clásica
        • 5.3.3 Adaptar los diccionarios a necesidades específicas
        • 5.3.4 Representación universal de datos
    • 6. Booleanos
      • 6.1 El tipo booleano
        • 6.1.1 Clase bool
        • 6.1.2 Los dos objetos True y False
        • 6.1.3 Diferencia entre el operador de igualdad y de identidad
      • 6.2 Evaluación booleana
        • 6.2.1 Método genérico
        • 6.2.2 Objetos clásicos
    • 7. Datos temporales
      • 7.1 Gestionar una fecha del calendario
        • 7.1.1 Noción de fecha del calendario
        • 7.1.2 Trabajar con una fecha
        • 7.1.3 Consideraciones astronómicas
        • 7.1.4 Consideraciones históricas
        • 7.1.5 Consideraciones técnicas
        • 7.1.6 Representación textual
      • 7.2 Gestionar un horario o un momento de la jornada
        • 7.2.1 Noción de instante
        • 7.2.2 Noción de huso horario
        • 7.2.3 Representación textual
      • 7.3 Gestionar un instante absoluto
        • 7.3.1 Noción de instante absoluto
        • 7.3.2 Relación con las nociones anteriores
        • 7.3.3 Representación textual
        • 7.3.4 Gestión de los husos horarios
        • 7.3.5 Crear una fecha a partir de una representación textual
      • 7.4 Gestionar una diferencia entre dos fechas o instantes
        • 7.4.1 Noción de diferencia y de resolución
        • 7.4.2 Consideraciones técnicas
        • 7.4.3 Uso con fechas del calendario
        • 7.4.4 Uso con horarios
        • 7.4.5 Uso con fechas absolutas
        • 7.4.6 El segundo como unidad básica
      • 7.5 Especificidades de los husos horarios
      • 7.6 Problemáticas de bajo nivel
        • 7.6.1 Timestamp y struct_time
        • 7.6.2 Medidas de rendimiento
      • 7.7 Uso del calendario
        • 7.7.1 Presentación del módulo calendar
        • 7.7.2 Funciones esenciales del calendario
  • Patrones de diseño
    • 1. Definición
      • 1.1 Situación respecto a la noción de objeto
      • 1.2 Organización del capítulo
      • 1.3 Situación respecto a otros conceptos
    • 2. Creación
      • 2.1 Singleton
      • 2.2 Fábrica
        • 2.2.1 Presentación de la problemática
        • 2.2.2 Soluciones
        • 2.2.3 Conclusiones
      • 2.3 Fábrica abstracta
        • 2.3.1 Presentación de la problemática
        • 2.3.2 Solución
      • 2.4 Constructor
        • 2.4.1 Presentación de la problemática
        • 2.4.2 Solución
        • 2.4.3 Conclusiones
      • 2.5 Prototipo
        • 2.5.1 Presentación de la problemática
        • 2.5.2 Solución
        • 2.5.3 Conclusiones
    • 3. Estructuración
      • 3.1 Adaptador
        • 3.1.1 Presentación de la problemática
        • 3.1.2 Solución
        • 3.1.3 Conclusiones
      • 3.2 Puente
        • 3.2.1 Presentación de la problemática
        • 3.2.2 Solución
        • 3.2.3 Conclusiones
      • 3.3 Composite
        • 3.3.1 Presentación de la problemática
        • 3.3.2 Solución
        • 3.3.3 Conclusiones
      • 3.4 Decorador
        • 3.4.1 Presentación de la problemática
        • 3.4.2 Solución
        • 3.4.3 Conclusiones
      • 3.5 Fachada
        • 3.5.1 Presentación de la problemática
        • 3.5.2 Solución
        • 3.5.3 Conclusiones
      • 3.6 Peso mosca
        • 3.6.1 Presentación de la problemática
        • 3.6.2 Solución
        • 3.6.3 Conclusiones
      • 3.7 Proxy
        • 3.7.1 Presentación de la problemática
        • 3.7.2 Solución
        • 3.7.3 Conclusiones
    • 4. Comportamiento
      • 4.1 Cadena de responsabilidad
        • 4.1.1 Presentación de la problemática
        • 4.1.2 Solución
        • 4.1.3 Conclusiones
      • 4.2 Solicitud
        • 4.2.1 Presentación de la problemática
        • 4.2.2 Solución
        • 4.2.3 Conclusiones
      • 4.3 Iterador
        • 4.3.1 Presentación de la problemática
        • 4.3.2 Solución
        • 4.3.3 Conclusiones
      • 4.4 Memento
        • 4.4.1 Presentación de la problemática
        • 4.4.2 Solución
        • 4.4.3 Conclusiones
      • 4.5 Visitante
        • 4.5.1 Presentación de la problemática
        • 4.5.2 Solución
        • 4.5.3 Conclusiones
      • 4.6 Observador
        • 4.6.1 Presentación de la problemática
        • 4.6.2 Solución
        • 4.6.3 Conclusiones
      • 4.7 Estrategia
        • 4.7.1 Presentación de la problemática
        • 4.7.2 Solución
        • 4.7.3 Conclusiones
      • 4.8 Retrollamada
        • 4.8.1 Presentación de la problemática
        • 4.8.2 Solución
        • 4.8.3 Conclusiones
    • 5. ZCA
      • 5.1 Consideraciones
      • 5.2 Adaptador
        • 5.2.1 Declaración
        • 5.2.2 Uso
      • 5.3 Utilidad
        • 5.3.1 Declaración
        • 5.3.2 Uso
      • 5.4 Fábrica
        • 5.4.1 Declaración
        • 5.4.2 Uso
      • 5.5 Para ir más allá
  • Manipulación de datos
    • 1. Bases de datos
      • 1.1 Presentación
      • 1.2 Acceso a una base de datos relacional
        • 1.2.1 Punto de entrada
        • 1.2.2 MySQL
        • 1.2.3 PostgreSQL
        • 1.2.4 SQLite
        • 1.2.5 Oracle
      • 1.3 Uso de un ORM
        • 1.3.1 ¿ Qué es un ORM ?
        • 1.3.2 ORM propuestos por Python
        • 1.3.3 SQLAlchemy
      • 1.4 Otras bases de datos
        • 1.4.1 CSV
        • 1.4.2 NoSQL
        • 1.4.3 Base de datos orientada a objetos: ZODB
        • 1.4.4 Base de datos de tipo clave-valor: REDIS
        • 1.4.5 Bases de datos orientadas a documentos: CouchDB y MongoDB
    • 2. LDAP
      • 2.1 Presentación
        • 2.1.1 Protocolo
        • 2.1.2 Servidores
        • 2.1.3 Terminología
      • 2.2 Instalación
      • 2.3 Abrir una conexión a un servidor
      • 2.4 Realizar una búsqueda
      • 2.5 Síncrono vs asíncrono
      • 2.6 Conexiones seguras
    • 3. XML
      • 3.1 XML y las tecnologías relacionadas
        • 3.1.1 Definición de XML, terminología asociada
        • 3.1.2 Noción de esquema
        • 3.1.3 Ventajas e inconvenientes de XML
        • 3.1.4 Distintas maneras de recorrer un archivo XML
        • 3.1.5 Módulos Python dedicados a XML
      • 3.2 Validar un documento XML
        • 3.2.1 Documento XML
        • 3.2.2 Esquema DTD
        • 3.2.3 Esquema XSD
        • 3.2.4 Esquema RNG (RelaxNG)
        • 3.2.5 Schematron
      • 3.3 DOM
        • 3.3.1 Lectura
        • 3.3.2 Escritura
      • 3.4 SAX
        • 3.4.1 Soporte de SAX en lxml
        • 3.4.2 API SAX ligera
      • 3.5 XPath
      • 3.6 XSLT
      • 3.7 El caso concreto de los archivos HTML
        • 3.7.1 Problemática
        • 3.7.2 Parsear un archivo HTML según DOM
        • 3.7.3 Parsear un archivo HTML según SAX
    • 4. Herramientas de manipulación de datos
      • 4.1 Encriptar un dato
        • 4.1.1 Funciones de hash
        • 4.1.2 Código de autenticación del mensaje
        • 4.1.3 Esteganografía
      • 4.2 Generar números aleatorios
      • 4.3 Expresiones regulares
    • 5. Trabajar con medios gráficos
      • 5.1 Imágenes
        • 5.1.1 Representación informática de una imagen
        • 5.1.2 Presentación de Pillow
        • 5.1.3 Formatos de imágenes matriciales
        • 5.1.4 Recuperar la información de una imagen
        • 5.1.5 Operaciones de conjunto sobre una imagen
        • 5.1.6 Trabajar con capas o con píxeles
  • Generación de contenido
    • 1. PDF
      • 1.1 Presentación
        • 1.1.1 Formato PDF
        • 1.1.2 Ventajas
        • 1.1.3 Inconvenientes
        • 1.1.4 Presentación de la librería libre
      • 1.2 Bajo nivel
        • 1.2.1 Librería de datos
        • 1.2.2 Canvas
      • 1.3 Alto nivel
        • 1.3.1 Estilos
        • 1.3.2 Flujo de datos
        • 1.3.3 Creación de un elemento visual
        • 1.3.4 Plantilla de página
        • 1.3.5 Página que contiene varias zonas
    • 2. OpenDocument
      • 2.1 Instalación
      • 2.2 OpenDocument Texto
        • 2.2.1 Hello World
      • 2.3 OpenDocument Hoja de cálculo
        • 2.3.1 Principios generales respecto al texto
        • 2.3.2 Ir más allá
  • Programación paralela
    • 1. Terminología
      • 1.1 Proceso
      • 1.2 Tarea
    • 2. Uso de una tarea
      • 2.1 Gestión de una tarea
        • 2.1.1 Presentación
        • 2.1.2 Creación
      • 2.2 Gestión de varias tareas
        • 2.2.1 Arranque y control
        • 2.2.2 Oportunidad de utilizar una tarea
      • 2.3 Resolución de problemáticas asociadas
        • 2.3.1 Sincronización
        • 2.3.2 Sincronización condicional
        • 2.3.3 Semáforo
    • 3. Uso de procesos
      • 3.1 Gestión de un proceso
        • 3.1.1 Presentación
        • 3.1.2 Creación
      • 3.2 Gestión de varios procesos
        • 3.2.1 Sincronización
        • 3.2.2 Paralelizar un trabajo
      • 3.3 Resolución de problemáticas asociadas
        • 3.3.1 Comunicación interproceso
        • 3.3.2 Compartir datos entre procesos
      • 3.4 Oportunidad de utilizar los procesos
      • 3.5 Demonio
    • 4. Ejecución asíncrona
      • 4.1 Introducción
      • 4.2 Presentación
      • 4.3 Programación asíncrona
  • Programación de sistema y de red
    • 1. Presentación
      • 1.1 Definición
      • 1.2 Objetivos del capítulo
    • 2. Escribir scripts de sistema
      • 2.1 Conozca su sistema operativo
        • 2.1.1 Advertencia
        • 2.1.2 Sistema operativo
        • 2.1.3 Procesos en curso
        • 2.1.4 Usuarios y grupos
        • 2.1.5 Constantes para el sistema de archivos
        • 2.1.6 Gestionar las rutas
      • 2.2 Gestión de archivos
        • 2.2.1 Abrir un archivo
        • 2.2.2 Leer un archivo
        • 2.2.3 Escribir un archivo
        • 2.2.4 Cambiar los permisos de un archivo
        • 2.2.5 Cambiar de propietario o de grupo
        • 2.2.6 Recuperar información relativa al archivo
        • 2.2.7 Eliminar un archivo
      • 2.3 Alternativas sencillas a los comandos bash habituales
        • 2.3.1 Carpetas
        • 2.3.2 Archivos
        • 2.3.3 Módulo de alto nivel
        • 2.3.4 Buscar un archivo
      • 2.4 Ejecutar comandos externos
        • 2.4.1 Ejecutar y mostrar el resultado
        • 2.4.2 Ejecutar y recuperar el resultado
      • 2.5 Herramientas
        • 2.5.1 Diferencias entre archivos
        • 2.5.2 Herramienta de salvaguarda
        • 2.5.3 Leer un archivo de configuración
        • 2.5.4 Pickle
      • 2.6 Comprimir y descomprimir un archivo
        • 2.6.1 Tarfile
        • 2.6.2 Gzip
        • 2.6.3 Bz2
        • 2.6.4 Zipfile
        • 2.6.5 Interfaz de alto nivel
    • 3. Trabajar con argumentos
      • 3.1 Presentación
      • 3.2 Implementación
    • 4. Programación de red
      • 4.1 Escribir un servidor y un cliente
        • 4.1.1 Uso de un socket TCP
        • 4.1.2 Uso de un socket UDP
        • 4.1.3 Creación de un servidor TCP
        • 4.1.4 Creación de un servidor UDP
        • 4.1.5 Un poco más allá
      • 4.2 Utilizar un protocolo estándar
        • 4.2.1 HTTP
        • 4.2.2 Proxy
        • 4.2.3 Cookies
        • 4.2.4 FTP y SFTP
        • 4.2.5 SSH
        • 4.2.6 POP y POPS
        • 4.2.7 IMAP e IMAPS
        • 4.2.8 SMTP y SMTPS
        • 4.2.9 NNTP
        • 4.2.10 IRC
      • 4.3 Servicios web
        • 4.3.1 REST
        • 4.3.2 SOAP
        • 4.3.3 Pyro
    • 5. Uso de hardware
      • 5.1 Wake-on-LAN
        • 5.1.1 Requisitos previos
        • 5.1.2 Implementación
      • 5.2 Uso del puerto serie
  • Buenas prácticas
    • 1. Desarrollo guiado por pruebas
      • 1.1 Pruebas unitarias
        • 1.1.1 Principios
        • 1.1.2 Interpretación
        • 1.1.3 Cobertura
        • 1.1.4 Herramientas
      • 1.2 Pruebas de no regresión
        • 1.2.1 Acciones de desarrollo
        • 1.2.2 Gestión de las anomalías detectadas
      • 1.3 Pruebas funcionales
      • 1.4 Pruebas de rendimiento
      • 1.5 Integración continua
    • 2. Programación dirigida por la documentación
      • 2.1 Documentación interna
        • 2.1.1 Destinada a los desarrolladores
        • 2.1.2 Destinada a los usuarios
      • 2.2 Documentación externa
        • 2.2.1 Presentación
        • 2.2.2 Inicio rápido
        • 2.2.3 Resultado
    • 3. Optimización
      • 3.1 Medir la calidad
      • 3.2 Herramientas de depuración
      • 3.3 Herramientas de perfilado
      • 3.4 Reglas de optimización
        • 3.4.1 ¿ Por qué optimizar ?
        • 3.4.2 Reglas generales
        • 3.4.3 Optimizar un algoritmo
        • 3.4.4 Optimizar el uso de la memoria
  • Crear una aplicación web en 30 minutos
    • 1. Descripción de la aplicación que se va a construir
    • 2. Implementación
      • 2.1 Aislar el entorno
      • 2.2 Creación del proyecto
      • 2.3 Configuración
      • 2.4 Primeros ensayos
    • 3. Realizar la aplicación
      • 3.1 Modelos
      • 3.2 Vistas
      • 3.3 Controladores
    • 4. Para ir más allá
  • Crear una aplicación de consola en 10 minutos
    • 1. Objetivo
    • 2. Registrar el script
    • 3. Creación de los datos
    • 4. Parser de argumentos
  • Crear una aplicación gráfica en 20 minutos
    • 1. Objetivo
      • 1.1 Funcional
      • 1.2 Técnica
    • 2. Breve presentación de Gtk y algunos trucos
      • 2.1 Presentación
      • 2.2 Trucos
    • 3. Iniciar el programa
    • 4. Interfaz gráfica con Glade
    • 5. Crear el componente gráfico
    • 6. Controlador
    • 7. Otras librerías gráficas
      • 7.1 TkInter
      • 7.2 wxPython
      • 7.3 PyQt
      • 7.4 PySide
      • 7.5 Otras
  • Crear un juego en 30 minutos con PyGame
    • 1. Presentación de PyGame
    • 2. Construcción de un juego Tetris
      • 2.1 Presentación del juego
      • 2.2 Presentación de la problemática
      • 2.3 Creación de constantes
  • Anexos
    • 1. Tabla UNICODE
      • 1.1 Script
    • 2. Bytes
      • 2.1 Script
      • 2.2 Resultado
      •  
      • índice

Añadir nuevo comentario

Filtered HTML

  • Las direcciones de las páginas web y las de correo se convierten en enlaces automáticamente.
  • Etiquetas HTML permitidas: <a> <em> <strong> <cite> <blockquote> <code> <ul> <ol> <li> <dl> <dt> <dd>
  • Saltos automáticos de líneas y de párrafos.

Plain text

  • No se permiten etiquetas HTML.
  • Las direcciones de las páginas web y las de correo se convierten en enlaces automáticamente.
  • Saltos automáticos de líneas y de párrafos.