数学重学 - 02 幂根号与指数

数学重学
,

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

幂、根号与指数

乘方是重复乘法，开方是乘方的逆运算

上一节：01-分数与小数

为什么要学这个

指数运算是计算机科学的基石：2^10 = 1024，程序员的”千”

安全领域：密钥强度用 2^n 衡量，AES-256 = 2^256 种可能的密钥

大数据领域：数据量级 KB/MB/GB/TB/PB，每级差 2^10 = 1024 倍

算法复杂度：O(n^2)、O(2^n)、O(log n) 都涉及指数概念

科学计数法：处理极大或极小的数，如纳秒级时间戳

乘方/幂

基本概念

2^3 = 2 × 2 × 2 = 8

底数 (base)：被重复相乘的数 → 2

指数 (exponent)：重复乘的次数 → 3

幂 (power)：运算结果 → 8

读法：2 的 3 次方，2 的 3 次幂

平方：面积的直觉

3^2 = 9

想象一个边长为 3 的正方形，面积就是 9

1
2
3
4
5
6
7
┌───┬───┬───┐
│   │   │   │
├───┼───┼───┤
│   │   │   │   3 × 3 = 9 = 3²
├───┼───┼───┤
│   │   │   │
└───┴───┴───┘

“平方”这个词就来自正方形（square）

面积单位用 m^2，就是因为面积 = 长 × 宽

立方：体积的直觉

2^3 = 8

想象一个边长为 2 的正方体，体积就是 8

“立方”这个词就来自正方体（cube）

体积单位用 m^3

常用幂值（程序员必记）

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
2^0  = 1
2^1  = 2
2^2  = 4
2^3  = 8
2^4  = 16
2^5  = 32
2^6  = 64
2^7  = 128
2^8  = 256
2^9  = 512
2^10 = 1024        ≈ 1K（千）
2^16 = 65536        端口号上限
2^20 = 1048576      ≈ 1M（百万）
2^30 = 1073741824   ≈ 1G（十亿）
2^32 = 4294967296   ≈ 43亿（IPv4地址数 / uint32上限）
2^64 = 约1.8×10^19  uint64上限 / 雪花ID空间

指数法则（必须熟记）

同底数幂相乘：指数相加

a^m × a^n = a^(m+n)

例：2^3 × 2^4 = 2^(3+4) = 2^7 = 128

直觉：2 乘了 3 次，再乘 4 次，一共乘了 7 次

同底数幂相除：指数相减

a^m ÷ a^n = a^(m-n)

例：2^7 ÷ 2^3 = 2^(7-3) = 2^4 = 16

直觉：乘了 7 次再消去 3 次，剩 4 次

幂的幂：指数相乘

(a^m)^n = a^(m×n)

例：(2^3)^4 = 2^(3×4) = 2^12 = 4096

直觉：先乘 3 次得到一个数，再把这个数乘 4 次

积的幂：分别求幂

(a × b)^n = a^n × b^n

例：(2 × 3)^4 = 2^4 × 3^4 = 16 × 81 = 1296

验证：6^4 = 1296

零次幂：任何非零数的 0 次方等于 1

a^0 = 1（a ≠ 0）

为什么？从指数相减推导：a^n ÷ a^n = a^(n-n) = a^0 = 1

0^0 是一个争议话题，通常约定为 1

负指数：取倒数

a^(-n) = 1 / a^n

例：2^(-3) = 1/2^3 = 1/8 = 0.125

直觉：负指数就是”翻到分母去”

推导：a^m × a^(-m) = a^0 = 1 → a^(-m) = 1/a^m

指数法则速查表

1
2
3
4
5
6
7
8
9
法则                公式                    例子
──────────────────────────────────────────────────
同底相乘            a^m × a^n = a^(m+n)     2^3 × 2^4 = 2^7
同底相除            a^m ÷ a^n = a^(m-n)     2^7 ÷ 2^3 = 2^4
幂的幂              (a^m)^n = a^(mn)         (2^3)^4 = 2^12
积的幂              (ab)^n = a^n × b^n      (2×3)^4 = 2^4 × 3^4
零次幂              a^0 = 1                  5^0 = 1
负指数              a^(-n) = 1/a^n          2^(-3) = 1/8
分数指数            a^(m/n) = (ⁿ√a)^m      8^(2/3) = 4

