Lógica de programación con Python para principiantes

La lógica de programación es la capacidad de transformar un problema en pasos claros que una computadora pueda ejecutar. Aprender sintaxis sin comprender decisiones, repeticiones, datos y validación produce programas frágiles. Python es una excelente herramienta para practicar lógica porque permite expresar algoritmos con poco ruido visual.

Para continuar estudiando, consulta las guías sobre algoritmos, entrada y salida, bucles, funciones y listas. Como fuentes externas, revisa el tutorial oficial de control de flujo y el tutorial oficial de estructuras de datos.

Empezar por el problema

Antes de escribir código, define qué datos llegan, qué resultado se espera y qué reglas conectan ambos. Por ejemplo, para calcular el promedio de notas debes saber si la lista puede estar vacía, qué rango es válido y cómo se redondea. Las preguntas de borde forman parte del problema, no son detalles posteriores.

Descomponer en pasos

Un problema grande se vuelve manejable al dividirlo en tareas pequeñas. Para un sistema de compras podrías separar lectura de productos, validación, cálculo del subtotal, aplicación de descuento, impuestos y presentación del total. Cada paso puede convertirse en una función.

Pseudocódigo

INICIO
  LEER lista de notas
  VALIDAR que no esté vacía
  SUMAR todas las notas
  DIVIDIR por la cantidad
  MOSTRAR promedio
FIN

El pseudocódigo no necesita una sintaxis rígida. Su objetivo es permitir revisar la idea antes de preocuparse por paréntesis o nombres exactos.

Entrada, proceso y salida

texto = input("Temperatura en Celsius: ")
celsius = float(texto)
fahrenheit = celsius * 9 / 5 + 32
print(f"{fahrenheit:.1f} °F")

Muchos algoritmos pueden analizarse como entrada, transformación y salida. Esta separación ayuda a localizar errores.

Variables con significado

Usa nombres que describan la información: precio_unitario, cantidad o total. Variables como x y a1 obligan a recordar su propósito y aumentan el riesgo de usar el dato equivocado.

Condiciones

if edad < 0:
    print("Edad inválida")
elif edad < 18:
    print("Menor de edad")
else:
    print("Adulto")

Ordena las condiciones desde casos inválidos o específicos hacia los generales. Una rama anterior puede impedir que otra se evalúe.

Operadores lógicos

puede_comprar = (
    cuenta_activa
    and saldo >= precio
    and producto_disponible
)

Asignar un nombre a una regla compleja mejora la lectura y permite probarla de forma independiente.

Bucles definidos

total = 0

for precio in precios:
    total += precio

Usa for cuando recorres una colección o una cantidad conocida. No modifiques la lista de forma destructiva mientras la recorres.

Bucles condicionados

while True:
    entrada = input("Escribe un número positivo: ")
    try:
        numero = int(entrada)
    except ValueError:
        print("No es un entero.")
        continue

    if numero > 0:
        break

    print("Debe ser positivo.")

while es apropiado cuando no sabes cuántos intentos serán necesarios. La condición de salida debe ser evidente.

Acumuladores y contadores

Un acumulador combina valores, como una suma. Un contador registra cuántas veces ocurre algo. Inicializarlos dentro del lugar incorrecto reinicia el resultado en cada iteración.

suma = 0
cantidad = 0

for valor in datos:
    if valor >= 0:
        suma += valor
        cantidad += 1

Funciones

def promedio(valores):
    if not valores:
        raise ValueError("La lista no puede estar vacía")
    return sum(valores) / len(valores)

Una función debe recibir datos y devolver un resultado claro. Evita depender de variables globales cuando puedes pasar argumentos.

Estructuras de datos

Utiliza listas para secuencias ordenadas, sets para valores únicos, diccionarios para asociaciones y tuplas para registros inmutables sencillos. Elegir una estructura adecuada puede simplificar más el algoritmo que cualquier truco de sintaxis.

Validación

No confíes en la entrada. Comprueba tipos, rangos, campos requeridos y combinaciones imposibles. La validación debe ocurrir cerca del límite del sistema para que el resto del código trabaje con datos consistentes.

Casos de borde

Prueba cero, valores negativos, colecciones vacías, duplicados, límites máximos, texto Unicode y archivos ausentes. Un algoritmo que funciona solo con el ejemplo principal todavía no está terminado.

Trazar el algoritmo

Cuando un resultado sea incorrecto, ejecuta manualmente una entrada pequeña y anota cómo cambian las variables. También puedes usar el depurador o logging. Añadir muchos print() sin una pregunta concreta suele producir ruido.

Ejemplo: mayor valor

def mayor(valores):
    if not valores:
        raise ValueError("No hay valores")

    candidato = valores[0]

    for valor in valores[1:]:
        if valor > candidato:
            candidato = valor

    return candidato

Este ejercicio enseña inicialización, recorrido y actualización de estado. Compararlo con max() ayuda a entender qué resuelve la función integrada.

Complejidad básica

Un recorrido completo suele crecer de forma lineal con la cantidad de datos. Dos bucles anidados pueden crecer cuadráticamente. No necesitas memorizar toda la teoría al comenzar, pero sí preguntar cuántas veces se repite cada operación cuando la entrada aumenta.

Pruebas unitarias

def test_promedio():
    assert promedio([10, 20, 30]) == 20

def test_mayor_negativos():
    assert mayor([-8, -2, -5]) == -2

Las pruebas convierten ejemplos esperados en verificaciones repetibles y protegen contra cambios futuros.

Proyecto práctico

Crea un menú de inventario que permita añadir productos, actualizar cantidades, buscar por nombre y mostrar faltantes. Divide cada acción en una función, valida entradas y guarda datos en JSON. Este proyecto combina decisiones, bucles, diccionarios y persistencia.

Errores frecuentes

Los errores comunes son empezar a codificar sin definir el resultado, usar variables globales, duplicar condiciones, olvidar casos vacíos, mezclar interfaz con lógica y crear funciones demasiado grandes. También es frecuente corregir síntomas con más condiciones en lugar de revisar el modelo del problema.

Conclusión

Mejorar la lógica requiere resolver problemas, explicar pasos y revisar casos límite. Empieza con entrada, proceso y salida; divide tareas en funciones y elige estructuras apropiadas. Después añade validación, pruebas y análisis de complejidad. Python facilita la expresión, pero la claridad del algoritmo depende de tu razonamiento.