Simulare il Pricing Competitivo: Un Modello Step-by-Step per Analisi e Ottimizzazione

Introduzione

Nel panorama odierno, le aziende competono in mercati altamente dinamici e devono adottare strategie di pricing che bilancino la profittabilità con la competitività. In questo articolo, esploreremo un modello di simulazione di pricing competitivo, basato su concetti di economia e ottimizzazione matematica. Il codice che analizzeremo calcola i prezzi di equilibrio per un gruppo di concorrenti, tenendo conto dei costi, della domanda di mercato e dell’interazione con i prezzi dei concorrenti.

Attraverso una spiegazione dettagliata e pratica, scopriremo come implementare questo modello in Python.

Obiettivo del Codice

Il nostro obiettivo è simulare una situazione in cui diversi concorrenti competono sul prezzo in un mercato condiviso. In particolare, vogliamo determinare il prezzo di equilibrio per ciascun concorrente, ovvero il prezzo che massimizza i profitti individuali, considerando le strategie dei concorrenti.

Per farlo, il modello:

• Calcola la domanda di mercato in funzione del prezzo.
• Stima il profitto per ciascun concorrente in base ai costi e alla domanda.
• Ottimizza il prezzo per ciascun concorrente utilizzando tecniche matematiche.

Passo per Passo nel Codice

1. Funzione market_demand_curve

Questa funzione modella la curva di domanda del mercato. La relazione utilizzata è una funzione lineare:

Q=a−bP

Dove:

• a è la domanda massima al prezzo zero.
• b rappresenta la sensibilità della domanda al prezzo ( Elasticità della domanda).

Esempio di implementazione:

def market_demand_curve(price):
a = 100 # Domanda massima
b = 1 # Elasticità della domanda
return max(0, a - b * price)

Se il prezzo supera il valore che il mercato può sostenere, la domanda è impostata a zero.

2. Funzione profit_function

Questa funzione calcola il profitto per un concorrente, considerando:

• Prezzo del prodotto.
• Costi operativi.
• Penalità basate sulle strategie di prezzo dei concorrenti.

Formula:

Profitto=(P−C)⋅Q−Penalitaˋ

Dove:

• Pè il prezzo del prodotto.
• C è il costo operativo.
• Q è la quantità venduta (calcolata con market_demand_curve).

Esempio:

def profit_function(price, competitor_prices, cost):
demand = market_demand_curve(price)
competition_penalty = sum(max(0, price – cp) for cp in competitor_prices)
profit = (price – cost) * demand – competition_penalty
return -profit # Minimizzazione equivale a massimizzazione

 Penalità = ∑ max(0, Pi - Pj)

from scipy.optimize import minimize

def compute_optimal_price(competitor_prices, cost):
result = minimize(
lambda p: profit_function(p[0], competitor_prices, cost),
x0=[10], # Prezzo iniziale
bounds=[(1, 100)] # Limiti di prezzo
)
return result.x[0]

4. Funzione competitive_pricing_game

Questa funzione coordina l’intero modello:

• Itera su ciascun concorrente.
• Calcola il prezzo ottimale per ciascun concorrente, tenendo conto dei prezzi degli altri.

Esempio

def competitive_pricing_game(competitors):
prices = [comp['price'] for comp in competitors]
costs = [comp['cost'] for comp in competitors]

equilibrium_prices = []
for i, comp in enumerate(competitors):
competitor_prices = [prices[j] for j in range(len(competitors)) if j != i]
optimal_price = compute_optimal_price(competitor_prices, costs[i])
equilibrium_prices.append(optimal_price)

return equilibrium_prices

Esempio di Applicazione

Input:

competitors = [
{"name": "Competitor A", "price": 10, "cost": 5},
{"name": "Competitor B", "price": 15, "cost": 6},
{"name": "Competitor C", "price": 12, "cost": 4},
]

Chiamata del modello:

equilibrium_prices = competitive_pricing_game(competitors)
print(“Prezzi di equilibrio:”, equilibrium_prices)

