数学重学 - 06 生活中的数学

数学重学
,

这是 数学重学路线图 阶段一的子页面

生活中的数学

数学不是教室里的抽象符号，它藏在每一笔房贷、每一份保单、每一张彩票里

这一章把数学拉回地面，用它解决真实的生活问题

一、房贷计算

直觉理解

房贷本质上是”你向银行借钱，银行向你收租金（利息）”

两种还法的区别就像两种吃蛋糕的方式

等额本息：每月吃一样大的蛋糕（月供固定），但前期大部分是奶油（利息），后期才吃到蛋糕胚（本金）

等额本金：每月吃一样多的蛋糕胚（本金固定），奶油越来越少，所以蛋糕越来越小（月供递减）

等额本息公式

M = P × r(1+r)^n / ((1+r)^n - 1)

M = 每月还款额（固定不变）

P = 贷款总额

r = 月利率 = 年利率 / 12

n = 总还款月数

特点：月供固定，方便规划生活

缺点：总利息较多

等额本金公式

每月本金 = P / n（固定）

第 k 个月的利息 = (P - (k-1) × P/n) × r

第 k 个月的月供 = P/n + 剩余本金 × r

特点：首月最高，逐月递减

优点：总利息较少

为什么30年房贷利息比本金还多？

以贷款100万，年利率5%，30年为例

等额本息月供 ≈ 5368元

总还款 = 5368 × 360 ≈ 193万

利息 = 93万，接近本金了

原因分析：

第1个月利息 = 100万 × 5%/12 ≈ 4167元

月供5368中只有1201元还本金

前几年几乎都在还利息！

这就是复利的威力——只不过这次站在你的对立面

提前还款划不划算？

划算的情况：

贷款前期（前1/3时间内），因为此时利息占比高

手上有闲钱且没有更好的投资渠道

利率较高（如5%以上）

不划算的情况：

已经还了大半，剩余月供主要是本金

资金有更高收益的去处（年化 > 贷款利率）

公积金贷款利率很低（3.1%）

判断原则：比较贷款利率和你能获得的投资回报率

Python 代码：房贷计算器（含对比图）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
import matplotlib.pyplot as plt
import matplotlib
matplotlib.rcParams['font.sans-serif'] = ['SimHei', 'Arial Unicode MS']
matplotlib.rcParams['axes.unicode_minus'] = False

def mortgage_calculator(principal, annual_rate, years):
"""完整房贷计算，返回两种方式的逐月明细"""
r = annual_rate / 12
n = years * 12

# === 等额本息 ===
if r > 0:
    monthly_payment = principal * r * (1+r)**n / ((1+r)**n - 1)
else:
    monthly_payment = principal / n

eq_payment_interest = []
eq_payment_principal = []
remaining = principal
for i in range(n):
    interest = remaining * r
    princ = monthly_payment - interest
    remaining -= princ
    eq_payment_interest.append(interest)
    eq_payment_principal.append(princ)

# === 等额本金 ===
monthly_princ = principal / n
eq_princ_interest = []
eq_princ_payment = []
remaining = principal
for i in range(n):
    interest = remaining * r
    eq_princ_interest.append(interest)
    eq_princ_payment.append(monthly_princ + interest)
    remaining -= monthly_princ

return {
    'eq_payment': {
        'monthly': round(monthly_payment, 2),
        'total_interest': round(sum(eq_payment_interest), 2),
        'interest_list': eq_payment_interest,
        'principal_list': eq_payment_principal,
    },
    'eq_principal': {
        'first_month': round(eq_princ_payment[0], 2),
        'last_month': round(eq_princ_payment[-1], 2),
        'total_interest': round(sum(eq_princ_interest), 2),
        'interest_list': eq_princ_interest,
        'payment_list': eq_princ_payment,
    }
}

# 计算
result = mortgage_calculator(1000000, 0.042, 30)

print("=== 贷款100万, 利率4.2%, 30年 ===")
print(f"等额本息月供: {result['eq_payment']['monthly']:,.2f}")
print(f"等额本息总利息: {result['eq_payment']['total_interest']:,.2f}")
print(f"等额本金首月: {result['eq_principal']['first_month']:,.2f}")
print(f"等额本金末月: {result['eq_principal']['last_month']:,.2f}")
print(f"等额本金总利息: {result['eq_principal']['total_interest']:,.2f}")
diff = result['eq_payment']['total_interest'] - result['eq_principal']['total_interest']
print(f"利息差额: {diff:,.2f}")

