1. Libros
  2. Python 3 - Los fundamentos del lenguaje (3a edición)

Python 3 Los fundamentos del lenguaje (3a edición)

  • Acceso ilimitado 24/7
  • Todos los libros online de ENI
  • Más de 5 novedades todos los meses
  • Novedades disponibles el mismo día de su publicación
  • Acceso 100% online
  • Disponible
  • Expedido en 24 horas
  • Envío gratis a partir de 25 € de compra
  • Versión online gratis por un año
  • Acceso gratuito a todos nuestros libros online durante 1 hora por toda compra
  • Consulta inmediata
  • Versión HTML online
  • Acceso ilimitado 24/7

Presentación

Este libro sobre los fundamentos del lenguaje Python 3 (en versión 3.8 beta en el momento de su escritura) está dirigido a todos los profesionales de la informática, ingenieros, estudiantes, profesores o incluso personas autodidactas que deseen 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, y presenta las novedades aportadas por la versión 3.8. Sin embargo, 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 ámbito de la informática en que se trabaje.

La segunda parte es una guía destinada a los debutantes, ya sea en Python o en el desarrollo en general, y permite abordar con tranquilidad los conceptos clave en torno a los proyectos que sirven de hilo conductor, y propone la realización de algunos ejercicios.

La tercera 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 cualquier persona 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 cuarta parte permite tener una vista previa del uso de las funcionalidades de Python 3 para la manipulación de archivos o bases de datos.

Para terminar, 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 una aplicación que cubre 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.

El código fuente de las partes 2, 4 y 5 puede descargarse íntegramente en el sitio www.ediciones-eni.com para permitir al lector probar los programas y modificarlos a su gusto de cara a realizar sus propios ejercicios y desarrollos.

