Curso de Programación en Pythón 3.

Acerca de este curso

Python es un lenguaje de programación interpretado, de alto nivel y de código abierto conocido por su sintaxis legible y fácil de aprender, lo que lo hace muy popular para principiantes. Es un lenguaje de propósito general utilizado en áreas como el desarrollo web (back-end), la ciencia de datos, el aprendizaje automático (machine learning) y la automatización de tareas. Su versatilidad, junto con un ecosistema de extensas bibliotecas y una comunidad activa, lo convierte en una herramienta poderosa para una amplia gama de aplicaciones.

Índice del curso

1. Fundamentos de Python

1.1 Introducción a Python

Breve historia del lenguaje
Filosofía y principios (“The Zen of Python”)
Ventajas y aplicaciones reales: Web, IA, DevOps, Ciencia de Datos, Automatización, etc.
Ventajas y desventajas frente a otros lenguajes
Ecosistema y comunidad

1.2 Instalación y Configuración del Entorno

Instalación de Python (Windows, Linux, macOS)
Variables de entorno y PATH
Uso de IDLE, VS Code, PyCharm
Entornos virtuales con venv y pip
Ejecución del primer script: Hola, Mundo

1.3 Tipos de Datos Fundamentales

Números (int, float, complex)
Cadenas (str): concatenación, slicing y métodos comunes
Booleanos (bool) y valores de verdad
Conversión entre tipos (casting)

1.4 Variables y Buenas Prácticas

Declaración y asignación
Tipado dinámico y mutabilidad
Convenciones de nombres (snake_case, PEP 8)
Uso de constantes, comentarios y documentación mínima

2. Operadores y Control de Flujo

2.1 Operadores

Aritméticos, de comparación y lógicos (and, or, not)
De asignación
De pertenencia (in, not in)
De identidad (is, is not)

2.2 Estructuras Condicionales

if, elif, else
Condiciones anidadas
Operador ternario
Buenas prácticas de legibilidad

2.3 Bucles y Control de Iteración

for con range() y sobre colecciones
while
Palabras clave break, continue, pass
Bucles anidados
Iteración con enumerate() y zip()

3. Funciones y Manejo de Errores

3.1 Funciones en Python

Definición y sintaxis (def)
Parámetros y argumentos (*args, **kwargs)
Valores de retorno
Alcance de variables (scope)
Documentación con docstrings
Funciones lambda
Anotaciones de tipo (type hints)

3.2 Manejo de Excepciones

Errores comunes en Python
Bloques try, except, else, finally
Lanzamiento de excepciones con raise
Jerarquía de excepciones
Depuración con assert

4. Estructuras de Datos

4.1 Listas (`list`)

Creación, indexación y slicing
Métodos (append, insert, remove, sort, etc.)
Iteración y búsqueda de elementos

4.2 Tuplas (`tuple`)

Inmutabilidad y ventajas de uso
Desempaquetado de valores
Conversión entre listas y tuplas

4.3 Diccionarios (`dict`)

Pares clave-valor
Acceso, modificación y eliminación
Iteración y métodos (keys, values, items)
Diccionarios anidados

4.4 Conjuntos (`set`)

Creación y eliminación de duplicados
Operaciones matemáticas: unión, intersección, diferencia
Métodos comunes (add, discard, update)

4.5 Comprehensions

List comprehensions
Dict y set comprehensions
Condicionales en comprensiones
Comprensiones anidadas y optimización

5. Programación Orientada a Objetos (POO)

5.1 Clases y Objetos

Definición de clases (class)
Constructor __init__ y atributos
Métodos de instancia y de clase
Métodos especiales (__str__, __repr__)

5.2 Encapsulación

Variables privadas y protegidas
Propiedades con @property
Métodos estáticos y de clase (@staticmethod, @classmethod)

5.3 Herencia

Herencia simple y múltiple
Uso de super()
Reutilización y extensión de código

5.4 Polimorfismo

Sobrecarga y sobrescritura de métodos
Clases abstractas y módulo abc
Interfaces y polimorfismo dinámico

5.5 Composición y Diseño Modular

Composición de objetos (relaciones has-a)
Modularización y paquetes (__init__.py)
Estructura profesional de proyectos
Patrones de diseño básicos

6. Línea de Comandos de Python

6.1 Intérprete Interactivo

Uso de python o python3
Diferencias entre modo interactivo y scripts
Comandos básicos (help(), dir(), type())

6.2 Ejecución de Scripts

Ejecución de archivos .py
Rutas absolutas y relativas
Permisos de ejecución en Unix/Linux

6.3 Argumentos desde la Terminal

Uso del módulo sys.argv
Lectura y validación de parámetros
Ejemplo práctico: script con argumentos

6.4 Modo REPL Avanzado

Historial y autocompletado
Variables especiales (_, __doc__, etc.)
Exploración con IPython y Jupyter

6.5 Casos Prácticos desde Terminal

Ejecución rápida con python -c
Automatización con os.system()
Ejemplo: ejecución programada con cron

7. Extra (Opcional para tu Curso Avanzado)

7.1 Manejo de Archivos

Lectura y escritura con open()
Manejo de rutas (os, pathlib)
Archivos CSV y JSON
Uso de context managers (with)

7.2 Módulos y Librerías Estándar

Librerías comunes: math, random, datetime, os, sys
Creación e importación de módulos propios
Exploración del entorno con help() y dir()

7.3 Entornos Virtuales y Dependencias

