• Descripción curso

  Scala es un lenguaje de programación moderno y versátil que combina características de programación orientada a objetos y funcional. Es conocido por su sintaxis concisa y expresiva, lo que permite escribir código más limpio y eficiente. Además, se ejecuta en la máquina virtual de Java (JVM), lo que facilita la integración con aplicaciones Java existentes.

  Scala es muy popular en el desarrollo de aplicaciones escalables y de alto rendimiento, especialmente en entornos de big data y sistemas distribuidos.

  ¡Es una excelente opción si buscas un lenguaje potente y flexible!

• Temario curso

   

  Tema 1: Primeros pasos - Un entorno por proyecto

  • Entornos virtuales.
    • Por qué los entornos virtuales son una buena idea.
    • Usando venv y virtualenv.
      • Crear un venv.
      • Activar un venv/virtualenv.
      • Instalación de paquetes.
    • Usando pyenv.
    • Usando Anaconda.
      • Primeros pasos con Anaconda Navigator.
      • Primeros pasos con conda.
  • Gestión de dependencias.
    • Usando pip y un archivo requirements.txt.
    • Especificadores de versión.
    • Instalación a través de repositorios de control de código fuente.
    • Dependencias adicionales usando extras.
    • Dependencias condicionales mediante marcadores de entorno.
    • Gestión automática de proyectos mediante poesía.
      • Crear un nuevo proyecto de poesía.
      • Agregar dependencias.
      • Actualización de dependencias.
      • Ejecución de comandos.
    • Seguimiento automático de dependencias mediante pipenv.
      • Actualización de los paquetes.
      • Implementación en producción.
      • Ejecución de comandos cron.

   

  Tema 2: Intérpretes interactivos de Python

  • El intérprete de Python.
    • Modificar el intérprete.
      • Habilitación y mejora del autocompletado.
  • Intérpretes alternativos.
    • bpython.
      • Rebobinando tu sesión.
      • Recarga de módulos.
    • ptpython.
    • IPython y Jupyter.
      • Uso básico del intérprete.
      • Guardar y cargar sesiones.
      • Modo normal de prompt / doctest de Python.
      • Introspección y ayuda.
      • Autocompletado.
      • Jupyter.
      • Instalación de Jupyter.
      • Resumen de IPython.

   

  Tema 3: Sintaxis pitónica y trampas comunes

  • Una breve historia de Python.
  • Estilo de código - ¿Qué es el código pitónico?
    • Espacios en blanco en lugar de llaves.
    • Dar formato a las cadenas: ¿printf, str.format o f-strings?
      • Formato simple.
      • Variables con nombre.
      • Expresiones arbitrarias.
    • PEP 20, el Zen de Python.
      • Hermoso es mejor que feo.
      • Explícito es mejor que implícito.
      • Lo simple es mejor que lo complejo.
      • Plano es mejor que anidado.
      • Lo escaso es mejor que lo denso.
      • La legibilidad cuenta.
      • La practicidad supera a la pureza.
      • Los errores nunca deben pasar en silencio.
      • Ante la ambigüedad, rechaza la tentación de adivinar.
      • Una forma obvia de hacerlo.
      • Difícil de explicar, fácil de explicar.
      • Los espacios de nombres son una gran idea.
    • Explicando PEP 8.
      • Escritura de pato.
      • Diferencias entre comparaciones de valor e identidad.
      • Bucles.
      • Longitud máxima de la línea.
    • Verificación de la calidad del código, pep8, pyflakes y más.
    • Adiciones recientes a la sintaxis de Python.
      • PEP 572: Expresiones de asignación/el operador de morsa.
      • PEP 634: Coincidencia de patrones estructurales, la instrucción switch.
  • Errores comunes.
    • ¡El alcance importa!
      • Variables globales.
      • Argumentos predeterminados de la función mutable.
      • Propiedades de clase.
    • Sobrescribir y/o crear elementos integrados adicionales.
    • Modificar mientras se itera.
    • Detección y almacenamiento de excepciones.
    • Encuadernación y cierres tardíos.
    • Importaciones circulares.
    • Importar colisiones.

   

  Tema 4: Patrones de diseño pitónico

  • Complejidad del tiempo: la notación de la gran O.
  • Colecciones principales.
    • list - Una lista mutable de elementos.
    • dieta - Un mapa de elementos.
    • set - Como un dictado sin valores.
    • tupla: la lista inmutable.
  • Patrones pitónicos utilizando colecciones avanzadas.
    • Almacenamiento inteligente de datos con sugerencias de tipos mediante clases de datos.
    • Combinación de múltiples ámbitos con ChainMap.
    • Valores predeterminados del diccionario usando defaultdict.
    • enumeración - Un grupo de constantes.
    • Ordenar colecciones mediante heapq.
    • Búsqueda en colecciones ordenadas mediante bisect.
    • Instancias globales que utilizan patrones Borg o Singleton.
    • No hay necesidad de getters y setters con propiedades.
    • Operadores de Dict Union.

   

  Tema 5: Programación funcional: legibilidad versus brevedad

  • Programación funcional.
    • Puramente funcional.
    • Programación funcional y Python.
    • Ventajas de la programación funcional.
  • Comprehensiones list, set y dict.
    • Comprehensiones básicas de listas.
    • Comprehensiones set.
    • Comprehensiones dict.
    • Trampas de comprensión.
  • Funciones lambda.
    • El combinador Y.
  • functools.
    • partial - Argumentos de la función de relleno previo.
    • reduce - Combinación de pares en un solo resultado.
      • Implementación de una función factorial.
      • Árboles de procesamiento.
      • Reduciendo en la otra dirección.
  • itertools.
    • Acumular - Reducir con resultados intermedios.
    • cadena: combinación de múltiples resultados.
    • compress: selección de elementos mediante una lista de booleanos.
    • dropwhile/takewhile: selección de elementos mediante una función.
    • count: rango infinito con pasos decimales.
    • groupby - Agrupar tu iterable ordenado.

   

  Tema 6: Decoradores - Habilitación de la reutilización de código mediante la decoración

  • Funciones de decoración.
    • Decoradores de funciones genéricas.
    • La importancia de functools.wraps.
    • Encadenar o anidar decoradores.
    • Registro de funciones mediante decoradores.
    • Memorización usando decoradores.
    • Decoradores con argumentos (opcionales).
    • Crear decoradores usando clases.
  • Funciones de clase de decoración.
    • Omitir la instancia: classmethod y staticmethod.
    • Propiedades: uso del descriptor inteligente.
  • Clases de decoración.
    • Singletons: clases con una sola instancia.
    • Ordenación total: hacer que las clases se puedan ordenar.
  • Decoradores útiles.
    • Envío único - Polimorfismo en Python.
    • contextmanager — con instrucciones simplificadas.
    • Validación, comprobaciones de tipo y conversiones.
    • Advertencias inútiles: cómo ignorarlas de forma segura.

   

  Tema 7: Generadores y corrutinas - Infinity, un paso a la vez

  • Generadores.
    • Creación de generadores.
    • Creando generadores infinitos.
    • Generadores que envuelven iterables.
    • Comprensión del generador.
    • Generadores e iteradores basados en clases.
  • Ejemplos de generadores.
    • Dividir un iterable en trozos / grupos.
    • itertools.islice: segmentación de iterables.
    • itertools.chain - Concatenación de múltiples iterables.
    • itertools.tee - Usando una salida varias veces.
    • contextlib.contextmanager: creación de administradores de contexto.
  • Corrutinas.
    • Un ejemplo básico.
    • Cebadura.
    • Cierre y lanzamiento de excepciones.
    • Mezcla de generadores y corrutinas.
    • Usando el estado.

   

  Tema 8: Metaclases - Haciendo que las clases (no las instancias) sean más inteligentes

  • Creación dinámica de clases.
  • Una metaclase básica.
    • Argumentos para metaclases.
    • Acceso a atributos de metaclase a través de clases.
  • Clases abstractas usando collections.abc.
    • Funcionamiento interno de las clases abstractas.
    • Comprobaciones de tipos personalizadas.
  • Registro automático de sistemas de plugins.
    • Importación de plugins bajo demanda.
    • Importación de plugins a través de la configuración.
    • Importación de plugins a través del sistema de archivos.
  • Clases de datos.
  • Orden de las operaciones al crear instancias de clases.
    • Encontrar la metaclase.
    • Preparación del espacio de nombres.
    • Ejecución del cuerpo de la clase.
    • Creación del objeto de clase (no instancia).
    • Ejecución de los decoradores de clase.
    • Creación de la instancia de clase.
    • Ejemplo.
  • Almacenamiento de atributos de clase en orden de definición.
    • La solución clásica sin metaclases.
    • Uso de metaclases para obtener un espacio de nombres ordenado.

   

  Tema 9: Documentación - Cómo usar Sphinx y reStructuredText

  • Sugerencia de tipo.
    • Ejemplo básico.
    • Tipos personalizados.
    • Genéricos.
    • Comprobación de tipos.
    • Archivos de interfaz de tipo Python.
    • Tipo que insinúa conclusión.
  • reStructuredText y Markdown.
    • Introducción a reStructuredText.
    • Primeros pasos con Markdown.
    • Marcado en línea.
    • Encabezados.
      • Encabezados con reStructuredText.
      • Encabezados con Markdown.
    • Listas.
      • Listas enumeradas.
      • Listas con viñetas.
      • Listas de opciones.
      • Listas de definiciones (solo reST).
      • Listas anidadas.
    • Enlaces, referencias y etiquetas.
    • Imágenes.
      • Imágenes con reStructuredText.
      • Imágenes con Markdown.
    • Sustituciones.
    • Bloques, código, matemáticas, comentarios y citas.
    • Conclusión.
  • El generador de documentación de Sphinx.
    • Primeros pasos con Sphinx.
      • Uso de sphinx-quickstart.
      • Usando sphinx-apidoc.
    • Directivas de la Esfinge.
    • Roles de la esfinge.
  • Documentar el código.
    • Documentar una clase con el estilo Esfinge.
    • Documentar una clase con el estilo de Google.
    • Documentar una clase con el estilo NumPy.
    • Qué estilo elegir.

 