Índice

  • Prólogo
    • 1. Introducción
    • 2. Contenido del libro
    • 3. Progresión del libro
    • 4. Destinado a profesores y alumnos
    • 5. Destinado a investigadores y doctores
    • 6. Destinado a aquellos que vienen de otro lenguaje
  • Claves teóricas
    • 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
    • 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. Python y el resto del mundo
      • 3.1 Posición estratégica del lenguaje Python
        • 3.1.1 Segmentos de mercado
        • 3.1.2 Nivel de complejidad
        • 3.1.3 Fortalezas del lenguaje
        • 3.1.4 Puntos débiles
      • 3.2 Integración con otros lenguajes
        • 3.2.1 Extensiones C
        • 3.2.2 Integración de programas escritos en C
        • 3.2.3 Integración de programas Python en C
        • 3.2.4 Integración de programas escritos en Java
        • 3.2.5 Integración de programas Python en Java
        • 3.2.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. Historia de Python
      • 2.1 La génesis
      • 2.2 Ampliación del perímetro funcional
      • 2.3 Evolución de la licencia
      • 2.4 El futuro
    • 3. Gobierno
      • 3.1 Desarrollo
        • 3.1.1 Ramas
        • 3.1.2 Comunidad
      • 3.2 Modo de gobierno
        • 3.2.1 Creador del lenguaje
        • 3.2.2 PEP
        • 3.2.3 Toma de decisiones
        • 3.2.4 Contribuir a Python
    • 4. ¿ Qué contiene Python ?
      • 4.1 Una gramática y una sintaxis
      • 4.2 Varias implementaciones
      • 4.3 Una librería estándar
      • 4.4 Librerías de terceros
      • 4.5 Frameworks
    • 5. Fases de ejecución de un programa Python
      • 5.1 Carga de la máquina virtual
      • 5.2 Compilación
      • 5.3 Interpretación
  • Por qué escoger Python
    • 1. Cualidades del lenguaje
      • 1.1 Puerta de entrada
      • 1.2 Cualidades intrínsecas
      • 1.3 Cobertura funcional
      • 1.4 Dominios de excelencia
      • 1.5 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 Internet de las cosas
      • 4.2 Sistemas y desarrollo web
      • 4.3 Enseñanza
      • 4.4 Informática embebida
      • 4.5 Desarrollo web
      • 4.6 ERP
  • Instalar el entorno de trabajo
    • 1. Introducción
    • 2. Instalar Python
      • 2.1 Para Windows
      • 2.2 Para Mac
      • 2.3 Para GNU/Linux et BSD
      • 2.4 Mediante compilación
      • 2.5 Para un smartphone
    • 3. Instalar una librería externa
      • 3.1 A partir de Python 3.4
      • 3.2 Para una versión inferior a Python 3.4
      • 3.3 Para Linux
    • 4. Crear un entorno virtual
      • 4.1 ¿ Para qué sirve un entorno virtual ?
      • 4.2 Para Python 3.3 o versiones superiores
      • 4.3 Para cualquier versión de Python
      • 4.4 Para Linux
    • 5. Instalar Anaconda
      • 5.1 Para Windows
      • 5.2 Para Linux
      • 5.3 Para Mac
      • 5.4 Actualizar Anaconda
      • 5.5 Instalar una librería externa
      • 5.6 Entornos virtuales
    • 6. Docker
    • 7. La consola Python
      • 7.1 Arrancar la consola Python
      • 7.2 BPython
      • 7.3 IPython
      • 7.4 IPython Notebook
    • 8. Instalar un IDE
      • 8.1 Lista de IDE
      • 8.2 Presentación de PyCharm
      • 8.3 Configuración de PyCharm
  • Primeros pasos
    • 1. Antes de comenzar
      • 1.1 Algunas nociones importantes
        • 1.1.1 ¿ Cómo funciona un ordenador ?
        • 1.1.2 ¿ Qué es un programa informático ?
        • 1.1.3 ¿ Qué es el código fuente ?
      • 1.2 Algunas convenciones utilizadas en este libro
        • 1.2.1 Código Python
        • 1.2.2 Terminal
        • 1.2.3 Formato
      • 1.3 ¿ Cuál es el mejor método para aprender ?
    • 2. Primer programa
      • 2.1 Hello world!
      • 2.2 Asignación
      • 2.3 Valor booleano
      • 2.4 Tipo
      • 2.5 Excepciones
      • 2.6 Bloque condicional
      • 2.7 Condiciones avanzadas
      • 2.8 Bloque iterativo
    • 3. Primer juego: Adivine el número
      • 3.1 Descripción del juego
      • 3.2 Pistas
        • 3.2.1 Gestión del azar
        • 3.2.2 Etapas del desarrollo
      • 3.3 Para ir más allá
  • Funciones y módulos
    • 1. Las funciones
      • 1.1 ¿ Por qué utilizar funciones ?
      • 1.2 Introducción a las funciones
        • 1.2.1 Cómo declarar una función
        • 1.2.2 Gestión de un parámetro
        • 1.2.3 Cómo hacer la función más genérica
        • 1.2.4 Parámetros por defecto
      • 1.3 Problemáticas de acoplamiento y duplicación de código
        • 1.3.1 Nivel de sus funciones
        • 1.3.2 Noción de complejidad
        • 1.3.3 Buenas prácticas
    • 2. Los módulos
      • 2.1 Introducción
        • 2.1.1 ¿ Qué es un módulo ?
        • 2.1.2 ¿ Cómo crear un módulo en Python ?
        • 2.1.3 Organizar el código
      • 2.2 Gestionar el código de los módulos
        • 2.2.1 Ejecutar un módulo, importar un módulo
        • 2.2.2 Gestionar un árbol de módulos
    • 3. Terminar el juego
      • 3.1 Crear niveles
      • 3.2 Determinar un número máximo de intentos
      • 3.3 Registrar las mejores puntuaciones
      • 3.4 Inteligencia artificial
  • Los principales tipos
    • 1. Cadenas de caracteres
      • 1.1 Sintaxis
      • 1.2 Formato de una cadena
      • 1.3 Noción de tamaño de letra
      • 1.4 Noción de longitud
      • 1.5 Pertenencia
      • 1.6 Noción de ocurrencia
      • 1.7 Reemplazo
      • 1.8 Noción de carácter
      • 1.9 Tipología de los caracteres
      • 1.10 Secuenciar una cadena de caracteres
    • 2. Listas
      • 2.1 Sintaxis
      • 2.2 índices
      • 2.3 Valores
      • 2.4 Azar
      • 2.5 Técnicas de iteración
      • 2.6 Ordenación
    • 3. Diccionarios
      • 3.1 Presentación de los diccionarios
      • 3.2 Recorrer un diccionario
      • 3.3 Ejemplo
  • Las clases
    • 1. Sintaxis
    • 2. Noción de instancia en curso
    • 3. Operadores
    • 4. Herencia
      • 4.1 Especialización
      • 4.2 Programación por composición
  • 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.9.1 Operador de expresión de asignación :=
      • 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.3 Uso de una expresión de asignación
        • 2.3.1 Instrucción switch
        • 2.3.2 Interrupciones
        • 2.3.3 Profundizando en las condiciones
        • 2.3.4 Rendimiento
      • 2.4 Iteraciones
        • 2.4.1 Instrucción for
        • 2.4.2 Instrucción while
        • 2.4.3 ¿ Cuál es la diferencia entre for y while ?
        • 2.4.4 Instrucción break
        • 2.4.5 Instrucción return
        • 2.4.6 Instrucción continue
        • 2.4.7 Instrucción else
        • 2.4.8 Generadores
      • 2.5 Construcciones funcionales
        • 2.5.1 Construcción condicional
        • 2.5.2 Generadores
        • 2.5.3 Recorrido de listas
        • 2.5.4 Recorrido de conjuntos
        • 2.5.5 Recorrido de diccionarios
      • 2.6 Recorrido y expresión de asignación
      • 2.7 Gestión de excepciones
        • 2.7.1 Breve presentación de las excepciones
        • 2.7.2 Elevar una excepción
        • 2.7.3 ¿ Por qué elevar una excepción ?
        • 2.7.4 Aserciones
        • 2.7.5 Capturar una excepción
        • 2.7.6 Manejar una excepción
        • 2.7.7 Gestionar la salida del bloque de captura
        • 2.7.8 Gestionar que no se produzcan excepciones
        • 2.7.9 Uso y liberación de recursos
        • 2.7.10 Programación asíncrona
      • 2.8 Otros
        • 2.8.1 Gestionar imports
        • 2.8.2 Compartir espacios de nombres
        • 2.8.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 Valor por defecto mutable
        • 2.2.5 Parámetros nombrados
        • 2.2.6 Declaración de parámetros extensibles
        • 2.2.7 Paso de parámetros con asterisco
        • 2.2.8 Firma universal
        • 2.2.9 Obligar a un parámetro a ser nombrado (keyword-only)
      • 2.3 Forzar un argumento a ser posicional (Positional-only)
        • 2.3.1 Anotaciones
        • 2.3.2 Tipos hint
    • 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 ¿ Para qué sirve un módulo ?
      • 4.2 Declaración
      • 4.3 Instrucciones específicas
      • 4.4 ¿ Cómo conocer el contenido de un módulo ?
      • 4.5 Compilación de los módulos
  • 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.2.6 Tuplas con nombre
      • 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
        • 3.2.6 Clases de datos
  • 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
    • 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 fila de espera
        • 2.6.5 Contenedor con mejor rendimiento
        • 2.6.6 Utilizar las listas para representar matrices
        • 2.6.7 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.2.4 Literales formateados
      • 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ítmicas clásicas
        • 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.4.7 Precisión al nanosegundo
      • 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
  • Manipulación de datos
    • 1. Manipular los archivos
      • 1.1 Abrir un archivo
      • 1.2 Leer un archivo
      • 1.3 Escribir un archivo
      • 1.4 Comparar dos archivos
    • 2. Herramienta de copia de seguridad
    • 3. Leer un archivo de configuración
    • 4. Formato de exportación/importación
      • 4.1 CSV
        • 4.1.1 Explotar un archivo CSV
        • 4.1.2 Generación de un archivo CSV
      • 4.2 JSON
      • 4.3 Base64
      • 4.4 Pickle
    • 5. Comprimir y descomprimir un archivo
      • 5.1 Tarfile
      • 5.2 Gzip
      • 5.3 Bz2
      • 5.4 Zipfile
      • 5.5 Interfaz de alto nivel
    • 6. Herramientas de manipulación de datos
      • 6.1 Generar números aleatorios
      • 6.2 Expresiones regulares
    • 7. Criptografía ligera
      • 7.1 Número aleatorio seguro
      • 7.2 Funciones de cifrado
      • 7.3 Código de autenticación del mensaje
      • 7.4 Huella de archivo
      • 7.5 Esteganografía
      • 7.6 Comunicación segura entre aplicaciones
  • Bases de datos
    • 1. Introducción
    • 2. Acceso a una base de datos relacional
      • 2.1 Punto de entrada
      • 2.2 MySQL
      • 2.3 PostgreSQL
      • 2.4 SQLite
      • 2.5 Oracle
    • 3. Uso de un ORM
      • 3.1 ¿ Qué es un ORM ?
      • 3.2 ORM propuestos por Python
      • 3.3 SQLAlchemy
    • 4. Otras bases de datos
      • 4.1 NoSQL
      • 4.2 Base de datos orientada a objetos: ZODB
      • 4.3 Base de datos orientada al grafo: Neo4j
      • 4.4 Base de datos de tipo clave-valor: Redis
      • 4.5 Bases de datos orientadas a documentos: CouchDB y MongoDB
      • 4.6 Bases de datos nativas XML: BaseX, eXist
      • 4.7 Cassandra
      • 4.8 Bases de datos orientadas a columnas: HBase
      • 4.9 Big Data: el ecosistema Hadoop
    • 5. LDAP
      • 5.1 Protocolo
      • 5.2 Servidores
      • 5.3 Terminología
      • 5.4 Instalación
      • 5.5 Abrir una conexión a un servidor
      • 5.6 Realizar una búsqueda
      • 5.7 Síncrono vs asíncrono
      • 5.8 Conexiones seguras
  • 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écnico
    • 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. Objetos mutables y no mutables
    • 2. Tabla Unicode
      • 2.1 Script
    • 3. Bytes
      • 3.1 Script
      • 3.2 Resultado
    • 4. Guía de migración a Python 3
    • índice

