Guía de Python 3 Nivel Medio: Estructuras de Datos, Funciones, POO y Archivos por Santiago Soñora

“Hola, mundo” en Python

El clásico 'Hola, mundo' en Python. A nivel intermedio, podrías encapsularlo en una función o usar f-strings para formateo.

📋 Copiar

nombre = "mundo"
print(f"Hola, {nombre}")

Resultado:

Output

Hola, mundo

Comandos básicos

Familiarizarse con estos comandos es esencial para interactuar eficientemente con Python:

Ejecutar un archivo Python
📋 Copiar
```
python archivo.py
```
Ejecuta un script Python desde la terminal utilizando el intérprete.
Iniciar intérprete interactivo
📋 Copiar
```
python
```
Abre una consola interactiva donde puedes escribir y probar código Python línea por línea.
Instalar un paquete con pip
📋 Copiar
```
pip install nombre_paquete
```
Instala bibliotecas y dependencias desde el Python Package Index (PyPI).
Instalar paquetes desde un archivo
📋 Copiar
```
pip install -r requirements.txt
```
Instala todas las dependencias listadas en el archivo `requirements.txt`.
Crear un entorno virtual
📋 Copiar
```
python -m venv env
```
Crea un entorno virtual aislado llamado `env` en el directorio actual para gestionar dependencias específicas del proyecto.
Activar entorno virtual (Linux/macOS)
📋 Copiar
```
source env/bin/activate
```
Activa el entorno virtual en sistemas Unix. La terminal mostrará el nombre del entorno.
Activar entorno virtual (Windows)
📋 Copiar
```
.\env\Scripts\activate
```
Activa el entorno virtual en sistemas Windows (CMD o PowerShell).
Desactivar entorno virtual
📋 Copiar
```
deactivate
```
Sale del entorno virtual activo y vuelve al entorno del sistema.
Declarar una Lista
📋 Copiar
```
mi_lista = [1, 'dos', 3.14, True]
```
Crea una lista: una colección ordenada y mutable de elementos.
Declarar un Diccionario
📋 Copiar
```
mi_diccionario = {'nombre': 'Juan', 'edad': 30, 'activo': True}
```
Crea un diccionario: una colección de pares clave-valor.
Declarar un Conjunto
📋 Copiar
```
mi_conjunto = {1, 2, 2, 3, 4}
```
Crea un conjunto: una colección no ordenada de elementos únicos. El resultado sería `{1, 2, 3, 4}`.
Declarar una Tupla
📋 Copiar
```
mi_tupla = (1, 'dos', 'tres')
```
Crea una tupla: una colección ordenada e inmutable de elementos.
Definir una Función con parámetros
📋 Copiar
```
def saludar(nombre):
  print(f"Hola, {nombre}")
```
Define una función llamada `saludar` que toma un argumento `nombre` e imprime un saludo.
Leer un archivo de texto
📋 Copiar
```
with open('datos.txt', 'r', encoding='utf-8') as f:
  contenido = f.read()
```
Abre el archivo 'datos.txt' para lectura ('r') con codificación UTF-8 y lee todo su contenido de forma segura.
Escribir en un archivo de texto
📋 Copiar
```
with open('salida.txt', 'w', encoding='utf-8') as f:
  f.write('Esta es la primera línea.\n')
  f.write('Esta es la segunda línea.')
```
Abre el archivo 'salida.txt' para escritura ('w'), borrando el contenido existente, y escribe varias líneas.
Manejar errores (Try/Except)
📋 Copiar
```
try:
  resultado = 1 / 0
except ZeroDivisionError:
  print("¡No se puede dividir por cero!")
except Exception as e:
  print(f"Ocurrió un error general: {e}")
```
Intenta ejecutar código. Si ocurre un `ZeroDivisionError`, ejecuta el primer `except`. Para cualquier otro error, ejecuta el segundo `except` y muestra el error.

Crear una Clase