Tema 10: Pruebas y registro - Preparación para errores

• Uso de la documentación como pruebas con doctest.
  • Un ejemplo sencillo de doctest.
  • Redacción de doctests.
  • Pruebas con documentación.
  • Las banderas doctest.
    • Verdadero y falso versus 1 y 0.
    • Normalización de espacios en blanco.
    • Elipsis.
  • Peculiaridades de Doctest.
    • Diccionarios de prueba.
    • Prueba de números de punto flotante.
    • Horarios y duraciones.
• Pruebas con py.test.
  • La diferencia entre la salida unittest y py.test.
  • La diferencia entre las pruebas unittest y py.test.
    • Simplificando las afirmaciones.
    • Parametrización de pruebas.
    • Argumentos automáticos mediante accesorios.
    • Imprimir extractos y registros.
    • Complementos.
• Objetos simulados.
  • Usando unittest.mock.
  • Usando py.test monkeypatch.
• Probar múltiples entornos con toxicología.
  • Primeros pasos con tox.
  • El archivo de configuración tox.ini.
  • Correr tox.
• Registro.
  • Configuración.
    • Configuración básica de registro.
    • Configuración del diccionario.
    • Configuración JSON.
    • Configuración de archivos ini.
    • La configuración de la red.
  • Logger.
    • Uso.
    • Formateo.
    • Formato moderno con f-strings y str.format.
  • Trampas de la tala.
  • Depuración de loggers.

 