根号/开方

平方根

√9 = 3，因为 3^2 = 9

√ 就是在问”什么数自乘得到这个数”

注意：(-3)^2 = 9，所以 9 有两个平方根：3 和 -3

但 √9 通常只取正值，叫算术平方根

立方根

∛8 = 2，因为 2^3 = 8

∛(-8) = -2，因为 (-2)^3 = -8

立方根可以对负数开方（平方根不行，在实数范围内）

n 次方根

ⁿ√a 就是问”什么数的 n 次方等于 a”

⁴√16 = 2，因为 2^4 = 16

根号的另一种写法：分数指数

这是连接幂和根号的桥梁，非常重要

√a = a^(1/2)

∛a = a^(1/3)

ⁿ√a = a^(1/n)

更一般地：a^(m/n) = (ⁿ√a)^m = ⁿ√(a^m)

例：8^(2/3) = (∛8)^2 = 2^2 = 4

常见根号值

√2 ≈ 1.414（对角线与边长之比）

√3 ≈ 1.732（等边三角形高与边长之比）

√5 ≈ 2.236

这些都是无理数，小数部分永远不循环

科学计数法

什么是科学计数法

把数写成 a × 10^n 的形式（1 ≤ a < 10）

314000000 = 3.14 × 10^8

0.000005 = 5 × 10^(-6)

为什么需要

太大或太小的数字，直接写容易数错零

光速 = 299792458 m/s ≈ 3 × 10^8 m/s

电子质量 = 0.00000000000000000000000000000091 kg = 9.1 × 10^(-31) kg

计算机中的应用

存储单位

1 KB = 10^3 字节（严格说是 2^10 = 1024）

1 MB = 10^6, 1 GB = 10^9, 1 TB = 10^12

1 PB = 10^15（大数据常见量级）

时间单位

1 毫秒(ms) = 10^(-3) 秒

1 微秒(μs) = 10^(-6) 秒

1 纳秒(ns) = 10^(-9) 秒

CPU 一个时钟周期约 0.3 ns（3 GHz 处理器）

Python 中的科学计数法

3.14e8 = 3.14 × 10^8 = 314000000.0

5e-6 = 5 × 10^(-6) = 0.000005

指数增长的直觉

折纸问题

一张纸厚 0.1mm

折 1 次 = 0.2mm，折 2 次 = 0.4mm

折 n 次 = 0.1 × 2^n mm

折 42 次 = 0.1 × 2^42 mm ≈ 4.4 × 10^8 mm ≈ 44 万公里

地月距离约 38 万公里 → 折 42 次超过地月距离！

这就是指数增长的恐怖之处

程序员必记的 2 的幂

2^10 ≈ 1000（千）→ 1 KB

2^20 ≈ 100 万（百万）→ 1 MB

2^30 ≈ 10 亿 → 1 GB

2^32 ≈ 43 亿 → IPv4 地址数量、uint32 上限

2^64 ≈ 1.8 × 10^19 → 雪花算法 ID 空间

算法复杂度与指数

O(1)：常数，和数据量无关

O(log n)：二分查找，每次砍一半

O(n)：遍历一遍

O(n log n)：排序

O(n^2)：双重循环

O(2^n)：指数爆炸，暴力枚举子集

n=30 时，n^2 = 900，2^n ≈ 10 亿 → 差了 100 万倍

安全领域应用

密钥空间

AES-128：密钥有 2^128 ≈ 3.4 × 10^38 种可能

AES-256：密钥有 2^256 ≈ 1.16 × 10^77 种可能

宇宙中原子数量约 10^80，AES-256 的密钥空间接近这个量级

暴力破解 AES-256 在物理上不可能

密码强度

8 位纯数字密码：10^8 = 1 亿种，暴力破解只需数秒

8 位大小写字母+数字：62^8 ≈ 2.18 × 10^14，约 2 天

12 位大小写字母+数字+特殊字符：95^12 ≈ 5.4 × 10^23，约 17 万年

每增加一位，难度乘以字符集大小 → 指数增长

哈希碰撞（生日攻击）

n 位哈希值的碰撞概率在约 2^(n/2) 次尝试后显著

MD5（128位）：2^64 ≈ 1.8 × 10^19 次就可能碰撞

