Los operadores son el lenguaje de las decisiones y los cálculos. Con ellos sumas un total, decides si una condición se cumple, o combinas reglas. Hoy verás cómo pensar y expresar operaciones de manera clara y segura.

- Aritmética fiable para cálculos (precios, promedios, porcentajes).

- Comparación para validar entradas y ordenar decisiones.

- Lógica para combinar reglas (`and`/`or`/`not`) con precedencia clara.

subtotal = 120

es_estudiante = True

aplica_descuento = (edad < 26) or es_estudiante

print("¿Descuento aplica?", aplica_descuento)

- Usa paréntesis cuando dudes de la precedencia.

- Evita expresiones densas: crea variables intermedias.

1) Calculadora mínima (solo `+`, `-`, `*`, `/`): pide dos números y la operación, y muestra el resultado (maneja división por cero).

2) Comparador: pide dos números y muestra si el primero es `>`, `<` o `==` que el segundo.

3) Paridad: pide un entero y dice si es par o impar usando `%`.

- Aritméticos: `+`, `-`, `*`, `/` (float), `//` (entera), `%` (módulo), `**` (potencia)

- Comparación: `==`, `!=`, `>`, `>=`, `<`, `<=`

- Lógicos: `and`, `or`, `not`

- Strings: `+` concatena, `*` repite (solo int)

- Orden y paréntesis: `**` `>` `*`, `/`, `//`, `%` `>` `+`, `-`; luego comparaciones; luego lógicos (`and` antes que `or`). Usa paréntesis si tienes dudas.

- División por cero: ZeroDivisionError.

- Comparar strings por longitud sin querer: usa `len(...)` explícitamente si eso buscas.

- Precedencia confusa: añade paréntesis para hacer la intención explícita.

- Desde Hello-Python: `../.venv/bin/python -m unittest -v`

- Deben pasar los tests de `tests/test_operators_utils.py`.

- Utilidades de operadores: `Basic/operators_utils.py`

- Pruebas: `tests/test_operators_utils.py`

- Sabes combinar operadores aritméticos, de comparación y lógicos con claridad.

- Puedes validar entradas y calcular resultados evitando trampas comunes.

- Condicionales: usarás operadores para tomar decisiones (`if`/`elif`/`else`) de manera estructurada.

Una tupla es como una foto: captura un conjunto de valores en un momento y no cambia. Cuando necesitas garantizar que “esto no se toca”, las tuplas te dan seguridad y claridad.

- Estructuras datos ordenados que no deben cambiar (configuraciones, coordenadas, fechas).

- Te permite usar elementos como claves en diccionarios si son hashables.

- Evitas mutaciones accidentales que luego son difíciles de rastrear.

person = ("Brais", "Moure", 35)

print(len(person)) # medir

- Dada una tupla con nombres, crea otra tupla con nombres únicos preservando el orden.

- Muestra la subtupla de los 2 últimos nombres usando `tupla[-2:]`.

- Pista: usa `in`, `not in` y concatenación con `+`.

- Crear: `()`, `(elemento,)` para una tupla de 1 elemento, `tuple(iterable)`

- Medir: `len(tupla)`

- Acceso: `tupla[i]`, `tupla[-1]`

- Pertenencia: `in`, `not in`

- `TypeError` al intentar asignar `tupla[i] = valor` (inmutables).

- `ValueError` en `.index(x)` si `x` no existe.

- Desempaquetado con cantidades diferentes de variables y elementos.

- Ejecuta `Basic/05_tuples.py` para ver las demos.

- Practica convirtiendo entre `list` y `tuple` para mutar con control.

- Código de referencia: `Basic/05_tuples.py`

- Sabes cuándo elegir `tuple` frente a `list` y cómo trabajar con slicing, conteo e inmutabilidad.

- Clase 06: `set` (colecciones desordenadas, sin duplicados).

Un `set` es como una bolsa mágica donde cada cosa aparece solo una vez. Cuando limpias datos, buscas pertenencia rápida o quieres operaciones de teoría de conjuntos, `set` es tu mejor aliado.

- Elimina duplicados de forma simple.

- Búsqueda de pertenencia `in`/`not in` muy eficiente.

- Operaciones potentes: unión `|`, intersección `&`, diferencia `-`, diferencia simétrica `^`.

nums = {1, 2, 3, 3, 2}

print(nums) # {1, 2, 3} sin duplicados