📋 Copiar

class Animal:
  def __init__(self, tipo):
    self.tipo = tipo
  def mostrar_tipo(self):
    print(f"Soy un {self.tipo}")

Define una clase `Animal` con un método constructor (`__init__`) y un método `mostrar_tipo`.

Lista por Comprensión
📋 Copiar
```
pares = [x for x in range(10) if x % 2 == 0]
```
Crea una lista de forma concisa conteniendo los números pares del 0 al 9.
Importar y usar un módulo
📋 Copiar
```
import math
print(math.sqrt(16))
```
Importa el módulo `math` de la biblioteca estándar y usa su función `sqrt` para calcular la raíz cuadrada.

Conceptos Clave

Comprender estos conceptos fundamentales te ayudará a dominar Python de forma más organizada y eficiente:

Estructuras de Datos Fundamentales (Listas, Tuplas, Diccionarios, Conjuntos):

Dominar el uso, las características (mutabilidad, orden) y las diferencias entre las estructuras de datos básicas de Python es crucial para organizar y manipular información de forma eficiente.
Funciones Avanzadas (Argumentos, Scope, *args, **kwargs):

Ir más allá de los parámetros simples: comprender cómo usar argumentos posicionales y de palabra clave, valores por defecto, empaquetar/desempaquetar argumentos con `*args` y `**kwargs`, y cómo el alcance (scope) de las variables afecta su visibilidad dentro y fuera de las funciones (regla LEGB).
Módulos y Paquetes:

Aprender a estructurar el código en archivos (`.py`) como módulos y organizar módulos relacionados en directorios como paquetes. Entender cómo usar la sentencia `import` para reutilizar código entre diferentes partes de tu aplicación.
Manejo de Archivos (File I/O):

Saber cómo leer y escribir datos en archivos de texto y binarios de forma segura utilizando la función `open()`, diferentes modos (`r`, `w`, `a`, `rb`, `wb`), y la sentencia `with` para asegurar que los archivos se cierren correctamente.
Manejo de Errores y Excepciones:

Implementar bloques `try...except` para capturar y gestionar diferentes tipos de errores (`Exception`) de forma controlada, evitando que el programa termine inesperadamente. Conocer el uso de `finally` (para limpieza) y `else` (código si no hay excepción).
Introducción a la Programación Orientada a Objetos (POO):

Comprender los conceptos fundamentales de POO en Python: definir clases (moldes para objetos), crear objetos (instancias de clases), métodos (funciones asociadas a la clase) y atributos (variables asociadas a la clase o instancia). Introducción a la herencia básica.
Entornos Virtuales (`venv`, `pipenv`, `poetry`):

La práctica esencial de usar entornos virtuales para cada proyecto Python para aislar sus dependencias. Esto evita conflictos de versiones entre bibliotecas y asegura que tu proyecto se ejecute con las versiones exactas de los paquetes que necesita.
Comprensiones de Colecciones (List, Dict, Set Comprehensions):

Una característica potente y legible para crear listas, diccionarios o conjuntos de forma concisa a partir de iterables existentes, a menudo reemplazando bucles `for` más verbosos.
Módulos Comunes de la Biblioteca Estándar:

Explorar la amplia funcionalidad incluida en la biblioteca estándar de Python. Familiarizarse con módulos clave como `os` (interacción con el SO), `sys` (parámetros y funciones del sistema), `json` (manejo de datos JSON), `datetime` (fechas y horas), `re` (expresiones regulares), `collections` (tipos de datos especializados).
El Zen de Python (`import this`):

Una colección de principios de diseño que influyen en el lenguaje Python. Leerlos (`import this` en el intérprete) ayuda a entender la filosofía de Python y escribir código más idiomático ('Pythonic').

Casos de uso

Algunos ejemplos de aplicaciones prácticas donde se utiliza Python:

Procesamiento y análisis de archivos de datos estructurados (CSV, JSON, Excel):