SHA-256：2^128 次，目前安全

大数据领域应用

数据量级

1
2
3
4
5
6
7
8
级别    字节数         约等于       典型场景
───────────────────────────────────────────
KB      2^10 = 1024    1千          一封短邮件
MB      2^20           100万        一张照片
GB      2^30           10亿         一部高清电影
TB      2^40           1万亿        中型数据库
PB      2^50           千万亿       大型互联网公司日志
EB      2^60           百亿亿       全球年数据量

布隆过滤器中的指数

误判率 ≈ (1 - e^(-kn/m))^k

其中 k 是哈希函数个数，n 是元素数量，m 是位数组大小

位数组越大，误判率指数级下降

分布式系统中的 2 的幂

一致性哈希环：通常用 2^32 个虚拟节点

分区数：Kafka 分区常设为 2 的幂次

位运算优化：n % 2^k 等价于 n & (2^k - 1)，效率更高

Python 代码实战

幂运算基础

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
# Python 中幂运算的三种方式
print(2 ** 10)         # 1024  ← 最常用
print(pow(2, 10))      # 1024  ← 内置函数
import math
print(math.pow(2, 10)) # 1024.0 ← 返回浮点数

# 大整数幂（Python 无上限）
print(2 ** 256)
# 115792089237316195423570985008687907853269984665640564039457584007913129639936

# 指数法则验证
a, m, n = 3, 4, 5
assert a**m * a**n == a**(m+n)       # 同底相乘
assert a**m / a**n == a**(m-n)       # 同底相除（浮点）
assert (a**m)**n == a**(m*n)         # 幂的幂
print("指数法则验证通过")

# 模幂运算（密码学核心）
# pow(base, exp, mod) 比 base**exp % mod 高效得多
base, exp, mod = 7, 256, 13
result = pow(base, exp, mod)
print(f"{base}^{exp} mod {mod} = {result}")

根号与开方

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
import math

# 平方根
print(math.sqrt(9))      # 3.0
print(math.sqrt(2))      # 1.4142135623730951
print(9 ** 0.5)          # 3.0  ← 用分数指数

# 立方根
print(8 ** (1/3))        # 2.0
print(27 ** (1/3))       # 3.0

# 注意浮点精度
print(64 ** (1/3))       # 3.9999999999999996 不是精确的4！
print(round(64 ** (1/3)))  # 4 ← 四舍五入修正

# n次方根
def nth_root(x, n):
"""计算 x 的 n 次方根"""
if x < 0 and n % 2 == 0:
    raise ValueError("偶数次方根不能对负数求值")
if x < 0:
    return -((-x) ** (1/n))
return x ** (1/n)

print(nth_root(16, 4))     # 2.0
print(nth_root(-8, 3))     # -2.0
print(nth_root(32, 5))     # 2.0

# 判断是否为完全平方数
def is_perfect_square(n):
if n < 0:
    return False
root = int(math.isqrt(n))
return root * root == n

print(is_perfect_square(16))   # True
print(is_perfect_square(15))   # False
print(is_perfect_square(10000))  # True

科学计数法与数据量级

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
# Python 中的科学计数法
speed_of_light = 3e8        # 3 × 10^8 m/s
electron_mass = 9.1e-31     # 9.1 × 10^(-31) kg

print(f"光速: {speed_of_light}")         # 300000000.0
print(f"电子质量: {electron_mass}")       # 9.1e-31
print(f"光速(科学计数法): {speed_of_light:.2e}")  # 3.00e+08

# 数据量级转换
def human_readable_size(size_bytes):
"""将字节数转换为人类可读格式"""
units = ['B', 'KB', 'MB', 'GB', 'TB', 'PB', 'EB']
unit_index = 0
size = float(size_bytes)
while size >= 1024 and unit_index < len(units) - 1:
    size /= 1024
    unit_index += 1
return f"{size:.2f} {units[unit_index]}"

print(human_readable_size(1024))             # 1.00 KB
print(human_readable_size(1536))              # 1.50 KB
print(human_readable_size(1073741824))        # 1.00 GB
print(human_readable_size(5 * 2**40))         # 5.00 TB