# 画对比图
fig, axes = plt.subplots(1, 2, figsize=(14, 5))

months = range(1, 361)

# 图1：月供对比
axes[0].plot(months, [result['eq_payment']['monthly']]*360,
         label='等额本息', linewidth=2)
axes[0].plot(months, result['eq_principal']['payment_list'],
         label='等额本金', linewidth=2)
axes[0].set_xlabel('月份')
axes[0].set_ylabel('月供 (元)')
axes[0].set_title('月供对比')
axes[0].legend()
axes[0].grid(True, alpha=0.3)

# 图2：累计利息对比
import itertools
cum_interest_1 = list(itertools.accumulate(result['eq_payment']['interest_list']))
cum_interest_2 = list(itertools.accumulate(result['eq_principal']['interest_list']))
axes[1].plot(months, cum_interest_1, label='等额本息累计利息', linewidth=2)
axes[1].plot(months, cum_interest_2, label='等额本金累计利息', linewidth=2)
axes[1].set_xlabel('月份')
axes[1].set_ylabel('累计利息 (元)')
axes[1].set_title('累计利息对比')
axes[1].legend()
axes[1].grid(True, alpha=0.3)

plt.tight_layout()
plt.savefig('mortgage_comparison.png', dpi=150)
plt.show()

二、理财与投资

单利 vs 复利

单利：只对本金计息

A = P × (1 + r × n)

例：10万存3年，年利率3%，单利

A = 100000 × (1 + 0.03 × 3) = 109,000

复利：利息也产生利息

A = P × (1 + r)^n

例：10万存3年，年利率3%，复利

A = 100000 × 1.03^3 = 109,272.7

短期差别不大，长期天差地别

30年后单利：100000 × (1 + 0.03×30) = 190,000

30年后复利：100000 × 1.03^30 = 242,726

年化收益率的正确算法

很多平台标”日利率0.05%”，看起来很低？

年化 = (1 + 0.0005)^365 - 1 ≈ 20.0%

不是 0.05% × 365 = 18.25%（这是单利算法）

复利年化总是比单利高

看到”日利率””周利率”时一定要自己算年化

定投均摊效应（定期定额投资）

每月固定投1000元买基金

价格高时买得少，价格低时买得多

自动实现”低买多、高买少”

长期来看，平均成本低于简单平均价格（调和平均 < 算术平均）

Python 代码：投资复利计算器

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
def investment_calculator(monthly_invest, annual_rate, years):
"""定投复利计算器"""
monthly_rate = annual_rate / 12
months = years * 12
total_invested = monthly_invest * months