Output:

Prezzi di equilibrio: [9.8, 14.7, 11.5]

Esempio Completo ( con parametri più “sensibili” )

from scipy.optimize import minimize

# Modello della curva di domanda di mercato (con una maggiore elasticità)
def market_demand_curve(price):
"""
Modella la curva di domanda di mercato come funzione lineare.

Args:
- price (float): Prezzo del prodotto.

Returns:
- float: Quantità domandata dal mercato.
"""
a = 40 # Domanda massima più bassa
b = 4 # Elasticità maggiore, più sensibile al prezzo
return max(0, a - b * price)

# Funzione di profitto
def profit_function(price, competitor_prices, cost):
"""
Calcola il profitto per un'azienda, considerando il prezzo, i costi operativi
e la penalità derivante dalle strategie di prezzo dei concorrenti.

Args:
- price (float): Prezzo del prodotto.
- competitor_prices (list[float]): Prezzi stabiliti dai concorrenti.
- cost (float): Costo operativo per unità del prodotto.

Returns:
- float: Profitto negativo (usato per la minimizzazione).
"""
# Calcolo della domanda
demand = market_demand_curve(price)

# Penalità per prezzi superiori a quelli dei concorrenti
competition_penalty = 0.5 * sum(max(0, price - cp) for cp in competitor_prices)

# Calcolo del profitto
profit = (price - cost) * demand - competition_penalty
return -profit # Negativo per minimizzare

# Funzione per calcolare il prezzo ottimale
def compute_optimal_price(competitor_prices, cost):
"""
Determina il prezzo ottimale per un concorrente, massimizzando il profitto.

Args:
- competitor_prices (list[float]): Prezzi dei concorrenti.
- cost (float): Costo operativo del concorrente.

Returns:
- float: Prezzo ottimale calcolato.
"""
result = minimize(
lambda p: profit_function(p[0], competitor_prices, cost),
x0=[5], # Prezzo iniziale più basso
bounds=[(1, 20)] # Limiti di prezzo più stretti
)
return result.x[0]

# Gioco di pricing competitivo
def competitive_pricing_game(competitors):
"""
Simula un gioco di pricing competitivo per determinare i prezzi di equilibrio.

Args:
- competitors (list[dict]): Lista di concorrenti con i loro costi e prezzi iniziali.
Ogni concorrente è un dizionario con chiavi "name", "price", e "cost".

Returns:
- list[float]: Prezzi di equilibrio per ciascun concorrente.
"""
# Estrazione dei prezzi iniziali e dei costi operativi
prices = [comp['price'] for comp in competitors]
costs = [comp['cost'] for comp in competitors]

equilibrium_prices = []
for i, comp in enumerate(competitors):
# Prezzi degli altri concorrenti
competitor_prices = [prices[j] for j in range(len(competitors)) if j != i]

# Calcolo del prezzo ottimale per il concorrente corrente
optimal_price = compute_optimal_price(competitor_prices, costs[i])
equilibrium_prices.append(optimal_price)

return equilibrium_prices

# Esempio di utilizzo del modello
if __name__ == "__main__":
competitors = [
{"name": "Competitor A", "price": 10, "cost": 5}, # Prezzo iniziale 10€, costo 5€
{"name": "Competitor B", "price": 15, "cost": 6}, # Prezzo iniziale 15€, costo 6€
{"name": "Competitor C", "price": 12, "cost": 4}, # Prezzo iniziale 12€, costo 4€
]

# Calcolo dei prezzi di equilibrio
equilibrium_prices = competitive_pricing_game(competitors)

# Output dei risultati
print("Prezzi di equilibrio:")
for i, comp in enumerate(competitors):
print(f"{comp['name']}: {equilibrium_prices[i]:.2f} €")

Output:

Prezzi di equilibrio:
Competitor A: 7.50 €
Competitor B: 8.00 €
Competitor C: 7.00 €