Python  

How to Find GINI Coefficient: Measuring Economic Inequality in a Smart City in Python

Table of Contents

  • Introduction

  • What is the GINI Coefficient?

  • Why It Matters in Urban Planning

  • Real-World Scenario: Real-Time Ride-Hailing Income Inequality in Austin

  • Step-by-Step Calculation Method

  • Complete Python Implementation with Live Simulation

  • Best Practices and Ethical Considerations

  • Conclusion

Introduction

In an era of smart cities and data-driven governance, understanding economic disparity isn’t just academic—it’s urgent. The GINI coefficient, a statistical measure of inequality ranging from 0 (perfect equality) to 1 (maximum inequality), has become a critical tool for urban planners, policymakers, and civic tech developers. This article shows you how to compute it accurately using real-world income data—no econometrics degree required.

What is the GINI Coefficient?

The GINI coefficient quantifies how evenly income (or wealth) is distributed across a population.

  • 0 = Everyone earns the same

  • 1 = One person earns everything

It’s derived from the Lorenz curve, which plots cumulative income share against cumulative population share. The GINI is the area between this curve and the line of perfect equality, doubled.

Why It Matters in Urban Planning

Cities like Barcelona, Singapore, and Toronto now embed inequality metrics into transportation, housing, and gig-economy regulations. Without measuring disparity, “smart” initiatives risk deepening divides—like ride-hailing apps that concentrate earnings among a few drivers while others barely break even.

Real-World Scenario: Real-Time Ride-Hailing Income Inequality in Austin

Imagine Austin’s Mobility Department wants to assess fairness in its gig economy. They partner with a ride-hailing platform (anonymized data) to analyze daily earnings of 1,000 drivers over one week.

PlantUML Diagram

Using live telemetry, they detect a troubling pattern:

Top 10% of drivers earn 48% of all income.

Before drafting new driver-support policies, they compute the GINI coefficient to quantify inequality objectively—and trigger alerts if it exceeds 0.45 (a common policy threshold).

This isn’t hypothetical: cities like Los Angeles already mandate such transparency from mobility platforms.

Step-by-Step Calculation Method

  1. Sort incomes in ascending order

  2. Compute cumulative population share (0 to 1)

  3. Compute cumulative income share

  4. Calculate area under the Lorenz curve using the trapezoidal rule

  5. GINI = 1 – 2 × (area under Lorenz curve)

This avoids complex integrals and works efficiently with Python lists.

Complete Python Implementation with Live Simulation

PlantUML Diagram
from typing import List
import random

def gini_coefficient(incomes: List[float]) -> float:
    """
    Computes the GINI coefficient for a list of incomes.
    Returns a float between 0.0 (perfect equality) and 1.0 (max inequality).
    """
    if not incomes:
        return 0.0
    
    # Remove non-positive values (GINI assumes positive incomes)
    incomes = [x for x in incomes if x > 0]
    if not incomes:
        return 0.0

    incomes.sort()
    n = len(incomes)
    
    # Cumulative population share: [0, 1/n, 2/n, ..., 1]
    # Cumulative income share
    cum_income = 0
    total_income = sum(incomes)
    lorenz_area = 0.0

    # Trapezoidal integration under Lorenz curve
    prev_cum_pop = 0.0
    prev_cum_inc = 0.0

    for i, income in enumerate(incomes):
        cum_pop = (i + 1) / n
        cum_income += income
        cum_inc = cum_income / total_income
        
        # Area of trapezoid between previous and current point
        width = cum_pop - prev_cum_pop
        height_avg = (prev_cum_inc + cum_inc) / 2
        lorenz_area += width * height_avg
        
        prev_cum_pop = cum_pop
        prev_cum_inc = cum_inc

    gini = 1 - 2 * lorenz_area
    return max(0.0, min(1.0, gini))  # Clamp to [0, 1]


# Simulate Austin ride-hailing driver earnings (USD/day)
def simulate_driver_earnings(n_drivers: int = 1000) -> List[float]:
    """Generates realistic skewed income distribution using log-normal model."""
    import math
    earnings = []
    for _ in range(n_drivers):
        # Log-normal mimics real gig economy: most earn modestly, few earn highly
        daily = math.exp(random.normalvariate(2.5, 0.8))  # Mean ~$12, skewed right
        earnings.append(round(daily, 2))
    return earnings


if __name__ == "__main__":
    # Simulate live data feed from Austin mobility platform
    driver_earnings = simulate_driver_earnings(1000)
    gini = gini_coefficient(driver_earnings)
    
    print(f"Austin Ride-Hailing GINI Coefficient: {gini:.3f}")
    if gini > 0.45:
        print(" Inequality alert: Policy intervention recommended!")
    else:
        print(" Income distribution within acceptable range.")
22

The code is error-free, handles edge cases (empty lists, zero/negative incomes), and uses numerical integration for accuracy—no external dependencies.

Best Practices and Ethical Considerations

  • Never use raw GINI alone: Pair it with median income and poverty rates.

  • Anonymize rigorously: Individual earnings must be aggregated to protect privacy.

  • Update frequently: In dynamic gig economies, weekly GINI > monthly.

  • Contextualize: A GINI of 0.4 may be normal in a tourist-heavy city but alarming in a residential suburb.

Cities that ignore this metric risk automating inequality under the guise of innovation.

Conclusion

The GINI coefficient isn’t just for economists—it’s a real-time civic health monitor for modern cities. By embedding it into data pipelines (like Austin’s ride-hailing dashboard), governments can move from reactive politics to proactive equity engineering. With just 25 lines of clean Python, you can turn raw income data into actionable insight—helping build cities that are not only smart, but fair. Start measuring. Start balancing. Your city’s social fabric depends on it.

Membership not found