从“石头剪刀布”到商业竞争用Python实战模拟完全信息静态博弈博弈论常被视为经济学中的数学武器库但它的魅力远不止于学术论文。当我们在电商平台比价时当两家外卖App同时发放优惠券时甚至当你在会议室与同事讨论项目分工时博弈论的无形之手都在悄然运作。本文将用Python代码为显微镜带你观察这些日常决策背后的博弈逻辑。1. 博弈论基础与Python建模准备完全信息静态博弈的核心特征可以概括为三点所有玩家同时行动、彼此清楚对方的收益矩阵、且无法结成有约束力的联盟。这种看似简单的设定却能解释从儿童游戏到跨国并购的各类竞争行为。1.1 必备工具栈配置推荐使用Anaconda环境管理以下库# 安装核心库 import numpy as np import matplotlib.pyplot as plt from itertools import product from scipy.optimize import minimize支付矩阵是博弈的DNA用NumPy数组表示囚徒困境prisoners_dilemma { A: np.array([[ -1, -10], # A选择坦白/抵赖时 [ 0, -3]]), # B选择坦白/抵赖时的A收益 B: np.array([[ -1, 0], # 转置视角 [-10, -3]]) }1.2 博弈可视化技巧用热力图直观展示收益分布def plot_payoff(matrix, title): fig, ax plt.subplots(figsize(8,6)) im ax.imshow(matrix, cmapRdYlGn) plt.colorbar(im) ax.set_xticks([0,1]) ax.set_yticks([0,1]) ax.set_xticklabels([合作,背叛]) ax.set_yticklabels([合作,背叛]) plt.title(title) plt.show() plot_payoff(prisoners_dilemma[A], 囚徒A的收益矩阵)2. 经典博弈模型的Python实现2.1 纳什均衡求解算法采用最佳响应函数法寻找纯策略均衡def find_pure_nash(payoff_a, payoff_b): nash_equilibria [] rows, cols payoff_a.shape for i in range(rows): for j in range(cols): is_nash True # 检查玩家A是否有动机偏离 for k in range(rows): if payoff_a[k,j] payoff_a[i,j]: is_nash False break # 检查玩家B是否有动机偏离 for l in range(cols): if payoff_b[i,l] payoff_b[i,j]: is_nash False break if is_nash: nash_equilibria.append((i,j)) return nash_equilibria测试囚徒困境nash_pd find_pure_nash(prisoners_dilemma[A], prisoners_dilemma[B]) print(f纳什均衡策略组合索引: {nash_pd}) # 输出 (1,1) 即(背叛,背叛)2.2 混合策略均衡计算以足球点球博弈为例计算最优混合策略# 守门员和射门者的收益矩阵 penalty_kick { Kicker: np.array([[ 1, -1], [-1, 1]]), Goalie: np.array([[-1, 1], [ 1, -1]]) } def solve_mixed_nash(payoff_a, payoff_b): # 玩家A的最佳响应 def obj_a(x): p x[0] # 玩家B选择策略1的概率 return -np.max(p*payoff_a[:,0] (1-p)*payoff_a[:,1]) # 最小化负收益 # 玩家B的最佳响应 def obj_b(x): q x[0] # 玩家A选择策略1的概率 return -np.max(q*payoff_b[0,:] (1-q)*payoff_b[1,:]) res_a minimize(obj_a, [0.5], bounds[(0,1)]) res_b minimize(obj_b, [0.5], bounds[(0,1)]) return {Player1: res_b.x[0], Player2: res_a.x[0]} mixed_nash solve_mixed_nash(penalty_kick[Kicker], penalty_kick[Goalie]) print(f混合策略纳什均衡: {mixed_nash}) # 双方各50%概率3. 商业场景中的博弈论应用3.1 价格战模拟伯川德模型两家公司的价格竞争可以建模为def bertrand_game(c1, c2, market_size): # 简化假设消费者总是选择价格更低的商家 def profit(p1, p2): if p1 p2: return (p1 - c1) * market_size, 0 elif p1 p2: return 0, (p2 - c2) * market_size else: return (p1 - c1) * market_size / 2, (p2 - c2) * market_size / 2 # 寻找均衡价格 def best_response(p_other, cost): if p_other cost: return min(p_other - 0.01, cost 0.01) # 略低于对手但高于成本 else: return cost # 无法盈利时按成本定价 p1, p2 c1 1, c2 1 # 初始价格 for _ in range(1000): # 迭代收敛 new_p1 best_response(p2, c1) new_p2 best_response(p1, c2) if abs(new_p1 - p1) 1e-5 and abs(new_p2 - p2) 1e-5: break p1, p2 new_p1, new_p2 return p1, p2, *profit(p1, p2) # 假设两家公司成本相同 equilibrium_price bertrand_game(10, 10, 1000) print(f均衡价格: {equilibrium_price[0]:.2f}, 利润: {equilibrium_price[2]:.2f})3.2 产品差异化博弈Hotelling线性城市模型的Python实现def hotelling_model(position_a, position_b, price_a, price_b, transport_cost1): 假设消费者均匀分布在[0,1]区间 transport_cost: 单位距离的运输成本 # 寻找无差异消费者位置 if position_a position_b: if price_a price_b: return 1.0, 0.0 elif price_a price_b: return 0.0, 1.0 else: return 0.5, 0.5 x (price_b - price_a transport_cost*(position_b**2 - position_a**2)) \ / (2 * transport_cost * (position_b - position_a)) x np.clip(x, 0, 1) share_a x share_b 1 - x return share_a, share_b # 模拟两家公司位于1/4和3/4处 market_shares hotelling_model(0.25, 0.75, 1.0, 1.0) print(f市场份额 - A: {market_shares[0]:.1%}, B: {market_shares[1]:.1%})4. 进阶应用与策略优化4.1 多智能体博弈模拟用博弈论分析推荐系统的冷启动问题class RecommenderGame: def __init__(self, n_users, n_items): self.user_prefs np.random.rand(n_users, n_items) self.item_qualities np.random.rand(n_items) def play_round(self, recommendations): # recommendations是字典 {用户索引: 推荐物品索引} rewards {} for user, item in recommendations.items(): engagement self.user_prefs[user, item] * self.item_qualities[item] rewards[user] engagement # 平台更新物品质量 (模拟用户反馈) for item in set(recommendations.values()): rec_count sum(1 for v in recommendations.values() if v item) self.item_qualities[item] * (1 0.1 * rec_count) return rewards # 模拟两个推荐系统的竞争 game RecommenderGame(1000, 10) strategies { A: lambda: np.random.choice(10), # 随机推荐 B: lambda: np.argmax(game.item_qualities) # 热门推荐 } results {A: [], B: []} for _ in range(100): recs {i: strategies[A]() for i in range(500)} # 前500用户用策略A recs.update({i: strategies[B]() for i in range(500,1000)}) # 后500用策略B rewards game.play_round(recs) results[A].append(sum(rewards[i] for i in range(500)) / 500) results[B].append(sum(rewards[i] for i in range(500,1000)) / 500) plt.plot(results[A], label随机策略) plt.plot(results[B], label热门策略) plt.title(推荐策略效果对比) plt.xlabel(迭代轮次) plt.ylabel(平均用户参与度) plt.legend()4.2 博弈论与强化学习结合Q-learning在重复博弈中的应用示例class QLearningPlayer: def __init__(self, n_actions, alpha0.1, gamma0.9, epsilon0.1): self.q_table np.zeros(n_actions) self.alpha alpha self.gamma gamma self.epsilon epsilon def choose_action(self): if np.random.random() self.epsilon: return np.random.randint(len(self.q_table)) else: return np.argmax(self.q_table) def learn(self, action, reward): self.q_table[action] self.alpha * (reward - self.q_table[action]) # 重复囚徒困境模拟 player1 QLearningPlayer(2) # 0合作, 1背叛 player2 QLearningPlayer(2) payoff [[(3,3), (0,5)], [(5,0), (1,1)]] # (R,S,T,P)标准参数 cooperation_rates [] for episode in range(1000): a1 player1.choose_action() a2 player2.choose_action() r1, r2 payoff[a1][a2] player1.learn(a1, r1) player2.learn(a2, r2) # 记录合作频率 if episode % 10 0: cr ((player1.q_table[0] player1.q_table[1]).astype(int) (player2.q_table[0] player2.q_table[1]).astype(int)) / 2 cooperation_rates.append(cr) plt.plot(np.arange(len(cooperation_rates))*10, cooperation_rates) plt.title(Q-learning智能体在重复囚徒困境中的合作演化) plt.xlabel(训练轮次) plt.ylabel(合作概率)