Tema 11: Depuración - Resolviendo los Errores

• Depuración no interactiva.
  • Inspección del script mediante el seguimiento.
  • Depuración mediante el registro.
  • Mostrando la pila de llamadas sin excepciones.
  • Control de bloqueos mediante faulthandler.
• Depuración interactiva.
  • Consola bajo demanda.
  • Depuración mediante el depurador de Python (pdb).
    • Interrupción.
    • Detección de excepciones.
    • Alias.
    • Comandos.
  • Depuración con IPython.
  • Depuración con Jupyter.
  • Otros depuradores.
    • Servicios de depuración.

 

Tema 12: Rendimiento - Seguimiento y reducción

• Su uso de memoria y CPU.
• ¿Qué es el rendimiento?
• Medición del rendimiento de la CPU y el tiempo de ejecución.
  • Timeit: comparación del rendimiento de fragmentos de código.
  • cProfile: búsqueda de los componentes más lentos.
    • Primera ejecución de perfiles.
    • Calibrar el generador de perfiles.
    • Perfilado selectivo mediante decoradores.
    • Uso de estadísticas de perfil.
  • Generador de perfiles de línea: seguimiento del rendimiento por línea.
• Mejorar el tiempo de ejecución.
  • Usando el algoritmo correcto.
  • Bloqueo global del intérprete.
  • Intenta versus si.
  • Listas versus generadores.
  • Concatenación de cadenas.
  • Suma versus generadores.
  • Mapas versus generadores y comprensiones de listas.
  • Caché.
  • Importaciones diferidas.
  • Usando tragamonedas.
  • Uso de bibliotecas optimizadas.
  • Compilación justo a tiempo.
  • Convertir partes de su código a C.
