:)

[jhonatanpastaz9-cmyk]

Cuaderno de Economía - Código en Python

Autor: Meta AI

import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import fsolve

Funciones de demanda y oferta

def demanda(p, a=100, b=1):
"""Curva de demanda: devuelve cantidad demandada a precio p."""
return a - b * p

def oferta(p, c=0, d=1):
"""Curva de oferta: devuelve cantidad ofrecida a precio p."""
return c + d * p

Equilibrio de mercado

def equilibrio(a=100, b=1, c=0, d=1, guess=50):
"""Calcula (p*, q*) resolviendo Qd(p)=Qo(p)."""
def f(p):
return demanda(p, a, b) - oferta(p, c, d)
p_star = fsolve(f, guess)[0]
q_star = demanda(p_star, a, b)
return round(float(p_star), 4), round(float(q_star), 4)

Elasticidad precio de la demanda

def elasticidad_precio_demanda(p, a=100, b=1):
"""Elasticidad precio en el punto (p, Qd(p)) para demanda lineal Q=a-bp."""
Q = demanda(p, a, b)
if Q == 0:
return np.nan
return round((-b) * p / Q, 4)

Gráfica de oferta y demanda

def graficar_oferta_demanda(a=100, b=1, c=0, d=1, p_max=None):
"""Grafica curvas de demanda y oferta y marca el equilibrio."""
if p_max is None:
p_max = (a + 10) / b
ps = np.linspace(0, p_max, 300)
qd = demanda(ps, a, b)
qo = oferta(ps, c, d)
p_star, q_star = equilibrio(a, b, c, d)
plt.figure(figsize=(8,5))
plt.plot(qd, ps, label='Demanda (Qd vs p)')
plt.plot(qo, ps, label='Oferta (Qo vs p)')
plt.scatter([q_star], [p_star], zorder=5)
plt.text(q_star, p_star, f' E ({q_star}, {p_star})')
plt.xlabel('Cantidad')
plt.ylabel('Precio')
plt.title('Curvas de Oferta y Demanda')
plt.legend()
plt.grid(True)
plt.show()

Maximización de utilidad - Cobb-Douglas

def cobb_douglas_opt(p_x, p_y, M, alpha=0.5):
"""Devuelve la demanda Marshalliana para Cobb-Douglas."""
x_star = alpha * M / p_x
y_star = (1 - alpha) * M / p_y
return round(x_star, 6), round(y_star, 6)

Simulación de impuesto específico

def impuesto_especifico(a=100, b=1, c=0, d=1, t=10):
"""Calcula nuevo equilibrio cuando se aplica un impuesto específico t al productor."""
def f(p):
return demanda(p, a, b) - oferta(p - t, c, d)
p_cons = fsolve(f, 50)[0]
p_prod = p_cons - t
q = demanda(p_cons, a, b)
return round(float(p_cons),4), round(float(p_prod),4), round(float(q),4)

Función para comparar escenarios

def comparar_parametros(param_name, valores, base_params):
"""Compara equilibrio ante variaciones de un parámetro."""
resultados = []
for val in valores:
params = base_params.copy()
params[param_name] = val
p, q = equilibrio(params['a'], params['b'], params['c'], params['d'])
resultados.append((val, p, q))
return resultados

Ejemplos

if name == "main":
p_eq, q_eq = equilibrio(a=120, b=1.5, c=10, d=0.8)
print(f"Equilibrio: precio = {p_eq}, cantidad = {q_eq}")

x_opt, y_opt = cobb_douglas_opt(p_x=2, p_y=1, M=100, alpha=0.3)
print(f"Demanda óptima: x = {x_opt}, y = {y_opt}")

pc, pp, q = impuesto_especifico(a=120, b=1.5, c=10, d=0.8, t=5)
print(f"Con impuesto: p_consumidor={pc}, p_productor={pp}, q={q}")

base = {'a':120,'b':1.5,'c':10,'d':0.8}
res = comparar_parametros('a', [80,100,120,140,160], base)
print('Comparativa variando a: (a, p_eq, q_eq)')
for r in res:
    print(r)