- Dada una lista de emails con duplicados y mayúsculas/minúsculas mezcladas, normaliza (`lower()`), elimina duplicados y cuenta cuántos únicos quedan.

- Muestra la intersección entre dos grupos de emails.

- Crear: `{}`, `set(iterable)` (ojo: `{}` crea `dict`, para set vacío usa `set()`)

- Añadir/eliminar: `.add(x)`, `.remove(x)`, `.discard(x)`, `.pop()`

- Limpieza: `.clear()`

- Conversión: `list(set(lista))` para quitar duplicados preservando luego con cuidado el orden si lo reconstruyes

- Usar `{}` esperando un set vacío: crea un `dict`; usa `set()`.

- `.remove(x)` sobre elemento inexistente lanza `KeyError`; si no estás seguro, usa `.discard(x)`.

- Conjuntos no mantienen orden; no los uses cuando el orden sea importante.

- Ejecuta `Basic/06_sets.py` para ver las demos.

- Código de referencia: `Basic/06_sets.py`

- Limpias duplicados, pruebas pertenencia y combinas conjuntos con claridad y seguridad.

- Clase 07: diccionarios (`dict`), pares clave-valor muy versátiles.

Un `dict` es como una agenda: buscas por clave y obtienes el valor al instante. Ideal para representar entidades (usuario, producto) y acceder a sus campos de forma directa.

- Acceso por clave rápido y expresivo.

- APIs claras y extensibles para datos estructurados.

- Métodos útiles para inspección: `.keys()`, `.values()`, `.items()`.

user = {"nombre": "Brais", "apellido": "Moure", "edad": 35}

print(user["nombre"]) # acceso por clave

- Dada una lista de tuplas `(nombre, nota)`, crea un `dict` y muestra solo alumnos con nota `>= 7`.

- A partir de un `dict` de productos, calcula el `precio_total` acumulado.

- Crear: `{clave: valor}`, `dict(pares)`, `dict.fromkeys(claves, valor)`

- Acceso/actualización: `d[clave]`, `d.get(clave, por_defecto)`, `d[clave] = valor`

- Inspección: `.keys()`, `.values()`, `.items()`

- Pertenencia: `in` (sobre claves)

- `KeyError` al acceder con `d[clave]` inexistente; usa `get()` si no estás seguro.

- Mutar mientras iteras sobre `d.items()` puede generar comportamientos inesperados.

- Claves deben ser `hashables` (inmutables típicamente: `str`, `int`, `tuple` de hashables).

- Ejecuta `Basic/07_dicts.py` para ver las demos.

- Código de referencia: `Basic/07_dicts.py`

- Modelas entidades con claridad, iteras por claves/valores y evitas errores comunes.

- Clase 08: condicionales (`if`/`elif`/`else`) para tomar decisiones.

Los condicionales son tus semáforos lógicos: te permiten decidir qué camino tomar según los datos. Desde validar formularios hasta activar descuentos, `if`/`elif`/`else` son el corazón del control de flujo.

- Activar o desactivar bloques de código según condiciones.

- Expresar reglas de negocio de forma clara y legible.

- Evitar errores típicos al comparar, combinar condiciones y tratar valores vacíos.

x = 15

if x > 10 and x < 20:

- Pide una `edad` y clasifícala: `< 18` = "menor", `18–64` = "adulto", `>= 65` = "senior".

- Valida una contraseña: longitud `>= 8`, contiene dígito y letra; imprime mensajes claros.

- Estructura: `if`, `elif`, `else` (en orden mutuamente excluyente)

- Comparación: `==`, `!=`, `>`, `<`, `>=`, `<=`

- Lógicos: `and`, `or`, `not` (usa paréntesis si hay duda de precedencia)

- Pertenencia/identidad (avanzado): `in`, `not in`, `is`, `is not` (cuidado, `is` no es igual que `==`)

- Truthiness: vacío/`0`/`None`/colección vacía evalúan a `False`

- Escribir `=` en lugar de `==` al comparar.

- Ramas inalcanzables por orden incorrecto de condiciones.

- Olvidar paréntesis cuando mezclas `and` y `or` y cambia la intención.

- Ejecuta `Basic/08_conditionals.py` para ver las demos.

- Código de referencia: `Basic/08_conditionals.py`

- Tomas decisiones claras con `if`/`elif`/`else` y dominas comparaciones y truthiness.

- Clase 09: bucles (`while`, `for`, `break`, `continue`, `else`).