• Uso de memoria.
  • tracemalloc.
  • Generador de perfiles de memoria.
  • Fugas de memoria.
    • Referencias circulares.
    • Análisis del uso de memoria mediante el recolector de elementos no utilizados.
    • Referencias débiles.
    • Limitaciones y trampas de Weakref.
  • Reducir el uso de memoria.
    • Generadores frente a listas.
    • Volver a crear colecciones frente a eliminar elementos.
    • Usando slots.
• Seguimiento del rendimiento.

 

Tema 13: asyncio - Multithreading sin Hilos

• Introducción a la asyncio.
  • Instrucciones de compatibilidad con versiones anteriores y async/await.
    • Python 3.4.
    • Python 3.5.
    • Python 3.7.
  • Un ejemplo básico de ejecución paralela.
  • conceptos de asyncio.
    • Corrutinas, futuros y tareas.
    • Bucles de eventos.
    • Ejecutores.
• Ejemplos asincrónicos.
  • Procesos.
  • Procesos interactivos.
  • Cliente y servidor de eco.
  • Operaciones de archivos asincrónicos.
  • Creación de generadores asíncronos para admitir async.
  • Constructores y destructores asincrónicos.
• Depuración de asyncio.
  • Olvidarse de esperar una corrutina.
  • Funciones de bloqueo lento.
  • Olvidarse de verificar los resultados o salir temprano.
  • Salir antes de que se realicen todas las tareas.

 

Tema 14: Multiprocesamiento - Cuando un solo núcleo de CPU no es suficiente

• El bloqueo global del intérprete (GIL).
  • El uso de múltiples hilos.
  • ¿Por qué necesitamos el GIL?
  • ¿Por qué todavía tenemos el GIL?
• Múltiples subprocesos y procesos.
  • Ejemplos básicos.
    • concurrente.futuros.
    • Threading.
    • multiprocesamiento.
  • Salir limpiamente de subprocesos y procesos de larga duración.
  • Procesamiento por lotes utilizando concurrent.futures.
  • Procesamiento por lotes mediante multiprocesamiento.
• Compartir datos entre subprocesos y procesos.
  • Memoria compartida entre procesos.
  • Seguridad de roscas.
  • Interbloqueos.
  • Variables locales de subproceso.
• ¿Procesos, subprocesos o un solo subproceso?
  • subprocesos frente a concurrent.futures.
  • multiprocesamiento frente a concurrent.futures.
• Hyper-threading frente a núcleos de CPU físicos.
• Procesos remotos.
  • Procesamiento distribuido mediante multiprocesamiento.
  • Procesamiento distribuido usando Dask.
    • Instalación de Dask.
    • Ejemplo básico.
    • Ejecutar un solo hilo.
    • Ejecución distribuida en varias máquinas.
  • Procesamiento distribuido usando ipyparallel.
    • ipython_config.py.
    • ipython_kernel_config.py.
    • ipcontroller_config.py.
    • ipengine_config.py.
    • ipcluster_config.py.

 

Tema 15: Python Científico y Plotting

• Almacenamiento de los paquetes.
• Matrices y matrices.
  • NumPy - Matrices y matrices rápidas.
  • Numba - Python más rápido en CPU o GPU.
  • SciPy - Algoritmos matemáticos y utilidades NumPy.
    • Matrices dispersas.
  • Pandas - Análisis de datos del mundo real.
    • Opciones de entrada y salida.
    • Pivotar y agrupar.
    • Fusión.
    • Ventanas enrollables o expansivas.
  • Statsmodels - Modelos estadísticos sobre Pandas.
  • xarray: matrices y conjuntos de datos etiquetados.
  • STUMPY - Encontrar patrones en series temporales.
• Matemáticas y cálculos precisos.
  • gmpy2 - Cálculos rápidos y precisos.
  • Sage: una alternativa a Mathematica/Maple/MATLAB.
  • mpmath - Cálculos cómodos y precisos.
  • SymPy - Matemática simbólica.
  • Patsy - Descripción de modelos estadísticos.
• Trazos, gráficos y gráficos.
  • Matplotlib.
  • Seaborn.
  • Yellowbrick.
  • Plotly.
  • Bokeh.
  • Datashader.

 

Tema 16: Inteligencia Artificial