# 逐月计算
balance = 0
history = []
for m in range(1, months + 1):
    balance = (balance + monthly_invest) * (1 + monthly_rate)
    if m % 12 == 0:
        history.append((m // 12, round(balance), total_invested // months * m))

return {
    'final_balance': round(balance, 2),
    'total_invested': total_invested,
    'total_return': round(balance - total_invested, 2),
    'return_rate': round((balance / total_invested - 1) * 100, 2),
    'yearly_history': history,
}

# 每月定投2000元，年化8%，坚持20年
result = investment_calculator(2000, 0.08, 20)
print(f"总投入: {result['total_invested']:,} 元")
print(f"最终金额: {result['final_balance']:,.0f} 元")
print(f"总收益: {result['total_return']:,.0f} 元")
print(f"收益率: {result['return_rate']}%")
print()
print("年度增长:")
for year, balance, invested in result['yearly_history']:
bar = '█' * (balance // 50000)
print(f"第{year:2d}年: 余额{balance:>10,}  投入{invested:>8,}  {bar}")

三、概率直觉

彩票中奖概率

双色球：从33个红球选6个 + 16个蓝球选1个

一等奖概率 = 1 / (C(33,6) × 16) = 1 / 17,721,088

约等于 1/1772万

直觉化：

相当于连续抛24次硬币全部正面朝上

相当于在北京随机找一个人，而且找对了

每周买一注，平均要买34万年才中一次

期望值：假设奖池500万

期望 = 500万 × (1/1772万) ≈ 0.28元

一注2元，期望回报0.28元

长期买彩票，每花100块平均只能回来14块

保险的数学本质

用确定的小额支出，对冲不确定的大额损失

例：车险每年3000元，出事故赔50万

你赔的概率可能只有1%

期望损失 = 50万 × 1% = 5000元

保费3000元 < 期望损失5000元？不对

保险公司还有运营成本，所以保费 ≈ 期望损失 + 利润

为什么还要买？

因为人的风险承受能力不对称

少花3000确定的钱 vs 可能一次赔50万倾家荡产

保险买的是”安心”和”不被极端事件击穿”

赌场为什么总赢？

大数定律 + 期望值为负

轮盘赌：37个数字（0-36），押中赔35倍

期望 = 35/37 × (+35) + (-1) × 36/37… 不对

简单算：赢的概率 1/37，赔率 35:1

期望 = (1/37) × 35 + (36/37) × (-1) = 35/37 - 36/37 = -1/37 ≈ -2.7%

每押100元，平均亏2.7元

少数几次你可能赢，但赌的次数够多，数学规律就显现了

这就是大数定律：样本量足够大时，样本均值趋近期望值

赌场不怕你偶尔赢，怕的是你赢了就走——所以赌场设计让你继续赌

Python 代码：赌场模拟

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
import random

def simulate_roulette(initial_money, bet_amount, num_rounds):
"""模拟轮盘赌"""
money = initial_money
history = [money]
for _ in range(num_rounds):
    if money < bet_amount:
        break
    # 37个数字，猜中1个赔35倍
    result = random.randint(0, 36)
    my_number = random.randint(0, 36)
    if result == my_number:
        money += bet_amount * 35
    else:
        money -= bet_amount
    history.append(money)
return history

# 模拟5个赌徒，各带1万元，每次押100，玩1000轮
random.seed(42)
for i in range(5):
history = simulate_roulette(10000, 100, 1000)
final = history[-1]
rounds = len(history) - 1
print(f"赌徒{i+1}: 玩了{rounds}轮, 最终{final:>8,}元 ({'赢' if final > 10000 else '亏'})")
# 大多数人最终亏钱——这就是数学

四、单位换算

长度单位

1英寸 = 2.54厘米（记住这一个就够了）

1英尺 = 12英寸 = 30.48厘米

1英里 = 1.609公里

1海里 = 1.852公里

重量单位

1磅 = 0.4536千克 ≈ 9两

1盎司 = 28.35克（金价常用）

1斤 = 500克（中国市斤）

体积单位

1加仑(美) = 3.785升

1盎司(液) = 29.57毫升

1茶匙 = 5毫升，1汤匙 = 15毫升

温度换算

F = C × 1.8 + 32

C = (F - 32) / 1.8

常用记忆点：

0°C = 32°F（水的冰点）

37°C = 98.6°F（体温）

100°C = 212°F（水的沸点）

计算机单位（重要！）

两套标准并存，非常混乱

二进制（IEC标准，实际存储用这个）：

1 KiB = 1024 Bytes

1 MiB = 1024 KiB = 1,048,576 Bytes

1 GiB = 1024 MiB

1 TiB = 1024 GiB

十进制（SI标准，厂商标容量用这个）：

1 KB = 1000 Bytes

1 MB = 1000 KB = 1,000,000 Bytes

1 GB = 1000 MB

1 TB = 1000 GB

这就是为什么买1TB硬盘实际只有931GiB

1 TB = 1,000,000,000,000 Bytes

转成 GiB = 1,000,000,000,000 / 1024^3 ≈ 931 GiB

网络带宽用 bit（小写b），存储用 Byte（大写B）

100Mbps宽带，实际下载速度 ≈ 100/8 = 12.5 MB/s

Python 代码：单位换算工具

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
class UnitConverter:
"""万能单位换算器"""

# 所有单位转换为基准单位的系数
CONVERSIONS = {
    'length': {  # 基准: 米
        'm': 1, 'km': 1000, 'cm': 0.01, 'mm': 0.001,
        'inch': 0.0254, 'ft': 0.3048, 'mile': 1609.344,
    },
    'weight': {  # 基准: 千克
        'kg': 1, 'g': 0.001, 'mg': 0.000001,
        'lb': 0.4536, 'oz': 0.02835, 'jin': 0.5,
    },
    'temperature': 'special',
    'data': {  # 基准: Byte
        'B': 1, 'KiB': 1024, 'MiB': 1024**2,
        'GiB': 1024**3, 'TiB': 1024**4,
        'KB': 1000, 'MB': 1000**2,
        'GB': 1000**3, 'TB': 1000**4,
    },
}

@staticmethod
def convert_temperature(value, from_unit, to_unit):
    # 先转成摄氏度
    if from_unit == 'C':
        celsius = value
    elif from_unit == 'F':
        celsius = (value - 32) / 1.8
    elif from_unit == 'K':
        celsius = value - 273.15
    # 再转目标
    if to_unit == 'C':
        return celsius
    elif to_unit == 'F':
        return celsius * 1.8 + 32
    elif to_unit == 'K':
        return celsius + 273.15

@classmethod
def convert(cls, value, from_unit, to_unit, category=None):
    if category == 'temperature':
        return cls.convert_temperature(value, from_unit, to_unit)
    # 自动检测类别
    if category is None:
        for cat, units in cls.CONVERSIONS.items():
            if isinstance(units, dict) and from_unit in units:
                category = cat
                break
    units = cls.CONVERSIONS[category]
    base_value = value * units[from_unit]
    return base_value / units[to_unit]

# 使用示例
uc = UnitConverter()
print(f"1 mile = {uc.convert(1, 'mile', 'km'):.3f} km")
print(f"1 TB = {uc.convert(1, 'TB', 'GiB'):.1f} GiB")
print(f"100°F = {uc.convert(100, 'F', 'C', 'temperature'):.1f}°C")
print(f"体温37°C = {uc.convert(37, 'C', 'F', 'temperature'):.1f}°F")

五、做饭数学

食谱比例缩放

食谱写”4人份”，你只需要做2人份？所有量除以2

但要注意：

调味料不一定线性缩放（盐减半可能太淡，因为有固定损耗）

烹饪时间不等比缩放（量减半不等于时间减半）

浓度配比

冲咖啡：1:15 的咖啡粉水比

20g咖啡粉 → 300ml水

调鸡尾酒：基酒:果汁:糖浆 = 2:3:1

总量300ml → 基酒100ml、果汁150ml、糖浆50ml

糖度计算

一杯500ml奶茶，含糖50g

含糖量 = 50/500 = 10%

全糖100%、七分糖70%、半糖50%、三分糖30%

半糖 = 50 × 50% = 25g ≈ 5块方糖

烤箱温度换算

很多外国食谱用华氏度

350°F = (350-32)/1.8 ≈ 177°C（常用烘焙温度）

400°F ≈ 204°C

425°F ≈ 218°C

六、更多生活数学

油耗计算

百公里油耗 = 加油量(L) / 行驶里程(km) × 100

例：加了45L油跑了600km → 45/600×100 = 7.5L/100km

油费 = 百公里油耗 × 油价 / 100 × 公里数

汇率计算

1美元 = 7.2人民币（假设）

1000美元的东西 = 7200人民币

注意买入价和卖出价的差（银行赚这个差价）

时间计算

时区换算：北京时间 = UTC+8

美西时间 = UTC-7（夏令时）或 UTC-8（冬令时）

北京时间 - 美西时间 = 15或16小时

工作日计算：一年365天 - 104天周末 - ~11天节假日 ≈ 250个工作日

日薪 = 年薪 / 250（粗略估算）

七、综合 Python 项目

生活计算器合集

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
"""生活数学计算器合集"""

def compare_mortgage(principal, annual_rate, years):
"""对比两种还款方式并输出摘要"""
r = annual_rate / 12
n = years * 12

# 等额本息
mp = principal * r * (1+r)**n / ((1+r)**n - 1)
total_1 = mp * n

# 等额本金
monthly_p = principal / n
total_2 = sum(monthly_p + (principal - i*monthly_p) * r for i in range(n))

print(f"贷款 {principal/10000:.0f}万, 利率{annual_rate*100}%, {years}年")
print(f"等额本息: 月供{mp:,.0f}, 总利息{total_1-principal:,.0f}")
print(f"等额本金: 首月{monthly_p + principal*r:,.0f}, "
      f"末月{monthly_p + monthly_p*r:,.0f}, 总利息{total_2-principal:,.0f}")
print(f"利息差: {(total_1-principal)-(total_2-principal):,.0f}")
print()

def lottery_reality_check(ticket_price=2, jackpot=5000000, total_outcomes=17721088):
"""彩票现实检验"""
prob = 1 / total_outcomes
expected = jackpot * prob
roi = (expected - ticket_price) / ticket_price * 100
years_to_win = total_outcomes / 52  # 每周买一注

print("=== 彩票现实检验 ===")
print(f"中奖概率: 1/{total_outcomes:,} ({prob:.10f})")
print(f"期望回报: {expected:.2f}元 (花{ticket_price}元)")
print(f"投资回报率: {roi:.1f}%")
print(f"每周买一注，平均{years_to_win:,.0f}年中一次")
print()

def rule_of_72(rate_percent):
"""72法则"""
import math
approx = 72 / rate_percent
exact = math.log(2) / math.log(1 + rate_percent/100)
print(f"利率{rate_percent}%: 72法则≈{approx:.1f}年, 精确={exact:.1f}年")

# 运行
compare_mortgage(1000000, 0.042, 30)
compare_mortgage(800000, 0.035, 20)  # 公积金

lottery_reality_check()

print("=== 72法则 ===")
for r in [2, 3, 5, 6, 8, 10, 12]:
rule_of_72(r)

练习题

题1：房贷决策

贷款60万，可选方案：

A：商业贷款，年利率4.9%，30年

B：公积金贷款，年利率3.1%，20年

计算两种方案的月供和总利息，哪个更划算？

A：月供约3184元，总利息约54.6万

B：月供约3373元，总利息约20.9万

B虽然月供多189元，但总利息少33.7万

如果月供承受得起，B远优于A

题2：理财对比

小明有10万元闲钱，两种选择：

A：银行定期3年，年利率2.5%，单利

B：基金定投，预期年化6%，复利

3年后各有多少钱？

A：100000 × (1 + 0.025 × 3) = 107,500元

B：100000 × 1.06^3 = 119,101.6元

B多出11,601.6元，但有风险

题3：概率思维

某安全系统检测率99%（有攻击时99%能检测到），误报率1%（没有攻击时1%会误报）

如果实际攻击概率为0.1%，当系统报警时，真的是攻击的概率是多少？

（提示：贝叶斯定理，先算一下再看答案）

P(攻击|报警) = P(报警|攻击) × P(攻击) / P(报警)

P(报警) = P(报警|攻击)×P(攻击) + P(报警|无攻击)×P(无攻击)

P(报警) = 0.99 × 0.001 + 0.01 × 0.999 = 0.00099 + 0.00999 = 0.01098

P(攻击|报警) = 0.00099 / 0.01098 ≈ 9.02%

即使报警了，真正是攻击的概率只有约9%

这就是基数谬误——当真实事件很稀有时，误报会淹没真实报警

题4：通胀侵蚀

假设年通胀率3%，现在100万的购买力

10年后相当于多少？20年后？30年后？

10年后：100万 × (1/1.03)^10 = 100万 × 0.7441 ≈ 74.4万

20年后：100万 × (1/1.03)^20 ≈ 55.4万

30年后：100万 × (1/1.03)^30 ≈ 41.2万

30年后购买力不到一半——这就是为什么钱不能只存银行

题5：油费计算

自驾从北京到上海，约1200km

车百公里油耗8L，92号汽油7.8元/L

高速过路费约550元

计算总花费。如果两个人分摊 vs 坐高铁（二等座约550元/人），哪个划算？

油费 = 1200/100 × 8 × 7.8 = 748.8元

总费用 = 748.8 + 550 = 1298.8元

两人分摊 = 649.4元/人

高铁 = 550元/人

两个人开车每人649元 > 高铁550元，高铁划算

但如果4个人：1298.8/4 = 324.7元/人，自驾划算

本章小结

房贷：等额本息月供固定但利息多，等额本金利息少但前期压力大

复利：长期投资的核心引擎，也是房贷利息多的原因

概率：彩票是穷人税，保险是风险管理，赌场靠数学赢钱

单位换算：1024 vs 1000 的混乱要记住，网速 bit 和 Byte 差8倍

核心认知：生活中到处是数学，算清楚再决策能省很多钱

上一章 → 05-基础统计思维

下一章 → 07-数据素养

上一章 目录 下一章
05-基础统计思维 数学重学路线图 07-数据素养