Autor

Sébastien CHAZALLETMás información

Experto técnico en Python / Django / Odoo y Web Backend / Frontend, Sébastien Chazallet colabora como independiente en amplias misiones de desarrollo, de auditoría, como experto y en formación (www.formation-python.com, www.inspyration.fr). Sus realizaciones impactan a desarrollos en torno a Python para proyectos de gran envergadura, esencialmente para aplicaciones de intranet a medida basadas en Django y Odoo (ex Open ERP), y también para aplicaciones de escritorio, scripts de sistema, creación de sitios web o e-commerce.

Características

  • Nivel Medio a Experto
  • Número de páginas 666 páginas
  • Publicación marzo 2020
    • Encuadernación rústica - 17 x 21 cm
    • ISBN: 978-2-409-02478-8
    • EAN: 9782409024788
    • Ref. ENI: RIT33PYT
  • Nivel Medio a Experto
  • Publicación marzo 2020
    • HTML
    • ISBN: 978-2-409-02479-5
    • EAN: 9782409024795
    • Ref. ENI: LNRIT33PYT

Descargas

Al completar este formulario, acepta recibir información y comunicaciones comerciales sobre nuestros productos y servicios. Puede darse de baja de nuestra newsletter en cualquier momento. Si desea conocer más información acerca de nuestra política de protección de datos, pulse aquí.
  • Descargar los ejemplos del libro (998 Ko)