• Introducción a la inteligencia artificial.
  • Tipos de IA.
• Instalación de los paquetes.
• Tratamiento de imágenes.
  • scikit-image.
    • Instalación de scikit-image.
    • Detección de bordes.
    • Detección de rostros.
    • descripción general de scikit-image.
  • OpenCV.
    • Instalación de OpenCV para Python.
    • Detección de bordes.
    • Detección de objetos.
  • OpenCV versus scikit-image.
• Procesamiento del lenguaje natural.
  • NLTK - Kit de herramientas de lenguaje natural.
  • spaCy - Procesamiento de lenguaje natural con Cython.
  • Gensim - Modelado de temas para humanos.
• Aprendizaje automático.
  • Tipos de aprendizaje automático.
    • Aprendizaje supervisado.
    • Aprendizaje por refuerzo.
    • Aprendizaje no supervisado.
    • Combinaciones de métodos de aprendizaje.
    • Aprendizaje profundo.
  • Redes neuronales artificiales y aprendizaje profundo.
    • Tensores.
    • PyTorch: redes neuronales rápidas (profundas).
    • PyTorch Lightning y PyTorch Ignite: API de PyTorch de alto nivel.
    • Skorch - Mezcla de PyTorch y scikit-learn.
    • TensorFlow/Keras: redes neuronales rápidas (profundas).
    • TensorFlow frente a PyTorch.
  • Algoritmos evolutivos.
  • Máquinas de vectores de soporte.
  • Redes bayesianas.
• Bibliotecas y utilidades de IA versátiles.
  • scikit-learn - Aprendizaje automático en Python.
    • Aprendizaje supervisado.
    • Aprendizaje no supervisado.
  • auto-sklearn - Aprendizaje automático de scikit.
  • mlxtend - Extensiones de aprendizaje automático.
  • Scikit-Lego - Utilidades de Scikit-Learn.
  • XGBoost - Aumento de gradiente extremo.
  • Featuretools: detección y predicción de características.
  • Snorkel - Mejora automática de los datos de ML.
  • TPOT - Optimización de modelos de ML mediante programación genética.

 

Tema 17: Extensiones en C/C++, llamadas al sistema y bibliotecas de C/C++

• Configuración de herramientas.
  • ¿Necesitas módulos C/C++?
  • Windows.
  • OS X.
  • Linux/Unix.
• Llamar a C/C++ con ctypes.
  • Bibliotecas específicas de la plataforma.
    • Windows.
    • Linux/Unix.
    • OS X.
    • Haciéndolo fácil.
  • Funciones de llamada y tipos nativos.
  • Estructuras de datos complejas.
  • Matrices.
  • Gotchas con gestión de memoria.
• CFFI.
  • Estructuras de datos complejas.
  • Matrices.
  • ¿ABI o API?
  • ¿CFFI o ctypes?
• Extensiones nativas de C/C++.
  • Un ejemplo básico.
  • C no es Python - El tamaño importa.
  • El ejemplo explicado.
    • estático.
    • PyObject*
    • Análisis de argumentos.
  • C no es Python - Los errores son silenciosos o letales.
  • Llamar a Python desde C: manejar tipos complejos.

 

Tema 18: Empaquetado - Creación de sus propias bibliotecas o aplicaciones

• Introducción a los paquetes.
  • Tipos de paquetes.
    • Ruedas: los nuevos huevos.
    • Paquetes fuente.
  • Herramientas de paquete.
• Control de versiones de paquetes.
• Construyendo paquetes.
  • Empaquetado usando pyproject.toml.
    • Crear un paquete básico.
    • Instalación de paquetes para el desarrollo.
    • Agregar código y datos.
    • Adición de comandos ejecutables.
    • Gestión de dependencias.
    • Construyendo el paquete.
    • Creación de extensiones de C/C++.
  • Empaquetado mediante setuptools con setup.py o setup.cfg.
    • Crear un paquete básico.
    • Instalación del paquete para el desarrollo.
    • Adición de paquetes.
    • Adición de datos de paquetes.
    • Gestión de dependencias.
    • Adición de comandos ejecutables.
    • Construyendo el paquete.
• Publicación de paquetes.
  • Adición de URLs.
  • Clasificadores de tesoros de PyPI.
  • Subiendo a PyPI.
• Extensiones de C/C++.
  • Extensiones regulares de C/C++.
  • Extensiones de Cython.
• Testing.
  • prueba unitaria.
  • py.test.