Python en la construcción: Calculando la rentabilidad real de la mano de obra

En la industria de la construcción, el control de costos es la diferencia entre ganar dinero o financiar la obra de tu bolsillo. Uno de los costos más difíciles de asignar con precisión es la Mano de obra.

A los trabajadores se les paga mensualmente (o quincenalmente).
Los cobros al cliente (Estados de Pago) ocurren en fechas arbitrarias (ej: del 5 al 25).
La rotación es alta: gente entra y sale a mitad de periodo.

Si intentas cruzar esto en Excel, terminas con fórmulas kilométricas y errores manuales. Por lo tanto, decidí resolver esto programáticamente.

Paso 1: Estructurando los datos

En lugar de luchar con celdas combinadas de Excel, en Python trabajamos con DataFrames. Para este ejemplo, simulemos una cuadrilla pequeña y una serie de Estados de Pago (EP) con fechas irregulares.

1
import pandas as pd
2
import numpy as np
3

4
# 1. Nuestra "Base de Datos" de trabajadores
5
# En la vida real, esto vendría de tu ERP o CSV de RRHH
6
datos_trabajadores = {
7
    'Nombre': ['Juan Pérez', 'Ana Silva', 'Carlos M.', 'Luis R.'],
8
    'Cargo': ['Maestro', 'Jornal', 'Admin', 'Maestro'],
9
    'Sueldo_Base': [800000, 500000, 1500000, 850000],
10
    'Fecha_Contrato': ['2023-01-01', '2023-02-15', '2023-01-01', '2023-03-01'],
11
    'Fecha_Salida': [None, None, None, '2023-04-15'] # None = Sigue trabajando
12
}
13

14
# 2. Los periodos que cobramos al cliente (Estados de Pago)
15
datos_estados_pago = {
16
    'EP': ['EP01', 'EP02', 'EP03'],
17
    'Inicio': ['2023-01-01', '2023-02-01', '2023-03-01'],
18
    'Fin': ['2023-01-31', '2023-02-28', '2023-03-31'],
19
    'Ingreso_Cobrado': [5000000, 8500000, 12000000]
20
}
21

22
# Convertimos a DataFrames de Pandas
23
df_workers = pd.DataFrame(datos_trabajadores)
24
df_ep = pd.DataFrame(datos_estados_pago)
25

26
# Vital: Convertir columnas de texto a objetos de Fecha (datetime)
27
cols_fecha = ['Fecha_Contrato', 'Fecha_Salida']
28
for col in cols_fecha:
29
    df_workers[col] = pd.to_datetime(df_workers[col])
30

31
cols_ep = ['Inicio', 'Fin']
32
for col in cols_ep:
33
    df_ep[col] = pd.to_datetime(df_ep[col])

Paso 2: La lógica de “días reales”

Aquí es donde Excel suele fallar y donde Python brilla. No podemos simplemente restar fechas, porque la realidad de la obra tiene múltiples “aristas”. Un trabajador puede estar en una de estas 4 situaciones durante un Estado de Pago (EP):

Continuidad: Ya estaba contratado antes y sigue después (Trabaja el periodo completo).
Ingreso: Fue contratado a mitad del periodo (Solo contamos desde su ingreso).
Salida: Fue finiquitado a mitad del periodo (Solo contamos hasta su salida).
Temporal: Entró y salió dentro del mismo periodo (Contamos solo esos días).

Para manejar esto con precisión, creamos una función que determina los límites efectivos de cada persona.

1
def calcular_dias_reales(inicio_contrato, fin_contrato, inicio_ep, fin_ep):
2
    """
3
    Calcula la intersección exacta de días trabajados dentro de un periodo específico,
4
    manejando ingresos, finiquitos y personal activo.
5
    """
6

7
    # 1. Definir el INICIO EFECTIVO
8
    # El trabajador empieza a contar desde la fecha más tardía entre:
9
    # A) El inicio del Estado de Pago (si ya estaba contratado)
10
    # B) Su fecha de contrato (si entró durante el periodo)
11
    inicio_efectivo = max(inicio_contrato, inicio_ep)
12

13
    # 2. Definir el FIN EFECTIVO
14
    # Primero, verificamos si el trabajador sigue activo (fin_contrato es NaT/None)
15
    if pd.isna(fin_contrato):
16
        # Si está activo, su tope es el fin del Estado de Pago
17
        fin_efectivo = fin_ep
