Patrones de Programación en Python para Manejo de Listas y Diccionarios

Algoritmos Esenciales para la Gestión de Datos en Python

1. Función de Búsqueda

Esta función permite localizar un elemento dentro de una lista de diccionarios utilizando una clave específica.

def buscar_algo(dato):
    for elemento in lista:
        if elemento["clave"] == dato:
            return elemento
    return None

2. Registro de Información

Registro Simple

Procedimiento básico para agregar un nuevo diccionario a la lista (pide agregar algo).

def registrar_algo(dato1, dato2):
    nuevo = {
        "dato1": dato1,
        "dato2": dato2
    }
    lista.append(nuevo)
    return True

Registrar Validando que no Exista

Asegura que no se dupliquen registros basados en un código identificador.

def registrar_algo(codigo, dato1, dato2):
    objeto = buscar_algo(codigo)
    if objeto is not None: # Si el objeto ya existe, no se registra
        return False
    
    for x in lista:
        if x["codigo"] == codigo:
            return False
            
    nuevo = {
        "codigo": codigo,
        "dato1": dato1,
        "dato2": dato2
    }
    lista.append(nuevo)
    return True

Registrar Usando Búsqueda

Se utiliza cuando el registro depende de elementos que deben existir previamente.

def registrar_algo(codigo1, codigo2, dato):
    objeto1 = buscar_objeto1(codigo1)
    objeto2 = buscar_objeto2(codigo2)
    
    if objeto1 is None:
        return False
    if objeto2 is None:
        return False
        
    nuevo = {
        "objeto1": objeto1, # El que está entre comillas es igual al de la lista
        "objeto2": objeto2,
        "dato": dato
    }
    lista.append(nuevo)
    return True

Registrar con Cálculo

Permite generar un registro que incluye una operación aritmética basada en datos existentes.

def registrar_algo(codigo1, codigo2, cantidad):
    objeto1 = buscar_objeto1(codigo1)
    objeto2 = buscar_objeto2(codigo2)
    
    if objeto1 is None:
        return False
    if objeto2 is None:
        return False
        
    resultado = objeto1["precio"] * cantidad
    nuevo = {
        "objeto1": objeto1,
        "objeto2": objeto2,
        "cantidad": cantidad,
        "resultado": resultado
    }
    lista.append(nuevo)
    return True

3. Visualización de Información

Mostrar Información Normal (Sin control de repeticiones)

def mostrar_info(dato):
    objeto = buscar_objeto(dato)
    if objeto is None:
        print("No existe")
        return
        
    for x in lista:
        if condicion: # Puede ser: if condicion1 and condicion2:
            print(x["dato1"], x["dato2"])

Mostrar Información (Sin repeticiones)

Utiliza una lista auxiliar para garantizar que los datos mostrados sean únicos.

def mostrar_algo(dato):
    objeto = buscar_objeto(dato) # Necesitas verificar que algo exista
    if objeto is None: # "Si no existe informar"
        print("No existe")
        return
        
    lista_aux = []
    for x in lista:
        if x["dato"] == valor: # O la condición que sea
            dato_guardar = x["otro_dato"]["otro_dato"]
            if dato_guardar not in lista_aux:
                lista_aux.append(dato_guardar)
                
    if len(lista_aux) == 0:
        print("No hay resultados")
    else:
        for v in lista_aux:
            print(v)

4. Operaciones de Agregación y Estadísticas

Acumulador (Sumar totales)

Útil para obtener montos totales o recaudaciones.

def calcular_total():
    dato = input("Ingrese dato: ")
    total = 0
    for x in lista:
        if condicion: # La condición sería if x["clave"] == dato o similar
            total += valor
    print("-", total)

Contador (Contar ocurrencias)

Determina la cantidad total de elementos que cumplen una condición.

def contar_algo():
    contador = 0
    for x in lista:
        if condicion: # La condición sería if x["clave"] == dato o similar
            contador += 1
    print(contador)

Promedio (Media aritmética)

def calcular_promedio(dato):
    objeto = buscar_algo(dato)
    if objeto is None:
        print("No existe")
        return
        
    suma = 0
    contador = 0
    for x in lista:
        if condicion:
            suma += valor # El valor es x["clave"]
            contador += 1
            
    if contador == 0:
        print("No hay resultados")
    else:
        promedio = suma / contador
        print(promedio)

5. Validaciones Avanzadas

Registrar Validando que no Exista una Combinación

Evita duplicados de combinaciones específicas (ej. misma fecha y mismo cliente).

def registrar_algo(objeto1, objeto2, dato):
    obj1 = buscar_objeto1(objeto1)
    obj2 = buscar_objeto2(objeto2)

    if obj1 is None:
        return False
    if obj2 is None:
        return False

    # VALIDAR DUPLICADO
    for x in lista:
        if x["objeto1"] == obj1 and x["objeto2"] == obj2:
            return False

    nuevo = {
        "objeto1": obj1, # El ["objeto1"] siempre igual al de la lista
        "objeto2": obj2,
        "dato": dato
    }
    lista.append(nuevo)
    return True

6. Resumen de Operadores Lógicos y Comparaciones

• 1) Igualdad: (de ese cliente, de esa competencia, de esa fecha, de ese producto)
  if x["algo"] == valor:
• 2) Mayor que: (superior a, mayor a, más de)
  if x["valor"] > numero:
• 3) Mayor o igual: (igual o superior, mayor o igual)
  if x["valor"] >= numero:
• 4) Menor que: (menor a, inferior a)
  if x["valor"] < numero:
• 5) Diferente: (distinto de, excepto)
  if x["algo"] != valor:
• 6) AND: (y además, misma fecha y misma sala, cliente y producto, competencia y puntaje)
  if condicion1 and condicion2:
  Ejemplos:
  if p["tirador"] == tir and p["competencia"] == com:
if r["fecha"] == fecha and r["sala"] == sala:
• 7) OR: (o, una cosa u otra)
  if condicion1 or condicion2:
  Ejemplo:
  if prod["tipo"] == "Bonos" or prod["tipo"] == "Fondos":
• 8) NOT IN: (sin repetir, sin repeticiones, únicos)
  if valor not in lista_aux:
• 9) == None: (debe existir previamente, validar existencia)
  if objeto == None: return False (Idea: no encontrado)
• 10) != None: (que no exista otro, nombre único, evitar duplicados)
  if objeto != None: return False (Idea: ya encontrado)