Introducción a venv
Instalación de librerías con pip
Uso del archivo requirements.txt
Buenas prácticas en entornos de desarrollo

8. Hilos y Tareas

8.1 Conceptos de Concurrencia y Paralelismo

Diferencia entre multitarea, multihilo y multiproceso
Concurrencia vs. paralelismo
Limitaciones del GIL (Global Interpreter Lock)

8.2 Programación con `threading`

Creación y ejecución de hilos
Sincronización (Lock, RLock, Semaphore, Event)
Comunicación entre hilos (Queue)
Ejemplo práctico: tareas concurrentes o descargas simultáneas

8.3 Programación Asíncrona con `asyncio`

Sintaxis async y await
Corutinas y tareas
Ejecución concurrente con asyncio.run()
Ejemplo: peticiones HTTP asíncronas

8.4 Multiprocesamiento con `multiprocessing`

Creación y ejecución de procesos independientes
Comunicación entre procesos (Pipe, Queue)
Uso del Pool de procesos
Ejemplo: procesamiento en paralelo de datos

8.5 Buenas Prácticas en Concurrencia

Evitar condiciones de carrera
Uso correcto de bloqueos
Optimización y rendimiento
Cuándo usar hilos, procesos o async

9. Mini Proyecto Final

Integración de los conocimientos aprendidos
Desarrollo de un programa práctico (gestor, calculadora, etc.)
Documentación y estilo (PEP 8)

Nuestra puntuación

¡Haz clic para puntuar esta entrada!

(Votos: 0 Promedio: 0)

Contenido del curso

Fundamentos de Python
Los fundamentos de Python incluyen la sintaxis (sangría para bloques de código), los tipos de datos básicos (numéricos, booleanos, cadenas de texto), las variables, el control de flujo (condicionales como if/elif/else y bucles como for/while), y las funciones (bloques de código reutilizables).

Operadores y Control de Flujo
Los operadores en Python se clasifican en varios tipos (aritméticos, de comparación, lógicos, de asignación, etc.), mientras que el control de flujo se refiere al orden en que se ejecutan las instrucciones, modificándolo con estructuras como if, elif, else (condicionales), y for o while (bucles). Las instrucciones break, continue y pass también controlan el flujo dentro de los bucles.

Funciones y Manejo de Errores
Las funciones en Python son bloques de código reutilizables, mientras que el manejo de errores (excepciones) se hace con los bloques try, except, else y finally para gestionar errores de ejecución y evitar que el programa se detenga abruptamente. try ejecuta un código, except lo captura si ocurre un error específico, else se ejecuta si no hay error y finally se ejecuta siempre, haya o no error.

Estructuras de Datos
Las estructuras de datos principales en Python son las listas, tuplas, diccionarios y conjuntos. Estos tipos de datos se diferencian por su mutabilidad (si sus elementos se pueden cambiar después de su creación) y si mantienen el orden de los elementos. Las listas son ordenadas y mutables, mientras que las tuplas son ordenadas e inmutables. Los diccionarios son colecciones no ordenadas de pares clave-valor, y los conjuntos son colecciones desordenadas de elementos únicos.

Programación Orientada a Objetos (POO)
La Programación Orientada a Objetos (POO) en Python es un paradigma que organiza el código en torno a objetos, que son instancias de clases. Las clases actúan como plantillas que definen los atributos (datos) y métodos (comportamientos) de los objetos, permitiendo crear programas más modularizados, reutilizables y fáciles de mantener. Python soporta conceptos clave de la POO como la herencia, el encapsulamiento y el polimorfismo.

Ambientes virtuales
Un entorno virtual de Python es un espacio aislado que permite instalar paquetes y dependencias específicos para un proyecto concreto sin afectar a otras aplicaciones o a la instalación global de Python. Se crea una carpeta con una instalación de Python y una copia local de pip dentro de este entorno, lo que permite a cada proyecto tener sus propias bibliotecas y versiones, evitando así conflictos entre diferentes proyectos que puedan requerir versiones distintas de la misma librería.

Archivos
El manejo de archivos en Python se realiza principalmente usando la función open() para abrir un archivo y los métodos read(), write(), append() y close() para manipularlo. Es crucial gestionar los archivos adecuadamente, cerrándolos para liberar recursos, aunque es más recomendable usar la sentencia with, que cierra el archivo automáticamente. Python permite trabajar con archivos de texto y binarios, así como con distintos modos de apertura como 'r' (solo lectura), 'w' (escritura/sobreescritura), y 'a' (añadir).

Módulos y Librerías Estándar
Un "módulo" en Python se refiere a dos conceptos distintos: un archivo .py con código que se puede importar para reutilizar funciones, clases y variables, y el operador % que calcula el residuo de una división entera. Ambos son útiles para organizar el código y resolver problemas matemáticos, respectivamente.

Hilos y tareas en Python
En Python, los hilos (threads) son secuencias de ejecución dentro de un proceso que permiten la concurrencia, ejecutando tareas simultáneamente para aprovechar mejor los recursos del sistema. Las tareas son las unidades de trabajo a realizar, como descargar archivos o procesar datos. Se utilizan para manejar operaciones que implican espera (I/O-bound) de forma eficiente, permitiendo que una aplicación no se bloquee mientras espera. Para ello, se usa el módulo threading, se crean objetos Thread que representan las tareas, se inician con .start() y se pueden sincronizar con mecanismos como Lock para evitar conflictos.

Valoraciones y reseñas de estudiantes

Aún no hay reseñas.