# 大数据量级感受
print("\n常见数据量级:")
data_sizes = {
"一条日志": 256,
"一个JSON响应": 2 * 1024,
"一张图片": 3 * 1024 * 1024,
"一天的访问日志(中等网站)": 5 * 2**30,
"Hive 中一张大表": 500 * 2**40,
}
for name, size in data_sizes.items():
print(f"  {name}: {human_readable_size(size)}")

密码强度计算

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
import math

def password_strength(length, charset_size):
"""
计算密码强度
length: 密码长度
charset_size: 字符集大小
"""
total_combinations = charset_size ** length
bits_of_entropy = math.log2(total_combinations)

# 假设每秒尝试 10 亿次（GPU 暴力破解）
attempts_per_sec = 1e9
seconds = total_combinations / attempts_per_sec

if seconds < 60:
    time_str = f"{seconds:.1f} 秒"
elif seconds < 3600:
    time_str = f"{seconds/60:.1f} 分钟"
elif seconds < 86400:
    time_str = f"{seconds/3600:.1f} 小时"
elif seconds < 86400 * 365:
    time_str = f"{seconds/86400:.1f} 天"
else:
    time_str = f"{seconds/(86400*365):.1e} 年"

return {
    'combinations': total_combinations,
    'entropy_bits': bits_of_entropy,
    'crack_time': time_str
}

# 各种密码类型
scenarios = [
("6位纯数字(手机验证码)", 6, 10),
("8位纯数字", 8, 10),
("8位小写字母", 8, 26),
("8位大小写+数字", 8, 62),
("12位大小写+数字+特殊", 12, 95),
("16位大小写+数字+特殊", 16, 95),
]

print(f"{'类型':<30} {'组合数':<20} {'熵(bits)':<12} {'暴力破解时间'}")
print("-" * 85)
for name, length, charset in scenarios:
r = password_strength(length, charset)
print(f"{name:<30} {r['combinations']:<20.2e} {r['entropy_bits']:<12.1f} {r['crack_time']}")

常见误区

误区1：(-3)^2 = -9

错！(-3)^2 = (-3) × (-3) = 9

但 -3^2 = -(3^2) = -9（注意有没有括号！）

误区2：√(a^2) = a

不完全对：√((-3)^2) = √9 = 3 ≠ -3

正确：√(a^2) = |a|（绝对值）

误区3：2^3 × 3^3 = 6^6

错！2^3 × 3^3 = (2×3)^3 = 6^3 = 216

指数不相加，底数相乘，指数保持不变

误区4：(a+b)^2 = a^2 + b^2

大错特错！(a+b)^2 = a^2 + 2ab + b^2

漏掉交叉项 2ab 是最经典的代数错误

误区5：0.999… ≠ 1

实际上 0.999… = 1，这是数学事实

证明：设 x = 0.999…，则 10x = 9.999… → 10x - x = 9 → x = 1

练习题

题目1：指数法则

化简：(2^3 × 4^2) / 8^2

提示：把所有底数统一成 2

答案：4 = 2^2, 8 = 2^3 → (2^3 × 2^4) / 2^6 = 2^7 / 2^6 = 2^1 = 2

题目2：分数指数

计算 27^(2/3)

答案：(∛27)^2 = 3^2 = 9

题目3：安全应用

某系统使用 64 位随机 token 做会话 ID

如果攻击者每秒能尝试 10 万个 token，暴力破解平均需要多少年？

答案：2^64 / (2 × 10^5) / (365.25 × 24 × 3600) ≈ 2.92 × 10^8 年（约 3 亿年）

题目4：编程题

用 Python 写一个函数，输入文件大小（字节），输出人类可读格式

例：1536 → “1.50 KB”，1073741824 → “1.00 GB”

题目5：指数增长

某数据库每天数据量增长 2%，现在有 1 TB

多少天后达到 2 TB？（提示：用对数求解 1.02^n = 2）

答案：n = log(2) / log(1.02) ≈ 35 天

小结

幂是重复乘法，指数法则是幂运算的基本工具

根号是幂的逆运算，分数指数统一了幂和根号

科学计数法处理极大/极小数字

指数增长极其恐怖，2^10 ≈ 1000 是程序员基本常识

安全和大数据领域处处都是指数和幂

下一节：03-比例百分比与增长率

上一章 目录 下一章
01-分数与小数 数学重学路线图 03-比例百分比与增长率