18
    else:
19
        # Si fue desvinculado, su tope es la fecha más temprana entre:
20
        # A) Su fecha de salida
21
        # B) El fin del Estado de Pago
22
        fin_efectivo = min(fin_contrato, fin_ep)
23

24
    # 3. Cálculo de Días (Inclusive)
25
    # En nómina, si trabajas del día 1 al 1, es 1 día trabajado.
26
    # La resta simple de fechas da 0, por eso sumamos +1.
27
    dias = (fin_efectivo - inicio_efectivo).days + 1
28

29
    # 4. Filtro de Seguridad
30
    # Si 'dias' es negativo, significa que los periodos no se solapan
31
    # (ej: entró después de que terminó el EP). Retornamos 0.
32
    return max(0, dias)

Explicación (¿Por qué tanta lógica?)

Esta función es la única forma de garantizar que si un trabajador entró el día 15 y el periodo de cobro cerró el 20, el sistema asigne exactamente 6 días de costo, ni uno más ni uno menos. Esta precisión acumulada en cientos de trabajadores es lo que define el margen real.

Paso 3: Cruzando la información

Ahora, iteramos por cada Estado de Pago y aplicamos nuestra función a toda la plantilla de trabajadores en milisegundos.

1
resultados = []
2

3
for idx, row in df_ep.iterrows():
4
    # Usamos una copia para no alterar los datos originales
5
    temp_df = df_workers.copy()
6

7
    # Aplicamos la función fila por fila
8
    temp_df['Dias_Periodo'] = temp_df.apply(
9
        lambda x: calcular_dias_reales(
10
            x['Fecha_Contrato'], x['Fecha_Salida'], row['Inicio'], row['Fin']
11
        ), axis=1
12
    )
13

14
    # Calculamos el costo real prorrateado
15
    # (Sueldo Base / 30) * Días trabajados
16
    temp_df['Costo_Real'] = (temp_df['Sueldo_Base'] / 30) * temp_df['Dias_Periodo']
17

18
    # Sumamos todo para obtener el Gasto Total del periodo
19
    gasto_total = temp_df['Costo_Real'].sum()
20
    utilidad = row['Ingreso_Cobrado'] - gasto_total
21

22
    resultados.append({
23
        'Periodo': row['EP'],
24
        'Ingreso': row['Ingreso_Cobrado'],
25
        'Gasto_MO_Real': round(gasto_total, 0),
26
        'Utilidad': round(utilidad, 0),
27
        'Margen_%': round((utilidad / row['Ingreso_Cobrado']) * 100, 1)
28
    })
29

30
# Convertimos los resultados en una tabla final
31
df_final = pd.DataFrame(resultados)
32
print(df_final)

El resultado

Al ejecutar el script, obtenemos una visión financiera precisa, limpia de distorsiones por fechas de ingreso o salida.

1
Periodo  Ingreso  Gasto_MO_Real  Utilidad  Margen_%
2
EP01  5,000,000  2,450,000  2,550,000  51.0%
3
EP02  8,500,000  3,383,333  5,116,667  60.2%
4
EP03  12,000,000  4,650,000  7,350,000  61.2%

Consejo

Este script transformó una tarea que tomaba de 1 a 2 días para un analista administrativo en un proceso de 30 segundos, permitiéndonos enfocar el tiempo en analizar las desviaciones y no en calcularlas.

Conclusión: De operativo a estratégico

Excel sigue siendo una herramienta fantástica para análisis rápidos, pero cuando buscamos escalabilidad y precisión en procesos repetitivos, Python es el claro ganador. Lo mejor de este script es que funciona igual de rápido con una cuadrilla de 10 personas que con una obra de 500 trabajadores, eliminando los errores manuales que suelen ocurrir al manejar grandes volúmenes de datos.

Más allá del código, aquí radica el verdadero valor del Business Engineer: pasar de “llenar planillas” a generar inteligencia de negocios. Ya no perdemos tiempo discutiendo si el cálculo manual es correcto; confiamos en el algoritmo y usamos ese tiempo para lo que realmente importa: tomar decisiones estratégicas para proteger el margen de la obra.

Te invito a copiar el código, probarlo con tus propios datos y dar el salto. Si tienes dudas sobre cómo implementarlo o quieres discutir otras formas de automatizar el control de gestión, siéntete libre de contactarme.

La curva de aprendizaje vale cada minuto de eficiencia ganada.