Escribir scripts para leer, limpiar, transformar y analizar datos de diferentes formatos de archivo utilizando la biblioteca estándar o bibliotecas de terceros como `pandas`.
Creación de scripts para interactuar con APIs web:

Utilizar la biblioteca `requests` para enviar peticiones HTTP (GET, POST, etc.) a APIs, procesar las respuestas (usualmente en formato JSON) e integrar datos externos en tus aplicaciones o flujos de trabajo.
Automatización de tareas del sistema operativo y gestión de archivos:

Desarrollar scripts que realicen operaciones como listar, crear, renombrar o eliminar archivos y directorios, ejecutar comandos externos, o manejar rutas de archivos de forma multiplataforma utilizando los módulos `os`, `sys` y `subprocess`.
Desarrollo de pequeñas aplicaciones o herramientas basadas en POO:

Modelar entidades o conceptos utilizando clases y objetos para crear programas más estructurados y modulares, facilitando la reusabilidad y el mantenimiento del código.
Organización de código en proyectos medianos utilizando módulos y paquetes:

Estructurar una aplicación Python que consta de múltiples archivos y directorios, utilizando importaciones para gestionar las dependencias y organizar el código de forma lógica.
Manejo robusto y elegante de errores en aplicaciones:

Implementar una estrategia de manejo de errores utilizando `try...except` para anticipar y gestionar posibles fallos (ej: errores de red, archivos inexistentes, entradas inválidas), proporcionando feedback útil al usuario o registrando el error.

Consejos para Principiantes

Aquí tienes algunas recomendaciones para facilitar tus inicios en Python:

Abraza el Estilo "Pythonic":

Intenta escribir código que sea legible, conciso y siga las convenciones de estilo (PEP 8). Aprende a usar comprensiones de listas/diccionarios, generadores, f-strings y otras características del lenguaje para código más elegante y eficiente.
Usa Entornos Virtuales Consistentemente:

Hazlo una regla: cada proyecto Python debe tener su propio entorno virtual (`venv`, `pipenv`, `poetry`). Esto te ahorrará muchos dolores de cabeza relacionados con conflictos de dependencias.
Escribe Funciones Claras y con una Sola Responsabilidad:

Divide tu lógica en funciones pequeñas y con nombres descriptivos. Cada función debe hacer una única cosa bien. Usa docstrings para explicar qué hacen y cuáles son sus argumentos y valor de retorno.
Aprende a Manejar Errores Correctamente con Try/Except:

No asumas que todo saldrá bien. Anticipa posibles fallos (errores de archivo, de red, de datos) y usa bloques `try...except` para gestionarlos de forma controlada, evitando que tu programa falle abruptamente.
Explora la Biblioteca Estándar de Python:

Python ya incluye una gran cantidad de funcionalidades útiles en su biblioteca estándar (`os`, `sys`, `json`, `datetime`, `re`, `collections`, etc.). Antes de instalar un paquete externo, busca si la solución ya existe de forma nativa.
Comprende los Conceptos Básicos de POO:

Aunque no todas las aplicaciones se construyen con POO, entender cómo funcionan las clases, objetos, atributos y métodos te permitirá organizar tu código de forma más estructurada y trabajar con bibliotecas que utilizan este paradigma.
Domina las Comprensiones de Listas, Diccionarios y Conjuntos:

Son herramientas muy potentes para crear colecciones. Te permitirán escribir código más conciso y eficiente para tareas comunes de procesamiento de datos.
Utiliza un Linter y Formateador (ej: Flake8, Black):

Configura herramientas como Flake8 (linter) para verificar el estilo y posibles errores, y Black (formateador) para dar formato automático a tu código. Esto asegura la consistencia y sigue PEP 8.

Herramientas relacionadas

Si te interesa Python, también podrías explorar estas herramientas:

Recursos útiles

Amplía tus conocimientos con estos enlaces y materiales: